oksdalgen.cxx File Reference

#include "class_info.hpp"
#include "oks/kernel.hpp"
#include "oks/class.hpp"
#include "oks/attribute.hpp"
#include "oks/relationship.hpp"
#include "oks/method.hpp"
#include <stdlib.h>
#include <ctype.h>
#include <algorithm>
#include <string>
#include <list>
#include <set>
#include <iostream>

Include dependency graph for oksdalgen.cxx:

Go to the source code of this file.

Functions
std::string	alnum_name (const std::string &in)
std::string	capitalize_name (const std::string &in)
void	print_description (std::ostream &s, const std::string &text, const char *dx)
void	print_indented (std::ostream &s, const std::string &text, const char *dx)
std::string	get_type (oks::OksData::Type oks_type, bool is_cpp)
void	gen_dump_application (std::ostream &s, std::list< std::string > &class_names, const std::string &cpp_ns_name, const std::string &cpp_hdr_dir, const char *conf_header, const char *conf_name, const char *headres_prologue, const char *main_function_prologue)
void	write_info_file (std::ostream &s, const std::string &cpp_namespace, const std::string &cpp_header_dir, const std::set< const oks::OksClass *, std::less< const oks::OksClass * > > &class_names)
std::string	get_full_cpp_class_name (const oks::OksClass *c, const ClassInfo::Map &cl_info, const std::string &cpp_ns_name)
std::string	get_include_dir (const oks::OksClass *c, const ClassInfo::Map &cl_info, const std::string &cpp_hdr_dir)
void	parse_arguments (int argc, char *argv[], std::list< std::string > &class_names, std::list< std::string > &file_names, std::list< std::string > &include_dirs, std::list< std::string > &user_classes, std::string &cpp_dir_name, std::string &cpp_ns_name, std::string &cpp_hdr_dir, std::string &info_file_name, bool &verbose)
bool	process_external_class (ClassInfo::Map &cl_info, const oks::OksClass *c, const std::list< std::string > &include_dirs, const std::list< std::string > &user_classes, bool verbose)
std::string	int2dx (int level)
int	open_cpp_namespace (std::ostream &s, const std::string &value)
void	close_cpp_namespace (std::ostream &s, int level)
std::string	get_method_header_prologue (oks::OksMethodImplementation *)
std::string	get_method_header_epilogue (oks::OksMethodImplementation *)
std::string	get_public_section (oks::OksMethodImplementation *mi)
std::string	get_private_section (oks::OksMethodImplementation *mi)
std::string	get_member_initializer_list (oks::OksMethodImplementation *mi)
std::string	get_method_implementation_body (oks::OksMethodImplementation *mi)
bool	get_add_algo_1 (oks::OksMethodImplementation *mi)
bool	get_add_algo_n (oks::OksMethodImplementation *mi)
oks::OksMethodImplementation *	find_cpp_method_implementation (const oks::OksMethod *method)
static bool	has_superclass (const oks::OksClass *tested, const oks::OksClass *c)
std::string	ltrim (const std::string &s)
std::string	rtrim (const std::string &s)
std::string	trim (const std::string &s)
static void	gen_header (const oks::OksClass *cl, std::ostream &cpp_file, const std::string &cpp_ns_name, const std::string &cpp_hdr_dir, const ClassInfo::Map &cl_info)
static void	set2out (std::ostream &out, const std::set< std::string > &data, bool &is_first)
static void	gen_cpp_body (const oks::OksClass *cl, std::ostream &cpp_s, const std::string &cpp_ns_name, const std::string &cpp_hdr_dir, const ClassInfo::Map &cl_info)
static void	load_schemas (oks::OksKernel &kernel, const std::list< std::string > &file_names, std::set< oks::OksFile *, std::less< oks::OksFile * > > &file_hs)
static void	gen_cpp_header_prologue (const std::string &file_name, std::ostream &s, const std::string &cpp_ns_name, const std::string &cpp_hdr_dir)
static void	gen_cpp_header_epilogue (std::ostream &s)
static void	gen_cpp_body_prologue (const std::string &file_name, std::ostream &src, const std::string &cpp_hdr_dir)
int	main (int argc, char *argv[])

Variables
const std::string	WHITESPACE = " \n\r\t\f\v"
const std::vector< std::string >	cpp_method_virtual_specifiers

Function Documentation

alnum_name()

std::string alnum_name ( const std::string & in )

extern

Definition at line 32 of file utils.cpp.

{
  std::string s(in);
  std::transform(s.begin(), s.end(), s.begin(), cvt_symbol);
  return s;
}

capitalize_name()

std::string capitalize_name ( const std::string & in )

extern

Definition at line 40 of file utils.cpp.

{
  std::string s(in);
  if (!in.empty())
    {
      if (isalpha(in[0]))
        {
          if (islower(in[0]))
            s[0] = toupper(in[0]);
        }
      else
        {
          s.insert(s.begin(), '_');
        }
    }
  return s;
}

close_cpp_namespace()

void close_cpp_namespace ( std::ostream & s, int level )

extern

Definition at line 657 of file utils.cpp.

{
  while (level > 0)
    {
      std::string dx = int2dx(--level);
      s << dx << "}\n";
    }
}

find_cpp_method_implementation()

oks::OksMethodImplementation * find_cpp_method_implementation ( const oks::OksMethod * method )

extern

gen_cpp_body()

static void gen_cpp_body ( const oks::OksClass * cl, std::ostream & cpp_s, const std::string & cpp_ns_name, const std::string & cpp_hdr_dir, const ClassInfo::Map & cl_info )

static

Definition at line 753 of file oksdalgen.cxx.

