Config Class Reference

Parses and stores config values from custom file format. More...

#include <CCSDSConfig.h>

Public Types
using	ConfigValue = std::variant< std::string, int, float, bool, std::vector< uint8_t > >

Public Member Functions
CCSDS::ResultBool	load (const std::string &filename)
	Load config file.
template<typename T >
CCSDS::Result< T >	get (const std::string &key) const
	Get value by key and type.
bool	isKey (const std::string &key) const

Static Private Member Functions
static std::tuple< std::string, std::string, std::string >	parseLine (const std::string &line)
	Parse a single line from config.
static CCSDS::ResultBuffer	parseBytes (const std::string &valueStr)
	Parse string "[1,2,3]" into vector<uint8_t>

Private Attributes
std::unordered_map< std::string, ConfigValue >	values

Detailed Description

Parses and stores config values from custom file format.

Definition at line 11 of file CCSDSConfig.h.

Member Typedef Documentation

ConfigValue

using Config::ConfigValue = std::variant<std::string, int, float, bool, std::vector<uint8_t> >

Definition at line 13 of file CCSDSConfig.h.

Member Function Documentation

get()

template<typename T >

CCSDS::Result< T > Config::get ( const std::string &  key ) const

inline

Get value by key and type.

Definition at line 20 of file CCSDSConfig.h.

                                                 {
    auto it = values.find(key);
    RET_IF_ERR_MSG(it == values.end(), CCSDS::ErrorCode::NO_DATA,"Config: No data found for key: " + key);
 
    if (const auto* p = std::get_if<T>(&it->second)) {
      return *p;
    }
    return CCSDS::Error{ CCSDS::ErrorCode::INVALID_DATA, "Config: Wrong type for key: " + key};
  }

Here is the caller graph for this function:

isKey()

bool Config::isKey

(

const std::string &

key

)

const

Definition at line 48 of file CCSDSConfig.cpp.

                                             {
  if (values.find(key) != values.end()) {
    return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

load()

CCSDS::ResultBool Config::load

(

const std::string &

filename

)

Load config file.

Definition at line 12 of file CCSDSConfig.cpp.

                                                      {
  std::ifstream file(filename);
  RET_IF_ERR_MSG(!file.is_open(),CCSDS::ErrorCode::CONFIG_FILE_ERROR, "Failed to open configuration file");
 
  std::string line;
  while (std::getline(file, line)) {
    if (line.empty() || line.front() == '#') continue;
 
    auto [key, type, valueStr] = parseLine(line);
    RET_IF_ERR_MSG(key.empty() || type.empty(),CCSDS::ErrorCode::CONFIG_FILE_ERROR, "Failed to parse configuration file");
    ConfigValue value;
    if (type == "string") {
      value = valueStr;
    } else if (type == "int") {
      std::uint8_t base = 10;
      if (valueStr.size() > 2 && valueStr.substr(0, 2) == "0x") {
        valueStr = valueStr.substr(2);
        base = 16;
      }
      value = std::stoi(valueStr, nullptr, base);
    } else if (type == "float") {
      value = std::stof(valueStr);
    } else if (type == "bool") {
      value = (valueStr == "true" || valueStr == "1");
    } else if (type == "bytes") {
      ASSIGN_CP( value, parseBytes(valueStr) );
    } else {
      return CCSDS::Error{CCSDS::ErrorCode::CONFIG_FILE_ERROR, " unknown type: " + type};
    }
 
    values[key] = value;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseBytes()

CCSDS::ResultBuffer Config::parseBytes ( const std::string &  valueStr )

staticprivate

Parse string "[1,2,3]" into vector<uint8_t>

Definition at line 72 of file CCSDSConfig.cpp.

                                                              {
  std::vector<uint8_t> result{};
  RET_IF_ERR_MSG(valueStr.empty() || valueStr.front() != '[' || valueStr.back() != ']',
                 CCSDS::ErrorCode::CONFIG_FILE_ERROR,
                 "Config: Invalid buffer formatting []");
 
  if (valueStr == "[]" || valueStr == "[ ]") {
    return result;
  }
 
  // Strip surrounding [ ... ]
  std::string inner = valueStr.substr(1, valueStr.size() - 2);
  std::stringstream ss(inner);
  std::string token;
 
  while (std::getline(ss, token, ',')) {
    // Remove all spaces inside each token
    token.erase(std::remove_if(token.begin(), token.end(),
                               [](unsigned char c){ return std::isspace(c); }),
                token.end());
 
    // Empty token after trimming is invalid (e.g., "[12, ,34]")
    if (token.empty()) {
      return CCSDS::Error{CCSDS::ErrorCode::CONFIG_FILE_ERROR, "Invalid byte value: <empty>"};
    }
 
    std::uint8_t base = 10;
    std::string_view sv{token};
 
    // Allow 0x / 0X prefix for hex
    if (sv.size() > 2 && sv[0] == '0' && (sv[1] == 'x' || sv[1] == 'X')) {
      sv.remove_prefix(2);
      base = 16;
      if (sv.empty()) {
        return CCSDS::Error{CCSDS::ErrorCode::CONFIG_FILE_ERROR, "Invalid byte value: 0x"};
      }
    }
 
    // Parse without exceptions
    std::uint8_t tmp = 0;
    const char* first = sv.data();
    const char* last  = sv.data() + sv.size();
    auto res = std::from_chars(first, last, tmp, base);
 
    // Valid if parsed ok, consumed all characters, and fits in a byte
    if (res.ec != std::errc{} || res.ptr != last || tmp > 0xFFu) {
      return CCSDS::Error{CCSDS::ErrorCode::CONFIG_FILE_ERROR,
                          std::string("Invalid byte value: ") + std::string(token)};
    }
    result.push_back(static_cast<uint8_t>(tmp));
  }
 
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseLine()

std::tuple< std::string, std::string, std::string > Config::parseLine ( const std::string &  line )

staticprivate

Parse a single line from config.

Definition at line 55 of file CCSDSConfig.cpp.

                                                                                 {
  auto colonPos = line.find(':');
  auto equalPos = line.find('=');
 
  if (colonPos == std::string::npos || equalPos == std::string::npos || equalPos < colonPos)
    return {"", "", ""};
 
  std::string key = line.substr(0, colonPos);
  std::string type = line.substr(colonPos + 1, equalPos - colonPos - 1);
  std::string value = line.substr(equalPos + 1);
 
  if (!value.empty() && value.front() == '"' && value.back() == '"')
    value = value.substr(1, value.size() - 2);
 
  return {key, type, value};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

values

std::unordered_map<std::string, ConfigValue> Config::values

private

Definition at line 33 of file CCSDSConfig.h.

---

The documentation for this class was generated from the following files:

• inc/CCSDSConfig.h
• src/CCSDSConfig.cpp