File indexing completed on 2024-04-21 04:57:27

 /*
  * SPDX-FileCopyrightText: 2022 Kai Uwe Broulik <kde@broulik.de>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "afcfile.h"
 
 #include "afc_debug.h"
 
 #include "afcutils.h"
 
 using namespace KIO;
 
 AfcFile::AfcFile(const AfcClient::Ptr &client, const QString &path)
     : m_client(client)
     , m_path(path)
 {
 }
 
 AfcFile::AfcFile(AfcFile &&other) Q_DECL_NOEXCEPT : m_client(std::move(other.m_client)), m_path(other.m_path), m_handle(other.m_handle)
 {
     other.m_handle.reset();
 }
 
 AfcFile::~AfcFile()
 {
     if (m_handle) {
         close();
     }
 }
 
 AfcClient::Ptr AfcFile::client() const
 {
     return m_client;
 }
 
 QString AfcFile::path() const
 {
     return m_path;
 }
 
 WorkerResult AfcFile::open(QIODevice::OpenMode mode)
 {
     Q_ASSERT(!m_handle);
 
     afc_file_mode_t fileMode = static_cast<afc_file_mode_t>(0);
 
     if (mode == QIODevice::ReadOnly) {
         fileMode = AFC_FOPEN_RDONLY;
     } else if (mode == QIODevice::WriteOnly) {
         fileMode = AFC_FOPEN_WRONLY;
     } else if (mode == QIODevice::ReadWrite) {
         fileMode = AFC_FOPEN_RW;
     } else if (mode == (QIODevice::ReadWrite | QIODevice::Truncate)) {
         fileMode = AFC_FOPEN_WR;
     } else if (mode == QIODevice::Append || mode == (QIODevice::Append | QIODevice::WriteOnly)) {
         fileMode = AFC_FOPEN_APPEND;
     } else if (mode == (QIODevice::Append | QIODevice::ReadWrite)) {
         fileMode = AFC_FOPEN_RDAPPEND;
     }
 
     if (!fileMode) {
         return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, QString::number(mode));
     }
 
     uint64_t handle = 0;
     const auto ret = afc_file_open(m_client->internalClient(), m_path.toLocal8Bit().constData(), fileMode, &handle);
 
     const WorkerResult result = AfcUtils::Result::from(ret);
     if (result.success()) {
         m_handle = handle;
     }
     return result;
 }
 
 WorkerResult AfcFile::seek(filesize_t offset)
 {
     Q_ASSERT(m_handle);
     const auto ret = afc_file_seek(m_client->internalClient(), m_handle.value(), offset, SEEK_SET);
     return AfcUtils::Result::from(ret);
 }
 
 WorkerResult AfcFile::truncate(filesize_t length)
 {
     Q_ASSERT(m_handle);
     const auto ret = afc_file_truncate(m_client->internalClient(), m_handle.value(), length);
     return AfcUtils::Result::from(ret);
 }
 
 WorkerResult AfcFile::write(const QByteArray &data, uint32_t &bytesWritten)
 {
     Q_ASSERT(m_handle);
     const auto ret = afc_file_write(m_client->internalClient(), m_handle.value(), data.constData(), data.size(), &bytesWritten);
     return AfcUtils::Result::from(ret);
 }
 
 WorkerResult AfcFile::close()
 {
     Q_ASSERT(m_handle);
 
     const auto ret = afc_file_close(m_client->internalClient(), m_handle.value());
 
     const WorkerResult result = AfcUtils::Result::from(ret);
     if (result.success()) {
         m_handle.reset();
     }
     return result;
 }
 
 AfcFileReader AfcFile::reader() const
 {
     Q_ASSERT(m_handle);
 
     AfcFileReader reader(m_client, m_handle.value());
     return reader;
 }