{
  cpp_s << "#include \"logging/Logging.hpp\"\n\n";
 
  const std::string name(alnum_name(cl->get_name()));
 
  std::set<oks::OksClass *> rclasses;
 
    // for each relationship, include the header file
 
  if (const std::list<oks::OksRelationship*> * rlist = cl->direct_relationships())
    {
      for (const auto& i : *rlist)
        {
          oks::OksClass * c = i->get_class_type();
          if (has_superclass(cl, c) == false && cl != c)
            {
              rclasses.insert(c);
            }
        }
    }
 
  if (const std::list<oks::OksMethod*> * mlist = cl->direct_methods())
    {
      for (const auto& i : *mlist)
        {
          if (oks::OksMethodImplementation * mi = find_cpp_method_implementation(i))
            {
              std::string prototype(mi->get_prototype());
              std::string::size_type idx = prototype.find('(');
 
              if (get_add_algo_n(mi) || get_add_algo_1(mi))
                {
 
                  if (idx != std::string::npos)
                    {
                      idx--;
 
                      // skip spaces between method name and ()
                      while (isspace(prototype[idx]) && idx > 0)
                        idx--;
 
                      // find beginning of the method name
                      while (!isspace(prototype[idx]) && idx > 0)
                        idx--;
 
                      // remove method name and arguments
                      prototype.erase(idx + 1);
 
                      // remove spaces
                      prototype.erase(std::remove_if(prototype.begin(), prototype.end(), [](unsigned char x)
                        { return std::isspace(x);}), prototype.end());
 
                      if (prototype.empty() == false)
                        {
                          idx = prototype.find('*');
                          prototype.erase(idx--);
 
                          if (idx != std::string::npos)
                            {
                              while (isalnum(prototype[idx]) && idx > 0)
                                idx--;
 
                              if(idx == 0 && get_add_algo_1(mi) && prototype.find("const") == 0)
                                prototype.erase(0, 5);
                              else
                                prototype.erase(0, idx+1);
 
                              if (oks::OksClass * c = cl->get_kernel()->find_class(prototype))
                                rclasses.insert(c);
                            }
                        }
                    }
                }
            }
        }
    }
 
  if (!rclasses.empty())
    {
      cpp_s << "  // include files for classes used in relationships and algorithms\n\n";
 
      for (const auto& j : rclasses)
        {
          cpp_s << "#include \"" << get_include_dir(j, cl_info, cpp_hdr_dir) << ".hpp\"\n";
        }
 
      cpp_s << std::endl << std::endl;
    }
 
 
    // open namespace
 
  int ns_level = open_cpp_namespace(cpp_s, cpp_ns_name);
  std::string ns_dx = int2dx(ns_level);
  std::string ns_dx2 = ns_dx + "    ";
 
  const char * dx  = ns_dx.c_str();    // are used for alignment
  const char * dx2 = ns_dx2.c_str();
 
 
    // static objects
 
  cpp_s << dx << "const std::string& " << name << "::s_class_name(dunedaq::conffwk::DalFactory::instance().get_known_class_name_ref(\"" << name << "\"));\n\n";
 
  std::set<std::string> algo_n_set, algo_1_set;
 
  if (const std::list<oks::OksMethod*> * mlist = cl->direct_methods())
    {
      for (const auto& i : *mlist)
        {
          if(oks::OksMethodImplementation * mi = find_cpp_method_implementation(i))
            {
              std::string prototype(mi->get_prototype());
              std::string::size_type idx = prototype.find('(');
 
              if (idx != std::string::npos)
                {
                  idx--;
 
                  // skip spaces between method name and ()
                  while (isspace(prototype[idx]) && idx > 0)
                    idx--;
 
                  // remove method arguments
                  prototype.erase(idx+1);
 
                  // find beginning of the method name
                  while (!isspace(prototype[idx]) && idx > 0)
                    idx--;
 
                  if (idx > 0)
                    {
                      prototype.erase(0, idx+1);
 
                      if (get_add_algo_n(mi))
                        {
                          algo_n_set.insert(prototype);
                        }
                      else if (get_add_algo_1(mi))
                        {
                          algo_1_set.insert(prototype);
                        }
                    }
                }
            }
        }
    }
 
 
  if ( !cl->get_is_abstract() ) {
  cpp_s
    << dx << "  // the factory initializer\n\n"
    << dx << "static struct __" << name << "_Registrator\n"
    << dx << "  {\n"
    << dx << "    __" << name << "_Registrator()\n"
    << dx << "      {\n"
    << dx << "        dunedaq::conffwk::DalFactory::instance().register_dal_class<" << name << ">(\"" << cl->get_name() << "\");\n"
    << dx << "      }\n"
    << dx << "  } registrator;\n\n\n";
  }
 
    // the constructor
 
  cpp_s
    << dx << "  // the constructor\n\n"
    << dx << name << "::" << name << "(conffwk::DalRegistry& db, const conffwk::ConfigObject& o) noexcept :\n"
    << dx << "  " << "dunedaq::conffwk::DalObject(db, o)";
 
 
    // fill member initializer list, if any
 
  std::list<std::string> initializer_list;
 
  if(const std::list<std::string*> * slist = cl->direct_super_classes())
    {
      for(auto & i : *slist)
        {
          initializer_list.push_back(get_full_cpp_class_name(cl->get_kernel()->find_class(*i), cl_info, "") + "(db, o)");
        }
    }
 
  if (const std::list<oks::OksRelationship *> *rlist = cl->direct_relationships())
    {
      for (std::list<oks::OksRelationship*>::const_iterator i = rlist->begin(); i != rlist->end(); ++i)
        {
          if ((*i)->get_high_cardinality_constraint() != oks::OksRelationship::Many)
            {
              initializer_list.push_back(std::string("m_") + alnum_name((*i)->get_name()) + " (nullptr)");
            }
        }
    }
 
 
  if(const std::list<oks::OksMethod*> * mlist = cl->direct_methods())
    {
      for (std::list<oks::OksMethod*>::const_iterator i = mlist->begin(); i != mlist->end(); ++i)
        {
          if (oks::OksMethodImplementation * mi = find_cpp_method_implementation(*i))
            {
              std::string member_initializer = get_member_initializer_list(mi);
              member_initializer.erase(remove(member_initializer.begin(), member_initializer.end(), '\n'), member_initializer.end());
 
              if (!member_initializer.empty())
                {
                  initializer_list.push_back(member_initializer);
                }
            }
        }
    }
 
  if (initializer_list.empty() == false)
    {
      for (auto & i : initializer_list)
        {
          cpp_s << ",\n" << dx << "  " << i;
        }
 
      cpp_s << std::endl;
    }
 
  cpp_s << "\n"
    << dx << "{\n"
    << dx << "  ;\n"
    << dx << "}\n\n\n";
 
 
    // print method
 
  cpp_s
    << dx << "void " << name << "::print(unsigned int indent, bool print_header, std::ostream& s) const\n"
    << dx << "{\n"
    << dx << "  check_init();\n\n"
    << dx << "  try {\n";
 
  if (cl->direct_attributes() || cl->direct_relationships())
    cpp_s << dx << "    const std::string str(indent+2, ' ');\n";
 
  cpp_s
    << '\n'
    << dx << "    if (print_header)\n"
    << dx << "      p_hdr(s, indent, s_class_name";
 
  if(!cpp_ns_name.empty()) {
    cpp_s << ", \"" << cpp_ns_name << '\"';
  }
 
  cpp_s << ");\n";
 
 
  if (const std::list<std::string*> * slist = cl->direct_super_classes())
    {
      cpp_s << "\n\n" << dx << "      // print direct super-classes\n\n";
 
      for (const auto& i : *slist)
        cpp_s << dx << "    " << get_full_cpp_class_name(cl->get_kernel()->find_class(*i), cl_info, cpp_ns_name) << "::print(indent, false, s);\n";
    }
 
  if(const std::list<oks::OksAttribute*> * alist = cl->direct_attributes()) {
    cpp_s << "\n\n" << dx << "      // print direct attributes\n\n";
 
    for(const auto& i : *alist) {
      const std::string aname(alnum_name(i->get_name()));
      std::string abase = (i->get_format() == oks::OksAttribute::Hex) ? "<dunedaq::conffwk::hex>" : (i->get_format() == oks::OksAttribute::Oct) ? "<dunedaq::conffwk::oct>" : "";
 
      if (i->get_is_multi_values())
        cpp_s << dx << "    dunedaq::conffwk::p_mv_attr" << abase << "(s, str, s_" << aname << ", m_" << aname << ");\n";
      else
        cpp_s << dx << "    dunedaq::conffwk::p_sv_attr" << abase << "(s, str, s_" << aname << ", m_" << aname << ");\n";
    }
  }
 
  if (const std::list<oks::OksRelationship*> * rlist = cl->direct_relationships())
    {
      cpp_s << "\n\n" << dx << "      // print direct relationships\n\n";
 
      for (const auto& i : *rlist)
        {
          const std::string rname(alnum_name(i->get_name()));
 
          if (i->get_high_cardinality_constraint() == oks::OksRelationship::Many)
            {
              if (i->get_is_composite())
                cpp_s << dx << "    dunedaq::conffwk::p_mv_rel(s, str, indent, s_" << rname << ", m_" << rname << ");\n";
              else
                cpp_s << dx << "    dunedaq::conffwk::p_mv_rel(s, str, s_" << rname << ", m_" << rname << ");\n";
            }
          else
            {
              if (i->get_is_composite())
                cpp_s << dx <<"    dunedaq::conffwk::p_sv_rel(s, str, indent, s_" << rname << ", m_" << rname << ");\n";
              else
                cpp_s << dx <<"    dunedaq::conffwk::p_sv_rel(s, str, s_" << rname << ", m_" << rname << ");\n";
            }
        }
    }
 
  cpp_s << dx << "  }\n"
        << dx << "  catch (dunedaq::conffwk::Exception & ex) {\n"
        << dx << "    dunedaq::conffwk::DalObject::p_error(s, ex);\n"
    << dx << "  }\n"
        << dx << "}\n\n\n";
 
 
   // init method
 
  {
    const char * ic_value = (
      ( cl->direct_relationships() && cl->direct_relationships()->size() ) ||
      ( cl->direct_super_classes() && cl->direct_super_classes()->size() )
        ? "init_children"
        : "/* init_children */"
    );
 
    cpp_s
      << dx << "void " << name << "::init(bool " << ic_value << ")\n"
      << dx << "{\n";
  }
 
  if (cl->direct_super_classes() == nullptr)
    {
      cpp_s
        << dx << "  p_was_read = true;\n"
        << dx << "  increment_read();\n";
    }
 
    // generate initialization for super classes    
 
  if (const std::list<std::string*> * slist = cl->direct_super_classes())
    {
      for (const auto& i : *slist)
        {
          cpp_s << dx << "  " << alnum_name(*i) << "::init(init_children);\n";
        }
      if (!slist->empty())
        cpp_s << std::endl;
    }
 
  cpp_s << dx << "  TLOG_DEBUG(5) << \"read object \" << this << \" (class \" << s_class_name << \')\';\n";
 
    // put try / catch only if there are attributes or relationships to be initialized
  const std::list<oks::OksAttribute*> *alist = cl->direct_attributes();
  const std::list<oks::OksRelationship*> *rlist = cl->direct_relationships();
 
  if ((alist && !alist->empty()) || (rlist && !rlist->empty()))
    {
      cpp_s << std::endl << dx << "  try {\n";
 
 
      // generate initialization for attributes
      if (alist)
        {
          for (const auto& i : *alist)
            {
              const std::string cpp_name = alnum_name(i->get_name());
              cpp_s << dx << "    p_obj.get(s_" << cpp_name << ", m_" << cpp_name << ");\n";
            }
        }
 
 
      // generate initialization for relationships
      if (rlist)
        {
          for (const auto& i : *rlist)
            {
              const std::string& rname = i->get_name();
              std::string cpp_name = alnum_name(rname);
              std::string rcname = get_full_cpp_class_name(i->get_class_type(), cl_info, cpp_ns_name);
              if (i->get_high_cardinality_constraint() == oks::OksRelationship::Many)
                {
                  cpp_s << dx << "    p_registry._ref<" << rcname << ">(p_obj, s_" << cpp_name << ", " << "m_" << cpp_name << ", init_children);\n";
                }
              else
                {
                  cpp_s << dx << "    m_" << cpp_name << " = p_registry._ref<" << rcname << ">(p_obj, s_" << cpp_name << ", init_children);\n";
                }
            }
        }
 
      cpp_s
        << dx << "  }\n"
        << dx << "  catch (dunedaq::conffwk::Exception & ex) {\n"
        << dx << "    throw_init_ex(ex);\n"
        << dx << "  }\n";
 
    }
 
  cpp_s << dx << "}\n\n";
 
 
    // destructor
 
  cpp_s
    << dx << name << "::~" << name << "() noexcept\n"
    << dx << "{\n"
    << dx << "}\n\n";
 
  cpp_s
    << dx << "std::vector<const dunedaq::conffwk::DalObject *> " << name << "::get(const std::string& name, bool upcast_unregistered) const\n"
    << dx << "{\n"
    << dx << "  std::vector<const dunedaq::conffwk::DalObject *> vec;\n\n"
    << dx << "  if (!get(name, vec, upcast_unregistered, true))\n"
    << dx << "    throw_get_ex(name, s_class_name, this);\n\n"
    << dx << "  return vec;\n"
    << dx << "}\n\n";
 
  cpp_s
    << dx << "bool " << name << "::get(const std::string& name, std::vector<const dunedaq::conffwk::DalObject *>& vec, bool upcast_unregistered, bool first_call) const\n"
    << dx << "{\n"
    << dx << "  if (first_call)\n"
    << dx << "    {\n"
    << dx << "      std::lock_guard scoped_lock(m_mutex);\n\n"
    << dx << "      check();\n"
    << dx << "      check_init();\n\n"
    << dx << "      if (get_rel_objects(name, upcast_unregistered, vec))\n"
    << dx << "        return true;\n"
    << dx << "    }\n\n";
 
 
  for (const auto &prototype : algo_n_set)
    cpp_s
      << dx << "  if (name == \"" << prototype << "()\")\n"
      << dx << "    {\n"
      << dx << "      p_registry.downcast_dal_objects(" << prototype << "(), upcast_unregistered, vec);\n"
      << dx << "      return true;\n"
      << dx << "    }\n\n";
 
  for (const auto &prototype : algo_1_set)
    cpp_s
      << dx << "  if (name == \"" << prototype << "()\")\n"
      << dx << "    {\n"
      << dx << "      p_registry.downcast_dal_object(" << prototype << "(), upcast_unregistered, vec);\n"
      << dx << "      return true;\n"
      << dx << "    }\n\n";
 
 
  if (const std::list<std::string*> * slist = cl->direct_super_classes())
    {
      for (const auto& i : *slist)
        {
          cpp_s << dx << "  if (" << alnum_name(*i) << "::get(name, vec, upcast_unregistered, false)) return true;\n";
        }
 
      cpp_s << "\n";
    }
 
  cpp_s
    << dx << "  if (first_call)\n"
    << dx << "    return get_algo_objects(name, vec);\n\n"
    << dx << "  return false;\n"
    << dx << "}\n\n";
 
 
      // generate relationship set methods
 
  if (const std::list<oks::OksRelationship*> *rlist = cl->direct_relationships())
    {
      for (const auto& i : *rlist)
        {
          const std::string rname(alnum_name(i->get_name()));
          std::string full_cpp_class_name = get_full_cpp_class_name(i->get_class_type(), cl_info, cpp_ns_name);
 
          cpp_s << dx << "void " << name << "::set_" << rname << "(const ";
 
          if (i->get_high_cardinality_constraint() == oks::OksRelationship::Many)
            {
              cpp_s
                << "std::vector<const " << full_cpp_class_name << "*>& value)\n"
                << dx << "{\n"
                << dx << "  _set_objects(s_" << rname << ", value);\n"
                << dx << "}\n\n";
            }
          else
            {
              cpp_s
                << full_cpp_class_name << " * value)\n"
                << dx << "{\n"
                << dx << "  _set_object(s_" << rname << ", value);\n"
                << dx << "}\n\n";
            }
        }
    }
 
 
    // generate methods for c++
 
  if (const std::list<oks::OksMethod*> * mlist = cl->direct_methods())
    {
      bool comment_is_printed = false;
      for (const auto& i : *mlist)
        {
          oks::OksMethodImplementation * mi = find_cpp_method_implementation(i);
 
          if (mi && !get_method_implementation_body(mi).empty())
            {
              if (comment_is_printed == false)
                {
                  cpp_s << dx << "    // user-defined algorithms\n\n";
                  comment_is_printed = true;
                }
 
              // generate description
 
              print_description(cpp_s, i->get_description(), dx2);
 
              // generate prototype
 
              std::string prototype(mi->get_prototype());
              std::string::size_type idx = prototype.find('(');
 
              if (idx != std::string::npos)
                {
                  idx--;
 
                  // skip spaces between method name and ()
 
                  while (isspace(prototype[idx]) && idx > 0)
                    idx--;
 
                  // find beginning of the method name
 
                  while ((isalnum(prototype[idx]) || prototype[idx] == '_') && idx > 0)
                    idx--;
 
                  prototype[idx] = '\n';
                  std::string s(dx);
                  s += alnum_name(name);
                  s += "::";
                  prototype.insert(idx + 1, s);
                }
 
              // Second pass
              std::string::size_type idx_open_bracket = prototype.find('(');
              std::string::size_type idx_space = prototype.rfind(' ', idx_open_bracket);
              std::string::size_type idx_close_bracket = prototype.rfind(')');
            
              auto prototype_attrs = prototype.substr(0,idx_space+1);
              auto prototype_head = prototype.substr(idx_space+1,idx_close_bracket-idx_space);
              auto prototype_specs = prototype.substr(idx_close_bracket+1);
 
              for ( const auto& spec : cpp_method_virtual_specifiers ) {
                  idx = prototype_attrs.find(spec);
                  if ( idx != std::string::npos) {
                      prototype_attrs.erase(idx,spec.size());
                  }
                  prototype_attrs = trim(prototype_attrs);
                                    
                  idx = prototype_specs.find(spec);
                  if ( idx != std::string::npos) {
                      prototype_specs.erase(idx,spec.size());
                  }
                  prototype_specs = trim(prototype_specs);
              }
 
              prototype = prototype_attrs + ' ' + prototype_head + ' ' + prototype_specs;
 
              cpp_s
                << dx << prototype << std::endl
                << dx << "{\n"
                << get_method_implementation_body(mi) << std::endl
                << dx << "}\n\n";
            }
        }
    }
 
 
    // close namespace
 
  close_cpp_namespace(cpp_s, ns_level);
}

