xcksfilewriter.cpp

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/>.
 */
 
//---------------------------------------------------------------------------
#include <boost/locale.hpp>
#include <algorithm>
//#include <filesystem>  // Included in "pathutil.hpp"
//#include <string>  // Included in "libxcks/version.hpp"
#include <iomanip>
#include <sstream>
#include <ctime>
#include <cassert>
 
#include "xcksfilewriter.hpp"
// #include "libxcks/types.hpp"  // Included in "libxcks/ckvalue.hpp"
#include "libxcks/defs.hpp"
#include "libxcks/version.hpp"
#include "libxcks/ckfactory.hpp"
#include "libxcks/xcksver.hpp"
// #include "libxcks/ckvalue.hpp"  // Included in "libxcks/ckfactory.hpp"
#include "pathutil.hpp"
#include "strutil.hpp"
//---------------------------------------------------------------------------
 
using namespace std;
 
// The Boost.Locale namespace.
using namespace boost::locale;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
//###########################################################################
// XCKSDirTree definition.
//###########################################################################
 
class XCKSDirStruct final
{
 protected:
  class Element;    // Element of the directories structure.
  class File;       // File of the directories structure.
  class Directory;  // Directory of the directories structure.
 
  Element* root;  
 
 public:
  class const_file_iterator;  // Iterator on files.
 
  XCKSDirStruct() : root(nullptr) {}
 
  XCKSDirStruct(const XCKSDirStruct&) = delete;
 
  XCKSDirStruct& operator=(const XCKSDirStruct&) = delete;
 
  // Returns an iterator pointing at the first file of the directory structure.
  const_file_iterator files_begin() const;
 
  // Returns an iterator pointing at the one-after-the-last file of directory structure.
  inline const_file_iterator files_end() const;
 
  // Adds a new file in the directory structure.
  bool addFile(const filesystem::path& filename, void* data = nullptr);
};
//---------------------------------------------------------------------------
 
 
class XCKSDirStruct::Element
{
 private:
  friend class XCKSDirStruct::const_file_iterator;
 
 protected:
  string   name;      
  Element* parent;    
  Element* previous;  
  Element* next;      
 
 public:
  Element() = delete;
 
  Element(const Element&) = delete;
 
  Element& operator=(const Element&) = delete;
 
  // Constructor.
  Element(const string& elementName, Element* parentElement, Element* previousElement);
 
  // Destructor.
  virtual ~Element();
 
  virtual bool hasChild() const { return false; }
 
  virtual bool hasPrevious() const final { return previous != nullptr; }
 
  virtual bool hasNext() const final { return next != nullptr; }
 
  virtual bool hasParent() const final { return parent != nullptr; }
 
  virtual bool isAFile() const = 0;
 
  // Does an element exist with the given name in the current level.
  virtual bool hasElement(const string& elementName) const final;
 
  virtual string getName() const final { return name; }
 
  virtual Element* getChild() const { return nullptr; }
 
  virtual void setChild(Element* newChild) { assert(false); /*"setChild() called on bad element type.";*/ }
 
  virtual Element* getPrevious() const final { return previous; }
 
  virtual void setPrevious(Element* newPrevious) final { previous = newPrevious; }
 
  virtual Element* getNext() const final { return next; }
 
  virtual void setNext(Element* newNext) final { next = newNext; }
 
  virtual Element* getParent() const final { return parent; }
 
  virtual void getParent(Element* newParent) final { parent = newParent; }
 
  virtual void* getData() const { return nullptr; }
 
  virtual void setData(void* newData) { assert(false); /* setData() called on bad element type. */ }
 
  // Gets the element with the given name in the current level.
  virtual Element* getElement(const string& elementName, Element** lastElement = nullptr) const final;
 
  // Adds a new file in the directory structure.
  bool addFile(const ArrayString& dirs, const size_t cur, const string& filename, void* data = nullptr);
 
 protected:
  // Creates the directory structure for the file.
  Element* createDirsAndAddFile(const ArrayString& dirs, const size_t cur, const string& filename, void* data = nullptr);
 
  // Gets the next file in the directory structure.
  XCKSDirStruct::File* getNextFileRec() const;
 
