dunedaq::oks::OksMethod Class Reference

OKS method class. More...

#include <method.hpp>

Collaboration diagram for dunedaq::oks::OksMethod:

Public Member Functions
	OksMethod (const std::string &name, OksClass *p=nullptr)
	OKS method constructor.
	OksMethod (const std::string &name, const std::string &description, OksClass *p=nullptr)
	OKS method constructor.
	~OksMethod ()
bool	operator== (const class OksMethod &) const
const std::string &	get_name () const noexcept
void	set_name (const std::string &name)
	Set method name.
const std::string &	get_description () const noexcept
void	set_description (const std::string &description)
	Set method description.
const std::list< OksMethodImplementation * > *	implementations () const noexcept
OksMethodImplementation *	find_implementation (const std::string &language) const
	Find method implementation.
void	add_implementation (const std::string &language, const std::string &prototype, const std::string &body)
	Add method implementation.
void	remove_implementation (const std::string &language)
	Remove method implementation.

Private Member Functions
	OksMethod (OksXmlInputStream &, OksClass *)
void	save (OksXmlOutputStream &) const

Private Attributes
OksClass *	p_class
std::string	p_name
std::string	p_description
std::list< OksMethodImplementation * > *	p_implementations

Static Private Attributes
static const char	method_xml_tag [] = "method"
static const char	name_xml_attr [] = "name"
static const char	description_xml_attr [] = "description"

Friends
class	OksKernel
class	OksClass
class	OksMethodImplementation
std::ostream &	operator<< (std::ostream &s, const OksMethod &m)

Detailed Description

OKS method class.

The class implements OKS method that is a part of OKS class. It has name, description and implementations.

Methods can be used in generated Data Access Libraries (DAL). This allows to insert user-defined methods (also known as "DAL algorithms") into generated DAL classes. In such case the method should have appropriate implementations for c++ and/or Java languages. For more information on DAL generation see oksdalgen User's Guide.

Definition at line 152 of file method.hpp.

Constructor & Destructor Documentation

OksMethod() [1/3]

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

OKS method constructor.

Create new OKS method providing name.

The parameter is:

Parameters

name	name of the method

Definition at line 108 of file method.cpp.

                                                      :
  p_class       (p),
  p_name        (nm),
  p_implementations (nullptr)
{
  try {
    oks::validate_not_empty(p_name, "method name");
  }
  catch(std::exception& ex) {
    Oks::error_msg("OksMethod::OksMethod()") << ex.what() << std::endl;
  }
}

OksMethod() [2/3]

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

OKS method constructor.

Create new OKS method providing name and descriptions.

The parameter is:

Parameters