gen_cpp_body_prologue()

static void gen_cpp_body_prologue ( const std::string & file_name, std::ostream & src, const std::string & cpp_hdr_dir )

static

Definition at line 1373 of file oksdalgen.cxx.

{
  src <<
    "#include \"conffwk/ConfigObject.hpp\"\n"
    "#include \"conffwk/DalFactory.hpp\"\n"
    "#include \"conffwk/DalObjectPrint.hpp\"\n"
    "#include \"conffwk/Errors.hpp\"\n"
    "#include \"";
    if(cpp_hdr_dir != "") {
      src <<  cpp_hdr_dir << "/";
    }
    src << file_name << ".hpp\"\n\n";
}

gen_cpp_header_epilogue()

static void gen_cpp_header_epilogue ( std::ostream & s )

static

Definition at line 1366 of file oksdalgen.cxx.

{
  s << "\n#endif\n";
}

gen_cpp_header_prologue()

static void gen_cpp_header_prologue ( const std::string & file_name, std::ostream & s, const std::string & cpp_ns_name, const std::string & cpp_hdr_dir )

static

Definition at line 1342 of file oksdalgen.cxx.

{
  s <<
    "// *** this file is generated by oksdalgen, do not modify it ***\n\n"
 
    "#ifndef _" << alnum_name(file_name) << "_0_" << alnum_name(cpp_ns_name) << "_0_" << alnum_name(cpp_hdr_dir) << "_H_\n"
    "#define _" << alnum_name(file_name) << "_0_" << alnum_name(cpp_ns_name) << "_0_" << alnum_name(cpp_hdr_dir) << "_H_\n\n"
 
    "#include <stdint.h>   // to define 64 bits types\n"
    "#include <iostream>\n"
    "#include <sstream>\n"
    "#include <string>\n"
    "#include <map>\n"
    "#include <vector>\n\n"
 
    "#include \"conffwk/Configuration.hpp\"\n"
    "#include \"conffwk/DalObject.hpp\"\n\n";
}

gen_dump_application()

void gen_dump_application ( std::ostream & s, std::list< std::string > & class_names, const std::string & cpp_ns_name, const std::string & cpp_hdr_dir, const char * conf_header, const char * conf_name, const char * headres_prologue, const char * main_function_prologue )

extern

Definition at line 162 of file utils.cpp.

