irsol::utils Namespace Reference

Contains general utility functions used throughout the irsol library. More...

Namespaces
namespace	internal
	Contains internal helper constants and functions.

Classes
class	SafeQueue
	A thread-safe, optionally bounded queue with blocking push and pop operations. More...

Functions
int	toInt (const irsol::types::protocol_value_t &x)
	Converts a protocol value to an integer.
double	toDouble (const irsol::types::protocol_value_t &x)
	Converts a protocol value to a double.
std::string	toString (const irsol::types::protocol_value_t &x)
	Converts a protocol value to a string.
std::string	uuid ()
	Generates a new UUID string.
std::vector< std::string >	split (const std::string &s, char delimiter)
	Splits a string into tokens based on a delimiter.
std::string	strip (const std::string &s, const std::string &delimiters=" \t\r\n")
	Removes leading and trailing characters from a string.
std::string	stripString (const std::string &s, const std::string &strippedString)
	Removes all occurrences of a specific substring from the start and end of a string.
std::string	timestampToString (irsol::types::timepoint_t tp)
	Converts a steady_clock time point to a human-readable string.
std::string	durationToString (irsol::types::duration_t dr)
	Converts a duration to a human-readable string.
std::vector< irsol::types::byte_t >	stringToBytes (const std::string &s)
	Converts a std::string to a std::vector of irsol::types::byte_t.
std::string	bytesToString (const std::vector< irsol::types::byte_t > &input)
	Converts a std::vector of irsol::types::byte_t to a std::string.
NeoAPI::Cam	loadDefaultCamera ()
	Loads the default camera device.
NeoAPI::CamInfoList &	discoverCameras ()
	Discovers all cameras connected to the system.

Detailed Description

Contains general utility functions used throughout the irsol library.

This namespace provides helper functions for type conversions, string manipulations, timestamp formatting, and camera device management.

Function Documentation

bytesToString()

std::string irsol::utils::bytesToString

(

const std::vector< irsol::types::byte_t > &

input

)

Converts a std::vector of irsol::types::byte_t to a std::string.

Each byte is reinterpreted as a character. This assumes that the bytes represent valid character data (e.g., UTF-8 or ASCII).

Parameters

input

The input irsol::types::byte_t vector to convert.

Returns

std::string A string constructed from the byte-wise content.

Definition at line 189 of file utils.cpp.

{
  const auto* data = reinterpret_cast<const char*>(input.data());
  return std::string(data, data + input.size());
}

discoverCameras()

NeoAPI::CamInfoList & irsol::utils::discoverCameras

(

)

Discovers all cameras connected to the system.

Uses NeoAPI to scan and retrieve information about all connected cameras. The returned reference remains valid until the next call to discoverCameras().

Returns

A reference to a list of all discovered cameras.

Definition at line 216 of file utils.cpp.

{
  IRSOL_LOG_TRACE("Discovering cameras");
  NeoAPI::CamInfoList& infoList = NeoAPI::CamInfoList::Get();
  IRSOL_LOG_TRACE("Refreshing camera list");
  infoList.Refresh();
 
  return infoList;
}

durationToString()

std::string irsol::utils::durationToString

(

irsol::types::duration_t

dr

)

Converts a duration to a human-readable string.

Converts a irsol::types::duration_t into a formatted string representing the duration.

Parameters

dr	The duration to convert.

Returns

A human-readable string representation of the duration.

Definition at line 133 of file utils.cpp.

{
  std::stringstream ss;
  if(dr.count() == 0) {
    return "0ns";
  }
 
  if(dr >= std::chrono::hours(1)) {
    auto hours = std::chrono::duration_cast<std::chrono::hours>(dr);
    ss << std::to_string(hours.count());
    ss << "hours ";
    dr -= hours;
  }
  if(dr >= std::chrono::minutes(1)) {
    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(dr);
    ss << std::setw(2) << std::setfill('0') << std::to_string(minutes.count());
    ss << "minutes ";
    dr -= minutes;
  }
  if(dr >= std::chrono::seconds(1)) {
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(dr);
    ss << std::setw(2) << std::setfill('0') << std::to_string(seconds.count());
    ss << "s ";
    dr -= seconds;
  }
  if(dr >= std::chrono::milliseconds(1)) {
    auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(dr);
    ss << std::setw(3) << std::setfill('0') << std::to_string(milliseconds.count());
    ss << "ms ";
    dr -= milliseconds;
  }
  if(dr >= std::chrono::microseconds(1)) {
    auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(dr);
    ss << std::setw(3) << std::setfill('0') << std::to_string(microseconds.count());
    ss << "us ";
    dr -= microseconds;
  }
  if(dr >= std::chrono::nanoseconds(1)) {
    auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(dr);
    ss << std::setw(3) << std::setfill('0') << std::to_string(nanoseconds.count());
    ss << "ns ";
    dr -= nanoseconds;
  }
 
  auto result = ss.str();
  return strip(result, " 0");
}

