OKS attribute class. More...

#include <attribute.hpp>

Collaboration diagram for dunedaq::oks::OksAttribute:

Public Types
enum	Format { Oct = 8 , Dec = 10 , Hex = 16 }

Public Member Functions
	OksAttribute (const std::string &name, OksClass *p=nullptr)
	OKS attribute simple constructor.

	OksAttribute (const std::string &name, const std::string &type, bool is_mv, const std::string &range, const std::string &init_v, const std::string &description, bool no_null, Format format=Dec, OksClass *p=nullptr)
	OKS attribute complete constructor.

	~OksAttribute ()

bool	operator== (const class OksAttribute &) const

const std::string &	get_name () const noexcept
	out stream operator

void	set_name (const std::string &name)
	Set attribute name.

const std::string &	get_type () const noexcept
	Get attribute string type.

void	set_type (const std::string &type, bool skip_init=false)
	Set attribute type.

const std::string &	get_range () const noexcept
	Get attribute range.

void	set_range (const std::string &range)
	Set attribute range.

OksData::Type	get_data_type () const noexcept

Format	get_format () const noexcept
	Get attribute format.

void	set_format (Format format)
	Set attribute format.

bool	is_integer () const noexcept

bool	is_number () const noexcept

bool	get_is_multi_values () const noexcept

void	set_is_multi_values (bool multi_values)
	Set attribute is a single-value or multi-value.

const std::string &	get_init_value () const noexcept

void	set_init_value (const std::string &init_value)
	Set attribute initialisation value.

std::list< std::string >	get_init_values () const
	Return list of initial values for mv-attribute.

const std::string &	get_description () const noexcept

void	set_description (const std::string &description)
	Set attribute description.

bool	get_is_no_null () const noexcept

void	set_is_no_null (bool no_null)
	Set attribute is-no-null property.

int	get_enum_index (const char *s, size_t length) const noexcept
	Finds index of given string in attribute's range.

int	get_enum_index (const std::string &s) const noexcept
	See get_enum_index(const char *, size_t);.

const std::string *	get_enum_value (const char *s, size_t length) const
	Returns pointer on internal enumerator data equal to given string, if such string is defined in attribute's range.

const std::string *	get_enum_value (const std::string &s) const
	See get_enum_value(const char *, size_t).

uint16_t	get_enum_value (const OksData &d) const noexcept
	Returns index of given enumeration in attribute's range (0 or positive integer value).

const std::string *	get_enum_string (uint16_t idx) const noexcept
	Returns enumeration string by value.

Static Public Member Functions
static OksData::Type	get_data_type (const std::string &type) noexcept
	Converts string to attribute OKS data type.

static OksData::Type	get_data_type (const char *type, size_t len) noexcept
	Converts string to attribute OKS data type (fast version).

static bool	find_token (const char token, const char range) noexcept
	Finds token in given range.

static Format	str2format (const char *) noexcept

static const char *	format2str (Format) noexcept

Static Public Attributes
static const char *	bool_type = "bool"

static const char *	s8_int_type = "s8"

static const char *	u8_int_type = "u8"

static const char *	s16_int_type = "s16"

static const char *	u16_int_type = "u16"

static const char *	s32_int_type = "s32"

static const char *	u32_int_type = "u32"

static const char *	s64_int_type = "s64"

static const char *	u64_int_type = "u64"

static const char *	float_type = "float"

static const char *	double_type = "double"

static const char *	date_type = "date"

static const char *	time_type = "time"

static const char *	string_type = "string"

static const char *	uid_type = "uid"

static const char *	enum_type = "enum"

static const char *	class_type = "class"

Private Member Functions
void	__set_data_type (const char *t, size_t len) noexcept

	OksAttribute (OksData::Type t, const OksClass *c) noexcept

	OksAttribute (OksXmlInputStream &, OksClass *)

void	save (OksXmlOutputStream &) const

void	init_enum ()

void	init_range ()

void	clean_range ()

void	set_init_data ()

Private Attributes
std::string	p_name

std::string	p_range

OksData::Type	p_data_type

bool	p_multi_values

bool	p_no_null

std::string	p_init_value

Format	p_format

std::string	p_description

OksClass *	p_class

std::vector< std::string > *	p_enumerators

OksRange *	p_range_obj

OksData	p_init_data

OksData	p_empty_init_data

bool	p_ordered

Static Private Attributes
static const char	attribute_xml_tag [] = "attribute"

static const char	name_xml_attr [] = "name"

static const char	description_xml_attr [] = "description"

static const char	type_xml_attr [] = "type"

static const char	format_xml_attr [] = "format"

static const char	range_xml_attr [] = "range"

static const char	is_multi_value_xml_attr [] = "is-multi-value"

static const char	mv_implement_xml_attr []

static const char	init_value_xml_attr [] = "init-value"

static const char	is_not_null_xml_attr [] = "is-not-null"

static const char	ordered_xml_attr [] = "ordered"

Friends
class	OksKernel

class	OksClass

class	OksIndex

class	OksObject

struct	OksData

std::ostream &	operator<< (std::ostream &s, const OksAttribute &a)
	equality operator

Detailed Description

OKS attribute class.

This class implements OKS attribute that is a part of an OKS class. An attribute has name, type, range, initial value and description. An attribute can be single-value or multi-value. An attribute can be non-null.