{
  s <<
    "  // *** this file is generated by oksdalgen ***\n"
    "\n"
    "#include \"conffwk/ConfigObject.hpp\"\n"
    "#include \"" << conf_header << "\"\n\n";
 
  // generate list of includes
  for (const auto& i : class_names)
    {
      std::string hname(cpp_hdr_dir);
      if (!hname.empty())
        hname += '/';
      hname += i;
      s << "#include \"" << hname << ".hpp\"\n";
    }
 
  if (headres_prologue && *headres_prologue)
    {
      s << "\n  // db implementation-specific headrers prologue\n\n" << headres_prologue << "\n";
    }
 
  s <<
      "\n"
      "\n"
      "static void usage(const char * s)\n"
      "{\n"
      "  std::cout << s << \" -d db-name -c class-name [-q query | -i object-id] [-t]\\n\"\n"
      "    \"\\n\"\n"
      "    \"Options/Arguments:\\n\"\n"
      "    \"  -d | --data db-name            mandatory name of the database\\n\"\n"
      "    \"  -c | --class-name class-name   mandatory name of class\\n\"\n"
      "    \"  -q | --query query             optional query to select class objects\\n\"\n"
      "    \"  -i | --object-id object-id     optional identity to select one object\\n\"\n"
      "    \"  -t | --init-children           all referenced objects are initialized (is used\\n\"\n"
      "    \"                                 for debug purposes and performance measurements)\\n\"\n"
      "    \"  -h | --help                    print this message\\n\"\n"
      "    \"\\n\"\n"
      "    \"Description:\\n\"\n"
      "    \"  The program prints out object(s) of given class.\\n\"\n"
      "    \"  If no query or object id is provided, all objects of the class are printed.\\n\"\n"
      "    \"  It is automatically generated by oksdalgen utility.\\n\"\n"
      "    \"\\n\";\n"
      "}\n"
      "\n"
      "static void no_param(const char * s)\n"
      "{\n"
      "  std::cerr << \"ERROR: the required argument for option \\\'\" << s << \"\\\' is missing\\n\\n\";\n"
      "  exit (EXIT_FAILURE);\n"
      "}\n"
      "\n"
      "int main(int argc, char *argv[])\n"
      "{\n";
 
  if (main_function_prologue && *main_function_prologue)
    {
      s << "    // db implementation-specific main function prologue\n\n  " << main_function_prologue << "\n\n";
    }
 
  s <<
      "    // parse parameters\n"
      "\n"
      "  const char * db_name = nullptr;\n"
      "  const char * object_id = nullptr;\n"
      "  const char * query = \"\";\n"
      "  std::string class_name;\n"
      "  bool init_children = false;\n"
      "\n"
      "  for(int i = 1; i < argc; i++) {\n"
      "    const char * cp = argv[i];\n"
      "    if(!strcmp(cp, \"-h\") || !strcmp(cp, \"--help\")) {\n"
      "      usage(argv[0]);\n"
      "      return 0;\n"
      "    }\n"
      "    if(!strcmp(cp, \"-t\") || !strcmp(cp, \"--init-children\")) {\n"
      "      init_children = true;\n"
      "    }\n"
      "    else if(!strcmp(cp, \"-d\") || !strcmp(cp, \"--data\")) {\n"
      "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { db_name = argv[i]; }\n"
      "    }\n"
      "    else if(!strcmp(cp, \"-c\") || !strcmp(cp, \"--class-name\")) {\n"
      "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { class_name = argv[i]; }\n"
      "    }\n"
      "    else if(!strcmp(cp, \"-i\") || !strcmp(cp, \"--object-id\")) {\n"
      "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { object_id = argv[i]; }\n"
      "    }\n"
      "    else if(!strcmp(cp, \"-q\") || !strcmp(cp, \"--query\")) {\n"
      "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { query = argv[i]; }\n"
      "    }\n"
      "    else {\n"
      "      std::cerr << \"ERROR: bad parameter \" << cp << std::endl;\n"
      "      usage(argv[0]);\n"
      "      return (EXIT_FAILURE);\n"
      "    }\n"
      "  }\n"
      "\n"
      "  if(db_name == nullptr) {\n"
      "    std::cerr << \"ERROR: no database name provided\\n\";\n"
      "    return (EXIT_FAILURE);\n"
      "  }\n"
      "\n"
      "  if(class_name.empty()) {\n"
      "    std::cerr << \"ERROR: no class name provided\\n\";\n"
      "    return (EXIT_FAILURE);\n"
      "  }\n"
      "\n"
      "  if(*query != 0 && object_id != nullptr) {\n"
      "    std::cerr << \"ERROR: only one parameter -i or -q can be provided\\n\";\n"
      "    return (EXIT_FAILURE);\n"
      "  }\n"
      "\n"
      "\n"
      "std::cout << std::boolalpha;\n"
      "\n";
 
  if (conf_name)
    {
      s <<
          "  " << conf_name << " impl_conf;\n"
          "\n"
          "  {\n"
          "    dunedaq::conffwk::Configuration conf(db_name, &impl_conf);\n";
    }
  else
    {
      s <<
          "  try {\n"
          "    dunedaq::conffwk::Configuration conf(db_name);\n";
    }
 
  s <<
      "\n"
      "    if(!conf.loaded()) {\n"
      "      std::cerr << \"Can not load database: \" << db_name << std::endl;\n"
      "      return (EXIT_FAILURE);\n"
      "    }\n"
      "    \n"
      "    std::vector< dunedaq::conffwk::ConfigObject > objects;\n"
      "    \n"
      "    if(object_id) {\n"
      "      dunedaq::conffwk::ConfigObject obj;\n"
      "      try {\n"
      "        conf.get(class_name, object_id, obj, 1);\n"
      "      }\n"
      "      catch (dunedaq::conffwk::NotFound & ex) {\n"
      "        std::cerr << \"Can not get object \\'\" << object_id << \"\\' of class \\'\" << class_name << \"\\':\\n\" << ex << std::endl;\n"
      "        return (EXIT_FAILURE);\n"
      "      }\n"
      "      objects.push_back(obj);\n"
      "    }\n"
      "    else {\n"
      "      try {\n"
      "        conf.get(class_name, objects, query, 1);\n"
      "      }\n"
      "      catch (dunedaq::conffwk::NotFound & ex) {\n"
      "        std::cerr << \"Can not get objects of class \\'\" << class_name << \"\\':\\n\" << ex << std::endl;\n"
      "        return (EXIT_FAILURE);\n"
      "      }\n"
      "    }\n"
      "    \n"
      "    struct SortByUId {\n"
      "      bool operator() (const dunedaq::conffwk::ConfigObject * o1, const dunedaq::conffwk::ConfigObject * o2) const {\n"
      "        return (o1->UID() < o2->UID());\n"
      "      };\n"
      "    };\n"
      "    \n"
      "    std::set< dunedaq::conffwk::ConfigObject *, SortByUId > sorted_objects;\n"
      "    \n"
      "    for(auto& i : objects)\n"
      "      sorted_objects.insert(&i);\n"
      "    \n"
      "    for(auto& i : sorted_objects) {\n";
 
  for (std::list<std::string>::iterator i = class_names.begin(); i != class_names.end(); ++i)
    {
      const char * op = (i == class_names.begin() ? "if" : "else if");
      std::string cname(cpp_ns_name);
 
      if (!cname.empty())
        cname += "::";
 
      cname += *i;
 
      s <<
          "      " << op << "(class_name == \"" << *i << "\") {\n"
          "        std::cout << *conf.get<" << cname << ">(*i, init_children) << std::endl;\n"
          "      }\n";
    }
 
  s <<
      "      else {\n"
      "        std::cerr << \"ERROR: do not know how to dump object of \" << class_name << \" class\\n\";\n"
      "        return (EXIT_FAILURE);\n"
      "      }\n"
      "    }\n"
      "  }\n"
      "  catch (dunedaq::conffwk::Exception & ex) {\n"
      "    std::cerr << \"Caught \" << ex << std::endl;\n"
      "    return (EXIT_FAILURE);\n"
      "  }\n"
      "\n"
      "  return 0;\n"
      "}\n";
}

gen_header()

static void gen_header ( const oks::OksClass * cl, std::ostream & cpp_file, const std::string & cpp_ns_name, const std::string & cpp_hdr_dir, const ClassInfo::Map & cl_info )

static

Definition at line 96 of file oksdalgen.cxx.