loadDefaultCamera()

NeoAPI::Cam irsol::utils::loadDefaultCamera

(

)

Loads the default camera device.

Queries the NeoAPI for connected cameras and attempts to open the camera with the default serial number defined in irsol::utils::internal::defaultCameraSerialNumber().

Exceptions

std::runtime_error

If no matching camera is found or initialization fails.

Returns

A handle to the opened NeoAPI camera device.

Definition at line 196 of file utils.cpp.

{
  IRSOL_LOG_DEBUG("Loading default camera");
  NeoAPI::Cam cam = NeoAPI::Cam();
 
  const auto cameraSerialNumber = internal::defaultCameraSerialNumber();
  IRSOL_LOG_TRACE("Trying to connect to default camera with SN '{0:s}'.", cameraSerialNumber);
  try {
    cam.Connect(cameraSerialNumber);
  } catch(NeoAPI::NotConnectedException& e) {
    IRSOL_ASSERT_FATAL(false, "Camera connection failed: %s", e.GetDescription());
    throw e;
  }
  IRSOL_ASSERT_FATAL(cam.IsConnected(), "Camera is not connected");
  IRSOL_LOG_DEBUG("Camera connection successful");
 
  return cam;
}

split()

std::vector< std::string > irsol::utils::split	(	const std::string &	s,
		char	delimiter
	)

Splits a string into tokens based on a delimiter.

Parses the input string s and splits it into substrings each time the character delimiter is encountered.

Parameters

s	The string to split.
delimiter	The character to use as the delimiter.

Returns

A vector of token substrings.

Definition at line 50 of file utils.cpp.

{
  std::vector<std::string> tokens;
  std::string              token;
  for(char c : s) {
    if(c == delimiter) {
      if(!token.empty()) {
        tokens.push_back(token);
        token.clear();
      }
    } else {
      token += c;
    }
  }
  if(!token.empty()) {
    tokens.push_back(token);
  }
  return tokens;
}

stringToBytes()

std::vector< irsol::types::byte_t > irsol::utils::stringToBytes

(

const std::string &

s

)

Converts a std::string to a std::vector of irsol::types::byte_t.

Each character in the input string is reinterpreted as a irsol::types::byte_t.

Parameters

s	The input string to convert.

Returns

A vector containing the byte-wise representation of the string.

Definition at line 182 of file utils.cpp.

{
  const auto* data = reinterpret_cast<const irsol::types::byte_t*>(s.data());
  return {data, data + s.size()};
}

strip()

std::string irsol::utils::strip	(	const std::string &	s,
		const std::string &	delimiters = " \t\r\n"
	)

Removes leading and trailing characters from a string.

Removes any characters contained in the delimiters string from both the start and the end of the input string s. Useful for trimming whitespace or custom characters.

Parameters

s	The input string to process.
delimiters	A string containing all characters to strip (default is whitespace characters).

Returns

A new string with specified characters removed from both ends.

Definition at line 71 of file utils.cpp.

{
  size_t start = 0;
  size_t end   = s.size();
  IRSOL_LOG_TRACE("Stripping delimiters '{0:s}' from string '{1:s}'", delimiters, s);
  while((start < end) && (delimiters.find(s[start]) != std::string::npos)) {
    start++;
  }
  while((start < end) && (delimiters.find(s[end - 1]) != std::string::npos)) {
    end--;
  }
 
  auto result = s.substr(start, end - start);
  IRSOL_LOG_TRACE("Stripped string '{0:s}' is '{1:s}'", s, result);
  return result;
}

stripString()

std::string irsol::utils::stripString	(	const std::string &	s,
		const std::string &	strippedString
	)

Removes all occurrences of a specific substring from the start and end of a string.

If the string s begins or ends with the substring strippedString, those occurrences are removed. This is repeated until s no longer starts or ends with that substring.

Parameters

s	The original string.
strippedString	The substring to remove from both ends.