name	name of the method (max 128 bytes, see #s_max_name_length variable)
description	description of the method (max 2000 bytes, see #s_max_description_length variable)

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 121 of file method.cpp.

                                                                             :
  p_class       (p),
  p_name        (nm),
  p_description     (desc),
  p_implementations (nullptr)
{
  oks::validate_not_empty(p_name, "method name");
}

~OksMethod()

dunedaq::oks::OksMethod::~OksMethod

(

)

Definition at line 130 of file method.cpp.

{
  if(p_implementations) {
    while(!p_implementations->empty()) {
      OksMethodImplementation * i = p_implementations->front();
      p_implementations->pop_front();
      delete i;
    }
 
    delete p_implementations;
  }
}

OksMethod() [3/3]

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

private

Definition at line 229 of file method.cpp.

                                                            :
 p_class           (parent),
 p_implementations (0)
{
  try {
    while(true) {
      OksXmlAttribute attr(s);
 
        // check for close of tag
 
      if(oks::cmp_str1(attr.name(), ">")) { break; }
 
        // check for known oks-relationship' attributes
 
      else if(oks::cmp_str4(attr.name(), name_xml_attr)) p_name.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str11(attr.name(), description_xml_attr)) p_description.assign(attr.value(), attr.value_len());
      else {
        s.throw_unexpected_attribute(attr.name());
      }
    }
  }
  catch(oks::exception & e) {
    throw oks::FailedRead("xml method", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("xml method", e.what());
  }
 
    // check validity of read values
 
  try {
    oks::validate_not_empty(p_name, "method name");
  }
  catch(std::exception& ex) {
    throw oks::FailedRead("oks method", oks::BadFileData(ex.what(), s.get_line_no(), s.get_line_pos()));
  }
 
 
    // read 'body' and 'method-actions'
 
  {
    while(true) try {
      const char * tag_start = s.get_tag_start();
 
      if(oks::cmp_str7(tag_start, "/method")) { break; }
 
      else if(!strcmp(tag_start, "method-implementation")) {
    if(!p_implementations) p_implementations = new std::list<OksMethodImplementation *>();
    p_implementations->push_back(new OksMethodImplementation(s, this));
      }
 
      else {
        std::ostringstream text;
    text << "Unexpected tag \'" << tag_start << "\' inside method \'" << p_name << "\'\n";
        throw std::runtime_error( text.str().c_str() );
      }
 
    }
    catch (oks::exception & e) {
      throw oks::FailedRead("method tag", e);
    }
    catch (std::exception & e) {
      throw oks::FailedRead("method tag", e.what());
    }
  }
}

Member Function Documentation

add_implementation()

void dunedaq::oks::OksMethod::add_implementation	(	const std::string &	language,
		const std::string &	prototype,
		const std::string &	body )

Add method implementation.

Add new method implementation. Implementations linked with method shall have different languages.

Parameters

language	language of method implementation
prototype	prototype of method implementation
body	body of method implementation

In case of problems the oks::exception is thrown.

Definition at line 365 of file method.cpp.

{
  if(find_implementation(language)) {
    std::ostringstream text;
    text << "Cannot add implementation on language \"" << language << "\" since it already exists.";
    throw oks::SetOperationFailed("OksMethod::add_implementation", text.str());
  }
 
  if(p_class) p_class->lock_file("OksMethod::add_implementation");
 
  if(!p_implementations) {
    p_implementations = new std::list<OksMethodImplementation *>();
  }
 
  OksMethodImplementation * i = new OksMethodImplementation(language, prototype, body);
 
  p_implementations->push_back(i);
  i->p_method = this;
 
  if(p_class) p_class->registrate_class_change(OksClass::ChangeMethodImplementation, (const void *)this);
}

find_implementation()

OksMethodImplementation * dunedaq::oks::OksMethod::find_implementation

(

const std::string &

language

)

const

Find method implementation.

Find method implementation by language.

Parameters

language

language of method implementation

Returns

the pointer on method implementation for given language, or 0, if it is not found

Definition at line 354 of file method.cpp.

{
  if(p_implementations) {
    for(std::list<OksMethodImplementation *>::iterator i = p_implementations->begin(); i != p_implementations->end(); ++i)
      if(language == (*i)->get_language()) return *i;
  }
 
  return 0;
}

get_description()

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

inlinenoexcept

Get description of method.

Definition at line 214 of file method.hpp.

{return p_description;}

get_name()

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

inlinenoexcept

Get name of method.

Definition at line 196 of file method.hpp.

{return p_name;}

implementations()

const std::list< OksMethodImplementation * > * dunedaq::oks::OksMethod::implementations ( ) const

inlinenoexcept

Get implementations of method.

Definition at line 230 of file method.hpp.

{return p_implementations;}

operator==()

bool dunedaq::oks::OksMethod::operator==

(

const class OksMethod &

m

)

const

Definition at line 145 of file method.cpp.

{
    // check if compare with self
 
  if(this == &m) return true;
 
 
    // check if attributes are different
 
  if(p_name != m.p_name || p_description != m.p_description) return false;
 
 
    // check if methods have no implementations
 
  if(p_implementations == 0 && m.p_implementations == 0) return true;
 
 
    // check if only one method has implementation
 
  if(p_implementations == 0 || m.p_implementations == 0) return false;
 
 
    // check if numbers of implementations are different
 
  if(p_implementations->size() != m.p_implementations->size()) return false;
 
 
    // check implementations
 
  std::list<OksMethodImplementation *>::const_iterator i1 = p_implementations->begin();
  std::list<OksMethodImplementation *>::const_iterator i2 = m.p_implementations->begin();
  
  for(;i1 != p_implementations->end(); ++i1, ++i2) {
    if( !(*(*i1) == *(*i2)) ) return false;
  }
  
  return true;
}

remove_implementation()

void dunedaq::oks::OksMethod::remove_implementation

(

const std::string &

language

)

Remove method implementation.

Remove method implementation by language.

Parameters

language

language of method implementation

In case of problems the oks::exception is thrown.

Definition at line 388 of file method.cpp.

{
  OksMethodImplementation * i = find_implementation(language);
 
  if(i == 0) {
    std::ostringstream text;
    text << "Cannot remove implementation on language \"" << language << "\" since it does not exist.";
    throw oks::SetOperationFailed("OksMethod::remove_implementation", text.str());
  }
 
  if(p_class) p_class->lock_file("OksMethod::remove_implementation");
 
  p_implementations->remove(i);
 
  if(p_implementations->empty()) {
    delete p_implementations;
    p_implementations = 0;
  }
 
  if(p_class) p_class->registrate_class_change(OksClass::ChangeMethodImplementation, (const void *)this);
}

save()

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

private

Definition at line 204 of file method.cpp.

{
  s.put_raw(' ');
  s.put_raw(' ');
 
  s.put_start_tag(method_xml_tag, sizeof(method_xml_tag)-1);
  
  s.put_attribute(name_xml_attr, sizeof(name_xml_attr)-1, p_name.c_str());
  s.put_attribute(description_xml_attr, sizeof(description_xml_attr)-1, p_description.c_str());
 
  s.put_raw('>');
  s.put_raw('\n');
 
  if(p_implementations) {
    for(std::list<OksMethodImplementation *>::iterator i = p_implementations->begin(); i != p_implementations->end(); ++i)
      (*i)->save(s);
  }
 
  s.put_raw(' ');
  s.put_raw(' ');
 
  s.put_last_tag(method_xml_tag, sizeof(method_xml_tag)-1);
}

set_description()

void dunedaq::oks::OksMethod::set_description

(

const std::string &

description

)

Set method description.

Parameters

description

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

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 412 of file method.cpp.

{
  if(p_description != desc) {
    if(p_class) p_class->lock_file("OksMethod::set_description");
 
    p_description = desc;
 
    if(p_class) p_class->registrate_class_change(OksClass::ChangeMethodDescription, (const void *)this);
  }
}

set_name()

void dunedaq::oks::OksMethod::set_name

(

const std::string &

name

)

Set method name.

Methods linked with the same class shall have different names.

Parameters

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

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 298 of file method.cpp.

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

Friends And Related Symbol Documentation

OksClass

friend class OksClass

friend

Definition at line 155 of file method.hpp.

OksKernel

friend class OksKernel

friend

Definition at line 154 of file method.hpp.

OksMethodImplementation

friend class OksMethodImplementation

friend

Definition at line 156 of file method.hpp.

operator<<

std::ostream & operator<< ( std::ostream & s, const OksMethod & m )

friend

Definition at line 184 of file method.cpp.

{
  s << "Method name: \"" << m.p_name << "\"\n"
       " description: \"" << m.p_description << "\"\n";
    
  if(m.p_implementations) {
    s << " implementations:\n";
 
    for(std::list<OksMethodImplementation *>::const_iterator i = m.p_implementations->begin(); i != m.p_implementations->end(); ++i)
      s << *(*i);
  }
  else
    s << " there are no implementation(s)\n";
 
  return s;
}

Member Data Documentation

description_xml_attr

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

staticprivate

Definition at line 293 of file method.hpp.

method_xml_tag

const char dunedaq::oks::OksMethod::method_xml_tag = "method"

staticprivate

Definition at line 291 of file method.hpp.

name_xml_attr

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

staticprivate

Definition at line 292 of file method.hpp.

p_class

OksClass* dunedaq::oks::OksMethod::p_class

private

Definition at line 277 of file method.hpp.

p_description

std::string dunedaq::oks::OksMethod::p_description

private

Definition at line 279 of file method.hpp.

p_implementations

std::list<OksMethodImplementation *>* dunedaq::oks::OksMethod::p_implementations

private

Definition at line 280 of file method.hpp.

p_name

std::string dunedaq::oks::OksMethod::p_name

private

Definition at line 278 of file method.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/oks/include/oks/method.hpp
• /github/workspace/dunedaq/sourcecode/oks/src/method.cpp