ckvalue.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 <algorithm>
#include <utility>
#include <stdexcept>
#include <cstring>
#include <cassert>
#include <cctype>
 
#include "libxcks/ckvalue.hpp"
#include "libxcks/ckfactory.hpp"
//---------------------------------------------------------------------------
 
 
using namespace std;
 
 
namespace libxcks
{
ChecksumValue::ChecksumValue()
{
  value = nullptr;
  valueSize = 0;
  type = ChecksumAlgoId::Invalid;
}
//---------------------------------------------------------------------------
 
 
void ChecksumValue::clone(const ChecksumValue& source)
{
  if (this != &source)
    setValue(source.value, source.valueSize, source.type);
}
//---------------------------------------------------------------------------
 
 
ChecksumValue::ChecksumValue(const ChecksumValue& source) : value(nullptr)
{
  clone(source);
}
//---------------------------------------------------------------------------
 
 
ChecksumValue::ChecksumValue(ChecksumValue&& rhs) : value(exchange(rhs.value, nullptr)),
                                                    valueSize(exchange(rhs.valueSize, 0)),
                                                    type(exchange(rhs.type, ChecksumAlgoId::Invalid))
{
}
//---------------------------------------------------------------------------
 
 
ChecksumValue& ChecksumValue::operator=(const ChecksumValue& source)
{
  clone(source);
  return *this;
}
//---------------------------------------------------------------------------
 
 
ChecksumValue& ChecksumValue::operator=(ChecksumValue&& rhs)
{
  if (this != &rhs)
  {
    if (value != nullptr)
      delete[] value;
    value = exchange(rhs.value, nullptr);
    valueSize = exchange(rhs.valueSize, 0);
    type = exchange(rhs.type, ChecksumAlgoId::Invalid);
  }
  return *this;
}
//---------------------------------------------------------------------------
 
 
ChecksumValue::ChecksumValue(const uint8_t* value, const size_t size, const ChecksumAlgoId type)
{
  this->value = nullptr;
  setValue(value, size, type);
}
//---------------------------------------------------------------------------
 
 
ChecksumValue::ChecksumValue(const std::string& strValue, const ChecksumAlgoId type)
{
  this->value = nullptr;
  setValue(strValue, type);
}
//---------------------------------------------------------------------------
 
 
ChecksumValue::ChecksumValue(const Checksum& checksum)
{
  valueSize = checksum.getSize();
  value = new uint8_t[valueSize];
  if (value == nullptr)
  {
    valueSize = 0;
    type = ChecksumAlgoId::Invalid;
  }
  else
  {
    checksum.getValue(value);
    type = checksum.getID();
  }
}
//---------------------------------------------------------------------------
 
 
ChecksumValue::~ChecksumValue()
{
  if (value != nullptr)
    setValue(nullptr, 0, ChecksumAlgoId::Invalid);
}
//---------------------------------------------------------------------------
 
 
bool ChecksumValue::operator==(const ChecksumValue& cmp) const
{
  if ((this->valueSize != cmp.valueSize) || (this->type != cmp.type))
    return false;
 
  bool equal = true;
  size_t i = 0;
  while (equal && i < this->valueSize)
  {
    if (this->value[i] != cmp.value[i])
      equal = false;
    i++;
  }
 
  return equal;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumValue::operator!=(const ChecksumValue& cmp) const
{
  return !((*this) == cmp);
}
//---------------------------------------------------------------------------
 
 
int ChecksumValue::compare(const ChecksumValue& cmp) const
{
  assert((this->valueSize == cmp.valueSize) && (this->type == cmp.type));
 
  int res = 0;
  size_t i = 0;
  while ((res == 0) && i < this->valueSize)
  {
    res = this->value[i] - cmp.value[i];
    i++;
  }
 
  return res;
}
//---------------------------------------------------------------------------
 
 
const uint8_t* ChecksumValue::getValue() const
{
  return value;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumValue::getValue(uint8_t* value, const size_t size) const
{
  if (size < valueSize)
    return false;
 
  memcpy(value, this->value, valueSize);
  return true;
}
//---------------------------------------------------------------------------
 
 
void ChecksumValue::setValue(const uint8_t* value, const size_t size, const ChecksumAlgoId type)
{
  if ((this->value != nullptr) && (this->value != value))
  {
    // Free the old value.
    delete[] this->value;
    this->value = nullptr;
  }
 
  if (value == nullptr || size == 0)
  {
    this->value = nullptr;
    this->valueSize = 0;
    this->type = ChecksumAlgoId::Invalid;
  }
  else
  {
    this->value = new uint8_t[size];
    if (this->value == nullptr)
    {
      this->valueSize = 0;
      this->type = ChecksumAlgoId::Invalid;
    }
    else
    {
      memcpy(this->value, value, size);
      this->valueSize = size;
      this->type = type;
    }
  }
}
//---------------------------------------------------------------------------
 
 
void ChecksumValue::setValue(const std::string& strValue, const ChecksumAlgoId type)
{
  if (strValue.empty())
  {
    setValue(nullptr, 0, ChecksumAlgoId::Invalid);
    return;
  }
 
  size_t size = 0;
  uint8_t* buf = new uint8_t[strValue.length() / 2];
  uint8_t* res = buf;
 
  const size_t l = strValue.length();
  size_t i = 0;
  string b;    // buffer string for a byte value
  int sc = 0;  // space count
  unsigned char c;  // the last read character
  while (res != nullptr && i < l)
  {
    c = strValue[i];
 
    if (isxdigit(c))
    {
      if (sc > 0 && b.length() > 0)  // not allowed
        res = nullptr;
      else
      {
        sc = 0;
        b += c;
        if (b.length() == 2)
        {
          unsigned long lVal;
          try
          {
            lVal = stoul(b, nullptr, 16);
          }
          catch (logic_error&)
          {
            res = nullptr;
          }
          b.clear();
          buf[size] = static_cast<uint8_t>(lVal);
          size++;
        }
      }
    }
    else if (isspace(c))  // it is a space ?
    {
      sc++;
      if (sc > 1 || i == 0 || i == l - 1)  // can't begin or end by a space
        res = nullptr;
    }
    else  // not a legal character
      res = nullptr;
 
    i++;
  }
  if (!b.empty())  // the last byte isn't complete
    res = nullptr;
 
  if (res == nullptr)
    setValue(nullptr, 0, ChecksumAlgoId::Invalid);
  else
    setValue(res, size, type);
 
  delete[] buf;
}
//---------------------------------------------------------------------------
 
 
size_t ChecksumValue::getSize() const
{
  return valueSize;
}
//---------------------------------------------------------------------------
 
 
ChecksumAlgoId ChecksumValue::getType() const
{
  return type;
}
//---------------------------------------------------------------------------
 
 
 
//###########################################################################
// Helper functions
//###########################################################################
 
bool hasChecksumValueWithAlgoId(const ArrayChecksumValue& ckvalues, const ChecksumAlgoId type)
{
  bool notFound = true;
  ArrayChecksumValue::const_iterator it = ckvalues.cbegin();
 
  while (notFound && it != ckvalues.cend())
  {
    if (it->getType() == type)
      notFound = false;
    else
      it++;
  }
 
  return !notFound;
}
//---------------------------------------------------------------------------
 
 
void getNullValues(ArrayChecksumValue& values, const ArrayChecksumAlgoId& ids)
{
  values.clear();
  for (const ChecksumAlgoId id : ids)
  {
    if (ChecksumFactory::exists(id))
      values.emplace_back(ChecksumFactory::getNullValue(id));
  }
}
//---------------------------------------------------------------------------
 
 
}  // namespace libxcks
//---------------------------------------------------------------------------