Returns

A new string with the specified substring removed from start and end.

Definition at line 89 of file utils.cpp.

{
  // Check if the stripped string is present in the input string at the beginning
  std::string result{s};
  IRSOL_LOG_TRACE("Stripping string '{0:s}' from string '{1:s}'", strippedString, s);
 
  if(result.find(strippedString) == 0) {
    result = result.substr(strippedString.length());
  }
 
  // Check if the stripped string is present in the input string at the end
  if(result.rfind(strippedString) == result.size() - strippedString.size()) {
    result = result.substr(0, result.size() - strippedString.size());
  }
 
  IRSOL_LOG_TRACE(
    "Stripped string '{0:s}' from string '{1:s}' is '{2:s}'", s, strippedString, result);
 
  return result;
}

timestampToString()

std::string irsol::utils::timestampToString

(

irsol::types::timepoint_t

tp

)

Converts a steady_clock time point to a human-readable string.

Converts a irsol::types::timepoint_t into a formatted string representation.

Parameters

tp	The time point to convert.

Returns

A human-readable string representation of the time point.

Definition at line 111 of file utils.cpp.

{
  using system_clock_t = std::chrono::system_clock;
  auto now_sys         = std::chrono::time_point_cast<system_clock_t::duration>(
    tp - irsol::types::clock_t::now() + system_clock_t::now());
 
  // Extract microseconds from time since epoch
  auto us = std::chrono::duration_cast<std::chrono::microseconds>(now_sys.time_since_epoch()) %
            std::chrono::seconds(1);
 
  // Convert to time_t for formatting
  std::time_t t_c = system_clock_t::to_time_t(now_sys);
  std::tm     tm  = *std::localtime(&t_c);
 
  std::stringstream ss;
  ss << std::put_time(&tm, "%F %T");                             // Date and time to seconds
  ss << '.' << std::setfill('0') << std::setw(6) << us.count();  // Append microseconds
 
  return ss.str();
}

toDouble()

double irsol::utils::toDouble ( const irsol::types::protocol_value_t &  x )

inline

Converts a protocol value to a double.

Extracts and returns the underlying double from the variant type irsol::types::protocol_value_t.

Parameters

x	The protocol value to convert.

Returns

The double representation of the input value.

Exceptions

std::bad_variant_access

if the variant does not hold a double.

Definition at line 55 of file utils.hpp.

{
  return std::get<double>(x);
}

toInt()

int irsol::utils::toInt ( const irsol::types::protocol_value_t &  x )

inline

Converts a protocol value to an integer.

Extracts and returns the underlying int from the variant type irsol::types::protocol_value_t.

Parameters

x	The protocol value to convert.

Returns

The integer representation of the input value.

Exceptions

std::bad_variant_access

if the variant does not hold an int.

Definition at line 39 of file utils.hpp.

{
  return std::get<int>(x);
}

toString()

std::string irsol::utils::toString ( const irsol::types::protocol_value_t &  x )

inline

Converts a protocol value to a string.

Extracts and returns the underlying std::string from the variant type irsol::types::protocol_value_t.

Parameters

x	The protocol value to convert.

Returns

The string representation of the input value.

Exceptions

std::bad_variant_access

if the variant does not hold a string.

Definition at line 71 of file utils.hpp.

{
  return std::get<std::string>(x);
}

uuid()

std::string irsol::utils::uuid

(

)

Generates a new UUID string.

Generates a version 4 (random) UUID and returns it as a string.

Returns

A newly generated UUID string, e.g., "123e4567-e89b-12d3-a456-426614174000".

Definition at line 16 of file utils.cpp.

{
  static std::random_device       rd;
  static std::mt19937             gen(rd());
  std::uniform_int_distribution<> dis(0, 15);
  std::uniform_int_distribution<> dis2(8, 11);
 
  std::stringstream ss;
  ss << std::hex;
 
  for(int i = 0; i < 8; i++) {
    ss << dis(gen);
  }
  ss << "-";
  for(int i = 0; i < 4; i++) {
    ss << dis(gen);
  }
  ss << "-4";  // Version 4
  for(int i = 0; i < 3; i++) {
    ss << dis(gen);
  }
  ss << "-";
  ss << dis2(gen);
  for(int i = 0; i < 3; i++) {
    ss << dis(gen);
  }
  ss << "-";
  for(int i = 0; i < 12; i++) {
    ss << dis(gen);
  }
  return ss.str();
}