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 46 of file attribute.hpp.

Constructor & Destructor Documentation

OksRange()

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

inline

Definition at line 50 of file attribute.hpp.

  {
    reset(range, a);
  }

Member Function Documentation

clear()

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

inlineprivate

Definition at line 80 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 62 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 844 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 945 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 72 of file attribute.hpp.

m_great

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

private

Definition at line 74 of file attribute.hpp.

m_interval

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

private

Definition at line 73 of file attribute.hpp.

m_less

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

private

Definition at line 71 of file attribute.hpp.

m_like

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

private

Definition at line 75 of file attribute.hpp.

m_range

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

private

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