{
  const std::string name(alnum_name(cl->get_name()));
 
 
    // get includes for super classes if necessary
 
  if (const std::list<std::string*> * super_list = cl->direct_super_classes())
    {
      cpp_file << "  // include files for classes used in inheritance hierarchy\n\n";
 
      for (const auto& i : *super_list)
        {
          oks::OksClass * c = cl->get_kernel()->find_class(*i);
          cpp_file << "#include \"" << get_include_dir(c, cl_info, cpp_hdr_dir) << ".hpp\"\n";
        }
    }
 
  cpp_file << std::endl;
 
 
    // generate forward declarations if necessary
    {
      // create set of classes to avoid multiple forward declarations of the same class
      std::set<oks::OksClass*> rclasses;
 
      // check direct relationships (c++)
      if (cl->direct_relationships() && !cl->direct_relationships()->empty())
        for (const auto &i : *cl->direct_relationships())
          rclasses.insert(i->get_class_type());
 
      // check methods
      if (const std::list<oks::OksMethod*> *mlist = cl->direct_methods())
        {
          for (const auto &i : *mlist)
            {
              if (oks::OksMethodImplementation *mi = find_cpp_method_implementation(i))
                {
                  const std::string mp(mi->get_prototype());
                  for (const auto &j : cl->get_kernel()->classes())
                    {
                      const std::string s(j.second->get_name());
                      std::string::size_type idx = mp.find(s);
                      if (idx != std::string::npos && (idx == 0 || !isalnum(mp[idx - 1])) && !isalnum(mp[idx + s.size()]))
                        rclasses.insert(j.second);
                    }
                }
            }
        }
 
      NameSpaceInfo ns_info;
 
      for (const auto &c : rclasses)
        {
          // check if the class' header is not already included
          if (has_superclass(cl, c) || cl == c)
            continue;
 
          ClassInfo::Map::const_iterator idx = cl_info.find(c);
          ns_info.add((idx != cl_info.end() ? (*idx).second.get_namespace() : cpp_ns_name), alnum_name(c->get_name()));
        }
 
      if (!ns_info.empty())
        {
          cpp_file << "  // forward declaration for classes used in relationships and algorithms\n\n";
          ns_info.print(cpp_file, 0);
          cpp_file << "\n\n";
        }
    }
 
    // generate methods prologues if necessary
 
  if (const std::list<oks::OksMethod*> *mlist = cl->direct_methods())
    for (const auto &i : *mlist)
      if (oks::OksMethodImplementation *mi = find_cpp_method_implementation(i))
        if (!get_method_header_prologue(mi).empty())
          {
            cpp_file << "  // prologue of method " << cl->get_name() << "::" << i->get_name() << "()\n";
            cpp_file << get_method_header_prologue(mi) << std::endl;
          }
 
 
    // open namespace
 
  int ns_level = open_cpp_namespace(cpp_file, cpp_ns_name);
  std::string ns_dx = int2dx(ns_level);
  std::string ns_dx2 = ns_dx + "    ";
  
  const char * dx  = ns_dx.c_str();    // are used for alignment
  const char * dx2 = ns_dx2.c_str();
 
 
    // generate description
 
  {
    std::string txt("Declares methods to get and put values of attributes / relationships, to print and to destroy object.\n");
 
    txt +=
      "<p>\n"
      "The methods can throw several exceptions:\n"
      "<ul>\n"
      " <li><code>conffwk.NotFoundException</code> - in case of wrong attribute or relationship name (e.g. in case of database schema modification)\n"
      " <li><code>conffwk.SystemException</code> - in case of system problems (communication or implementation database failure, schema modification, object destruction, etc.)\n"
      "</ul>\n"
      "<p>\n"
      "In addition the methods modifying database (set value, destroy object) can throw <code>conffwk.NotAllowedException</code> "
      "exception in case, if there are no write access rights or database is already locked by other process.\n";
 
    if (!cl->get_description().empty())
      {
        txt += "\n<p>\n";
        txt += cl->get_description();
        txt += "\n";
      }
 
    txt += "@author oksdalgen\n";
 
    cpp_file << std::endl;
    print_description(cpp_file, cl->get_description(), dx);
  }
 
    // generate class declaration itself
 
  cpp_file << dx << "class " << name << " : ";
 
    // generate inheritance list
 
  if (const std::list<std::string*> * super_list = cl->direct_super_classes())
    {
      for (std::list<std::string*>::const_iterator i = super_list->begin(); i != super_list->end();)
        {
          const oks::OksClass * c = cl->get_kernel()->find_class(**i);
          cpp_file << "public " << get_full_cpp_class_name(c, cl_info, cpp_ns_name);
          if (++i != super_list->end())
            cpp_file << ", ";
        }
    }
  else
    {
      cpp_file << "public virtual dunedaq::conffwk::DalObject";
    }
 
  cpp_file << " {\n\n";
 
    // generate standard methods
 
  cpp_file
    << dx << "  friend class conffwk::Configuration;\n"
    << dx << "  friend class conffwk::DalObject;\n"
    << dx << "  friend class conffwk::DalFactory;\n"
    << dx << "  friend class conffwk::DalRegistry;\n\n"
    << dx << "  protected:\n\n"
    << dx << "    " << name << "(conffwk::DalRegistry& db, const conffwk::ConfigObject& obj) noexcept;\n"
    << dx << "    virtual ~" << name << "() noexcept;\n"
    << dx << "    virtual void init(bool init_children);\n\n"
    << dx << "  public:\n\n"
    << dx << "      /** The name of the configuration class. */\n\n"
    << dx << "    static const std::string& s_class_name;\n\n\n"
    << dx << "      /**\n"
    << dx << "       * \\brief Print details of the " << name << " object.\n"
    << dx << "       *\n"
    << dx << "       * Parameters are:\n"
    << dx << "       *   \\param offset        number of spaces to shift object right (useful to print nested objects)\n"
    << dx << "       *   \\param print_header  if false, do not print object header (to print attributes of base classes)\n"
    << dx << "       *   \\param s             output stream\n"
    << dx << "       */\n\n"
    << dx << "    virtual void print(unsigned int offset, bool print_header, std::ostream& s) const;\n\n\n"
    << dx << "      /**\n"
    << dx << "       * \\brief Get values of relationships and results of some algorithms as a vector of dunedaq::conffwk::DalObject pointers.\n"
    << dx << "       *\n"
    << dx << "       * Parameters are:\n"
    << dx << "       *   \\param name          name of the relationship or algorithm\n"
    << dx << "       *   \\return              value of relationship or result of algorithm\n"
    << dx << "       *   \\throw               std::exception if there is no relationship or algorithm with such name in this and base classes\n"
    << dx << "       */\n\n"
    << dx << "    virtual std::vector<const dunedaq::conffwk::DalObject *> get(const std::string& name, bool upcast_unregistered = true) const;\n\n\n"
    << dx << "  protected:\n\n"
    << dx << "    bool get(const std::string& name, std::vector<const dunedaq::conffwk::DalObject *>& vec, bool upcast_unregistered, bool first_call) const;\n\n\n";
 
 
    // generate class attributes and relationships in accordance with
    // database schema
 
  if (cl->direct_attributes() || cl->direct_relationships() || cl->direct_methods())
    {
      cpp_file << dx << "  private:\n\n";
 
      // generate attributes:
      //  - for single attributes this is a normal member variable.
      //  - for multiple values this is a std::vector<T>.
 
      if (const std::list<oks::OksAttribute*> * alist = cl->direct_attributes())
        {
          for (const auto& i : *alist)
            {
              const std::string aname(alnum_name(i->get_name()));
              std::string cpp_type = get_type(i->get_data_type(), true);
 
              if (i->get_is_multi_values())
                cpp_file << dx << "    std::vector<" << cpp_type << "> m_" << aname << ";\n";
              else
                cpp_file << dx << "    " << cpp_type << " m_" << aname << ";\n";
            }
        }
 
 
      // generate relationships:
      //  - for single values this is just a pointer.
      //  - for multiple values this is a vector of pointers.
 
      if (const std::list<oks::OksRelationship*> *rlist = cl->direct_relationships())
        {
          for (const auto& i : *rlist)
            {
              const std::string rname(alnum_name(i->get_name()));
              const std::string full_class_name(get_full_cpp_class_name(i->get_class_type(), cl_info, cpp_ns_name));
              if (i->get_high_cardinality_constraint() == oks::OksRelationship::Many)
                cpp_file << dx << "    std::vector<const " << full_class_name << "*> m_" << rname << ";\n";
              else
                cpp_file << dx << "    const " << full_class_name << "* m_" << rname << ";\n";
            }
        }
 
 
      // generate methods extension if any
 
      if (const std::list<oks::OksMethod*> * mlist = cl->direct_methods())
        {
          for (const auto& i : *mlist)
            {
              if (oks::OksMethodImplementation * mi = find_cpp_method_implementation(i))
                {
                  std::string method_extension = get_private_section(mi);
                  if (!method_extension.empty())
                    {
                      cpp_file << "\n" << dx << "      // extension of method " << cl->get_name() << "::" << i->get_name() << "()\n";
                      print_indented(cpp_file, method_extension, dx2);
                    }
                }
            }
        }
 
 
      cpp_file << std::endl << std::endl << dx << "  public:\n\n";
 
 
      // generate attribute accessors:
      //  1. for each attribute generate static std::string with it's name
      //  2a. for single values this is just:
      //     - attribute_type attribute_name() const { return m_attribute; }
      //  2b. for multiple values this is:
      //     - const std::vector<attribute_type>& attribute_name() const { return m_attribute; }
 
      if (const std::list<oks::OksAttribute*> *alist = cl->direct_attributes())
        {
 
          cpp_file << dx << "      // attribute names\n\n";
 
          for (const auto& i : *alist)
            {
              const std::string& aname(i->get_name());
              cpp_file << dx << "    inline static const std::string s_" << alnum_name(aname) << " = \"" << aname << "\";\n";
            }
 
          cpp_file << "\n";
 
          for (const auto& i : *alist)
            {
              const std::string& cpp_aname(alnum_name(i->get_name()));
              cpp_file << dx << "    static const std::string& __get_" << cpp_aname << "_str() noexcept { return s_" << cpp_aname << "; }\n";
            }
 
          cpp_file << std::endl << std::endl;
 
          for (const auto& i : *alist)
            {
              const std::string aname(alnum_name(i->get_name()));
 
              // generate enum values
 
              if (i->get_data_type() == oks::OksData::enum_type && !i->get_range().empty())
                {
                  std::string description("Valid enumeration values to compare with value returned by get_");
                  description += aname;
                  description += "() and to pass value to set_";
                  description += aname;
                  description += "() methods.";
 
                  print_description(cpp_file, description, dx2);
 
                  description += "\nUse toString() method to compare and to pass the values. Do not use name() method.";
 
                  cpp_file << dx << "    struct " << capitalize_name(aname) << " {\n";
 
                  oks::Oks::Tokenizer t(i->get_range(), ",");
                  std::string token;
                  while (!(token = t.next()).empty())
                    {
                      cpp_file << dx << "      inline static const std::string " << capitalize_name(alnum_name(token)) << " = \"" << token << "\";\n";
                    }
 
                  cpp_file << dx << "    };\n\n";
                }
 
              // generate get method description
 
                {
 
                  std::string description("Get \"");
                  description += i->get_name();
                  description += "\" attribute value.\n\n";
                  description += i->get_description();
 
                  std::string description2("\\brief ");
                  description2 += description;
                  description2 += "\n\\return the attribute value\n";
                  description2 += "\\throw dunedaq::conffwk::Generic, dunedaq::conffwk::DeletedObject\n";
 
                  print_description(cpp_file, description2, dx2);
                }
 
              // generate method body
 
              cpp_file << dx << "    ";
 
              std::string cpp_type = get_type(i->get_data_type(), true);
 
              if (i->get_is_multi_values())
                {
                  cpp_file << "const std::vector<" << cpp_type << ">&";
                }
              else
                {
                  if (cpp_type == "std::string")
                    cpp_file << "const std::string&";
                  else
                    cpp_file << cpp_type;
                }
 
              cpp_file << '\n'
                  << dx << "    get_" << aname << "() const\n"
                  << dx << "      {\n"
                  << dx << "        std::lock_guard scoped_lock(m_mutex);\n"
                  << dx << "        check();\n"
                  << dx << "        check_init();\n"
                  << dx << "        return m_" << aname << ";\n"
                  << dx << "      }\n\n";
 
              // generate set method description
 
                {
                  std::string description("Set \"");
                  description += i->get_name();
                  description += "\" attribute value.\n\n";
                  description += i->get_description();
 
                  std::string description2("\\brief ");
                  description2 += description;
                  description2 += "\n\\param value  new attribute value\n";
                  description2 += "\\throw dunedaq::conffwk::Generic, dunedaq::conffwk::DeletedObject\n";
 
                  print_description(cpp_file, description2, dx2);
                }
 
              // generate set method
 
              cpp_file << dx << "    void\n" << dx << "    set_" << aname << '(';
 
              if (i->get_is_multi_values())
                {
                  cpp_file << "const std::vector<" << cpp_type << ">&";
                }
              else
                {
                  if (cpp_type == "std::string")
                    {
                      cpp_file << "const std::string&";
                    }
                  else
                    {
                      cpp_file << cpp_type;
                    }
                }
 
              cpp_file << " value)\n"
                << dx << "      {\n"
                << dx << "        std::lock_guard scoped_lock(m_mutex);\n"
                << dx << "        check();\n"
                << dx << "        clear();\n"
                << dx << "        p_obj.";
 
              if (i->get_data_type() == oks::OksData::string_type && i->get_is_multi_values() == false)
                {
                  cpp_file << "set_by_ref";
                }
              else if (i->get_data_type() == oks::OksData::enum_type)
                {
                  cpp_file << "set_enum";
                }
              else if (i->get_data_type() == oks::OksData::class_type)
                {
                  cpp_file << "set_class";
                }
              else if (i->get_data_type() == oks::OksData::date_type)
                {
                  cpp_file << "set_date";
                }
              else if (i->get_data_type() == oks::OksData::time_type)
                {
                  cpp_file << "set_time";
                }
              else
                {
                  cpp_file << "set_by_val";
                }
 
              cpp_file << "(s_" << aname << ", value);\n"
                  << dx << "      }\n\n\n";
            }
        }
 
 
      // generate relationship accessors.
      //  1. for each relationship generate static std::string with it's name
      //  2a. for single values this is just:
      //      - const relation_type * relation() const { return m_relation; }
      //  2b. for multiple values this is:
      //      - const std::vector<const relation_type*>& relation() const { return m_relation; }
 
      if (const std::list<oks::OksRelationship*> *rlist = cl->direct_relationships())
        {
 
          cpp_file << dx << "      // relationship names\n\n";
 
          for (const auto& i : *rlist)
            {
              const std::string& rname(i->get_name());
              cpp_file << dx << "    inline static const std::string s_" << alnum_name(rname) << " = \"" << rname << "\";\n";
            }
 
          cpp_file << "\n";
 
          for (const auto& i : *rlist)
            {
              const std::string& cpp_rname(alnum_name(i->get_name()));
              cpp_file << dx << "    static const std::string& __get_" << cpp_rname << "_str() noexcept { return s_" << cpp_rname << "; }\n";
            }
 
          cpp_file << std::endl << std::endl;
 
          for (const auto& i : *rlist)
            {
 
              // generate description
 
                {
                  std::string description("Get \"");
                  description += i->get_name();
                  description += "\" relationship value.\n\n";
                  description += i->get_description();
 
                  std::string description2("\\brief ");
                  description2 += description;
                  description2 += "\n\\return the relationship value\n";
                  description2 += "\\throw dunedaq::conffwk::Generic, dunedaq::conffwk::DeletedObject\n";
 
                  print_description(cpp_file, description2, dx2);
                }
 
              // generate method body
 
              cpp_file << dx << "    const ";
 
              const std::string rname(alnum_name(i->get_name()));
              std::string full_cpp_class_name = get_full_cpp_class_name(i->get_class_type(), cl_info, cpp_ns_name);
 
              if (i->get_high_cardinality_constraint() == oks::OksRelationship::Many)
                {
                  cpp_file << "std::vector<const " << full_cpp_class_name << "*>&";
                }
              else
                {
                  cpp_file << full_cpp_class_name << " *";
                }
 
              cpp_file << "\n"
                  << dx << "    get_" << rname << "() const\n"
                  << dx << "    {\n"
                  << dx << "      std::lock_guard scoped_lock(m_mutex);\n"
                  << dx << "      check();\n"
                  << dx << "      check_init();\n";
 
              if (i->get_low_cardinality_constraint() == oks::OksRelationship::One)
                {
                  if (i->get_high_cardinality_constraint() == oks::OksRelationship::One)
                    {
                      cpp_file
                          << dx << "      if (!m_" << rname << ")\n"
                          << dx << "        {\n"
                          << dx << "          std::ostringstream text;\n"
                          << dx << "          text << \"relationship \\\"\" << s_" << rname << " << \"\\\" of object \" << this << \" is not set\";\n"
                          << dx << "          throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str());\n"
                          << dx << "        }\n";
                    }
                  else
                    {
                      cpp_file
                          << dx << "      if (m_" << rname << ".empty())\n"
                          << dx << "        {\n"
                          << dx << "          std::ostringstream text;\n"
                          << dx << "          text << \"relationship \\\"\" << s_" << rname << " << \"\\\" of object \" << this << \" is empty\";\n"
                          << dx << "          throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str());\n"
                          << dx << "        }\n";
                    }
                }
 
              cpp_file
                  << dx << "      return m_" << rname << ";\n"
                  << dx << "    }\n\n\n";
 
              // generate set method
 
                {
                  std::string description("Set \"");
                  description += i->get_name();
                  description += "\" relationship value.\n\n";
                  description += i->get_description();
 
                  std::string description2("\\brief ");
                  description2 += description;
                  description2 += "\n\\param value  new relationship value\n";
                  description2 += "\\throw dunedaq::conffwk::Generic, dunedaq::conffwk::DeletedObject\n";
 
                  print_description(cpp_file, description2, dx2);
                }
 
              cpp_file << dx << "    void\n" << dx << "    set_" << rname << "(const ";
 
              if (i->get_high_cardinality_constraint() == oks::OksRelationship::Many)
                {
                  cpp_file << "std::vector<const " << full_cpp_class_name << "*>&";
                }
              else
                {
                  cpp_file << full_cpp_class_name << " *";
                }
 
              cpp_file << " value);\n\n";
            }
        }
    }
 
 
    // generate methods
 
  if (const std::list<oks::OksMethod*> *mlist = cl->direct_methods())
    {
      bool cpp_comment_is_printed = false;
 
      for (const auto& i : *mlist)
        {
 
          // C++ algorithms
 
          if (oks::OksMethodImplementation * mi = find_cpp_method_implementation(i))
            {
              if (cpp_comment_is_printed == false)
                {
                  cpp_file << std::endl << dx << "  public:\n\n" << dx << "      // user-defined algorithms\n\n";
                  cpp_comment_is_printed = true;
                }
              else
                {
                  cpp_file << "\n\n";
                }
 
              // generate description
 
              print_description(cpp_file, i->get_description(), dx2);
 
              // generate prototype
 
              cpp_file << dx << "    " << mi->get_prototype() << ";\n";
 
 
              // generate public section extension
 
              std::string public_method_extension = get_public_section(mi);
              if (!public_method_extension.empty())
                {
                  cpp_file << "\n" << "      // extension of method " << cl->get_name() << "::" << i->get_name() << "()\n";
                  print_indented(cpp_file, public_method_extension, "    ");
                }
            }
 
        }
    }
 
 
    // class finished
 
  cpp_file << dx << "};\n\n";
 
 
    // generate ostream operators and typedef for iterator
 
  cpp_file
    << dx << "  // out stream operator\n\n"
    << dx << "inline std::ostream& operator<<(std::ostream& s, const " << name << "& obj)\n"
    << dx << "  {\n"
    << dx << "    return obj.print_object(s);\n"
    << dx << "  }\n\n"
    << dx << "typedef std::vector<const " << name << "*>::const_iterator " << name << "Iterator;\n\n";
 
 
    // close namespace
 
  close_cpp_namespace(cpp_file, ns_level);
 
 
    // generate methods epilogues if necessary
 
  if (const std::list<oks::OksMethod*> * mlist = cl->direct_methods())
    {
      for (const auto & i : *mlist)
        {
          oks::OksMethodImplementation * mi = find_cpp_method_implementation(i);
          if (mi && !get_method_header_epilogue(mi).empty())
            {
              cpp_file << "  // epilogue of method " << cl->get_name() << "::" << i->get_name() << "()\n";
              cpp_file << get_method_header_epilogue(mi) << std::endl;
            }
        }
    }
 
}