  // Gets the next file in the directory structure.
  XCKSDirStruct::File* getNextFile(const bool calledFromChild) const;
 
 public:
  // Gets the next file in the directory structure.
  XCKSDirStruct::File* getNextFile() const;
};
//---------------------------------------------------------------------------
 
 
class XCKSDirStruct::File final : public XCKSDirStruct::Element
{
 protected:
  void* data;   
 
 public:
  File() = delete;
 
  File(const File&) = delete;
 
  File& operator=(const File&) = delete;
 
  // Constructor.
  File(const string& elementName, XCKSDirStruct::Element* parentElement,
       XCKSDirStruct::Element* previousElement, void* elementData = nullptr);
 
  virtual ~File() {}
 
  bool isAFile() const override final { return true; };
 
  void* getData() const override { return data; }
 
  void setData(void* newData) override final { data = newData; }
};
//---------------------------------------------------------------------------
 
 
class XCKSDirStruct::Directory final : public XCKSDirStruct::Element
{
 protected:
  Element* child;   
 
 public:
  Directory() = delete;
 
  Directory(const Directory&) = delete;
 
  Directory& operator=(const Directory&) = delete;
 
  // Constructor.
  Directory(const string& directoryName, XCKSDirStruct::Element* parentElement, XCKSDirStruct::Element* previousElement);
 
  virtual ~Directory() {}
 
  bool hasChild() const override final { return child != nullptr; }
 
  bool isAFile() const  override final { return false; }
 
  Element* getChild() const override final { return child; }
 
  void setChild(Element* newChild) override final { child = newChild; }
};
//---------------------------------------------------------------------------
 
 
class XCKSDirStruct::const_file_iterator
{
 protected:
  XCKSDirStruct::File* file;  
 
 public:
  const_file_iterator() : file(nullptr) {}
 
  const_file_iterator(const const_file_iterator&) = default;
 
  const_file_iterator& operator=(const const_file_iterator&) = default;
 
  const_file_iterator(XCKSDirStruct::File* initFile) : file(initFile) {}
 
 protected:
  inline void plusPlus()
  {
    if (file != nullptr)
      file = file->getNextFile();
  }
 
 public:
  bool operator==(const const_file_iterator& it) const { return this->file == it.file; }
 
  bool operator!=(const const_file_iterator& it) const { return this->file != it.file; }
 
  const_file_iterator& operator++() { plusPlus(); return *this; }
 
  const_file_iterator operator++(int) { const_file_iterator it = *this; plusPlus(); return it; }
 
  const XCKSDirStruct::File& operator*() const { return *file; }
 
  const XCKSDirStruct::File* operator->() const { return file; }
};
//---------------------------------------------------------------------------
 
 
//###########################################################################
// XCKSDirTree implementation.
//###########################################################################
 
XCKSDirStruct::const_file_iterator XCKSDirStruct::files_begin() const
{
  if (root == nullptr)
    return const_file_iterator();
  else
  {
    XCKSDirStruct::File* f;
    if (root->isAFile())
      f = dynamic_cast<XCKSDirStruct::File*>(root);
    else
      f = root->getNextFile();
    assert(f != nullptr);  // "The file element shouldn't be null."
 
    return const_file_iterator(f);
  }
}
//---------------------------------------------------------------------------
 
 
inline XCKSDirStruct::const_file_iterator XCKSDirStruct::files_end() const
{
  return const_file_iterator();
}
//---------------------------------------------------------------------------
 
 
bool XCKSDirStruct::addFile(const filesystem::path& filename, void* data)
{
  ArrayString dirs = getDirectoriesAsArrayString(filename);
 
  if (root == nullptr)
  {
    if (dirs.size() > 0)  // add directory
    {
      root = new XCKSDirStruct::Directory(dirs[0], nullptr, nullptr);
      return root->addFile(dirs, 0, from_u8string(filename.filename().u8string()), data);
    }
    else
    {
      root = new XCKSDirStruct::File(from_u8string(filename.filename().u8string()), nullptr, nullptr, data);
      return true;
    }
  }
  else
    return root->addFile(dirs, 0, from_u8string(filename.filename().u8string()), data);
}
//---------------------------------------------------------------------------
 
 
//###########################################################################
// XCKSDirTree::Element implementation.
//###########################################################################
 
