dunedaq::oks::OksAttribute Class Reference

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 93 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 104 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 181 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 196 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 154 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 508 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 308 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 562 of file attribute.hpp.

{
  p_data_type = get_data_type(t, len);
}

clean_range()

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

inlineprivate

Definition at line 530 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 729 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 61 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 277 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 423 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 417 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 358 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 117 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 413 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 461 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 136 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 157 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 436 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 285 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 334 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 318 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 372 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 165 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 222 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 480 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 79 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 104 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 67 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 73 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 227 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 267 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 631 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 659 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 538 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 608 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 592 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 645 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 544 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 673 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 510 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 55 of file attribute.cpp.

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

Friends And Related Symbol Documentation

OksClass

friend class OksClass

friend

Definition at line 96 of file attribute.hpp.

OksData

friend struct OksData

friend

Definition at line 99 of file attribute.hpp.

OksIndex

friend class OksIndex

friend

Definition at line 97 of file attribute.hpp.

OksKernel

friend class OksKernel

friend

Definition at line 95 of file attribute.hpp.

OksObject

friend class OksObject

friend

Definition at line 98 of file attribute.hpp.

operator<<

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

friend

equality operator

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

bool_type

const char * dunedaq::oks::OksAttribute::bool_type = "bool"

static

Valid attribute types

Definition at line 467 of file attribute.hpp.

class_type

const char * dunedaq::oks::OksAttribute::class_type = "class"

static

Definition at line 483 of file attribute.hpp.

date_type

const char * dunedaq::oks::OksAttribute::date_type = "date"

static

Definition at line 478 of file attribute.hpp.

description_xml_attr

const char dunedaq::oks::OksAttribute::description_xml_attr = "description"

staticprivate

Definition at line 550 of file attribute.hpp.

double_type

const char * dunedaq::oks::OksAttribute::double_type = "double"

static

Definition at line 477 of file attribute.hpp.

enum_type

const char * dunedaq::oks::OksAttribute::enum_type = "enum"

static

Definition at line 482 of file attribute.hpp.

float_type

const char * dunedaq::oks::OksAttribute::float_type = "float"

static

Definition at line 476 of file attribute.hpp.

format_xml_attr

const char dunedaq::oks::OksAttribute::format_xml_attr = "format"

staticprivate

Definition at line 552 of file attribute.hpp.

init_value_xml_attr

const char dunedaq::oks::OksAttribute::init_value_xml_attr = "init-value"

staticprivate

Definition at line 556 of file attribute.hpp.

is_multi_value_xml_attr

const char dunedaq::oks::OksAttribute::is_multi_value_xml_attr = "is-multi-value"

staticprivate

Definition at line 554 of file attribute.hpp.

is_not_null_xml_attr

const char dunedaq::oks::OksAttribute::is_not_null_xml_attr = "is-not-null"

staticprivate

Definition at line 557 of file attribute.hpp.

mv_implement_xml_attr

const char dunedaq::oks::OksAttribute::mv_implement_xml_attr[]

staticprivate

Definition at line 555 of file attribute.hpp.

name_xml_attr

const char dunedaq::oks::OksAttribute::name_xml_attr = "name"

staticprivate

Definition at line 549 of file attribute.hpp.

ordered_xml_attr

const char dunedaq::oks::OksAttribute::ordered_xml_attr = "ordered"

staticprivate

Definition at line 558 of file attribute.hpp.

p_class

OksClass* dunedaq::oks::OksAttribute::p_class

private

Definition at line 497 of file attribute.hpp.

p_data_type

OksData::Type dunedaq::oks::OksAttribute::p_data_type

private

Definition at line 491 of file attribute.hpp.

p_description

std::string dunedaq::oks::OksAttribute::p_description

private

Definition at line 496 of file attribute.hpp.

p_empty_init_data

OksData dunedaq::oks::OksAttribute::p_empty_init_data

private

Definition at line 501 of file attribute.hpp.

p_enumerators

std::vector<std::string>* dunedaq::oks::OksAttribute::p_enumerators

private

Definition at line 498 of file attribute.hpp.

p_format

Format dunedaq::oks::OksAttribute::p_format

private

Definition at line 495 of file attribute.hpp.

p_init_data

OksData dunedaq::oks::OksAttribute::p_init_data

private

Definition at line 500 of file attribute.hpp.

p_init_value

std::string dunedaq::oks::OksAttribute::p_init_value

private

Definition at line 494 of file attribute.hpp.

p_multi_values

bool dunedaq::oks::OksAttribute::p_multi_values

private

Definition at line 492 of file attribute.hpp.

p_name

std::string dunedaq::oks::OksAttribute::p_name

private

Definition at line 489 of file attribute.hpp.

p_no_null

bool dunedaq::oks::OksAttribute::p_no_null

private

Definition at line 493 of file attribute.hpp.

p_ordered

bool dunedaq::oks::OksAttribute::p_ordered

private

Definition at line 502 of file attribute.hpp.

p_range

std::string dunedaq::oks::OksAttribute::p_range

private

Definition at line 490 of file attribute.hpp.

p_range_obj

OksRange* dunedaq::oks::OksAttribute::p_range_obj

private

Definition at line 499 of file attribute.hpp.

range_xml_attr

const char dunedaq::oks::OksAttribute::range_xml_attr = "range"

staticprivate

Definition at line 553 of file attribute.hpp.

s16_int_type

const char * dunedaq::oks::OksAttribute::s16_int_type = "s16"

static

Definition at line 470 of file attribute.hpp.

s32_int_type

const char * dunedaq::oks::OksAttribute::s32_int_type = "s32"

static

Definition at line 472 of file attribute.hpp.

s64_int_type

const char * dunedaq::oks::OksAttribute::s64_int_type = "s64"

static

Definition at line 474 of file attribute.hpp.

s8_int_type

const char * dunedaq::oks::OksAttribute::s8_int_type = "s8"

static

Definition at line 468 of file attribute.hpp.

string_type

const char * dunedaq::oks::OksAttribute::string_type = "string"

static

Definition at line 480 of file attribute.hpp.

time_type

const char * dunedaq::oks::OksAttribute::time_type = "time"

static

Definition at line 479 of file attribute.hpp.

type_xml_attr

const char dunedaq::oks::OksAttribute::type_xml_attr = "type"

staticprivate

Definition at line 551 of file attribute.hpp.

u16_int_type

const char * dunedaq::oks::OksAttribute::u16_int_type = "u16"

static

Definition at line 471 of file attribute.hpp.

u32_int_type

const char * dunedaq::oks::OksAttribute::u32_int_type = "u32"

static

Definition at line 473 of file attribute.hpp.

u64_int_type

const char * dunedaq::oks::OksAttribute::u64_int_type = "u64"

static

Definition at line 475 of file attribute.hpp.

u8_int_type

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

static

Definition at line 469 of file attribute.hpp.

uid_type

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

static

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