dunedaq::oks::OksRange Class Reference

OKS range class. More...

#include <attribute.hpp>

Public Member Functions
	OksRange (const std::string &range, OksAttribute *a)
void	reset (const std::string &range, OksAttribute *a)
bool	validate (const OksData &) const
bool	is_empty ()

Private Member Functions
void	clear ()

Private Attributes
std::string	m_range
std::list< OksData >	m_less
std::list< OksData >	m_equal
std::list< std::pair< OksData, OksData > >	m_interval
std::list< OksData >	m_great
std::list< boost::regex >	m_like

Detailed Description

OKS range class.

The OksRange class implements OKS range that can be defined for an OKS attribute. The range is a set of list of conditions using UML syntax. For string types the range is a regular expression.

Definition at line 44 of file attribute.hpp.

Constructor & Destructor Documentation

OksRange()

dunedaq::oks::OksRange::OksRange ( const std::string & range, OksAttribute * a )

inline

Definition at line 47 of file attribute.hpp.

{ reset(range, a); }

Member Function Documentation

clear()

void dunedaq::oks::OksRange::clear ( )

inlineprivate

Definition at line 68 of file attribute.hpp.

  {
    m_range.clear();
 
    m_less.clear();
    m_equal.clear();
    m_interval.clear();
    m_great.clear();
    m_like.clear();
  }

is_empty()

bool dunedaq::oks::OksRange::is_empty ( )

inline

Definition at line 53 of file attribute.hpp.

  {
    return (m_less.empty() && m_equal.empty() && m_interval.empty() && m_great.empty() && m_like.empty());
  }

reset()

void dunedaq::oks::OksRange::reset	(	const std::string &	range,
		OksAttribute *	a )

Definition at line 756 of file attribute.cpp.

{
  clear();
 
  if (a->get_data_type() != OksData::string_type) {
    if (!range.empty()) {
      Oks::Tokenizer t(range, ",");
      std::string token, token1, token2;
 
      while (t.next(token)) {
        if (is_star(token)) {
          TLOG_DEBUG(2) << "token \'" << token << "\' of \'" << range << "\' allows any value";
          clear();
          return;
        }
 
        static const char __dot_dot_str[] = "..";
        std::string::size_type p = token.find(__dot_dot_str, 0, (sizeof(__dot_dot_str) - 1));
 
        bool pi; // if true, then it is plus infinity, i.e. x..*
 
        if (p != std::string::npos) {
          token1.assign(token, 0, p);
          token2.assign(token, p + 2, std::string::npos);
          pi = (is_star(token2));
        } else {
          token1.assign(token);
          token2.clear();
          pi = false;
        }
 
        bool mi = (is_star(token1)); // if true, then it is minus infinity, i.e. *..x
 
        if (mi && pi) {
          TLOG_DEBUG(2) << "token \'" << token << "\' of \'" << range << "\' allows any value";
          clear();
          return;
        }
 
        OksData d1, d2;
 
        if (!mi) {
          d1.type = a->get_data_type();
          d1.ReadFrom(token1, a);
        }
 
        if (token2.empty()) {
          TLOG_DEBUG(2) << "token \'" << token << "\' of \'" << range << "\' defines equality condition";
          m_equal.emplace_back(d1);
        } else {
          if (!pi) {
            d2.type = a->get_data_type();
            d2.ReadFrom(token2, a);
          }
 
          if (mi) {
            TLOG_DEBUG(2) << "token \'" << token << "\' of \'" << range << "\' defines smaller condition";
            m_less.emplace_back(d2);
          } else if (pi) {
            TLOG_DEBUG(2) << "token \'" << token << "\' of \'" << range << "\' defines greater condition";
            m_great.emplace_back(d1);
          } else {
            TLOG_DEBUG(2) << "token \'" << token << "\' of \'" << range << "\' defines interval condition";
            m_interval.emplace_back(d1, d2);
          }
        }
      }
    }
  } else {
    try {
      m_like.emplace_back(range);
    } catch (std::exception& ex) {
      throw BadReqExp(range, ex.what());
    }
  }
}

validate()

bool dunedaq::oks::OksRange::validate

(

const OksData &

d

)

const

Definition at line 834 of file attribute.cpp.

{
  for (const auto& x : m_less) {
    if (d <= x)
      return true;
  }
 
  for (const auto& x : m_great) {
    if (d >= x)
      return true;
  }
 
  for (const auto& x : m_equal) {
    if (d == x)
      return true;
  }
 
  for (const auto& x : m_interval) {
    if (d >= x.first && d <= x.second)
      return true;
  }
 
  for (const auto& x : m_like) {
    if (OksKernel::get_skip_string_range())
      return true;
 
    if (boost::regex_match(d.str(), x))
      return true;
  }
 
  return false;
}

Member Data Documentation

m_equal

std::list<OksData> dunedaq::oks::OksRange::m_equal

private

Definition at line 62 of file attribute.hpp.

m_great

std::list<OksData> dunedaq::oks::OksRange::m_great

private

Definition at line 64 of file attribute.hpp.

m_interval

std::list<std::pair<OksData, OksData> > dunedaq::oks::OksRange::m_interval

private

Definition at line 63 of file attribute.hpp.

m_less

std::list<OksData> dunedaq::oks::OksRange::m_less

private

Definition at line 61 of file attribute.hpp.

m_like

std::list<boost::regex> dunedaq::oks::OksRange::m_like

private

Definition at line 65 of file attribute.hpp.

m_range

std::string dunedaq::oks::OksRange::m_range

private

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