get_add_algo_1()

bool get_add_algo_1 ( oks::OksMethodImplementation * mi )

extern

get_add_algo_n()

bool get_add_algo_n ( oks::OksMethodImplementation * mi )

extern

get_full_cpp_class_name()

std::string get_full_cpp_class_name ( const oks::OksClass * c, const ClassInfo::Map & cl_info, const std::string & cpp_ns_name )

extern

get_include_dir()

std::string get_include_dir ( const oks::OksClass * c, const ClassInfo::Map & cl_info, const std::string & cpp_hdr_dir )

extern

get_member_initializer_list()

std::string get_member_initializer_list ( oks::OksMethodImplementation * mi )

extern

get_method_header_epilogue()

std::string get_method_header_epilogue ( oks::OksMethodImplementation * )

extern

get_method_header_prologue()

std::string get_method_header_prologue ( oks::OksMethodImplementation * )

extern

get_method_implementation_body()

std::string get_method_implementation_body ( oks::OksMethodImplementation * mi )

extern

get_private_section()

std::string get_private_section ( oks::OksMethodImplementation * mi )

extern

get_public_section()

std::string get_public_section ( oks::OksMethodImplementation * mi )

extern

get_type()

std::string get_type ( oks::OksData::Type oks_type, bool is_cpp )

