handlers.hpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef INC_HANDLERS_HPP_48EADBB6_2C70_45A8_B132_289939A427CC
#define INC_HANDLERS_HPP_48EADBB6_2C70_45A8_B132_289939A427CC
 
//---------------------------------------------------------------------------
// #include <string>  // Included in "libxcks/types.hpp"
// #include <filesystem>  // Included in "libxcks/types.hpp"
#include <ctime>
 
#include "libxcks/export.hpp"
// #include "libxcks/types.hpp"  // Included in "libxcks/ckvalue.hpp"
#include "libxcks/defs.hpp"
#include "libxcks/ckvalue.hpp"
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
//###########################################################################
// XCKS reader handlers.
//###########################################################################
 
class LIBXCKS_SO_EXPORT XCKSReaderHandler
{
 public:
  virtual ~XCKSReaderHandler() = default;
 
  virtual void onChecksumsFile(const std::string& version) = 0;
 
  virtual void onGenerated(const std::string& by, const std::string& version,
                           const std::time_t on) = 0;
 
  virtual void onAlgorithm(const ChecksumAlgoId type) = 0;
 
  virtual void onAlgorithmsStart() = 0;
 
  virtual void onAlgorithmsEnd() = 0;
 
  virtual void onAlgorithms(const ArrayChecksumAlgoId& types) = 0;
 
  virtual void onLocalFilesStart() = 0;
 
  virtual void onLocalFilesEnd() = 0;
 
  virtual void onParentDirectoryStart() = 0;
 
  virtual void onParentDirectoryStart(const std::filesystem::path& path) = 0;
 
  virtual void onParentDirectoryEnd() = 0;
 
  virtual void onDirectoryStart(const std::string name) = 0;
 
  virtual void onDirectoryStart(const std::filesystem::path& path) = 0;
 
  virtual void onDirectoryEnd() = 0;
 
  virtual void onFileStart(const std::string name) = 0;
 
  virtual void onFileStart(const std::filesystem::path& path) = 0;
 
  virtual void onFileEnd() = 0;
 
  virtual void onFileInformation(const uintmax_t size = Invalid_File_Size,
                                 const time_t date = Invalid_DateTime) = 0;
 
  virtual void onFileChecksum(const ChecksumValue& value) = 0;
 
  virtual void onFile(const std::filesystem::path& path,
                      const ArrayChecksumValue& checksums,
                      const uintmax_t size = Invalid_File_Size,
                      const time_t date = Invalid_DateTime) = 0;
 
  virtual void onFatalError(const std::string& errorMessage, int line, int column) = 0;
};
//---------------------------------------------------------------------------
 
 
class LIBXCKS_SO_EXPORT XCKSReaderDefaultHandler : public XCKSReaderHandler
{
 public:
  virtual ~XCKSReaderDefaultHandler() = default;
 
  void onChecksumsFile(const std::string& version) override {}
 
  void onGenerated(const std::string& by, const std::string& version,
                   const std::time_t on) override {}
 
  void onAlgorithm(const ChecksumAlgoId type) override {}
 
  void onAlgorithmsStart() override {}
 
  void onAlgorithmsEnd() override {}
 
  void onAlgorithms(const ArrayChecksumAlgoId& types) override {}
 
  void onLocalFilesStart() override {}
 
  void onLocalFilesEnd() override {}
 
  void onParentDirectoryStart() override {}
 
  void onParentDirectoryStart(const std::filesystem::path& path) override {}
 
  void onParentDirectoryEnd() override {}
 
  void onDirectoryStart(const std::string name) override {}
 
  void onDirectoryStart(const std::filesystem::path& path) override {}
 
  void onDirectoryEnd() override {}
 
  void onFileStart(const std::string name) override {}
 
  void onFileStart(const std::filesystem::path& path) override {}
 
  void onFileEnd() override {}
 
  void onFileInformation(const uintmax_t size = Invalid_File_Size,
                         const time_t date = Invalid_DateTime) override {}
 
  void onFileChecksum(const ChecksumValue& value) override {}
 
  void onFile(const std::filesystem::path& path,
              const ArrayChecksumValue& checksums,
              const uintmax_t size = Invalid_File_Size,
              const time_t date = Invalid_DateTime) override {}
 
  void onFatalError(const std::string& errorMessage, int line, int column) override {}
};
//---------------------------------------------------------------------------
 
 
 
 
//###########################################################################
// XCKS writer handlers.
//###########################################################################
 
class LIBXCKS_SO_EXPORT XCKSWriterChecksumProvider
{
 public:
  enum class Status : int
  {
    Ok,                 
    FileNotFound,       
    ReadError,          
    BadChecksumValue,   
    BadDuplicateValue,  
    MissingAlgorithm,   
  };
 
  XCKSWriterChecksumProvider() = default;
 
  virtual ~XCKSWriterChecksumProvider() = default;
 