XCKSDirStruct::Element::Element(const string& elementName,
                                XCKSDirStruct::Element* parentElement,
                                XCKSDirStruct::Element* previousElement) :
                                                     name(elementName),
                                                     parent(parentElement),
                                                     previous(previousElement),
                                                     next(nullptr)
{
}
//---------------------------------------------------------------------------
 
 
XCKSDirStruct::Element::~Element()
{
  if (hasChild())
    delete getChild();
  if (hasNext())
    delete getNext();
}
//---------------------------------------------------------------------------
 
 
bool XCKSDirStruct::Element::hasElement(const string& elementName) const
{
  Element* e = const_cast<Element*>(this);
  bool found = false;
 
  while (!found && e != nullptr)
  {
    if (compareFileName(e->getName(), elementName) == 0)
      found = true;
    else
      e = e->getNext();
  }
 
  return true;
}
//---------------------------------------------------------------------------
 
 
XCKSDirStruct::Element* XCKSDirStruct::Element::getElement(const string& elementName, XCKSDirStruct::Element** lastElement) const
{
  Element* e = const_cast<Element*>(this);
  Element* r = nullptr;
 
  while ((r == nullptr) && (e != nullptr))
  {
    if (compareFileName(e->getName(), elementName) == 0)
      r = e;
    else
    {
      if (e->getNext() == nullptr)
      {
        if (lastElement != nullptr)
          *lastElement = e;
        e = nullptr;
      }
      else
        e = e->getNext();
    }
  }
 
  return r;
}
//---------------------------------------------------------------------------
 
 
bool XCKSDirStruct::Element::addFile(const ArrayString& dirs, const size_t cur, const string& filename, void* data)
{
  bool addDir = cur < dirs.size();
  const string& fn = addDir ? dirs[cur] : filename;
  bool res;
 
  Element* last;  // last element of the current level
  Element* n;     // new element
  Element* e = this->getElement(fn, &last);
  if (addDir)
  {
    if (e == nullptr)
    {
      n = new XCKSDirStruct::Directory(fn, this->getParent(), last);
      assert(last->getNext() == nullptr);  // "Last element have a next element."
      last->setNext(n);
      n->setChild(n->createDirsAndAddFile(dirs, cur + 1, filename, data));
      return true;
    }
    else
    {
      if (e->isAFile())
        res = false;
      else
      {
        if (e->hasChild())
          res = e->getChild()->addFile(dirs, cur + 1, filename, data);
        else
        {
          e->setChild(e->createDirsAndAddFile(dirs, cur + 1, filename, data));
          return true;
        }
      }
    }
  }
  else
  {
    if (e == nullptr)
    {
      n = new XCKSDirStruct::File(fn, this->getParent(), last, data);
      assert(last->getNext() == nullptr);  // "Last element have a next element."
      last->setNext(n);
      return true;
    }
    else  // already existing
    {
      res = false;
    }
  }
 
  return res;
}
//---------------------------------------------------------------------------
 
 
XCKSDirStruct::Element* XCKSDirStruct::Element::createDirsAndAddFile(const ArrayString& dirs,
                                                                     const size_t cur,
                                                                     const string& filename,
                                                                     void* data)
{
  bool addDir = cur < dirs.size();
  const string& fn = addDir ? dirs[cur] : filename;
 
  Element* n;  // new element
  if (addDir)
  {
    n = new XCKSDirStruct::Directory(fn, this, nullptr);
    n->setChild(n->createDirsAndAddFile(dirs, cur + 1, filename, data));
  }
  else
    n = new XCKSDirStruct::File(fn, this, nullptr, data);
 
  return n;
}
//---------------------------------------------------------------------------
 
 
XCKSDirStruct::File* XCKSDirStruct::Element::getNextFileRec() const
{
  XCKSDirStruct::File* next;
 
  if (this->isAFile())
  {
    next = dynamic_cast<XCKSDirStruct::File*>(const_cast<XCKSDirStruct::Element*>(this));
    assert(next != nullptr); //  "The element should cast to XCKSDirStruct::File*."
  }
  else
  {
    if (this->hasChild())
    {
      next = this->getChild()->getNextFileRec();
      assert(next != nullptr);  // "A directory element should have at least a file in its children."
    }
    else if (this->hasNext())
    {
      next = this->getNext()->getNextFileRec();
      assert(next != nullptr);  // "An element with a next element should have at least a file in its successors."
    }
    else
    {
      next = nullptr;
      assert(false);  // "A directory element should have at least a file in its children."
    }
  }
 
  return next;
}
//---------------------------------------------------------------------------
 
 
XCKSDirStruct::File* XCKSDirStruct::Element::getNextFile(const bool calledFromChild) const
{
  XCKSDirStruct::File* next;
//const string name = this->getName();
 
  if (calledFromChild)
  {
    if (this->hasNext())
    {
      next = this->getNext()->getNextFileRec();
      assert(next != nullptr);  // "An element with a next element should have at least a file in its successors."
    }
    else
    {
      if (this->hasParent())
        next = this->getParent()->getNextFile(true);
      else
        next = nullptr;
    }
  }
  else  // !calledFromChild
  {
    if (this->hasChild())
    {
      next = this->getChild()->getNextFileRec();
      assert(next != nullptr);  // "A directory element should have at least a file in its children."
    }
    else
    {
      if (this->hasNext())
      {
        next = this->getNext()->getNextFileRec();
        assert(next != nullptr);  // "An element with a next element should have at least a file in its successors."
      }
      else
      {
        if (this->hasParent())
          next = this->getParent()->getNextFile(true);
        else
          next = nullptr;
      }
    }
  }
 
  return next;
}
//---------------------------------------------------------------------------
 
 
XCKSDirStruct::File* XCKSDirStruct::Element::getNextFile() const
{
  return this->getNextFile(false);
}
//---------------------------------------------------------------------------
 
 
//###########################################################################
// XCKSDirTree::File implementation.
//###########################################################################
 