extern

Definition at line 99 of file utils.cpp.

{
  switch (oks_type)
    {
      case OksData::unknown_type:
        return "UNKNOWN";
      case OksData::s8_int_type:
        return (is_cpp ? "int8_t" : "char");
      case OksData::u8_int_type:
        return (is_cpp ? "uint8_t" : "byte");
      case OksData::s16_int_type:
        return (is_cpp ? "int16_t" : "short");
      case OksData::u16_int_type:
        return (is_cpp ? "uint16_t" : "short");
      case OksData::s32_int_type:
        return (is_cpp ? "int32_t" : "int");
      case OksData::u32_int_type:
        return (is_cpp ? "uint32_t" : "int");
      case OksData::s64_int_type:
        return (is_cpp ? "int64_t" : "long");
      case OksData::u64_int_type:
        return (is_cpp ? "uint64_t" : "long");
      case OksData::float_type:
        return "float";
      case OksData::double_type:
        return "double";
      case OksData::bool_type:
        return (is_cpp ? "bool" : "boolean");
 
      case OksData::string_type:
      case OksData::enum_type:
      case OksData::date_type:
      case OksData::time_type:
      case OksData::class_type:
        return (is_cpp ? "std::string" : "String");
 
      case OksData::object_type:
      case OksData::list_type:
      case OksData::uid_type:
      case OksData::uid2_type:
        return "funnytype";
    }
 
  return "invalid";
}

has_superclass()

static bool has_superclass ( const oks::OksClass * tested, const oks::OksClass * c )

static

The function has_superclass returns true if 'tested' class has class 'c' as a superclass

Definition at line 55 of file oksdalgen.cxx.

{
  if (const oks::OksClass::FList * sclasses = tested->all_super_classes())
    {
      for (const auto& i : *sclasses)
        {
          if (i == c)
            {
              return true;
            }
        }
    }
 
  return false;
}

int2dx()

std::string int2dx ( int level )

extern

Definition at line 629 of file utils.cpp.

{
  return std::string(level * 2, ' ');
}

load_schemas()

static void load_schemas ( oks::OksKernel & kernel, const std::list< std::string > & file_names, std::set< oks::OksFile *, std::less< oks::OksFile * > > & file_hs )

static

Definition at line 1325 of file oksdalgen.cxx.

{
  for (const auto& i : file_names)
    {
      if (oks::OksFile * fh = kernel.load_schema(i))
        {
          file_hs.insert(fh);
        }
      else
        {
          std::cerr << "ERROR: can not load schema file \"" << i << "\"\n";
          exit(EXIT_FAILURE);
        }
    }
}

ltrim()

std::string ltrim

(

const std::string &

s

)

Definition at line 73 of file oksdalgen.cxx.

{
    size_t start = s.find_first_not_of(WHITESPACE);
    return (start == std::string::npos) ? "" : s.substr(start);
}

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 1391 of file oksdalgen.cxx.

{
  std::list<std::string> class_names;
  std::list<std::string> file_names;
  std::list<std::string> include_dirs;
  std::list<std::string> user_classes;
 
  std::string cpp_dir_name = ".";                // directory for c++ implementation files
  std::string cpp_hdr_dir = "";                  // directory for c++ header files
  std::string cpp_ns_name = "";                  // c++ namespace
  std::string info_file_name = "oksdalgen.info"; // name of info file
  bool verbose = false;
 
  parse_arguments(argc, argv, class_names, file_names, include_dirs, user_classes, cpp_dir_name, cpp_ns_name, cpp_hdr_dir, info_file_name, verbose);
 
  // init OKS
 
  std::set<oks::OksFile *, std::less<oks::OksFile *> > file_hs;
 
  oks::OksKernel kernel(false, false, false, false);
 
  try
    {
      load_schemas(kernel, file_names, file_hs);
 
      // if no user defined classes, generate all
 
      if (class_names.size() == 0)
        {
          if (verbose)
            {
              std::cout << "No explicit classes were provided,\n"
                  "search for classes which belong to the given schema files:\n";
            }
 
          const oks::OksClass::Map& class_list = kernel.classes();
 
          if (!class_list.empty())
            {
              for (const auto& i : class_list)
                {
                  if (verbose)
                    {
                      std::cout << " * check for class \"" << i.first << "\" ";
                    }
 
                  if (file_hs.find(i.second->get_file()) != file_hs.end())
                    {
                      class_names.push_back(i.second->get_name());
                      if (verbose)
                        {
                          std::cout << "OK\n";
                        }
                    }
                  else
                    {
                      if (verbose)
                        {
                          std::cout << "skip\n";
                        }
                    }
                }
            }
          else
            {
              std::cerr << "No classes in schema file and no user classes specified\n";
              exit(EXIT_FAILURE);
            }
        }
 
      // calculate set of classes which should be mentioned by the generator;
      // note, some of classes can come from other DALs
 
      typedef std::set<const oks::OksClass *, std::less<const oks::OksClass *> > Set;
      Set generated_classes;
      ClassInfo::Map cl_info;
 
      unsigned int error_num = 0;
 
      // build set of classes which are generated
 
      for (const auto& i : class_names)
        {
          if (oks::OksClass *cl = kernel.find_class(i))
            {
              generated_classes.insert(cl);
            }
          else
            {
              std::cerr << "ERROR: can not find class " << i << std::endl;
              error_num++;
            }
        }
 
      // build set of classes which are external to generated
 
      for (const auto& i : generated_classes)
        {
          if (const std::list<oks::OksRelationship *> * rels = i->direct_relationships())
            {
              for (const auto& j : *rels)
                {
                  const oks::OksClass * rc = j->get_class_type();
 
                  if (rc == 0)
                    {
                      std::cerr << "\nERROR: the class \"" << j->get_type() << "\" (it is used by the relationship \"" << j->get_name() << "\" of class \"" << i->get_name() << "\") is not defined by the schema.\n";
                      error_num++;
                    }
                  else if (generated_classes.find(rc) == generated_classes.end())
                    {
                      if (process_external_class(cl_info, rc, include_dirs, user_classes, verbose) == false)
                        {
                          std::cerr << "\nERROR: the class \"" << j->get_type() << "\" is used by the relationship \"" << j->get_name() << "\" of class \"" << i->get_name() << "\".\n"
                              "       The class is not in the list of generated classes, "
                              "it was not found among already generated headers "
                              "(search list is defined by the -I | --include-dirs parameter) and "
                              "it is not defined by user via -D | --user-defined-classes.\n";
                          error_num++;
                        }
                    }
                }
            }
 
          if (const std::list<std::string *> * sclasses = i->direct_super_classes())
            {
              for (const auto& j : *sclasses)
                {
                  const oks::OksClass * rc = kernel.find_class(*j);
 
                  if (rc == 0)
                    {
                      std::cerr << "\nERROR: the class \"" << *j << "\" (it is direct superclass of class \"" << i->get_name() << "\") is not defined by the schema.\n";
                      error_num++;
                    }
                  else if (generated_classes.find(rc) == generated_classes.end())
                    {
                      if (process_external_class(cl_info, rc, include_dirs, user_classes, verbose) == false)
                        {
                          std::cerr << "\nERROR: the class \"" << rc->get_name() << "\" is direct superclass of class \"" << i->get_name() << "\".\n"
                              "       The class is not in the list of generated classes, "
                              "it was not found among already generated headers "
                              "(search list is defined by the -I | --include-dirs parameter) and "
                              "it is not defined by user via -D | --user-defined-classes.\n";
                          error_num++;
                        }
                    }
                }
            }
        }
 
      if (error_num != 0)
        {
          std::cerr << "\n*** " << error_num << (error_num == 1 ? " error was" : " errors were") << " found.\n\n";
          return (EXIT_FAILURE);
        }
 
      for (const auto& cl : generated_classes)
        {
          std::string name(alnum_name(cl->get_name()));
 
          std::string cpp_hdr_name = cpp_dir_name + "/" + name + ".hpp";
          std::string cpp_src_name = cpp_dir_name + "/" + name + ".cpp";
 
          std::ofstream cpp_hdr_file(cpp_hdr_name.c_str());
          std::ofstream cpp_src_file(cpp_src_name.c_str());
 
          if (!cpp_hdr_file)
            {
              std::cerr << "ERROR: can not create file \"" << cpp_hdr_name << "\"\n";
              return (EXIT_FAILURE);
            }
 
          if (!cpp_src_file)
            {
              std::cerr << "ERROR: can not create file \"" << cpp_src_name << "\"\n";
              return (EXIT_FAILURE);
            }
 
          gen_cpp_header_prologue(name, cpp_hdr_file, cpp_ns_name, cpp_hdr_dir);
          gen_cpp_body_prologue(name, cpp_src_file, cpp_hdr_dir);
 
          gen_header(cl, cpp_hdr_file, cpp_ns_name, cpp_hdr_dir, cl_info);
          gen_cpp_body(cl, cpp_src_file, cpp_ns_name, cpp_hdr_dir, cl_info);
 
          gen_cpp_header_epilogue(cpp_hdr_file);
        }
 
      // generate dump applications
 
        {
          struct ConfigurationImplementations
          {
            const char * name;
            const char * header;
            const char * class_name;
            const char * header_prologue;
            const char * main_function_prologue;
          } confs[] =
            {
              { 0, "conffwk/Configuration.hpp", 0, "", "" } };
 
          for (unsigned int i = 0; i < sizeof(confs) / sizeof(ConfigurationImplementations); ++i)
            {
              std::string dump_name = cpp_dir_name + "/dump";
              if (!cpp_ns_name.empty())
                {
                  dump_name += '_';
                  dump_name += alnum_name(cpp_ns_name);
                }
              if (confs[i].name)
                {
                  dump_name += '_';
                  dump_name += confs[i].name;
                }
              dump_name += ".cpp";
 
              std::ofstream dmp(dump_name.c_str());
 
              dmp.exceptions(std::ostream::failbit | std::ostream::badbit);
 
              if (dmp)
                {
                  try
                    {
                      gen_dump_application(dmp, class_names, cpp_ns_name, cpp_hdr_dir, confs[i].header, confs[i].class_name, confs[i].header_prologue, confs[i].main_function_prologue);
                    }
                  catch (std::exception& ex)
                    {
                      std::cerr << "ERROR: can not create file \"" << dump_name << "\": " << ex.what() << std::endl;
                    }
                }
              else
                {
                  std::cerr << "ERROR: can not create file \"" << dump_name << "\"\n";
                  return (EXIT_FAILURE);
                }
            }
        }
 
      // generate info file
 
        {
          std::ofstream info(info_file_name.c_str());
 
          if (info)
            {
              write_info_file(info, cpp_ns_name, cpp_hdr_dir, generated_classes);
            }
          else
            {
              std::cerr << "ERROR: can not create file \"" << info_file_name << "\"\n";
              return (EXIT_FAILURE);
            }
        }
 
    }
  catch (oks::exception & ex)
    {
      std::cerr << "Caught oks exception:\n" << ex << std::endl;
      return (EXIT_FAILURE);
    }
  catch (std::exception & e)
    {
      std::cerr << "Caught standard C++ exception: " << e.what() << std::endl;
      return (EXIT_FAILURE);
    }
  catch (...)
    {
      std::cerr << "Caught unknown exception" << std::endl;
      return (EXIT_FAILURE);
    }
 
  return (EXIT_SUCCESS);
}