  virtual Status getChecksumValues(ArrayChecksumValue& sumValues,
                                   uintmax_t& filesize,
                                   time_t& filedatetime,
                                   const ArrayChecksumAlgoId& ids,
                                   const std::filesystem::path& filepath) = 0;
};
//---------------------------------------------------------------------------
 
 
class LIBXCKS_SO_EXPORT XCKSWriterHandler
{
 public:
  virtual ~XCKSWriterHandler() = default;
 
  virtual void onChecksumsFileStart(const std::string& version) = 0;
 
  virtual void onChecksumsFileEnd() = 0;
 
  virtual void onGenerated(const std::string& by, const std::string& version,
                           const std::time_t on) = 0;
 
  virtual void onAlgorithm(const ChecksumAlgoId type) = 0;
 
  virtual void onAlgorithmsStart() = 0;
 
  virtual void onAlgorithmsEnd() = 0;
 
  virtual void onAlgorithms(const ArrayChecksumAlgoId& types) = 0;
 
  virtual void onLocalFilesStart() = 0;
 
  virtual void onLocalFilesEnd() = 0;
 
  virtual void onParentDirectoryStart() = 0;
 
  virtual void onParentDirectoryStart(const std::filesystem::path& path) = 0;
 
  virtual void onParentDirectoryEnd() = 0;
 
  virtual void onDirectoryStart(const std::string name) = 0;
 
  virtual void onDirectoryStart(const std::filesystem::path& path) = 0;
 
  virtual void onDirectoryEnd() = 0;
 
  virtual void onFileStart(const std::string name) = 0;
 
  virtual void onFileStart(const std::filesystem::path& path) = 0;
 
  virtual void onFileEnd() = 0;
 
  virtual void onFileInformation(const uintmax_t size = Invalid_File_Size,
                                 const time_t date = Invalid_DateTime) = 0;
 
  virtual void onFileChecksum(const ChecksumValue& value) = 0;
 
  virtual void onFile(const std::filesystem::path& path,
                      const ArrayChecksumValue& checksums,
                      const uintmax_t size = Invalid_File_Size,
                      const time_t date = Invalid_DateTime) = 0;
 
  virtual void onFileGetChecksumsError(const std::filesystem::path& relativePath,
                                       const std::filesystem::path& absolutePath,
                                       const XCKSWriterChecksumProvider::Status status,
                                       bool& stopWriting,
                                       const ChecksumAlgoId algoId = ChecksumAlgoId::Invalid) = 0;
 
  virtual void onFileGetChecksumError(const std::filesystem::path& relativePath,
                                      const std::filesystem::path& absolutePath,
                                      const XCKSWriterChecksumProvider::Status status,
                                      const ChecksumValue& ckValue) = 0;
 
  virtual void onFatalError(const std::string& errorMessage) = 0;
};
//---------------------------------------------------------------------------
 
 
class LIBXCKS_SO_EXPORT XCKSWriterDefaultHandler : public XCKSWriterHandler
{
 public:
  virtual ~XCKSWriterDefaultHandler() = default;
 
  void onChecksumsFileStart(const std::string& version) override {}
 
  void onChecksumsFileEnd() override {}
 
  void onGenerated(const std::string& by, const std::string& version,
                   const std::time_t on) override {}
 
  void onAlgorithm(const ChecksumAlgoId type) override {}
 
  void onAlgorithmsStart() override {}
 
  void onAlgorithmsEnd() override {}
 
  void onAlgorithms(const ArrayChecksumAlgoId& types) override {}
 
  void onLocalFilesStart() override {}
 
  void onLocalFilesEnd() override {}
 
  void onParentDirectoryStart() override {}
 
  void onParentDirectoryStart(const std::filesystem::path& path) override {}
 
  void onParentDirectoryEnd() override {}
 
  void onDirectoryStart(const std::string name) override {}
 
  void onDirectoryStart(const std::filesystem::path& path) override {}
 
  void onDirectoryEnd() override {}
 
  void onFileStart(const std::string name) override {}
 
  void onFileStart(const std::filesystem::path& path) override {}
 
  void onFileEnd() override {}
 
  void onFileInformation(const uintmax_t size = Invalid_File_Size,
                         const time_t date = Invalid_DateTime) override {}
 
  void onFileChecksum(const ChecksumValue& value) override {}
 
  void onFile(const std::filesystem::path& path,
              const ArrayChecksumValue& checksums,
              const uintmax_t size = Invalid_File_Size,
              const time_t date = Invalid_DateTime) override {}
 
  void onFileGetChecksumsError(const std::filesystem::path& relativePath,
                               const std::filesystem::path& absolutePath,
                               const XCKSWriterChecksumProvider::Status status,
                               bool& stopWriting,
                               const ChecksumAlgoId algoId = ChecksumAlgoId::Invalid) override {}
 
