ckformatter.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 <sstream>
#include <algorithm>
#include <regex>
 
#include "libxcks/ckformatter.hpp"
#include "libxcks/ckfactory.hpp"
//---------------------------------------------------------------------------
 
 
using namespace std;
 
 
namespace libxcks
{
//###########################################################################
// A checksum' formatter
//###########################################################################
 
ChecksumFormatter::ChecksumFormatter(const ConfigurationProvider& provider,
                                     const std::string& algoName, const bool lookInAltNames)
{
  ChecksumAlgoId id;
 
  if (!ChecksumFactory::getAlgorithmId(id, algoName, lookInAltNames))
    id = ChecksumAlgoId::Invalid;
 
  initialise(provider, id);
}
//---------------------------------------------------------------------------
 
 
ChecksumFormatter::ChecksumFormatter(const ConfigurationProvider& provider,
                                     const ChecksumAlgoId type)
{
  initialise(provider, type);
}
//---------------------------------------------------------------------------
 
 
ChecksumFormatter::ChecksumFormatter(const bool uc, const NumericBase nb,
                                     const Positions& sp)
{
  setUpperCase(uc);
  setNumericBase(nb);
  setSpacesPositions(sp);
}
//---------------------------------------------------------------------------
 
 
void ChecksumFormatter::initialise(const ConfigurationProvider& provider,
                                   const ChecksumAlgoId type)
{
  setUpperCase(provider.getUpperCase(type));
  setNumericBase(provider.getNumericBase(type));
  setSpacesPositions(provider.getSpacesPositions(type));
}
//---------------------------------------------------------------------------
 
 
string ChecksumFormatter::format(const uint8_t* value, const size_t size)
{
  if (value == nullptr || size == 0)
    return string();
 
  string byteFormatter;
  switch (getNumericBase())
  {
    case NumericBase::octal :
      byteFormatter = "%03o";
      break;
    case NumericBase::decimal :
      byteFormatter = "%03u";
      break;
    default :  // hexadecimal
      byteFormatter = (getUpperCase()) ? "%02X" : "%02x";
  }
 
  ostringstream ss;
  size_t lastSpacePos = size - 1;
  constexpr size_t bufSize = 4;  
  char buf[bufSize];
  for (size_t i = 0; i < size; i++)
  {
    snprintf(buf, bufSize, byteFormatter.c_str(), static_cast<uint_fast16_t>(value[i]));
    ss << buf;
 
    if (i < lastSpacePos && std::find(spacesPos.begin(), spacesPos.end(), static_cast<unsigned int>(i)) != spacesPos.end())
      ss << ' ';
  }
 
  return ss.str();
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFormatter::getUpperCase() const
{
  return upperCase;
}
//---------------------------------------------------------------------------
 
 
void ChecksumFormatter::setUpperCase(const bool isUpperCase)
{
  upperCase = isUpperCase;
}
//---------------------------------------------------------------------------
 
 
ChecksumFormatter::NumericBase ChecksumFormatter::getNumericBase() const
{
  return numericBase;
}
//---------------------------------------------------------------------------
 
 
void ChecksumFormatter::setNumericBase(const NumericBase base)
{
  switch (base)
  {
    case NumericBase::hexadecimal :
    case NumericBase::octal       :
    case NumericBase::decimal     :
      numericBase = base;
      break;
    default :
      numericBase = NumericBase::hexadecimal;
  }
}
//---------------------------------------------------------------------------
 
 
ChecksumFormatter::Positions ChecksumFormatter::getSpacesPositions() const
{
  return spacesPos;
}
//---------------------------------------------------------------------------
 
 
void ChecksumFormatter::setSpacesPositions(const std::string& spacesPositions)
{
  Positions sp = toSpacesPositions(spacesPositions);
 
  setSpacesPositions(sp);
}
//---------------------------------------------------------------------------
 
 
void ChecksumFormatter::setSpacesPositions(const Positions& spacesPositions)
{
  spacesPos = spacesPositions;
}
//---------------------------------------------------------------------------
 
 
string ChecksumFormatter::format(const ConfigurationProvider& provider,
                                 const uint8_t* value, const size_t size,
                                 const std::string& algoName,
                                 const bool lookInAltNames)
{
  ChecksumAlgoId id;
 
  if (!ChecksumFactory::getAlgorithmId(id, algoName, lookInAltNames))
    id = ChecksumAlgoId::Invalid;
 
  return format(provider, value, size, id);
}
//---------------------------------------------------------------------------
 
 
string ChecksumFormatter::format(const ConfigurationProvider& provider,
                                 const uint8_t* value, const size_t size,
                                 const ChecksumAlgoId type)
{
  ChecksumFormatter ckf(provider, type);
  return ckf.format(value, size);
}
//---------------------------------------------------------------------------
 
 
string ChecksumFormatter::format(const ConfigurationProvider& provider,
                                 const ChecksumValue& value)
{
  return format(provider, value.getValue(), value.getSize(), value.getType());
}
//---------------------------------------------------------------------------
 
 
ChecksumFormatter::Positions ChecksumFormatter::toSpacesPositions(const std::string& spacesPositions)
{
  const regex re(R"(\s*[,]\s*)");  // R"([\s|,]+)"
  sregex_token_iterator it{ spacesPositions.begin(), spacesPositions.end(), re, -1 };
  ArrayString ssp{ it, {} };
  ssp.erase(std::remove_if(ssp.begin(), ssp.end(), [](string const& s) {
                                                     return s.empty(); }),
            ssp.end());
 
  Positions sp;
  for (string token : ssp)
  {
    unsigned long lPos;
    try
    {
      lPos = stoul(token);
      sp.insert(static_cast<uint_fast16_t>(lPos));
    }
    catch (logic_error&)
    {
      // Ignore conversion error.
    }
  }
 
  return sp;
}
//---------------------------------------------------------------------------
 
}  // namespace libxcks
//---------------------------------------------------------------------------