XCKSDirStruct::File::File(const string& fileName,
                          XCKSDirStruct::Element* parentElement,
                          XCKSDirStruct::Element* previousElement,
                          void* elementData) :
                                        XCKSDirStruct::Element(fileName,
                                                               parentElement,
                                                               previousElement),
                                        data(elementData)
{
}
//---------------------------------------------------------------------------
 
 
//###########################################################################
// XCKSDirTree::Directory implementation.
//###########################################################################
 
XCKSDirStruct::Directory::Directory(const string& fileName,
                                    XCKSDirStruct::Element* parentElement,
                                    XCKSDirStruct::Element* previousElement) :
                                        XCKSDirStruct::Element(fileName,
                                                               parentElement,
                                                               previousElement),
                                        child(nullptr)
{
}
//---------------------------------------------------------------------------
 
 
//###########################################################################
// XCKSDirTree::const_file_iterator implementation.
//###########################################################################
 
 
//---------------------------------------------------------------------------
 
 
 
 
 
//###########################################################################
// XCKSFileBase implementation.
//###########################################################################
 
const string XCKSFileWriter::parentDir = "..";
//---------------------------------------------------------------------------
 
 
XCKSFileWriter::XCKSFileWriter(XCKSWriterHandler& xcksWriterHandler,
                               XCKSWriterChecksumProvider& checksumProvider,
                               const XCKSWriterOptions& options,
                               const std::filesystem::path& baseDir,
                               const ArrayChecksumAlgoId& algoIds,
                               const ChecksumFormatter::ConfigurationProvider& confProvider,
                               Version version) :
                                 writerHandler(xcksWriterHandler),
                                 ckProvider(checksumProvider),
                                 writerOptions(options),
                                 baseDirectory(baseDir),
                                 version(getValidVersion(version)),
                                 possibleSumsAlgos(getAvailableChecksumTypesName()),
                                 sumsAlgos(getValidChecksumTypesForNewEntries(algoIds)),
                                 ckfConfProvider(confProvider)
{
  assert(baseDir.is_absolute());
  if (sumsAlgos.empty())
    writerHandler.onFatalError(translate("No valid algorithm of checksum provided.").str(libxcks_domain));
}
//---------------------------------------------------------------------------
 
 
XCKSFileWriter::~XCKSFileWriter()
{
}
//---------------------------------------------------------------------------
 
 
StringSet XCKSFileWriter::getAvailableChecksumTypesName() const
{
  return getAvailableAlgorithmNames(getVersion());
}
//---------------------------------------------------------------------------
 
 
ArrayChecksumAlgoId XCKSFileWriter::getAvailableChecksumTypes() const
{
  ArrayChecksumAlgoId ids;
  for (const string& algoName : possibleSumsAlgos)
  {
    ChecksumAlgoId id;
    if (ChecksumFactory::getAlgorithmId(id, algoName, true))
      ids.push_back(id);
  }
 
  assert(ids.size() == possibleSumsAlgos.size());
 
  return ids;
}
//---------------------------------------------------------------------------
 
 
ArrayChecksumAlgoId XCKSFileWriter::getChecksumTypesForNewEntries() const
{
  return sumsAlgos;
}
//---------------------------------------------------------------------------
 
 
Version XCKSFileWriter::getVersion() const
{
  return version;
}
//---------------------------------------------------------------------------
 
 
void XCKSFileWriter::getVersion(unsigned int& major, unsigned int& minor, unsigned int& revision) const
{
  switch (getVersion())
  {
    case Version::V1_0_0 :
      major = 1u;
      minor = 0u;
      revision = 0u;
      break;
  }
}
//---------------------------------------------------------------------------
 
 
string XCKSFileWriter::getStrVersion() const
{
  unsigned int major, minor, revision;
  getVersion(major, minor, revision);
  return to_string(major) + '.' + to_string(minor) + '.' + to_string(revision);
}
//---------------------------------------------------------------------------
 
 
bool XCKSFileWriter::write(ostream& os, const ArrayPath& relativePaths)
{
  if (sumsAlgos.empty())
    return false;
 
  bool ok;
  unsigned int major, minor, revision;
  getVersion(major, minor, revision);
  if (major == 1)
    ok = writeV1(os, relativePaths);
  else
  {
    assert(false);  // "Unexpected XCKS version."
    writerHandler.onFatalError((format(translate("Unexpected XCKS version: {1}.").str(libxcks_domain)) % getStrVersion()).str());
    return false;
  }
 
  if (!ok)
    writerHandler.onFatalError(translate("Error while writing the XCKS file.").str(libxcks_domain));
 
  return ok;
}
//---------------------------------------------------------------------------
 
 
Version XCKSFileWriter::getValidVersion(const Version ver)
{
  if (ver >= Version::First_Valid && ver <= Version::Last_Valid)
    return ver;
  else
    return Version::Last_Valid;
}
//---------------------------------------------------------------------------
 
 
ArrayChecksumAlgoId XCKSFileWriter::getValidChecksumTypesForNewEntries(const ArrayChecksumAlgoId& ids) const
{
  const ArrayChecksumAlgoId aIds = getAvailableChecksumTypes();
  ArrayChecksumAlgoId res = ids;
 
  // Removes all duplicates values.
  /*sort(res.begin(), res.end());
  ArrayChecksumAlgoId::iterator last = unique(res.begin(), res.end());
  res.erase(last, res.end());*/
  // Want to keep the order.
  size_t i = 0;
  while (i < res.size())
  {
    size_t j = i + 1;
    while (j < res.size())
    {
      if (res[j] == res[i])
        res.erase(res.begin() + j);
      else
        j++;
    }
    i++;
  }
 
  // Check if remaining algorithms of checksums are valid.
  i = 0;
  while (i < res.size())
  {
    ArrayChecksumAlgoId::const_iterator a = find(aIds.cbegin(), aIds.cend(), res[i]);
    if (a == aIds.cend())
      res.erase(res.begin() + i);
    else
      i++;
  }
 
  return res;
}
//---------------------------------------------------------------------------
 
 
XCKSWriterChecksumProvider::Status XCKSFileWriter::getChecksumValues(ArrayChecksumValue& ckValues,
                                       uintmax_t& filesize,
                                       time_t& filedatetime,
                                       const ArrayChecksumAlgoId& ids,
                                       const filesystem::path& filePath,
                                       bool& stopWriting) const
{
  using Status = XCKSWriterChecksumProvider::Status;
  Status status = ckProvider.getChecksumValues(ckValues, filesize, filedatetime, sumsAlgos,
                                               (baseDirectory / filePath).lexically_normal());
  if (status == Status::Ok || status == Status::MissingAlgorithm)
  {
    // Checks if all asked values have been returned.
    ArrayChecksumAlgoId diff;
    for (const ChecksumAlgoId id : ids)
    {
      if (find_if(ckValues.cbegin(), ckValues.cend(), [&](const ChecksumValue& ckv) { return ckv.getType() == id; }) == ckValues.cend())
        diff.push_back(id);
    }
    if (!diff.empty())
    {
      status = Status::MissingAlgorithm;
      for (const ChecksumAlgoId id : diff)
        writerHandler.onFileGetChecksumsError(filePath, (baseDirectory / filePath).lexically_normal(),
                                              status, stopWriting, id);
    }
 
    // Removing all unasked algorithms.
    if (status == Status::Ok && ckValues.size() > ids.size())
    {
      size_t i = 0;
      while (i < ckValues.size())
      {
        if (find(ids.cbegin(), ids.cend(), ckValues[i].getType()) == ids.cend())
          ckValues.erase(ckValues.begin() + i);
        else
          i++;
      }
    }
 
    // Checks the returned values.
    if (status == Status::Ok && writerOptions.checkReturnedChecksums())
    {
      for (const ChecksumValue& ckv : ckValues)
      {
        if (ckv.getSize() != ChecksumFactory::getSize(ckv.getType()))
        {
          status = Status::BadChecksumValue;
 
          writerHandler.onFileGetChecksumError(filePath, (baseDirectory / filePath).lexically_normal(),
                                               status, ckv);
        }
      }
    }
 
    // Checks and removes duplicates values.
    if (status == Status::Ok && writerOptions.checkReturnedChecksums() && ckValues.size() > ids.size())
    {
      size_t i = 0;
      while (i < ckValues.size())
      {
        const ChecksumValue& ckv = ckValues[i];
        size_t j = i + 1;
        while (j < ckValues.size())
        {
          if (ckv.getType() == ckValues[j].getType())
          {
            if (ckv == ckValues[j])
              ckValues.erase(ckValues.begin() + j);
            else
            {
              status = Status::BadDuplicateValue;
              writerHandler.onFileGetChecksumError(filePath, (baseDirectory / filePath).lexically_normal(),
                                                   status, ckv);
              j++;
            }
          }
          else
            j++;
        }
        i++;
      }
    }
  }
  else
  {
    writerHandler.onFileGetChecksumsError(filePath, (baseDirectory / filePath).lexically_normal(),
                                          status, stopWriting);
  }
 
  return status;
}
//---------------------------------------------------------------------------
 
 
bool XCKSFileWriter::writeLocalFilesV1(ostream& os, const ArrayPath& relativePaths, int& indent)
{
  using Status = XCKSWriterChecksumProvider::Status;
  XCKSDirStruct dirs;
  for (const filesystem::path& p : relativePaths)
    dirs.addFile(p, const_cast<filesystem::path*>(&p));  // doing this ugly cast because lifetimes of relativePaths and dirs are the compatible
 
  ArrayChecksumValue ckValues;
  uintmax_t filesize;
  time_t filedatetime;
  ArrayString curDir;
  bool ok = true;
  XCKSDirStruct::const_file_iterator it = dirs.files_begin();
  while (ok && it != dirs.files_end())
  {
    const filesystem::path& fnNewRel = *(reinterpret_cast<const filesystem::path* const>(it->getData()));  // must be const because of the upper const_cast
 
    ckValues.clear();
    filesize = Invalid_File_Size;
    filedatetime = Invalid_DateTime;
    Status status;
    bool stopWriting = false;
    if ((status = getChecksumValues(ckValues, filesize, filedatetime, sumsAlgos, fnNewRel, stopWriting)) == Status::Ok)
    {
      // Writing directories
      ArrayString dirs = getDirectoriesAsArrayString(fnNewRel);
      size_t dirIdx = 0;
      while ((dirIdx < curDir.size()) && (dirs.size() > 0))
      {
        if (compareFileName(curDir[dirIdx], dirs[0]) == 0)
        {
          dirs.erase(dirs.begin());
          dirIdx++;
        }
        else
          break;
      }
      while (ok && curDir.size() > dirIdx)
      {
        if (curDir.back() == parentDir)
        {
          ok = writeLine(os, "</parentDirectory>", --indent);
          writerHandler.onParentDirectoryEnd();
        }
        else
        {
          ok = writeLine(os, "</directory>", --indent);
          writerHandler.onDirectoryEnd();
        }
        curDir.pop_back();
      }
      while (ok && dirs.size() > 0)
      {
        curDir.emplace_back(dirs[0]);
        if (dirs[0] == parentDir)
        {
          ok = writeLine(os, "<parentDirectory>", indent++);
          writerHandler.onParentDirectoryStart();
          writerHandler.onParentDirectoryStart(ensureEndsWithPathSeparator(constructPath(curDir)));
        }
        else
        {
          ok = writeLine(os, "<directory name=\"" + escapeForXML(dirs[0]) + "\">", indent++);
          writerHandler.onDirectoryStart(dirs[0]);
          writerHandler.onDirectoryStart(ensureEndsWithPathSeparator(constructPath(curDir)));
        }
        dirs.erase(dirs.begin());
      }
 
      // File part
      ok = writeLine(os, "<file name=\"" + escapeForXML(from_u8string(fnNewRel.filename().u8string())) + "\">", indent++);
      writerHandler.onFileStart(fnNewRel);
      writerHandler.onFileStart(it->getName());  // writerHandler.onFileStart(from_u8string(fnNewRel.filename().u8string()));
      if ((writerOptions.writeFileSize() && (filesize != Invalid_File_Size)) || (writerOptions.writeFileDateTime() && (filedatetime != Invalid_DateTime)))
      {
        string line = "<information";
        if (filesize != Invalid_File_Size)
          line += " size=\"" + to_string(filesize) + "\"";
        if (filedatetime != Invalid_DateTime)
        {
          ostringstream ss;
          #if defined(_WIN32) || defined(_WIN64)
          ss << put_time(localtime(&filedatetime), "%Y-%m-%dT%T");
          #else
          ss << put_time(localtime(&filedatetime), "%FT%T");
          #endif
          line += " date=\"" + ss.str() + "\"";
        }
        line += "/>";
        ok = writeLine(os, line, indent);
        writerHandler.onFileInformation(filesize, filedatetime);
      }
 
      for (const ChecksumValue& ckv : ckValues)
      {
        string algoName;
        if (getXCKSAlgorithmName(algoName, ckv.getType()))
        {
          ChecksumFormatter ckf(ckfConfProvider, ckv.getType());
          ckf.setNumericBase(ChecksumFormatter::NumericBase::hexadecimal);
          if (writerOptions.useCompactXML())
            ckf.setSpacesPositions(ChecksumFormatter::Positions());
          ok = ok && writeLine(os, "<checksum type=\"" + algoName + "\" value=\"" + ckf.format(ckv.getValue(), ckv.getSize()) + "\"/>", indent);
          writerHandler.onFileChecksum(ckv);
        }
        else
          assert(false);  // "Unexpected unknown checksums algorithm."
      }
      ok = writeLine(os, "</file>", --indent);
      writerHandler.onFileEnd();
      writerHandler.onFile(fnNewRel, ckValues, filesize, filedatetime);
    }
    else
    {
      if (stopWriting || (status == Status::BadChecksumValue) ||
          (status == Status::BadDuplicateValue) || (status == Status::MissingAlgorithm))
        ok = false;
    }
    ++it;
  }
  while (ok && curDir.size() > 0)
  {
    if (curDir.back() == parentDir)
    {
      ok = writeLine(os, "</parentDirectory>", --indent);
      writerHandler.onParentDirectoryEnd();
    }
    else
    {
      ok = writeLine(os, "</directory>", --indent);
      writerHandler.onDirectoryEnd();
    }
    curDir.pop_back();
  }
 
  return ok;
}
//---------------------------------------------------------------------------
 
 
bool XCKSFileWriter::writeV1(ostream& os, const ArrayPath& relativePaths)
{
  int indent = 0;  // beware to the position of the -- and ++ operators in the calls of writeLine  ;)
  const ArrayChecksumAlgoId& checksumTypesForNewEntries = sumsAlgos;
  bool ok;
 
  // Header
  os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
  ok = os.good();
 
  // Root start tag
  ok = ok && writeLine(os, "<checksumsFile xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://xcks.sourceforge.net/schemas/xsd-1.0/xcks-" + getStrVersion() + ".xsd\" version=\"" + getStrVersion() + "\">", indent++);
  writerHandler.onChecksumsFileStart(getStrVersion());
 
  // "generated" start tag
  if (writerOptions.writeGeneratedElement())
  {
    ostringstream ss;
    time_t t = time(nullptr);
    #if defined(_WIN32) || defined(_WIN64)
    ss << put_time(localtime(&t), "%Y-%m-%dT%T");
    #else
    ss << put_time(localtime(&t), "%FT%T");
    #endif
    string appName = writerOptions.getApplicationWriter();
    string appVersion = writerOptions.getApplicationWriterVersion();
    if (appName.empty() || appVersion.empty())
    {
      appName = getLibraryName();
      appVersion = getLibraryVersion();
    }
    else
    {
      if (writerOptions.writeLibXCKSVersion())
        appName += " (with " + getLibraryNameAndVersion() + ')';
    }
    ok = ok && writeLine(os, "<generated by=\"" + appName + "\" version=\"" + appVersion + "\" on=\"" + ss.str() + "\"/>", indent);
    writerHandler.onGenerated(getLibraryName(), getLibraryVersion(), t);
  }
 
  // "algorithms" start tag
  ok = ok && writeLine(os, "<algorithms>", indent++);
  writerHandler.onAlgorithmsStart();
 
  // "algorithm" tags
  for (ChecksumAlgoId ckId : checksumTypesForNewEntries)
  {
    string algoName;
    if (getXCKSAlgorithmName(algoName, ckId))
    {
      ok = ok && writeLine(os, "<algorithm type=\"" + algoName + "\"/>", indent);
      writerHandler.onAlgorithm(ckId);
    }
    else
      assert(false);  // "Unexpected unknown checksums algorithm."
  }
 
  // "algorithms" end tag
  ok = ok && writeLine(os, "</algorithms>", --indent);
  writerHandler.onAlgorithms(checksumTypesForNewEntries);
 
  // "localFiles" start tag
  ok = ok && writeLine(os, "<localFiles>", indent++);
  writerHandler.onLocalFilesStart();
  ok = ok && writeLocalFilesV1(os, relativePaths, indent);
 
  // "localFiles" end tag
  ok = ok && writeLine(os, "</localFiles>", --indent);
  writerHandler.onLocalFilesEnd();
 
  // Root end tag
  ok = ok && writeLine(os, "</checksumsFile>", --indent);
  writerHandler.onChecksumsFileEnd();
 
  os.flush();
 
  return (os.good() && ok);
}
//---------------------------------------------------------------------------
 
 
bool XCKSFileWriter::writeLine(ostream& os, const string& line, const int indent)
{
  if ((!writerOptions.useCompactXML()) && indent > 0)
  {
    string sIndent;
    if (writerOptions.useTabsforIndentation())
      sIndent.append(indent, '\t');
    else
      sIndent.append(indent * writerOptions.getIndentSpaces(), ' ');
    os << sIndent;
  }
 
  os << line;
  if (!writerOptions.useCompactXML())
    os << '\n';
 
  return os.good();
}
//---------------------------------------------------------------------------
 
 
bool XCKSFileWriter::getXCKSAlgorithmName(string& algoName, const ChecksumAlgoId algoId)
{
  const StringSet& availableChecksumTypesName = possibleSumsAlgos;
  ArrayString algoNames;
  if (!ChecksumFactory::getAlgorithmAltNames(algoNames, algoId, true))
    return false;
  StringSet::const_iterator idx = availableChecksumTypesName.cend();
  ArrayString::const_iterator it = algoNames.cbegin();
  while ((idx == availableChecksumTypesName.cend()) && (it != algoNames.cend()))
  {
    idx = availableChecksumTypesName.find(*it);
    it++;
  }
  if (idx == availableChecksumTypesName.cend())
    return false;
  else
  {
    algoName = *idx;
    return true;
  }
}
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------