irsol::protocol::Parser Class Reference

Parses raw input strings into structured InMessage instances. More...

#include <parser.hpp>

Static Public Member Functions
static std::optional< InMessage >	parse (const std::string &line)
	Attempts to parse a single protocol input line into a structured InMessage.

Static Private Member Functions
static internal::ParserResult< Assignment >	parseAssignment (const std::string &line)
	Parses an assignment message from a protocol line.
static internal::ParserResult< Inquiry >	parseInquiry (const std::string &line)
	Parses an inquiry message from a protocol line.
static internal::ParserResult< Command >	parseCommand (const std::string &line)
	Parses a command message from a protocol line.
static irsol::types::protocol_value_t	parseValue (const std::string &valueString)
	Attempts to parse a raw value string into a typed protocol value.

Detailed Description

Parses raw input strings into structured InMessage instances.

The Parser provides static methods to convert protocol input lines (e.g., x=42, reset, x?) into well-formed irsol::protocol::InMessage variants. Parsing is designed to be robust and safe, returning an empty result on failure.

Definition at line 31 of file parser.hpp.

Member Function Documentation

parse()

std::optional< InMessage > irsol::protocol::Parser::parse ( const std::string &  line )

static

Attempts to parse a single protocol input line into a structured InMessage.

This method sequentially tries to interpret the input string as one of the supported message types:

• Assignment (e.g., "foo=42" or "temp[1]=36.5"): Key-value bindings with optional indexed identifiers.
• Inquiry (e.g., "foo?" or "temp[2]?"): Used to query the current value of an identifier.
• Command (e.g., "reset" or "shutdown"): Control messages without arguments.

The function internally trims whitespace, applies regular expressions to match expected message formats, and uses helper functions to convert the raw string into a strongly-typed variant.

Parsing proceeds in order of decreasing specificity:

1. parseAssignment() is attempted first. If it fails, the reason is recorded.
2. parseInquiry() is attempted next. If it fails, the reason is recorded.
3. parseCommand() is attempted last.

If none of the parsers succeed, a warning is logged with details from each parsing attempt, and the method returns std::nullopt.

Parameters

line	A raw protocol line (e.g., from a client or script), which may contain leading/trailing whitespace.

Returns

An optional containing the parsed InMessage variant if successful, or std::nullopt on failure.

See also

parseAssignment

parseInquiry

parseCommand

Definition at line 11 of file parser.cpp.

{
  IRSOL_LOG_TRACE("Parsing string '{}' for message", line);
  std::string s = utils::trim(line);
  IRSOL_LOG_TRACE("Trimmed result: '{}'", s);
  std::vector<std::string> errorMessages;
  errorMessages.reserve(3);
  if(auto asg = parseAssignment(s)) {
    IRSOL_LOG_TRACE(
      "String '{}' parsed as assignment message: '{}'", line, asg.getMessage().toString());
    return asg.getMessage();
  } else {
    errorMessages.push_back(asg.getError());
  }
  if(auto inq = parseInquiry(s)) {
    IRSOL_LOG_TRACE("String '{}' parsed as inquiry message: {}", line, inq.getMessage().toString());
    return inq.getMessage();
  } else {
    errorMessages.push_back(inq.getError());
  }
  if(auto cmd = parseCommand(s)) {
    IRSOL_LOG_TRACE("String '{}' parsed as command message: {}", line, cmd.getMessage().toString());
    return cmd.getMessage();
  } else {
    errorMessages.push_back(cmd.getError());
  }
 
  std::string fullErrorMessage = "";
  for(const auto& errorMessage : errorMessages) {
    fullErrorMessage += errorMessage + "; ";
  }
  IRSOL_LOG_WARN(
    "String '{}' could not be parsed as any known message type. {}", line, fullErrorMessage);
  return std::nullopt;
}

parseAssignment()

internal::ParserResult< Assignment > irsol::protocol::Parser::parseAssignment ( const std::string &  line )

staticprivate

Parses an assignment message from a protocol line.

Matches lines of the form:

identifier=value

where:

• identifier must begin with a letter and contain alphanumeric characters and underscores.
• Array-style indexing is supported, e.g., array[0], arr[1][2].
• value is interpreted as an integer, double, or string, depending on its format.

Valid examples:

• "x=42"
• "temperature[1]=36.5"
• ‘"name='Alice’"`
• `"meta={some description}"`

If the regex matches but value parsing fails, an error string is returned. If the format does not match, a descriptive parsing error is returned.

Parameters

line	The raw line to parse.

Returns

A ParserResult containing a valid Assignment or an error message.

Definition at line 48 of file parser.cpp.

{
  // An assignment line looks like:
  // <identifier>=<value>
  // where:
  // <identifier> is a string of alphanumeric characters and underscores (no spaces allowed), with
  // optional array-indexing <value> is a string that is dynamically interpreted as an integer,
  // double, or string The '=' is mandatory.
 
  // Example valid assignment lines:
  // foo=32
  // bar=53.6
  // qux_123=0.432
  // _underscore=43
  // array_like[1]=hello
  // nested_array_like[1][2]=0  -> TODO: multidimensional has commas for indices and not multiple
  // brackets. single_quote='single quote' double_quote="double quote" braces={sting value}
  static const std::regex re(R"(^([a-zA-Z]+[a-zA-Z0-9_]*(?:\[\d+\])*)=(.+)$)");
  std::smatch             m;
  std::string             errorMessage;
  if(std::regex_match(line, m, re)) {
    try {
      return {Assignment{utils::trim(m[1]), parseValue(utils::trim(m[2]))}};
    } catch(const std::invalid_argument& e) {
      errorMessage = e.what();
    }
  } else {
    errorMessage = "Regex pattern for Assignment did not match";
  }
  return {std::move(errorMessage)};
}

parseCommand()

internal::ParserResult< Command > irsol::protocol::Parser::parseCommand ( const std::string &  line )

staticprivate

Parses a command message from a protocol line.

Matches lines consisting of a single bare identifier:

identifier

where:

• identifier must start with a letter and contain only alphanumeric characters and underscores.
• No parameters or arguments are allowed.

Valid examples:

• "reset"
• "shutdown"
• "ping"

Returns a Command object on success, or an error message on failure.

Parameters

line	The raw line to parse.

Returns

A ParserResult containing a valid Command or an error message.

Definition at line 113 of file parser.cpp.

{
  // A command line looks like:
  // <identifier>
  // where:
  // <identifier> is a string of alphanumeric characters and underscores (no spaces allowed)
 
  // Example valid command lines:
  // foo
  // bar
  // qux_123
  // _underscore
 
  static const std::regex re(R"(^([a-zA-Z]+[a-zA-Z0-9_]*)$)");
  std::smatch             m;
  std::string             errorMessage;
  if(std::regex_match(line, m, re)) {
    try {
      return {Command{utils::trim(m[1])}};
    } catch(const std::invalid_argument& e) {
      errorMessage = e.what();
    }
  } else {
    errorMessage = "Regex pattern for Command did not match";
  }
  return {std::move(errorMessage)};
}

parseInquiry()

internal::ParserResult< Inquiry > irsol::protocol::Parser::parseInquiry ( const std::string &  line )

staticprivate

Parses an inquiry message from a protocol line.

Matches lines of the form:

identifier?

where:

• identifier must begin with a letter and contain alphanumeric characters and underscores.
• Array-style indexing is supported (e.g., array[0]).
• Whitespace is trimmed before matching.

Valid examples:

• "x?"
• "temperature[1]?"
• "config_setting?"

Returns a valid Inquiry message on success, or a detailed error message on failure.

Parameters

line	The raw line to parse.

Returns

A ParserResult containing a valid Inquiry or an error message.

Definition at line 81 of file parser.cpp.

{
  // An inquiry line looks like:
  // <identifier>?
  // where:
  // <identifier> is a string of alphanumeric characters and underscores (no spaces allowed), with
  // optional array-indexing The '?' is mandatory.
 
  // Example valid inquiry lines:
  // foo?
  // bar?
  // qux_123?
  // _underscore?
  // array_like[1]?
  // nested_array_like[1][2]?
 
  static const std::regex re(R"(^([a-zA-Z]+[a-zA-Z0-9_]*(?:\[\d+\])*)\?$)");
  std::smatch             m;
  std::string             errorMessage;
  if(std::regex_match(line, m, re)) {
    try {
      return {Inquiry{utils::trim(m[1])}};
    } catch(const std::invalid_argument& e) {
      errorMessage = e.what();
    }
  } else {
    errorMessage = "Regex pattern for Inquiry did not match";
  }
  return {std::move(errorMessage)};
}

parseValue()

irsol::types::protocol_value_t irsol::protocol::Parser::parseValue ( const std::string &  valueString )

staticprivate

Attempts to parse a raw value string into a typed protocol value.

The parser uses the following heuristics, in order:

1. If the string can be converted to a double, and contains . or scientific notation (e/E), it is treated as a double.
2. If the value is numeric and within int range, it is converted to int.
3. If the value is quoted with ‘’,"<tt>, or wrapped in</tt>{}<tt>, the delimiters are stripped and the result is returned as a</tt>std::string`. 4. Otherwise, the raw string is returned as-is. Examples: - <tt>"42"</tt> → <tt>int</tt> - <tt>"3.14"</tt> → <tt>double</tt> - <tt>"1e-3"</tt> → <tt>double</tt> - &lsquo;"'hello’"`, `'"hello"'`, `"{hello}"` → `"hello"` - `"raw_string"` → `"raw_string"`

Parameters

valueString

The string representation of the value (right-hand side of an assignment).

Returns

A irsol::types::protocol_value_t holding the parsed value.

Definition at line 142 of file parser.cpp.

{
  // Try double first (more general)
  try {
    double d = utils::fromString<double>(valStr);
 
    // Heuristic: if the string contains a '.' or 'e'/'E', treat it as double
    // This allows to parse a value such as '5.0' as a double, not an int.
    if(
      valStr.find('.') != std::string::npos || valStr.find('e') != std::string::npos ||
      valStr.find('E') != std::string::npos) {
      return d;
    }
 
    // Otherwise, treat as int if within range
    if(d >= std::numeric_limits<int>::min() && d <= std::numeric_limits<int>::max()) {
      return static_cast<int>(d);
    }
 
    return d;
  } catch(...) {
    // Fall through
  }
 
  // Else, string (strip quotes/braces if needed)
  if(
    !valStr.empty() && ((valStr.front() == '"' && valStr.back() == '"') ||
                        (valStr.front() == '\'' && valStr.back() == '\'') ||
                        (valStr.front() == '{' && valStr.back() == '}'))) {
    return valStr.substr(1, valStr.size() - 2);
  }
 
  return valStr;
}

---

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

• src/irsol/include/irsol/protocol/parsing/parser.hpp
• src/irsol/lib/irsol/protocol/parsing/parser.cpp