Definition at line 101 of file attribute.hpp.

Member Enumeration Documentation

◆ Format

enum dunedaq::oks::OksAttribute::Format

Format for integer representation (OKS data file, print output)

Enumerator
Oct
Dec
Hex

Definition at line 113 of file attribute.hpp.

              {
    Oct = 8,
    Dec = 10,
    Hex = 16
  };

Constructor & Destructor Documentation

◆ OksAttribute() [1/4]

dunedaq::oks::OksAttribute::OksAttribute	(	const std::string &	name,
		OksClass *	p = nullptr )

OKS attribute simple constructor.

Create new OKS attribute providing name.

The parameter is:

Parameters

name	name of the attribute
p	containing parent class

Exceptions

oks::exception is thrown in case of problems.

Definition at line 206 of file attribute.cpp.

                                                            :
  p_name       (nm),
  p_data_type      (OksData::string_type),
  p_multi_values   (false),
  p_no_null    (false),
  p_format         (OksAttribute::Dec),
  p_class          (p),
  p_enumerators    (nullptr),
  p_range_obj      (nullptr),
  p_ordered        (false)
 
{
  validate_not_empty(p_name, "attribute name");
}

◆ OksAttribute() [2/4]

dunedaq::oks::OksAttribute::OksAttribute	(	const std::string &	name,
		const std::string &	type,
		bool	is_mv,
		const std::string &	range,
		const std::string &	init_v,
		const std::string &	description,
		bool	no_null,
		Format	format = Dec,
		OksClass *	p = nullptr )

OKS attribute complete constructor.

Create new OKS attribute providing all properties.

The parameters are:

Parameters