open_cpp_namespace()

int open_cpp_namespace ( std::ostream & s, const std::string & value )

extern

Definition at line 635 of file utils.cpp.

{
  int level = 0;
  std::string dx;
 
  if (!value.empty())
    {
      Oks::Tokenizer t(value, ":");
      std::string token;
 
      while (!(token = t.next()).empty())
        {
          s << dx << "namespace " << token << " {\n";
          level++;
          dx += "  ";
        }
    }
 
  return level;
}

parse_arguments()

void parse_arguments ( int argc, char * argv[], std::list< std::string > & class_names, std::list< std::string > & file_names, std::list< std::string > & include_dirs, std::list< std::string > & user_classes, std::string & cpp_dir_name, std::string & cpp_ns_name, std::string & cpp_hdr_dir, std::string & info_file_name, bool & verbose )

extern

Definition at line 48 of file parse_cmdl.cpp.

{
 
  for (int i = 1; i < argc; i++)
    {
      const char * cp = argv[i];
 
      if (!strcmp(cp, "-h") || !strcmp(cp, "--help"))
        {
          usage();
          exit(EXIT_SUCCESS);
        }
      else if (!strcmp(cp, "-v") || !strcmp(cp, "--verbose"))
        {
          verbose = true;
        }
      else if (!strcmp(cp, "-d") || !strcmp(cp, "--c++-dir-name"))
        {
          if (++i == argc || argv[i][0] == '-')
            no_param(cp);
          else
            cpp_dir_name = argv[i];
        }
      else if (!strcmp(cp, "-n") || !strcmp(cp, "--c++-namespace"))
        {
          if (++i == argc || argv[i][0] == '-')
            no_param(cp);
          else
            cpp_ns_name = argv[i];
        }
      else if (!strcmp(cp, "-i") || !strcmp(cp, "--c++-headers-dir"))
        {
          if (++i == argc || argv[i][0] == '-')
            no_param(cp);
          else
            cpp_hdr_dir = argv[i];
        }
      else if (!strcmp(cp, "-f") || !strcmp(cp, "--info-file-name"))
        {
          if (++i == argc || argv[i][0] == '-')
            no_param(cp);
          else
            info_file_name = argv[i];
        }
      else
        {
          std::list<std::string> * slist = (
            (!strcmp(cp, "-c") || !strcmp(cp, "--classes"))              ? &class_names  :
            (!strcmp(cp, "-s") || !strcmp(cp, "--schema-files"))         ? &file_names   :
            (!strcmp(cp, "-I") || !strcmp(cp, "--include-dirs"))         ? &include_dirs :
            (!strcmp(cp, "-D") || !strcmp(cp, "--user-defined-classes")) ? &user_classes :
            nullptr
          );
 
          if (slist)
            {
              int j = 0;
              for (; j < argc - i - 1; ++j)
                {
                  if (argv[i + 1 + j][0] != '-')
                    slist->push_back(argv[i + 1 + j]);
                  else
                    break;
                }
              i += j;
            }
          else
            {
              std::cerr << "ERROR: Unexpected parameter: \"" << cp << "\"\n\n";
              usage();
              exit(EXIT_FAILURE);
            }
        }
    }
 
  if (file_names.size() == 0)
    {
      std::cerr << "At least one schema file is required\n";
      exit(EXIT_FAILURE);
    }
 
  if (verbose)
    {
      std::cout <<
          "VERBOSE:\n"
          "  Command line parameters:\n"
          "    c++ directory name:    \"" << cpp_dir_name << "\"\n"
          "    c++ namespace name:    \"" << cpp_ns_name << "\"\n"
          "    c++ headers directory: \"" << cpp_hdr_dir << "\"\n"
          "    classes:";
 
      if (!class_names.empty())
        {
          std::cout << std::endl;
 
          for (const auto& i : class_names)
            std::cout << "      - " << i << std::endl;
        }
      else
        {
          std::cout << " no\n";
        }
 
      std::cout << "    file names:";
 
      if (!file_names.empty())
        {
          std::cout << std::endl;
 
          for (const auto& i : file_names)
            std::cout << "      * " << i << std::endl;
        }
      else
        {
          std::cout << " no\n";
        }
 
      std::cout << "    include directories for search:";
 
      if (!include_dirs.empty())
        {
          std::cout << std::endl;
 
          for (const auto& i : include_dirs)
            std::cout << "      * " << i << std::endl;
        }
      else
        {
          std::cout << " no\n";
        }
 
      std::cout << "    user-defined classes:";
 
      if (!user_classes.empty())
        {
          std::cout << std::endl;
 
          for (const auto& i : user_classes)
            std::cout << "      * " << i << std::endl;
        }
      else
        {
          std::cout << " no\n";
        }
    }
}

print_description()

void print_description ( std::ostream & s, const std::string & text, const char * dx )

extern

The function print_description() is used for printing of the multi-line text with right alignment.

Definition at line 65 of file utils.cpp.

{
  if (!text.empty())
    {
      s << dx << " /**\n";
 
      Oks::Tokenizer t(text, "\n");
      std::string token;
 
      while (!(token = t.next()).empty())
        {
          s << dx << "  *  " << token << std::endl;
        }
 
      s << dx << "  */\n\n";
    }
}

print_indented()

void print_indented ( std::ostream & s, const std::string & text, const char * dx )

extern

Definition at line 84 of file utils.cpp.

{
  if (!text.empty())
    {
      Oks::Tokenizer t(text, "\n");
      std::string token;
 
      while (!(token = t.next()).empty())
        {
          s << dx << token << std::endl;
        }
    }
}

process_external_class()

bool process_external_class ( ClassInfo::Map & cl_info, const oks::OksClass * c, const std::list< std::string > & include_dirs, const std::list< std::string > & user_classes, bool verbose )

extern

rtrim()

std::string rtrim

(

const std::string &

s

)

Definition at line 79 of file oksdalgen.cxx.

{
    size_t end = s.find_last_not_of(WHITESPACE);
    return (end == std::string::npos) ? "" : s.substr(0, end + 1);
}

set2out()

static void set2out ( std::ostream & out, const std::set< std::string > & data, bool & is_first )

static

Definition at line 739 of file oksdalgen.cxx.

{
  for (const auto& x : data)
    {
      if (is_first)
        is_first = false;
      else
        out << ',';
      out << '\"' << x << "()\"";
    }
}

trim()

std::string trim

(

const std::string &

s

)

Definition at line 85 of file oksdalgen.cxx.

                                   {
    return rtrim(ltrim(s));
}

write_info_file()

void write_info_file ( std::ostream & s, const std::string & cpp_namespace, const std::string & cpp_header_dir, const std::set< const oks::OksClass *, std::less< const oks::OksClass * > > & class_names )

extern

Variable Documentation

cpp_method_virtual_specifiers

const std::vector<std::string> cpp_method_virtual_specifiers

Initial value:

= {
    "virtual",
    "override",
    "final"
}

Definition at line 89 of file oksdalgen.cxx.

                                                           {
    "virtual",
    "override",
    "final"
};

WHITESPACE

const std::string WHITESPACE = " \n\r\t\f\v"

Definition at line 71 of file oksdalgen.cxx.