ckformatter.hpp

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/>.
 */
 
#ifndef INC_CKFORMATTER_HPP_443C2F6F_1843_46B8_B365_FC45329314CD
#define INC_CKFORMATTER_HPP_443C2F6F_1843_46B8_B365_FC45329314CD
 
//---------------------------------------------------------------------------
#include <set>
//#include <string>  // included in "libxcks/types.hpp"
 
// #include "libxcks/types.hpp"  // included in "libxcks/ckvalue.hpp"
#include "libxcks/ckvalue.hpp"
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
class LIBXCKS_SO_EXPORT ChecksumFormatter
{
 public:
  using Positions = std::set<uint_fast16_t>;
 
  enum class NumericBase : uint_least8_t
  {
    hexadecimal = 0,
    decimal = 1,
    octal = 2
  };
 
  class LIBXCKS_SO_EXPORT ConfigurationProvider
  {
   public:
    ConfigurationProvider() = default;
 
    ConfigurationProvider(const ConfigurationProvider&) = delete;
 
    ConfigurationProvider& operator=(const ConfigurationProvider&) = delete;
 
    virtual ~ConfigurationProvider() = default;
 
    virtual NumericBase getNumericBase(const ChecksumAlgoId type) const = 0;
 
    virtual bool getUpperCase(const ChecksumAlgoId type) const = 0;
 
    virtual const Positions& getSpacesPositions(const ChecksumAlgoId type) const = 0;
  };
 
 
 protected:
  bool         upperCase;    
  NumericBase  numericBase;  
  Positions    spacesPos;    
 
 public:
  #if defined(_MSC_VER) && defined(LIBXCKS_SHARED)
  ChecksumFormatter() : upperCase(false), numericBase(NumericBase::hexadecimal),
                        spacesPos() {}
  #else
  ChecksumFormatter() = delete;
  #endif
 
  ChecksumFormatter(const ChecksumFormatter&) = delete;
 
  ChecksumFormatter& operator=(const ChecksumFormatter&) = delete;
 
  // Constructs a new checksum's formatter for the given algorithm name or
  // alternative name.
  ChecksumFormatter(const ConfigurationProvider& provider,
                    const std::string& algoName, const bool lookInAltNames = true);
 
  // Constructs a new checksum's formatter for the given algorithm type.
  ChecksumFormatter(const ConfigurationProvider& provider, const ChecksumAlgoId type);
 
  // Constructs a new checksum's formatter with the given parameters.
  #if defined(_MSC_VER) && defined(LIBXCKS_SHARED)
  ChecksumFormatter(const bool uc,
                    const NumericBase nb = NumericBase::hexadecimal,
                    const Positions& sp = Positions());
  #else
  ChecksumFormatter(const bool uc = false,
                    const NumericBase nb = NumericBase::hexadecimal,
                    const Positions& sp = Positions());
  #endif
 
 protected:
  // Initializes the instance.
  void initialise(const ConfigurationProvider& provider, const ChecksumAlgoId type);
 
 public:
  // Format the given checksum's value.
  std::string format(const uint8_t* value, const size_t size);
 
  // Returns whether the output will be in uppercase.
  bool getUpperCase() const;
 
  // Sets whether the output will be in uppercase.
  void setUpperCase(const bool isUpperCase);
 
  // Returns the numeric base for the output.
  NumericBase getNumericBase() const;
 
  // Sets the numeric base for the output.
  void setNumericBase(const NumericBase base);
 
  // Returns the positions of the spaces between two bytes.
  Positions getSpacesPositions() const;
 
  // Sets the positions of the spaces between two bytes.
  void setSpacesPositions(const std::string& spacesPositions);
 
  // Sets the positions of the spaces between two bytes.
  void setSpacesPositions(const Positions& spacesPositions);
 
  // Format the given checksum's value with the given algorithm's name.
  static std::string format(const ConfigurationProvider& provider,
                            const uint8_t* value, const size_t size,
                            const std::string& algoName,
                            const bool lookInAltNames = true);
 
  // Format the given checksum's value with the given algorithm's type.
  static std::string format(const ConfigurationProvider& provider,
                            const uint8_t* value, const size_t size,
                            const ChecksumAlgoId type);
 
  // Format the given checksum's value.
  static std::string format(const ConfigurationProvider& provider,
                            const ChecksumValue& value);
 
  // Gets the positions of the spaces between two bytes from a string.
  static Positions toSpacesPositions(const std::string& spacesPositions);
};
//---------------------------------------------------------------------------
 
 
class LIBXCKS_SO_EXPORT DefaultCKFConfigurationProvider : public ChecksumFormatter::ConfigurationProvider
{
 private:
  const ChecksumFormatter::Positions defaultPositions;  
 
 public:
  DefaultCKFConfigurationProvider() = default;
 
  DefaultCKFConfigurationProvider(const DefaultCKFConfigurationProvider&) = delete;
 
  DefaultCKFConfigurationProvider& operator=(const DefaultCKFConfigurationProvider&) = delete;
 
  virtual ~DefaultCKFConfigurationProvider() = default;
 
  ChecksumFormatter::NumericBase getNumericBase(const ChecksumAlgoId type) const override
  {
    return ChecksumFormatter::NumericBase::hexadecimal;
  }
 
  bool getUpperCase(const ChecksumAlgoId type) const override
  {
    return true;
  }
 
  const ChecksumFormatter::Positions& getSpacesPositions(const ChecksumAlgoId type) const override
  {
    return defaultPositions;
  }
};
//---------------------------------------------------------------------------
 
}  // namespace libxcks
//---------------------------------------------------------------------------
 
#endif  // INC_CKFORMATTER_HPP_443C2F6F_1843_46B8_B365_FC45329314CD