xckswriter.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 <fstream>
#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/locale.hpp>
 
#include "libxcks/xckswriter.hpp"
#include "xcksfilewriter.hpp"
#include "strutil.hpp"
#include "pathutil.hpp"
//---------------------------------------------------------------------------
 
 
using namespace std;
 
using namespace boost::locale;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
//###########################################################################
// XCKSWriter
//###########################################################################
 
/*
 * Constructor.
 */
XCKSWriter::XCKSWriter(XCKSWriterHandler& xcksWriterHandler,
                       XCKSWriterChecksumProvider& checksumProvider,
                       const XCKSWriterOptions& options,
                       const Version version,
                       const ArrayChecksumAlgoId& algoIds,
                       const ChecksumFormatter::ConfigurationProvider& ckftConfProvider) :
                         writerHandler(xcksWriterHandler),
                         ckProvider(checksumProvider),
                         writerOptions(options),
                         version(version),
                         sumsAlgos(algoIds),
                         ckfConfProvider(ckftConfProvider)
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Destructor.
 */
XCKSWriter::~XCKSWriter()
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Writes an XCKS file to an output stream.
 */
bool XCKSWriter::write(std::ostream& os, const std::filesystem::path& basePath,
                       const ArrayPath& relativePaths)
{
  if (checkBaseDirAndPathList(basePath, relativePaths))
    return doWrite(os, basePath, relativePaths);
  else
    return false;
}
//---------------------------------------------------------------------------
 
 
/*
 * Writes an XCKS file to a file.
 */
bool XCKSWriter::write(const std::filesystem::path& fileFullPath,
                       const ArrayPath& relativePaths)
{
  if (!fileFullPath.is_absolute())
  {
    writerHandler.onFatalError((format(translate("The file path {1} must be an absolute path.").str(libxcks_domain))
                                 % from_u8string(fileFullPath.u8string())).str());
    return false;
  }
 
  if (checkBaseDirAndPathList(fileFullPath.parent_path(), relativePaths))
  {
    ofstream os(fileFullPath, ios_base::out | ios_base::binary);
    if (!os.is_open())
    {
      writerHandler.onFatalError((format(translate("Can't open {1}.").str(libxcks_domain))
                                   % from_u8string(fileFullPath.u8string())).str());
      return false;
    }
 
    return doWrite(os, fileFullPath.parent_path(), relativePaths);
  }
  else
    return false;
}
//---------------------------------------------------------------------------
 
 
/*
 * Writes an XCKS file to a file with a different base path.
 */
bool XCKSWriter::write(const std::filesystem::path& filePath,
                       const std::filesystem::path& basePath,
                       const ArrayPath& relativePaths)
{
  if (checkBaseDirAndPathList(basePath, relativePaths))
  {
    ofstream os(filePath, ios_base::out | ios_base::binary);
    if (!os.is_open())
    {
      writerHandler.onFatalError((format(translate("Can't open {1}.").str(libxcks_domain))
                                   % from_u8string(filePath.u8string())).str());
      return false;
    }
 
    return doWrite(os, basePath, relativePaths);
  }
  else
    return false;
}
//---------------------------------------------------------------------------
 
 
/*
 * Checks if the provided base directory has an absolute path and the files
 * to add to the XCKS file have all a relative path.
 *
 * @return @c true if the upper requirements are met, @c false otherwise.
 */
bool XCKSWriter::checkBaseDirAndPathList(const filesystem::path& basePath,
                                         const ArrayPath& relativePaths) const
{
  if (!basePath.is_absolute())
  {
    writerHandler.onFatalError((format(translate("The base path {1} must be an absolute path.").str(libxcks_domain))
                                 % from_u8string(basePath.u8string())).str());
    return false;
  }
 
  bool allRelative = true;
  ArrayPath::const_iterator it = relativePaths.cbegin();
  while (allRelative && it != relativePaths.cend())
  {
    if (it->is_relative())
      ++it;
    else
      allRelative = false;
  }
  if (!allRelative)
  {
    writerHandler.onFatalError(translate("All provided paths of files must be relative.").str(libxcks_domain));
    return false;
  }
 
  return true;
}
//---------------------------------------------------------------------------
 
 
/*
 * Writes an XCKS file to an output stream.
 */
bool XCKSWriter::doWrite(ostream& os, const filesystem::path& basePath,
                         const ArrayPath& relativePaths)
{
  XCKSFileWriter writer(writerHandler, ckProvider, writerOptions,
                        ensureEndsWithPathSeparator(basePath), sumsAlgos,
                        ckfConfProvider, version);
  if (writer.getChecksumTypesForNewEntries().empty())
    return false;
 
  return writer.write(os, relativePaths);
}
//---------------------------------------------------------------------------
 
 
 
 
//###########################################################################
// XCKSWriter
//###########################################################################
 
/*
 * Constructor.
 */
ZXCKSWriter::ZXCKSWriter(XCKSWriterHandler& xcksWriterHandler,
                         XCKSWriterChecksumProvider& checksumProvider,
                         const ZXCKSWriterOptions& options,
                         const Version version,
                         const ArrayChecksumAlgoId& algoIds,
                         const ChecksumFormatter::ConfigurationProvider& ckftConfProvider) :
                           XCKSWriter(xcksWriterHandler, checksumProvider,
                                      options, version, algoIds, ckftConfProvider)
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Destructor.
 */
ZXCKSWriter::~ZXCKSWriter()
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Writes a ZXCKS file to an output stream.
 */
bool ZXCKSWriter::doWrite(ostream& os, const filesystem::path& basePath,
                         const ArrayPath& relativePaths)
{
  boost::iostreams::filtering_streambuf<boost::iostreams::output> outbuf;
  outbuf.push(boost::iostreams::gzip_compressor(dynamic_cast<const ZXCKSWriterOptions&>(writerOptions).getCompressionLevel()));
  outbuf.push(os);
  ostream outstream(&outbuf);
 
  bool res = XCKSWriter::doWrite(outstream, basePath, relativePaths);
 
  // Closing GZip stream.
  boost::iostreams::close(outbuf);
 
  return res;
}
//---------------------------------------------------------------------------
 
}  // namespace libxcks
//---------------------------------------------------------------------------