  void onFileGetChecksumError(const std::filesystem::path& relativePath,
                              const std::filesystem::path& absolutePath,
                              const XCKSWriterChecksumProvider::Status status,
                              const ChecksumValue& ckValue) override {}
 
  void onFatalError(const std::string& errorMessage) override {}
};
//---------------------------------------------------------------------------
 
 
 
class LIBXCKS_SO_EXPORT XCKSWriterOptions
{
 private:
  bool writeGenerated;       
  bool writeSizeOfFile;      
  bool writeDateTimeOfFile;  
 
  bool compactXML;     
  bool tabsforIndent;  
  unsigned int indentSpaces;  
 
  bool checkReturnedCks;         
  std::string appWriter;         
  std::string appWriterVersion;  
  bool writeLibXCKSVer;          
 
  static constexpr unsigned int max_indent_spaces = 16u;     
 protected:
  static constexpr unsigned int default_indent_spaces = 2u;  
 
 public:
  XCKSWriterOptions(const bool writeGeneratedElement = true,
                    const bool writeFileSize = true,
                    const bool writeFileDateTime = true,
                    const bool useCompactXML = false,
                    const bool useTabsforIndentation = false,
                    const unsigned int nbIndentSpaces = default_indent_spaces,
                    const bool checkReturnedChecksums = true,
                    const std::string applicationWriter = std::string(),
                    const std::string applicationVersion = std::string(),
                    const bool writeLibXCKSVersion = false);
 
  virtual ~XCKSWriterOptions() = default;
 
  virtual bool writeGeneratedElement() const final { return writeGenerated; }
 
  virtual void setWriteGeneratedElement(const bool writeGeneratedElement) final { writeGenerated = writeGeneratedElement; }
 
  virtual bool writeFileSize() const final { return writeSizeOfFile; }
 
  virtual void setWriteFileSize(const bool writeFileSize) final { writeSizeOfFile = writeFileSize; }
 
  virtual bool writeFileDateTime() const final { return writeDateTimeOfFile; }
 
  virtual void setWriteFileDateTime(const bool writeFileDateTime) final { writeDateTimeOfFile = writeFileDateTime; }
 
  virtual bool useCompactXML() const final { return compactXML; }
 
  virtual void setUseCompactXML(const bool useCompactXML) final { compactXML = useCompactXML; }
 
  virtual bool useTabsforIndentation() const final { return tabsforIndent; }
 
  virtual void setUseTabsforIndentation(const bool useTabsforIndentation) final { tabsforIndent = useTabsforIndentation; }
 
  virtual unsigned int getIndentSpaces() const final { return indentSpaces; }
 
  virtual void setIndentSpaces(const unsigned int nbIndentSpaces) final;
 
  virtual bool checkReturnedChecksums() const final { return checkReturnedCks; }
 
  virtual void setCheckReturnedChecksums(const bool checkReturnedChecksums) final { checkReturnedCks = checkReturnedChecksums; }
 
  virtual std::string getApplicationWriter() const final { return appWriter; }
 
  virtual void setApplicationWriter(const std::string& applicationWriter) final { appWriter = applicationWriter; }
 
  virtual std::string getApplicationWriterVersion() const final { return appWriterVersion; }
 
  virtual void setApplicationWriterVersion(const std::string& applicationVersion) final { appWriterVersion = applicationVersion; }
 
  virtual bool writeLibXCKSVersion() const final { return writeLibXCKSVer; }
 
  virtual void setWriteLibXCKSVersion(const bool writeLibXCKSVersion) final { writeLibXCKSVer = writeLibXCKSVersion; }
};
//---------------------------------------------------------------------------
 
 
class LIBXCKS_SO_EXPORT ZXCKSWriterOptions : public XCKSWriterOptions
{
 private:
  int compressionLevel;      
 
 public:
  static constexpr int min_compression_level = 1;      
  static constexpr int max_compression_level = 9;      
  static constexpr int default_compression_level = max_compression_level;  
 
  ZXCKSWriterOptions(const bool writeGeneratedElement = true,
                     const bool writeFileSize = true,
                     const bool writeFileDateTime = true,
                     const bool useCompactXML = true,
                     const bool useTabsforIndentation = false,
                     const unsigned int nbIndentSpaces = default_indent_spaces,
                     const bool checkReturnedChecksums = true,
                     const std::string applicationWriter = std::string(),
                     const std::string applicationVersion = std::string(),
                     const bool writeLibXCKSVersion = false,
                     const int compressionLevel = default_compression_level);
 
  virtual ~ZXCKSWriterOptions() = default;
 
  virtual int getCompressionLevel() const final { return compressionLevel; }
 
  virtual void setCompressionLevel(const int level) final;
};
//---------------------------------------------------------------------------
 
 
}  // namespace libxcks
//---------------------------------------------------------------------------
 
#endif  // INC_HANDLERS_HPP_48EADBB6_2C70_45A8_B132_289939A427CC