xcksreader.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/xcksreader.hpp"
#include "xcksfilereader.hpp"
#include "strutil.hpp"
#include "pathutil.hpp"
//---------------------------------------------------------------------------
 
 
using namespace std;
 
using namespace boost::locale;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
//###########################################################################
// XCKSReader
//###########################################################################
 
/*
 * Constructor.
 */
XCKSReader::XCKSReader(XCKSReaderHandler& xcksReaderHandler) : readerHandler(xcksReaderHandler)
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Destructor.
 */
XCKSReader::~XCKSReader()
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Parses an XCKS file from an input stream.
 */
bool XCKSReader::parse(std::istream& is, const std::filesystem::path& basePath)
{
  if (!basePath.is_absolute())
  {
    readerHandler.onFatalError((format(translate("The base path {1} must be an absolute path.").str(libxcks_domain))
                                 % from_u8string(basePath.u8string())).str(), -1 , -1);
    return false;
  }
 
  XCKSFileReader reader(readerHandler, ensureEndsWithPathSeparator(basePath));
  return reader.parse(is);
}
//---------------------------------------------------------------------------
 
 
/*
 * Parses an XCKS file from a file.
 */
bool XCKSReader::parse(const std::filesystem::path& fileFullPath)
{
  if (!fileFullPath.is_absolute())
  {
    readerHandler.onFatalError((format(translate("The file path {1} must be an absolute path.").str(libxcks_domain))
                                 % from_u8string(fileFullPath.u8string())).str(), -1, -1);
    return false;
  }
 
  ifstream is(fileFullPath, ios_base::in | ios_base::binary);
  if (!is.is_open())
  {
    readerHandler.onFatalError((format(translate("Can't open {1}.").str(libxcks_domain))
                                 % from_u8string(fileFullPath.u8string())).str(), -1, -1);
    return false;
  }
 
  return parse(is, fileFullPath.parent_path());
}
//---------------------------------------------------------------------------
 
 
/*
 * Parses an XCKS file from a file and a base path.
 */
bool XCKSReader::parse(const std::filesystem::path& filePath,
                       const std::filesystem::path& basePath)
{
  if (!basePath.is_absolute())
  {
    readerHandler.onFatalError((format(translate("The base path {1} must be an absolute path.").str(libxcks_domain))
                                 % from_u8string(basePath.u8string())).str(), -1, -1);
    return false;
  }
 
  ifstream is(filePath, ios_base::in | ios_base::binary);
  if (!is.is_open())
  {
    readerHandler.onFatalError((format(translate("Can't open {1}.").str(libxcks_domain))
                                 % from_u8string(filePath.u8string())).str(), -1, -1);
    return false;
  }
 
  return parse(is, basePath);
}
//---------------------------------------------------------------------------
 
 
/*
 * Convenience method for parsing an XCKS file from an input stream.
 */
bool XCKSReader::parseXCKS(XCKSReaderHandler& xcksReaderHandler, std::istream& is,
                           const std::filesystem::path& basePath)
{
  XCKSReader reader(xcksReaderHandler);
  return reader.parse(is, basePath);
}
//---------------------------------------------------------------------------
 
 
/*
 * Convenience method for parsing an XCKS file from a file.
 */
bool XCKSReader::parseXCKS(XCKSReaderHandler& xcksReaderHandler,
                           const std::filesystem::path& fileFullPath)
{
  XCKSReader reader(xcksReaderHandler);
  return reader.parse(fileFullPath);
}
//---------------------------------------------------------------------------
 
 
/*
 * Convenience method for parsing an XCKS file from a file and a base path.
 */
bool XCKSReader::parseXCKS(XCKSReaderHandler& xcksReaderHandler,
                           const std::filesystem::path& filePath,
                           const std::filesystem::path& basePath)
{
  XCKSReader reader(xcksReaderHandler);
  return reader.parse(filePath, basePath);
}
//---------------------------------------------------------------------------
 
 
 
 
//###########################################################################
// ZXCKSReader
//###########################################################################
 
/*
 * Constructor.
 */
ZXCKSReader::ZXCKSReader(XCKSReaderHandler& xcksReaderHandler) :
                                                  XCKSReader(xcksReaderHandler)
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Destructor.
 */
ZXCKSReader::~ZXCKSReader()
{
}
//---------------------------------------------------------------------------
 
 
/*
 * Parses an ZXCKS file from an input stream.
 */
bool ZXCKSReader::parse(istream& is, const std::filesystem::path& basePath)
{
  boost::iostreams::filtering_streambuf<boost::iostreams::input> inbuf;
  inbuf.push(boost::iostreams::gzip_decompressor());
  inbuf.push(is);
  istream instream(&inbuf);
 
  // Try to peek a character to see if the stream is a gzip stream.
  bool res = true;
  try
  {
    instream.peek();
    res = instream.good();
  }
  catch (const boost::iostreams::gzip_error& e)
  {
    res = false;
    readerHandler.onFatalError(e.what(), -1, -1);
  }
  catch (const exception& e)
  {
    res = false;
    readerHandler.onFatalError(e.what(), -1, -1);
  }
 
  return res ? XCKSReader::parse(instream, basePath) : res;
}
//---------------------------------------------------------------------------
 
 
/*
 * Convenience method for parsing an ZXCKS file from an input stream.
 */
bool ZXCKSReader::parseZXCKS(XCKSReaderHandler& xcksReaderHandler,
                             std::istream& is, const std::filesystem::path& basePath)
{
  ZXCKSReader reader(xcksReaderHandler);
  return reader.parse(is, basePath);
}
//---------------------------------------------------------------------------
 
 
/*
 * Convenience method for parsing an ZXCKS file from a file.
 */
bool ZXCKSReader::parseZXCKS(XCKSReaderHandler& xcksReaderHandler,
                             const std::filesystem::path& fileFullPath)
{
  ZXCKSReader reader(xcksReaderHandler);
  return reader.parse(fileFullPath);
}
//---------------------------------------------------------------------------
 
 
/*
 * Convenience method for parsing an ZXCKS file from a file and a base path.
 */
bool ZXCKSReader::parseZXCKS(XCKSReaderHandler& xcksReaderHandler,
                             const std::filesystem::path& filePath,
                             const std::filesystem::path& basePath)
{
  ZXCKSReader reader(xcksReaderHandler);
  return reader.parse(filePath, basePath);
}
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------