Filesystem.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */
 
#pragma once
 
#include "AddonBase.h"
#include "c-api/filesystem.h"
 
#ifdef __cplusplus
 
#include <cstring>
#include <map>
#include <vector>
 
namespace kodi
{
namespace vfs
{
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Main page text for filesystem group by Doxygen.
//{{{
 
//==============================================================================
//------------------------------------------------------------------------------
 
//==============================================================================
//------------------------------------------------------------------------------
 
//==============================================================================
//------------------------------------------------------------------------------
 
//==============================================================================
//------------------------------------------------------------------------------
 
//==============================================================================
//------------------------------------------------------------------------------
 
//}}}
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" related filesystem definitions
//{{{
 
//==============================================================================
class ATTR_DLL_LOCAL FileStatus : public kodi::addon::CStructHdl<FileStatus, STAT_STRUCTURE>
{
public:
  FileStatus() { memset(m_cStructure, 0, sizeof(STAT_STRUCTURE)); }
  FileStatus(const FileStatus& channel) : CStructHdl(channel) {}
  FileStatus(const STAT_STRUCTURE* channel) : CStructHdl(channel) {}
  FileStatus(STAT_STRUCTURE* channel) : CStructHdl(channel) {}
 
 
  void SetDeviceId(uint32_t deviceId) { m_cStructure->deviceId = deviceId; }
 
  uint32_t GetDeviceId() const { return m_cStructure->deviceId; }
 
  void SetFileSerialNumber(uint64_t fileSerialNumber)
  {
    m_cStructure->fileSerialNumber = fileSerialNumber;
  }
 
  uint64_t GetFileSerialNumber() const { return m_cStructure->fileSerialNumber; }
 
  void SetSize(uint64_t size) { m_cStructure->size = size; }
 
  uint64_t GetSize() const { return m_cStructure->size; }
 
  void SetAccessTime(time_t accessTime) { m_cStructure->accessTime = accessTime; }
 
  time_t GetAccessTime() const { return m_cStructure->accessTime; }
 
  void SetModificationTime(time_t modificationTime)
  {
    m_cStructure->modificationTime = modificationTime;
  }
 
  time_t GetModificationTime() const { return m_cStructure->modificationTime; }
 
  void SetStatusTime(time_t statusTime) { m_cStructure->statusTime = statusTime; }
 
  time_t GetStatusTime() const { return m_cStructure->statusTime; }
 
  void SetIsDirectory(bool isDirectory) { m_cStructure->isDirectory = isDirectory; }
 
  bool GetIsDirectory() const { return m_cStructure->isDirectory; }
 
  void SetIsSymLink(bool isSymLink) { m_cStructure->isSymLink = isSymLink; }
 
  bool GetIsSymLink() const { return m_cStructure->isSymLink; }
 
  void SetIsBlock(bool isBlock) { m_cStructure->isBlock = isBlock; }
 
  bool GetIsBlock() const { return m_cStructure->isBlock; }
 
  void SetIsCharacter(bool isCharacter) { m_cStructure->isCharacter = isCharacter; }
 
  bool GetIsCharacter() const { return m_cStructure->isCharacter; }
 
  void SetIsFifo(bool isFifo) { m_cStructure->isFifo = isFifo; }
 
  bool GetIsFifo() const { return m_cStructure->isFifo; }
 
  void SetIsRegular(bool isRegular) { m_cStructure->isRegular = isRegular; }
 
  bool GetIsRegular() const { return m_cStructure->isRegular; }
 
  void SetIsSocket(bool isSocket) { m_cStructure->isSocket = isSocket; }
 