name	name of the attribute (max 128 bytes, see #s_max_name_length variable)
type	type of attribute; see set_type() for details
is_mv	if true, the attribute is multi-values, see set_is_multi_values() for details
range	range of attribute, see set_range() for details
init_v	initial value of attribute
description	description of the method (max 2000 bytes, see #s_max_description_length variable)
no_null	if true, the value of attribute cannot be null, see set_is_no_null() for details
format	format of attribute for integers, see set_format() for details
p	containing parent class

Exceptions

oks::exception is thrown in case of problems.

Definition at line 222 of file attribute.cpp.

                                                     :
  p_name       (nm),
  p_range      (r),
  p_data_type      (get_data_type(t)),
  p_multi_values   (is_mv),
  p_no_null        (no_null),
  p_init_value     (init_v),
  p_format         (f),
  p_description    (ds),
  p_class      (p),
  p_enumerators    (nullptr),
  p_range_obj      (nullptr),
  p_ordered        (false)
{
  set_type(t, true);
  validate_not_empty(p_name, "attribute name");
  init_enum();
  init_range();
  // cannot call set_init_data() because of the CLASS data type, since other class may not be known yet;
  // initialize the init_data in the register_all_classes() call
}

◆ ~OksAttribute()

dunedaq::oks::OksAttribute::~OksAttribute ( )

inline

Definition at line 157 of file attribute.hpp.

  {
    if (p_enumerators)
      delete p_enumerators;
 
    clean_range();
  }

◆ OksAttribute() [3/4]

dunedaq::oks::OksAttribute::OksAttribute	(	OksData::Type	t,
		const OksClass *	c )

inlineprivatenoexcept

Private constructor used by OksData

Definition at line 606 of file attribute.hpp.

                                                           :
      p_data_type(t), p_class(const_cast<OksClass*>(c)), p_enumerators(nullptr), p_range_obj(nullptr), p_ordered(false)
  {
    ;
  }

◆ OksAttribute() [4/4]

dunedaq::oks::OksAttribute::OksAttribute	(	OksXmlInputStream &	s,
		OksClass *	parent )

private

Private constructor from XML stream

Definition at line 335 of file attribute.cpp.

                                                                 :
  p_data_type      (OksData::unknown_type),
  p_multi_values   (false),
  p_no_null    (false),
  p_format         (OksAttribute::Dec),
  p_class          (parent),
  p_enumerators    (nullptr),
  p_range_obj      (nullptr),
  p_ordered        (false)
{
  // read attributes of OksAttribute from xml
 
  try
    {
      while (true)
        {
          OksXmlAttribute attr(s);
 
          // check for close of tag
 
          if (cmp_str1(attr.name(), "/"))
            {
              break;
            }
 
          // check for known oks-attribute' attributes
 
          else if (cmp_str4(attr.name(), name_xml_attr))
            p_name.assign(attr.value(), attr.value_len());
          else if (cmp_str11(attr.name(), description_xml_attr))
            p_description.assign(attr.value(), attr.value_len());
          else if (cmp_str4(attr.name(), type_xml_attr))
            {
              __set_data_type(attr.value(), attr.value_len());
              if (p_data_type == OksData::unknown_type)
                {
                  throw BadFileData(std::string("Value \'") + attr.value() + "\' is not a valid attribute type", s.get_line_no(), s.get_line_pos());
                }
            }
          else if (cmp_str5(attr.name(), range_xml_attr))
            p_range.assign(attr.value(), attr.value_len());
          else if (cmp_str6(attr.name(), format_xml_attr))
            p_format = str2format(attr.value());
          else if (cmp_str14(attr.name(), is_multi_value_xml_attr))
            p_multi_values = xml::str2bool(attr.value());
          else if (cmp_str10(attr.name(), init_value_xml_attr))
            p_init_value.assign(attr.value(), attr.value_len());
          else if (cmp_str11(attr.name(), is_not_null_xml_attr))
            p_no_null = xml::str2bool(attr.value());
          else if (cmp_str7(attr.name(), ordered_xml_attr))
            p_ordered = xml::str2bool(attr.value());
          else if (!strcmp(attr.name(), "multi-value-implementation"))
            s.error_msg("OksAttribute::OksAttribute(OksXmlInputStream&)") << "Obsolete oks-attribute\'s attribute \'" << attr.name() << "\'\n";
          else
            s.throw_unexpected_attribute(attr.name());
        }
    }
  catch (exception & e)
    {
      throw FailedRead("xml attribute", e);
    }
  catch (std::exception & e)
    {
      throw FailedRead("xml attribute", e.what());
    }
 
  // check validity of read values
 
  if (p_data_type == OksData::unknown_type)
    {
      throw FailedRead("oks attribute", BadFileData("attribute type is not set", s.get_line_no(), s.get_line_pos()));
    }
 
  try
    {
      validate_not_empty(p_name, "attribute name");
      init_enum();
      init_range();
    }
  catch (std::exception& ex)
    {
      throw FailedRead("oks attribute", BadFileData(ex.what(), s.get_line_no(), s.get_line_pos()));
    }
 
  if (p_init_value.empty())
    {
      if (p_data_type == OksData::class_type && p_multi_values == false)
        {
          std::ostringstream text;
          text << "single-value attribute \"" << p_name << "\" is of \"class_type\" and has empty init value";
          throw FailedRead("oks attribute", BadFileData(text.str(), s.get_line_no(), s.get_line_pos()));
        }
    }
  else
    {
      if (p_data_type == OksData::date_type || p_data_type == OksData::time_type)
        {
          try
            {
              OksData _d;
              if (p_multi_values)
                {
                  _d.SetValues(p_init_value.c_str(), this);
                }
              else
                {
                  _d.type = p_data_type;
                  _d.SetValue(p_init_value.c_str(), 0);
                }
            }
          catch (exception& ex)
            {
              std::ostringstream text;
              text << "attribute \"" << p_name << "\" has bad init value:\n" << ex.what();
              throw FailedRead("oks attribute", BadFileData(text.str(), s.get_line_no(), s.get_line_pos()));
            }
        }
    }
 
  try
    {
      validate_init2range(this);
    }
  catch (std::exception& ex)
    {
      std::ostringstream text;
      text << "attribute \"" << p_name << "\" has mismatch between init value and range:\n" << ex.what();
      throw FailedRead("oks attribute", BadFileData(text.str(), s.get_line_no(), s.get_line_pos()));
    }
 
//  set_init_data();
}

Member Function Documentation

◆ __set_data_type()

void dunedaq::oks::OksAttribute::__set_data_type	(	const char *	t,
		size_t	len )

inlineprivatenoexcept

Definition at line 665 of file attribute.hpp.

{
  p_data_type = get_data_type(t, len);
}

◆ clean_range()

void dunedaq::oks::OksAttribute::clean_range ( )

inlineprivate

Definition at line 630 of file attribute.hpp.

  {
    if (p_range_obj)
      {
        delete p_range_obj;
        p_range_obj = nullptr;
      }
  }

◆ find_token()

bool dunedaq::oks::OksAttribute::find_token	(	const char *	token,
		const char *	range )

staticnoexcept

Finds token in given range.

Parameters

token	string to find
range	pass true to declare the value cannot be null

Returns: The method returns true, if the token is found in the range

Definition at line 805 of file attribute.cpp.

{
  const char * p;
 
  if (token && (p = strstr(range, token)) != 0)
    {
      int len = strlen(token);
 
      do
        {
          if (((p != range) && (p[-1] != ',')) || ((p[len] != ',') && (p[len] != '\0')))
            {
              p = strstr(p + 1, token);
            }
          else
            {
              return true;
            }
 
        }
      while (p != 0);
    }
 
  return false;
}

◆ format2str()

const char * dunedaq::oks::OksAttribute::format2str ( Format f )

staticnoexcept

Definition at line 62 of file attribute.cpp.

{
  return (
    f == Dec ? "dec" :
    f == Hex ? "hex" :
    "oct"
  );
}

◆ get_data_type() [1/3]

OksData::Type dunedaq::oks::OksAttribute::get_data_type ( ) const

inlinenoexcept

Get attribute OKS data type.

Definition at line 304 of file attribute.hpp.

  {
    return p_data_type;
  }

◆ get_data_type() [2/3]

OksData::Type dunedaq::oks::OksAttribute::get_data_type	(	const char *	type,
		size_t	len )

staticnoexcept

Converts string to attribute OKS data type (fast version).

See set_type() for more information about allowed values.

Parameters

type	the string value to be converted to data type
len	lenght of type value

Returns: the OKS data type; return OksData::unknown_type if the type cannot be detected

Definition at line 477 of file attribute.cpp.

{
  switch(len) {
    case 3:
      if     ( cmp_str3n  (t, uid_type)     ) return OksData::uid2_type;     // "uid"
      else if( cmp_str3n  (t, u32_int_type) ) return OksData::u32_int_type;  // "u32"
      else if( cmp_str3n  (t, s32_int_type) ) return OksData::s32_int_type;  // "s32"
      else if( cmp_str3n  (t, u16_int_type) ) return OksData::u16_int_type;  // "u16"
      else if( cmp_str3n  (t, s16_int_type) ) return OksData::s16_int_type;  // "s16"
      else if( cmp_str3n  (t, s64_int_type) ) return OksData::s64_int_type;  // "s64"
      else if( cmp_str3n  (t, u64_int_type) ) return OksData::u64_int_type;  // "u64"
      break;
 
    case 6:
      if(      cmp_str6n  (t, string_type)  ) return OksData::string_type;   // "string"
      else if( cmp_str6n  (t, double_type)  ) return OksData::double_type;   // "double"
      break;
 
    case 4:
      if(      cmp_str4n (t, bool_type)     ) return OksData::bool_type;    // "bool"
      else if( cmp_str4n (t, enum_type)     ) return OksData::enum_type;    // "enum"
      else if( cmp_str4n (t, date_type)     ) return OksData::date_type;    // "date"
      else if( cmp_str4n (t, time_type)     ) return OksData::time_type;    // "time"
      break;
 
    case 5:
      if(      cmp_str5n  (t, float_type)   ) return OksData::float_type;   // "float"
      else if( cmp_str5n  (t, class_type)   ) return OksData::class_type;   // "class"
      break;
 
    case 2:
      if(      cmp_str2n  (t, s8_int_type)  ) return OksData::s8_int_type;  // "s8"
      else if( cmp_str2n  (t, u8_int_type)  ) return OksData::u8_int_type;  // "u8"
      break;
  }
 
  return OksData::unknown_type;
}

◆ get_data_type() [3/3]

OksData::Type dunedaq::oks::OksAttribute::get_data_type ( const std::string & type )

staticnoexcept

Converts string to attribute OKS data type.

See set_type() for more information about allowed values.

Parameters

type	the string value to be converted to data type

Returns: the OKS data type; return OksData::unknown_type if the type cannot be detected

Definition at line 470 of file attribute.cpp.

{
  return get_data_type(t.c_str(), t.size());
}

◆ get_description()

const std::string & dunedaq::oks::OksAttribute::get_description ( ) const

inlinenoexcept

Return description of attribute

Definition at line 417 of file attribute.hpp.

  {
    return p_description;
  }

◆ get_enum_index() [1/2]

int dunedaq::oks::OksAttribute::get_enum_index	(	const char *	s,
		size_t	length ) const

noexcept

Finds index of given string in attribute's range.

The method can only be applied, if attribute is enumeration.

Parameters

s	string to find
length	length of string

Returns: The method returns 0 or positive integer index, if the string was found, and negative integer, if not.

Definition at line 131 of file attribute.cpp.

{
  if (p_data_type == OksData::enum_type)
    {
      for (int i = 0; i < (int) p_enumerators->size(); ++i)
        {
          const std::string * x = &((*p_enumerators)[i]);
          if (x->length() == length)
            {
              if (memcmp(s, x->data(), length) == 0)
                {
                  return i;
                }
            }
        }
 
      return (-1);
    }
 
  return (-2);
}

◆ get_enum_index() [2/2]

int dunedaq::oks::OksAttribute::get_enum_index ( const std::string & s ) const

inlinenoexcept

See get_enum_index(const char *, size_t);.

Definition at line 490 of file attribute.hpp.

  {
    return get_enum_index(s.data(), s.length());
  }

◆ get_enum_string()

const std::string * dunedaq::oks::OksAttribute::get_enum_string ( uint16_t idx ) const

inlinenoexcept

Returns enumeration string by value.

The method can only be applied, if attribute is enumeration and the index is within number of items in enumeration range.

Parameters

idx	enumeration index

Returns: The method returns pointer on string corresponding to enumeration integer value.

Definition at line 551 of file attribute.hpp.

  {
    return &(*p_enumerators)[idx];
  }

◆ get_enum_value() [1/3]

const std::string * dunedaq::oks::OksAttribute::get_enum_value	(	const char *	s,
		size_t	length ) const

Returns pointer on internal enumerator data equal to given string, if such string is defined in attribute's range.

The method can only be applied, if attribute is enumeration. The returned pointer is valid unless the attribute is not destroyed or modified.

Parameters

s	string to find
length	length of string

Returns: The method returns pointer on internal enumerator data, if given string is defined in attribute's range.

Exceptions

std::exception is thrown, if no such string found.

Definition at line 154 of file attribute.cpp.

{
  if (p_data_type == OksData::enum_type)
    {
      for (unsigned int i = 0; i < p_enumerators->size(); ++i)
        {
          const std::string * x = &((*p_enumerators)[i]);
          if (x->length() == length)
            {
              if (memcmp(s, x->data(), length) == 0)
                {
                  return x;
                }
            }
        }
 
      std::ostringstream text;
      text << "value \'" << s << "\' is out of range \'" << get_range() << '\'';
      throw std::runtime_error(text.str().c_str());
    }
 
  throw std::runtime_error("attribute is not enumeration");
}

◆ get_enum_value() [2/3]

uint16_t dunedaq::oks::OksAttribute::get_enum_value ( const OksData & d ) const

noexcept

Returns index of given enumeration in attribute's range (0 or positive integer value).

The method can only be applied, if attribute is enumeration and the data were created for given attribute.

Parameters

d	OKS data created for given attribute

Returns: The method returns integer value of given enumeration.

Definition at line 179 of file attribute.cpp.

{
  const std::string * p_enumerators_first(&((*p_enumerators)[0]));
  return (d.data.ENUMERATION - p_enumerators_first);
}

◆ get_enum_value() [3/3]

const std::string * dunedaq::oks::OksAttribute::get_enum_value ( const std::string & s ) const

inline

See get_enum_value(const char *, size_t).

Definition at line 519 of file attribute.hpp.

  {
    return get_enum_value(s.data(), s.length());
  }

◆ get_format()

Format dunedaq::oks::OksAttribute::get_format ( ) const

inlinenoexcept

Get attribute format.

The format meaning is described by the set_format() method.

Definition at line 317 of file attribute.hpp.

  {
    return p_format;
  }

◆ get_init_value()

const std::string & dunedaq::oks::OksAttribute::get_init_value ( ) const

inlinenoexcept

The attribute initialisation value.

Definition at line 384 of file attribute.hpp.

  {
    return p_init_value;
  }

◆ get_init_values()

std::list< std::string > dunedaq::oks::OksAttribute::get_init_values ( ) const

Return list of initial values for mv-attribute.

Exceptions

oks::AttributeReadError is thrown if initial values became invalid (may happen for class_type attributes),

◆ get_is_multi_values()

bool dunedaq::oks::OksAttribute::get_is_multi_values ( ) const

inlinenoexcept

The method returns true, if the attribute is multi-values.

Definition at line 361 of file attribute.hpp.

  {
    return p_multi_values;
  }

◆ get_is_no_null()

bool dunedaq::oks::OksAttribute::get_is_no_null ( ) const

inlinenoexcept

Return true, if the attribute's value cannot be equal to null.

Definition at line 438 of file attribute.hpp.

  {
    return p_no_null;
  }

◆ get_name()

const std::string & dunedaq::oks::OksAttribute::get_name ( ) const

inlinenoexcept

out stream operator

Definition at line 170 of file attribute.hpp.

  {
    return p_name;
  }

◆ get_range()

const std::string & dunedaq::oks::OksAttribute::get_range ( ) const

inlinenoexcept

Get attribute range.

The range meaning is described by the set_range() method.

Definition at line 238 of file attribute.hpp.

  {
    return p_range;
  }

◆ get_type()

const std::string & dunedaq::oks::OksAttribute::get_type ( ) const

noexcept

Get attribute string type.

The type meaning is described by the set_type() method.

Definition at line 518 of file attribute.cpp.

{
  static std::string __types [] = {
    "unknown",     // unknown_type = 0
    "s8",          // s8_int_type  = 1
    "u8",          // u8_int_type  = 2
    "s16",         // s16_int_type = 3,
    "u16",         // u16_int_type = 4,
    "s32",         // s32_int_type = 5,
    "u32",         // u32_int_type = 6,
    "s64",         // s64_int_type = 7,
    "u64",         // u64_int_type = 8,
    "float",       // float_type   = 9,
    "double",      // double_type  = 10,
    "bool",        // bool_type    = 11,
    "class",       // class_type   = 12,
    "object",      // object_type  = 13,
    "date",        // date_type    = 14,
    "time",        // time_type    = 15,
    "string",      // string_type  = 16,
    "list",        // list_type    = 17,
    "uid",         // uid_type     = 18,
    "uid2",        // uid2_type    = 19,
    "enum"         // enum_type    = 20
  };
 
  return __types[(int)p_data_type];
}

◆ init_enum()

void dunedaq::oks::OksAttribute::init_enum ( )

private

Definition at line 84 of file attribute.cpp.

{
  if (p_data_type == OksData::enum_type)
    {
      if (p_enumerators)
        {
          p_enumerators->clear();
        }
      else
        {
          p_enumerators = new std::vector<std::string>();
        }
 
      Oks::Tokenizer t(p_range, ",");
      std::string token;
 
      while (t.next(token))
        {
          p_enumerators->push_back(token);
        }
 
      if (p_enumerators->empty())
        {
          std::ostringstream text;
          text << "range of enumeration attribute \"" << p_name << "\" is empty";
          throw std::runtime_error(text.str().c_str());
        }
    }
}

◆ init_range()

void dunedaq::oks::OksAttribute::init_range ( )

private

Definition at line 115 of file attribute.cpp.

{
  clean_range();
 
  if (p_range.empty() == false)
    {
      p_range_obj = new OksRange(p_range, this);
      if (p_range_obj->is_empty())
        {
          clean_range();
        }
    }
}

◆ is_integer()

bool dunedaq::oks::OksAttribute::is_integer ( ) const

noexcept

The method returns true, if the attribute is an integer number.

Definition at line 72 of file attribute.cpp.

{
  return (p_data_type >= OksData::s8_int_type && p_data_type <= OksData::u64_int_type);
}

◆ is_number()

bool dunedaq::oks::OksAttribute::is_number ( ) const

noexcept

The method returns true, if the attribute is a number.

Definition at line 78 of file attribute.cpp.

{
  return (p_data_type >= OksData::s8_int_type && p_data_type <= OksData::bool_type);
}

◆ operator==()

bool dunedaq::oks::OksAttribute::operator== ( const class OksAttribute & a ) const

Definition at line 247 of file attribute.cpp.

{
  return (
    ( this == &a ) ||
    (
      ( p_name == a.p_name ) &&
      ( p_range == a.p_range ) &&
      ( p_data_type == a.p_data_type ) &&
      ( p_multi_values == a.p_multi_values ) &&
      ( p_init_value == a.p_init_value ) &&
      ( p_description == a.p_description ) &&
      ( p_no_null == a.p_no_null ) &&
      ( p_ordered == a.p_ordered )
   )
  );
}

◆ save()

void dunedaq::oks::OksAttribute::save ( OksXmlOutputStream & s ) const

private

Private method to save in XML stream

Definition at line 292 of file attribute.cpp.

{
  if (p_data_type == OksData::class_type && p_init_value.empty() && p_multi_values == false)
    {
      std::ostringstream text;
      text << "single-value attribute \"" << p_name << "\" is of \"class_type\" and has empty init value";
      throw std::runtime_error(text.str().c_str());
    }
 
  validate_init2range(this);
 
  s.put("  ");
  s.put_start_tag(attribute_xml_tag, sizeof(attribute_xml_tag) - 1);
 
  s.put_attribute(name_xml_attr, sizeof(name_xml_attr) - 1, p_name.c_str());
 
  if (!p_description.empty())
    s.put_attribute(description_xml_attr, sizeof(description_xml_attr) - 1, p_description.c_str());
 
  s.put_attribute(type_xml_attr, sizeof(type_xml_attr) - 1, get_type().c_str());
 
  if (!p_range.empty())
    s.put_attribute(range_xml_attr, sizeof(range_xml_attr) - 1, p_range.c_str());
 
  if (is_integer() && p_format != OksAttribute::Dec)
    s.put_attribute(format_xml_attr, sizeof(format_xml_attr) - 1, format2str(p_format));
 
  if (p_multi_values)
    s.put_attribute(is_multi_value_xml_attr, sizeof(is_multi_value_xml_attr) - 1, xml::bool2str(p_multi_values));
 
  if (!p_init_value.empty())
    s.put_attribute(init_value_xml_attr, sizeof(init_value_xml_attr) - 1, p_init_value.c_str());
 
  if (p_no_null)
    s.put_attribute(is_not_null_xml_attr, sizeof(is_not_null_xml_attr) - 1, xml::bool2str(p_no_null));
 
  if (p_ordered)
    s.put_attribute(ordered_xml_attr, sizeof(ordered_xml_attr) - 1, xml::bool2str(p_ordered));
 
  s.put_end_tag();
}

◆ set_description()

void dunedaq::oks::OksAttribute::set_description ( const std::string & description )

Set attribute description.

Parameters

description new description of attribute (max 2000 bytes, see #s_max_description_length variable)

Exceptions

oks::exception is thrown in case of problems.

Definition at line 689 of file attribute.cpp.

{
  if (p_description != ds)
    {
      if (p_class)
        p_class->lock_file("OksAttribute::set_description");
 
      p_description = ds;
 
      if (p_class)
        p_class->registrate_class_change(OksClass::ChangeAttributeDescription, (const void *) this);
    }
}

◆ set_format()

void dunedaq::oks::OksAttribute::set_format ( Format format )

Set attribute format.

There are 3 OKS formats for integer attributes:

dec or decimal (default),
oct or octal,
hex or hexadecimal. For other attributes the format does not make sense.

The value of an integer attribute will be printed out and stored by OKS in the format defined by the schema for that attribute accordingly to C/C++ style. E.g. decimal value 255 can also be presented as 0377 (oct) or 0xFF (hex).

The method parameter is:

Parameters

format new format

Exceptions

oks::exception is thrown in case of problems.

Definition at line 720 of file attribute.cpp.

{
  if (f != p_format)
    {
      if (p_class)
        p_class->lock_file("OksAttribute::set_format");
 
      p_format = f;
 
      if (p_class)
        p_class->registrate_class_change(OksClass::ChangeAttributeFormat, (const void *) this);
    }
}

◆ set_init_data()

void dunedaq::oks::OksAttribute::set_init_data ( )

inlineprivate

Definition at line 640 of file attribute.hpp.

  {
    p_init_data.set_init_value(this, false);
    p_empty_init_data.set_init_value(this, true);
  }

◆ set_init_value()

void dunedaq::oks::OksAttribute::set_init_value ( const std::string & init_value )

Set attribute initialisation value.

When new object is created, this is default value of attribute.

Parameters

multi_values new init value

Exceptions

oks::exception is thrown in case of problems.

Definition at line 662 of file attribute.cpp.

{
  if (p_init_value != init_v)
    {
      std::string old_value = p_init_value;
 
      if (p_class)
        p_class->lock_file("OksAttribute::set_init_value");
 
      p_init_value = init_v;
 
      try
        {
          validate_init2range(this);
        }
      catch (...)
        {
          p_init_value = old_value;
          throw;
        }
 
      if (p_class)
        p_class->registrate_class_change(OksClass::ChangeAttributeInitValue, (const void *) this);
    }
}

◆ set_is_multi_values()

void dunedaq::oks::OksAttribute::set_is_multi_values ( bool multi_values )

Set attribute is a single-value or multi-value.

If true, the attribute value contains multiple single values, e.g. list of numbers, strings, etc.

Parameters

multi_values pass true to declare the value is multi-value

Exceptions

oks::exception is thrown in case of problems.

Definition at line 644 of file attribute.cpp.

{
  if (p_multi_values != is_mv)
    {
      if (p_class)
        p_class->lock_file("OksAttribute::set_is_multi_values");
 
      p_multi_values = is_mv;
 
      if (p_class)
        {
          p_class->registrate_class_change(OksClass::ChangeAttributeMultiValueCardinality, (const void *) this);
          p_class->registrate_attribute_change(this);
        }
    }
}

◆ set_is_no_null()

void dunedaq::oks::OksAttribute::set_is_no_null ( bool no_null )

Set attribute is-no-null property.

If true, a number cannot be 0 or string cannot be empty.

Parameters

no_null pass true to declare the value cannot be null

Exceptions

oks::exception is thrown in case of problems.

Definition at line 705 of file attribute.cpp.

{
  if (p_no_null != no_null)
    {
      if (p_class)
        p_class->lock_file("OksAttribute::set_is_no_null");
 
      p_no_null = no_null;
 
      if (p_class)
        p_class->registrate_class_change(OksClass::ChangeAttributeIsNoNull, (const void *) this);
    }
}

◆ set_name()

void dunedaq::oks::OksAttribute::set_name ( const std::string & name )

Set attribute name.

Attributes linked with the same class shall have different names.

Parameters

name	new name of attribute (max 128 bytes, see #s_max_name_length variable)

Exceptions

oks::exception is thrown in case of problems.

Definition at line 589 of file attribute.cpp.

{
  // ignore when name is the same
 
  if (p_name == new_name)
    return;
 
  // additional checks are required,
  // if the attribute already belongs to some class
 
  if (p_class)
    {
      // check allowed length for attribute name
 
      try
        {
          validate_not_empty(new_name, "name");
        }
      catch (std::exception& ex)
        {
          throw SetOperationFailed("OksAttribute::set_name", ex.what());
        }
 
      // having a direct attribute with the same name is an error
 
      if (p_class->find_direct_attribute(new_name) != 0)
        {
          std::ostringstream text;
          text << "Class \"" << p_class->get_name() << "\" already has direct attribute \"" << new_name << '\"';
          throw SetOperationFailed("OksAttribute::set_name", text.str());
        }
 
      // check that the file can be updated
 
      p_class->lock_file("OksAttribute::set_name");
 
      // probably a non-direct attribute already exists
 
      OksAttribute * a = p_class->find_attribute(new_name);
 
      // change the name
 
      p_name = new_name;
 
      // registrate the change
 
      p_class->registrate_class_change(OksClass::ChangeAttributesList, (const void *) a);
    }
  else
    {
      p_name = new_name;
    }
}

◆ set_range()

void dunedaq::oks::OksAttribute::set_range ( const std::string & range )

Set attribute range.

To define a range the UML syntax is used. It can be defined as list of tokens e.g. "A,B,C..D,*..F,G..*", which means that the attribute may have one of the following value:

A
B
greater or equal to C and less or equal to D
less or equal to F
greater or equal to G

Note, that spaces are not allowed.

The empty range means that the attribute may have any value allowed by its type. The are two exceptions:

boolean attributes have predefined range "true,false"
enumeration attributes shall have non-empty range

Parameters

range new range (max 1024 bytes, see #s_max_range_length variable)

Exceptions

oks::exception is thrown in case of problems.

Definition at line 735 of file attribute.cpp.

{
  if (s != p_range)
    {
      std::string old_value = p_range;
 
      if (p_class)
        p_class->lock_file("OksAttribute::set_range");
 
      p_range.erase();
      int count = 0;
      Oks::Tokenizer t(s, ", \t");
      std::string token;
 
      while (t.next(token))
        {
          if (count++ != 0)
            {
              p_range += ',';
            }
 
          p_range += token;
        }
 
      if (count != 0)
        {
          if (p_data_type == OksData::bool_type)
            {
              p_range.erase();
              throw SetOperationFailed("OksAttribute::set_range", "boolean type can't have user-defined range!");
            }
        }
 
      try
        {
          init_enum();
          init_range();
          validate_init2range(this);
        }
      catch (std::exception& ex)
        {
          p_range = old_value;
 
          try
            {
              init_enum();
            }
          catch (...)
            {
              ;
            }
 
          try
            {
              init_range();
            }
          catch (...)
            {
              ;
            }
 
          throw SetOperationFailed("OksAttribute::set_range", ex.what());
        }
 
      if (p_class)
        p_class->registrate_class_change(OksClass::ChangeAttributeRange, (const void *) this);
    }
}

◆ set_type()

void dunedaq::oks::OksAttribute::set_type	(	const std::string &	type,
		bool	skip_init = false )

Set attribute type.

The valid attribute types are:

"bool" - boolean
"s8" - signed 8-bits integer number
"u8" - unsigned 8-bits integer number
"s16" - signed 16-bits integer number
"u16" - unsigned 16-bits integer number
"s32" - signed 32-bits integer number
"u32" - unsigned 32-bits integer number
"s64" - signed 64-bits integer number
"u64" - unsigned 64-bits integer number
"float" - floating-point number
"double" - double precision floating-point number
"date" - date type
"time" - time type
"string" - string
"enum" - enumeration
"class" - reference on OKS class

Parameters

type	new type
skip_init	if true, do not initialise enum and range

Exceptions

oks::exception is thrown in case of problems.

Definition at line 549 of file attribute.cpp.

{
  OksData::Type p_dt = get_data_type(t);
 
  if (p_dt == OksData::unknown_type)
    {
      std::ostringstream text;
      text << "the type \'" << t << "\' is not valid";
      throw SetOperationFailed("OksAttribute::set_type", text.str());
    }
 
  if (p_data_type == p_dt)
    return;
 
  if (p_class)
    p_class->lock_file("OksAttribute::set_type");
 
  p_data_type = p_dt;
 
  if (skip_init == false)
    {
      try
        {
          init_enum();
          init_range();
        }
      catch (std::exception& ex)
        {
          throw SetOperationFailed("OksAttribute::set_type", ex.what());
        }
    }
 
  if (p_class)
    {
      p_class->registrate_attribute_change(this);
      p_class->registrate_class_change(OksClass::ChangeAttributeType, (const void *) this);
    }
}

◆ str2format()

OksAttribute::Format dunedaq::oks::OksAttribute::str2format ( const char * s )

staticnoexcept

Definition at line 52 of file attribute.cpp.

{
  return (
    cmp_str3(s, "dec") ? Dec :
    cmp_str3(s, "hex") ? Hex :
    Oct
  );
}

Definition at line 106 of file attribute.hpp.

◆ operator<<

std::ostream & operator<<	(	std::ostream &	s,
		const OksAttribute &	a )

friend

equality operator

Definition at line 264 of file attribute.cpp.

{
  s << "Attribute name: \"" << a.p_name << "\"\n"
       " type: \"" << a.get_type() << "\"\n"
       " range: \"" << a.p_range << "\"\n";
 
  if(a.is_integer()) {
    s << " format: \"" << OksAttribute::format2str(a.p_format) << "\"\n";
  }
 
  if(a.p_multi_values == true) {
    s << " is \'multi values\'\n";
  }
  else {
    s << " is \'single value\'\n";
  }
 
  s << " initial value: \"" << a.p_init_value << "\"\n"
       " has description: \"" << a.p_description << "\"\n"
    << (a.p_no_null == true ? " can not be null\n" : " can be null\n")
    << " is " << (a.p_ordered == true ? "ordered" : "unordered") << std::endl;
 
  return s;
}

Member Data Documentation

◆ attribute_xml_tag

const char dunedaq::oks::OksAttribute::attribute_xml_tag = "attribute"

staticprivate

Valid xml tags and attributes

Definition at line 650 of file attribute.hpp.

◆ bool_type

◆ u8_int_type

const char * dunedaq::oks::OksAttribute::u8_int_type = "u8"

static

Definition at line 563 of file attribute.hpp.

◆ uid_type

const char * dunedaq::oks::OksAttribute::uid_type = "uid"

static

Definition at line 575 of file attribute.hpp.

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

/github/workspace/dunedaq/sourcecode/oks/include/oks/attribute.hpp
/github/workspace/dunedaq/sourcecode/oks/src/attribute.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ Format

Constructor & Destructor Documentation

◆ OksAttribute() [1/4]

◆ OksAttribute() [2/4]

◆ ~OksAttribute()

◆ OksAttribute() [3/4]

◆ OksAttribute() [4/4]

Member Function Documentation

◆ __set_data_type()

◆ clean_range()

◆ find_token()

◆ format2str()

◆ get_data_type() [1/3]

◆ get_data_type() [2/3]

◆ get_data_type() [3/3]

◆ get_description()

◆ get_enum_index() [1/2]

◆ get_enum_index() [2/2]

◆ get_enum_string()

◆ get_enum_value() [1/3]

◆ get_enum_value() [2/3]

◆ get_enum_value() [3/3]

◆ get_format()

◆ get_init_value()

◆ get_init_values()

◆ get_is_multi_values()

◆ get_is_no_null()

◆ get_name()

◆ get_range()

◆ get_type()

◆ init_enum()

◆ init_range()

◆ is_integer()

◆ is_number()

◆ operator==()

◆ save()

◆ set_description()

◆ set_format()

◆ set_init_data()

◆ set_init_value()

◆ set_is_multi_values()

◆ set_is_no_null()

◆ set_name()

◆ set_range()

◆ set_type()

◆ str2format()

Friends And Related Symbol Documentation

◆ OksClass

◆ OksData

◆ OksIndex

◆ OksKernel

◆ OksObject

◆ operator<<

Member Data Documentation

◆ attribute_xml_tag

◆ bool_type

◆ class_type

◆ date_type

◆ description_xml_attr

◆ double_type

◆ enum_type

◆ float_type

◆ format_xml_attr

◆ init_value_xml_attr

◆ is_multi_value_xml_attr

◆ is_not_null_xml_attr

◆ mv_implement_xml_attr

◆ name_xml_attr

◆ ordered_xml_attr

◆ p_class