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 106 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 118 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 211 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 227 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 162 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 611 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 340 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 670 of file attribute.hpp.

{
  p_data_type = get_data_type(t, len);
}

◆ clean_range()

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

inlineprivate

Definition at line 635 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 810 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 67 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 309 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 482 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 475 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 422 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 136 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 495 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 556 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 159 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 184 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 524 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 322 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 389 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 366 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 443 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 175 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 243 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 523 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 89 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 120 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 77 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 83 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 252 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 297 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 694 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 725 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 645 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 667 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 649 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 710 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 594 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 740 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 554 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 57 of file attribute.cpp.

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

Definition at line 269 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 655 of file attribute.hpp.

◆ bool_type

◆ u8_int_type

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

static

Definition at line 568 of file attribute.hpp.

◆ uid_type

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

static

Definition at line 580 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