  bool GetIsSocket() const { return m_cStructure->isSocket; }
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL CacheStatus
  : public kodi::addon::CStructHdl<CacheStatus, VFS_CACHE_STATUS_DATA>
{
public:
  CacheStatus() { memset(m_cStructure, 0, sizeof(VFS_CACHE_STATUS_DATA)); }
  CacheStatus(const CacheStatus& channel) : CStructHdl(channel) {}
  CacheStatus(const VFS_CACHE_STATUS_DATA* channel) : CStructHdl(channel) {}
  CacheStatus(VFS_CACHE_STATUS_DATA* channel) : CStructHdl(channel) {}
 
 
  void SetForward(uint64_t forward) { m_cStructure->forward = forward; }
 
  uint64_t GetForward() { return m_cStructure->forward; }
 
  void SetMaxRate(uint32_t maxrate) { m_cStructure->maxrate = maxrate; }
 
  uint32_t GetMaxRate() { return m_cStructure->maxrate; }
 
  void SetCurrentRate(uint32_t currate) { m_cStructure->currate = currate; }
 
  uint32_t GetCurrentRate() { return m_cStructure->currate; }
 
  void SetLowRate(uint32_t lowrate) { m_cStructure->lowrate = lowrate; }
 
  uint32_t GetLowRate() { return m_cStructure->lowrate; }
 
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL HttpHeader
{
public:
  //==========================================================================
  HttpHeader()
  {
    using namespace ::kodi::addon;
 
    CPrivateBase::m_interface->toKodi->kodi_filesystem->http_header_create(
        CPrivateBase::m_interface->toKodi->kodiBase, &m_handle);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  ~HttpHeader()
  {
    using namespace ::kodi::addon;
 
    CPrivateBase::m_interface->toKodi->kodi_filesystem->http_header_free(
        CPrivateBase::m_interface->toKodi->kodiBase, &m_handle);
  }
  //--------------------------------------------------------------------------
 
 
 
  //==========================================================================
  std::string GetValue(const std::string& param) const
  {
    using namespace ::kodi::addon;
 
    if (!m_handle.handle)
      return "";
 
    std::string protoLine;
    char* string = m_handle.get_value(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle,
                                      param.c_str());
    if (string != nullptr)
    {
      protoLine = string;
      CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                     string);
    }
    return protoLine;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  std::vector<std::string> GetValues(const std::string& param) const
  {
    using namespace kodi::addon;
 
    if (!m_handle.handle)
      return std::vector<std::string>();
 
    int numValues = 0;
    char** res(m_handle.get_values(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle,
                                   param.c_str(), &numValues));
    if (res)
    {
      std::vector<std::string> vecReturn;
      vecReturn.reserve(numValues);
      for (int i = 0; i < numValues; ++i)
      {
        vecReturn.emplace_back(res[i]);
      }
      CPrivateBase::m_interface->toKodi->free_string_array(
          CPrivateBase::m_interface->toKodi->kodiBase, res, numValues);
      return vecReturn;
    }
    return std::vector<std::string>();
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  std::string GetHeader() const
  {
    using namespace ::kodi::addon;
 
    if (!m_handle.handle)
      return "";
 
    std::string header;
    char* string =
        m_handle.get_header(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle);
    if (string != nullptr)
    {
      header = string;
      CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                     string);
    }
    return header;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  std::string GetMimeType() const
  {
    using namespace ::kodi::addon;
 
    if (!m_handle.handle)
      return "";
 
    std::string protoLine;
    char* string =
        m_handle.get_mime_type(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle);
    if (string != nullptr)
    {
      protoLine = string;
      CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                     string);
    }
    return protoLine;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  std::string GetCharset() const
  {
    using namespace ::kodi::addon;
 
    if (!m_handle.handle)
      return "";
 
    std::string protoLine;
    char* string =
        m_handle.get_charset(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle);
    if (string != nullptr)
    {
      protoLine = string;
      CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                     string);
    }
    return protoLine;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  std::string GetProtoLine() const
  {
    using namespace ::kodi::addon;
 
    if (!m_handle.handle)
      return "";
 
    std::string protoLine;
    char* string =
        m_handle.get_proto_line(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle);
    if (string != nullptr)
    {
      protoLine = string;
      CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                     string);
    }
    return protoLine;
  }
  //--------------------------------------------------------------------------
 
 
  KODI_HTTP_HEADER m_handle;
};
//----------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL CDirEntry
{
public:
  //============================================================================
  CDirEntry(const std::string& label = "",
            const std::string& path = "",
            bool folder = false,
            int64_t size = -1,
            time_t dateTime = 0)
    : m_label(label),
      m_path(path),
      m_folder(folder),
      m_size(size),
      m_dateTime(dateTime)
  {
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  // @note Not necessary for addon development, therefore it's
  // disabled for doxygen below!
  //
  // @ingroup cpp_kodi_vfs_CDirEntry
  // @brief Constructor to create own copy
  //
  // @param[in] dirEntry pointer to own class type
  //
  explicit CDirEntry(const VFSDirEntry& dirEntry)
    : m_label(dirEntry.label ? dirEntry.label : ""),
      m_path(dirEntry.path ? dirEntry.path : ""),
      m_folder(dirEntry.folder),
      m_size(dirEntry.size),
      m_dateTime(dirEntry.date_time)
  {
  }
  //----------------------------------------------------------------------------
 
 
 
  //============================================================================
  const std::string& Label(void) const { return m_label; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  const std::string& Title(void) const { return m_title; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  const std::string& Path(void) const { return m_path; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  bool IsFolder(void) const { return m_folder; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  int64_t Size(void) const { return m_size; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  time_t DateTime() { return m_dateTime; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetLabel(const std::string& label) { m_label = label; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetTitle(const std::string& title) { m_title = title; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetPath(const std::string& path) { m_path = path; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetFolder(bool folder) { m_folder = folder; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetSize(int64_t size) { m_size = size; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetDateTime(time_t dateTime) { m_dateTime = dateTime; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void AddProperty(const std::string& id, const std::string& value) { m_properties[id] = value; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void ClearProperties() { m_properties.clear(); }
  //----------------------------------------------------------------------------
 
  //============================================================================
  const std::map<std::string, std::string>& GetProperties() const { return m_properties; }
  //----------------------------------------------------------------------------
 
 
private:
  std::string m_label;
  std::string m_title;
  std::string m_path;
  std::map<std::string, std::string> m_properties;
  bool m_folder;
  int64_t m_size;
  time_t m_dateTime;
};
//------------------------------------------------------------------------------
 
//}}}
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" Directory related functions
//{{{
 
//==============================================================================
inline bool ATTR_DLL_LOCAL CreateDirectory(const std::string& path)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->create_directory(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL DirectoryExists(const std::string& path)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->directory_exists(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL RemoveDirectory(const std::string& path, bool recursive = false)
{
  using namespace kodi::addon;
 
  if (!recursive)
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->remove_directory(
        CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
  else
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->remove_directory_recursive(
        CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL GetDirectory(const std::string& path,
                                        const std::string& mask,
                                        std::vector<kodi::vfs::CDirEntry>& items)
{
  using namespace kodi::addon;
 
  VFSDirEntry* dir_list = nullptr;
  unsigned int num_items = 0;
  if (CPrivateBase::m_interface->toKodi->kodi_filesystem->get_directory(
          CPrivateBase::m_interface->toKodi->kodiBase, path.c_str(), mask.c_str(), &dir_list,
          &num_items))
  {
    if (dir_list)
    {
      for (unsigned int i = 0; i < num_items; ++i)
        items.emplace_back(dir_list[i]);
 
      CPrivateBase::m_interface->toKodi->kodi_filesystem->free_directory(
          CPrivateBase::m_interface->toKodi->kodiBase, dir_list, num_items);
    }
 
    return true;
  }
  return false;
}
//------------------------------------------------------------------------------
 
//}}}
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" File related functions
//{{{
 
//==============================================================================
inline bool ATTR_DLL_LOCAL FileExists(const std::string& filename, bool usecache = false)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->file_exists(
      CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), usecache);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL StatFile(const std::string& filename, kodi::vfs::FileStatus& buffer)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->stat_file(
      CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), buffer);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL DeleteFile(const std::string& filename)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->delete_file(
      CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL RenameFile(const std::string& filename, const std::string& newFileName)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->rename_file(
      CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), newFileName.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL CopyFile(const std::string& filename, const std::string& destination)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->copy_file(
      CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), destination.c_str());
}
//------------------------------------------------------------------------------
 
//}}}
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" General filesystem functions
//{{{
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetFileMD5(const std::string& path)
{
  using namespace kodi::addon;
 
  std::string strReturn;
  char* strMd5 = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_md5(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
  if (strMd5 != nullptr)
  {
    if (std::strlen(strMd5))
      strReturn = strMd5;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   strMd5);
  }
  return strReturn;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetCacheThumbName(const std::string& filename)
{
  using namespace kodi::addon;
 
  std::string strReturn;
  char* strThumbName = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_cache_thumb_name(
      CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str());
  if (strThumbName != nullptr)
  {
    if (std::strlen(strThumbName))
      strReturn = strThumbName;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   strThumbName);
  }
  return strReturn;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL MakeLegalFileName(const std::string& filename)
{
  using namespace kodi::addon;
 
  std::string strReturn;
  char* strLegalFileName = CPrivateBase::m_interface->toKodi->kodi_filesystem->make_legal_filename(
      CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str());
  if (strLegalFileName != nullptr)
  {
    if (std::strlen(strLegalFileName))
      strReturn = strLegalFileName;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   strLegalFileName);
  }
  return strReturn;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL MakeLegalPath(const std::string& path)
{
  using namespace kodi::addon;
 
  std::string strReturn;
  char* strLegalPath = CPrivateBase::m_interface->toKodi->kodi_filesystem->make_legal_path(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
  if (strLegalPath != nullptr)
  {
    if (std::strlen(strLegalPath))
      strReturn = strLegalPath;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   strLegalPath);
  }
  return strReturn;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL TranslateSpecialProtocol(const std::string& source)
{
  using namespace kodi::addon;
 
  std::string strReturn;
  char* protocol = CPrivateBase::m_interface->toKodi->kodi_filesystem->translate_special_protocol(
      CPrivateBase::m_interface->toKodi->kodiBase, source.c_str());
  if (protocol != nullptr)
  {
    if (std::strlen(protocol))
      strReturn = protocol;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   protocol);
  }
  return strReturn;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL GetDiskSpace(const std::string& path,
                                        uint64_t& capacity,
                                        uint64_t& free,
                                        uint64_t& available)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_disk_space(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str(), &capacity, &free, &available);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetFileName(const std::string& path)
{
  /* find the last slash */
  const size_t slash = path.find_last_of("/\\");
  return path.substr(slash + 1);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetDirectoryName(const std::string& path)
{
  // Will from a full filename return the directory the file resides in.
  // Keeps the final slash at end and possible |option=foo options.
 
  size_t iPosSlash = path.find_last_of("/\\");
  if (iPosSlash == std::string::npos)
    return ""; // No slash, so no path (ignore any options)
 
  size_t iPosBar = path.rfind('|');
  if (iPosBar == std::string::npos)
    return path.substr(0, iPosSlash + 1); // Only path
 
  return path.substr(0, iPosSlash + 1) + path.substr(iPosBar); // Path + options
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL RemoveSlashAtEnd(std::string& path)
{
  if (!path.empty())
  {
    char last = path[path.size() - 1];
    if (last == '/' || last == '\\')
      path.erase(path.size() - 1);
  }
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline unsigned int ATTR_DLL_LOCAL GetChunkSize(unsigned int chunk, unsigned int minimum)
{
  if (chunk)
    return chunk * ((minimum + chunk - 1) / chunk);
  else
    return minimum;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL IsInternetStream(const std::string& path, bool strictCheck = false)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_internet_stream(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str(), strictCheck);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL IsOnLAN(const std::string& path)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_on_lan(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL IsRemote(const std::string& path)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_remote(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL IsLocal(const std::string& path)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_local(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL IsURL(const std::string& path)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_url(
      CPrivateBase::m_interface->toKodi->kodiBase, path.c_str());
}
//--------------------------------------------------------------------------
 
//============================================================================
inline bool ATTR_DLL_LOCAL GetHttpHeader(const std::string& url, HttpHeader& header)
{
  using namespace ::kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_http_header(
      CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &header.m_handle);
}
//----------------------------------------------------------------------------
 
//============================================================================
inline bool ATTR_DLL_LOCAL GetMimeType(const std::string& url,
                                       std::string& mimeType,
                                       const std::string& useragent = "")
{
  using namespace ::kodi::addon;
 
  char* cMimeType = nullptr;
  bool ret = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_mime_type(
      CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &cMimeType, useragent.c_str());
  if (cMimeType != nullptr)
  {
    mimeType = cMimeType;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   cMimeType);
  }
  return ret;
}
//----------------------------------------------------------------------------
 
//============================================================================
inline bool ATTR_DLL_LOCAL GetContentType(const std::string& url,
                                          std::string& content,
                                          const std::string& useragent = "")
{
  using namespace ::kodi::addon;
 
  char* cContent = nullptr;
  bool ret = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_content_type(
      CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &cContent, useragent.c_str());
  if (cContent != nullptr)
  {
    content = cContent;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   cContent);
  }
  return ret;
}
//----------------------------------------------------------------------------
 
//============================================================================
inline bool ATTR_DLL_LOCAL GetCookies(const std::string& url, std::string& cookies)
{
  using namespace ::kodi::addon;
 
  char* cCookies = nullptr;
  bool ret = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_cookies(
      CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &cCookies);
  if (cCookies != nullptr)
  {
    cookies = cCookies;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   cCookies);
  }
  return ret;
}
//----------------------------------------------------------------------------
 
//}}}
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" CFile class
//{{{
 
//==============================================================================
class ATTR_DLL_LOCAL CFile
{
public:
  //============================================================================
  CFile() = default;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ~CFile() { Close(); }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool OpenFile(const std::string& filename, unsigned int flags = 0)
  {
    using namespace kodi::addon;
 
    Close();
    m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->open_file(
        CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), flags);
    return m_file != nullptr;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool OpenFileForWrite(const std::string& filename, bool overwrite = false)
  {
    using namespace kodi::addon;
 
    Close();
 
    // Try to open the file. If it fails, check if we need to create the directory first
    // This way we avoid checking if the directory exists every time
    m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->open_file_for_write(
        CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), overwrite);
    if (!m_file)
    {
      std::string cacheDirectory = kodi::vfs::GetDirectoryName(filename);
      if (CPrivateBase::m_interface->toKodi->kodi_filesystem->directory_exists(
              CPrivateBase::m_interface->toKodi->kodiBase, cacheDirectory.c_str()) ||
          CPrivateBase::m_interface->toKodi->kodi_filesystem->create_directory(
              CPrivateBase::m_interface->toKodi->kodiBase, cacheDirectory.c_str()))
        m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->open_file_for_write(
            CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), overwrite);
    }
    return m_file != nullptr;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool IsOpen() const { return m_file != nullptr; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  void Close()
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return;
    CPrivateBase::m_interface->toKodi->kodi_filesystem->close_file(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
    m_file = nullptr;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool CURLCreate(const std::string& url)
  {
    using namespace kodi::addon;
 
    m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->curl_create(
        CPrivateBase::m_interface->toKodi->kodiBase, url.c_str());
    return m_file != nullptr;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool CURLAddOption(CURLOptiontype type, const std::string& name, const std::string& value)
  {
    using namespace kodi::addon;
 
    if (!m_file)
    {
      kodi::Log(ADDON_LOG_ERROR, "kodi::vfs::CURLCreate(...) needed to call before!");
      return false;
    }
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->curl_add_option(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, type, name.c_str(), value.c_str());
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool CURLOpen(unsigned int flags = 0)
  {
    using namespace kodi::addon;
 
    if (!m_file)
    {
      kodi::Log(ADDON_LOG_ERROR, "kodi::vfs::CURLCreate(...) needed to call before!");
      return false;
    }
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->curl_open(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, flags);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  ssize_t Read(void* ptr, size_t size)
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return -1;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->read_file(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, ptr, size);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool ReadLine(std::string& line)
  {
    using namespace kodi::addon;
 
    line.clear();
    if (!m_file)
      return false;
    // Read 1024 chars into buffer. If file position advanced that many
    // chars, we didn't hit a newline. Otherwise, we read a newline
    // or we reached the end of the file.
    //
    // The strncpy idiom is used here (C++ allows a simpler implementation):
    //
    // char buffer[BUFFER_SIZE];
    // strncpy(buffer, sourceString, BUFFER_SIZE - 1);
    // buffer[BUFFER_SIZE - 1] = '\0';
    //
    char buffer[1025]{};
    if (CPrivateBase::m_interface->toKodi->kodi_filesystem->read_file_string(
            CPrivateBase::m_interface->toKodi->kodiBase, m_file, buffer, sizeof(buffer) - 1))
    {
      line = buffer;
      return !line.empty();
    }
    return false;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  ssize_t Write(const void* ptr, size_t size)
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return -1;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->write_file(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, ptr, size);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  void Flush()
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return;
    CPrivateBase::m_interface->toKodi->kodi_filesystem->flush_file(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  int64_t Seek(int64_t position, int whence = SEEK_SET)
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return -1;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->seek_file(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, position, whence);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  int Truncate(int64_t size)
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return -1;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->truncate_file(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, size);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  int64_t GetPosition() const
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return -1;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_position(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  int64_t GetLength() const
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return -1;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_length(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool AtEnd() const
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return true;
    int64_t length = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_length(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
    int64_t position = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_position(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
    return position >= length;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  int GetChunkSize() const
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return -1;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_chunk_size(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool IoControlGetSeekPossible() const
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return false;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_get_seek_possible(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool IoControlGetCacheStatus(CacheStatus& status) const
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return false;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_get_cache_status(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, status);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool IoControlSetCacheRate(uint32_t rate)
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return false;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_set_cache_rate(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, rate);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  bool IoControlSetRetry(bool retry)
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return false;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_set_retry(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, retry);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  const std::string GetPropertyValue(FilePropertyTypes type, const std::string& name) const
  {
    using namespace kodi::addon;
 
    if (!m_file)
    {
      kodi::Log(ADDON_LOG_ERROR,
                "kodi::vfs::CURLCreate(...) needed to call before GetPropertyValue!");
      return "";
    }
    std::vector<std::string> values = GetPropertyValues(type, name);
    if (values.empty())
    {
      return "";
    }
    return values[0];
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  const std::vector<std::string> GetPropertyValues(FilePropertyTypes type,
                                                   const std::string& name) const
  {
    using namespace kodi::addon;
 
    if (!m_file)
    {
      kodi::Log(ADDON_LOG_ERROR,
                "kodi::vfs::CURLCreate(...) needed to call before GetPropertyValues!");
      return std::vector<std::string>();
    }
    int numValues = 0;
    char** res(CPrivateBase::m_interface->toKodi->kodi_filesystem->get_property_values(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file, type, name.c_str(), &numValues));
    if (res)
    {
      std::vector<std::string> vecReturn;
      vecReturn.reserve(numValues);
      for (int i = 0; i < numValues; ++i)
      {
        vecReturn.emplace_back(res[i]);
      }
      CPrivateBase::m_interface->toKodi->free_string_array(
          CPrivateBase::m_interface->toKodi->kodiBase, res, numValues);
      return vecReturn;
    }
    return std::vector<std::string>();
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  double GetFileDownloadSpeed() const
  {
    using namespace kodi::addon;
 
    if (!m_file)
      return 0.0;
    return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_download_speed(
        CPrivateBase::m_interface->toKodi->kodiBase, m_file);
  }
  //--------------------------------------------------------------------------
 
private:
  void* m_file = nullptr;
};
//------------------------------------------------------------------------------
 
//}}}
 
} /* namespace vfs */
} /* namespace kodi */
 
#endif /* __cplusplus */