utils.cpp File Reference

#include "class_info.hpp"
#include "oks/kernel.hpp"
#include "oks/method.hpp"
#include <ctype.h>
#include <algorithm>
#include <ctime>
#include <initializer_list>
#include <iomanip>
#include <iostream>

Include dependency graph for utils.cpp:

Go to the source code of this file.

Functions
char	cvt_symbol (char c)
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 (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 OksClass *, std::less< const OksClass * > > &classes)
std::string	get_full_cpp_class_name (const OksClass *c, const ClassInfo::Map &cl_info, const std::string &cpp_ns_name)
std::string	get_include_dir (const OksClass *c, const ClassInfo::Map &cl_info, const std::string &cpp_hdr_dir)
bool	process_external_class (ClassInfo::Map &cl_info, const 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)
const std::string	begin_header_prologue ("BEGIN_HEADER_PROLOGUE")
const std::string	end_header_prologue ("END_HEADER_PROLOGUE")
const std::string	begin_header_epilogue ("BEGIN_HEADER_EPILOGUE")
const std::string	end_header_epilogue ("END_HEADER_EPILOGUE")
const std::string	begin_public_section ("BEGIN_PUBLIC_SECTION")
const std::string	end_public_section ("END_PUBLIC_SECTION")
const std::string	begin_private_section ("BEGIN_PRIVATE_SECTION")
const std::string	end_private_section ("END_PRIVATE_SECTION")
const std::string	begin_member_initializer_list ("BEGIN_MEMBER_INITIALIZER_LIST")
const std::string	end_member_initializer_list ("END_MEMBER_INITIALIZER_LIST")
const std::string	has_add_algo_1 ("ADD_ALGO_1")
const std::string	has_add_algo_n ("ADD_ALGO_N")
static std::string	get_method_header_x_logue (OksMethodImplementation *mi, const std::string &begin, const std::string &end)
std::string	get_method_header_prologue (OksMethodImplementation *mi)
std::string	get_method_header_epilogue (OksMethodImplementation *mi)
std::string	get_public_section (OksMethodImplementation *mi)
std::string	get_private_section (OksMethodImplementation *mi)
std::string	get_member_initializer_list (OksMethodImplementation *mi)
bool	get_add_algo_1 (OksMethodImplementation *mi)
bool	get_add_algo_n (OksMethodImplementation *mi)
static void	remove_string_section (std::string &s, const std::string &begin, const std::string &end)
std::string	get_method_implementation_body (OksMethodImplementation *mi)
static OksMethodImplementation *	find_method_implementation (const OksMethod *method, std::initializer_list< std::string > names)
OksMethodImplementation *	find_cpp_method_implementation (const OksMethod *method)

Function Documentation

alnum_name()

std::string alnum_name

(

const std::string &

in

)

Definition at line 32 of file utils.cpp.

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

begin_header_epilogue()

const std::string begin_header_epilogue

(

"BEGIN_HEADER_EPILOGUE"

)

begin_header_prologue()

const std::string begin_header_prologue

(

"BEGIN_HEADER_PROLOGUE"

)

begin_member_initializer_list()

const std::string begin_member_initializer_list

(

"BEGIN_MEMBER_INITIALIZER_LIST"

)

begin_private_section()

const std::string begin_private_section

(

"BEGIN_PRIVATE_SECTION"

)

begin_public_section()

const std::string begin_public_section

(

"BEGIN_PUBLIC_SECTION"

)

capitalize_name()

std::string capitalize_name

(

const std::string &

in

)

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 )

Definition at line 657 of file utils.cpp.

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

cvt_symbol()

char cvt_symbol

(

char

c

)

The functions cvt_symbol() and alnum_name() are used to replace all symbols allowed in names of classes, attributes and relationships, but misinterpreted by c++.

Definition at line 26 of file utils.cpp.

{
  return (isalnum(c) ? c : '_');
}

end_header_epilogue()

const std::string end_header_epilogue

(

"END_HEADER_EPILOGUE"

)

end_header_prologue()

const std::string end_header_prologue

(

"END_HEADER_PROLOGUE"

)

end_member_initializer_list()

const std::string end_member_initializer_list

(

"END_MEMBER_INITIALIZER_LIST"

)

end_private_section()

const std::string end_private_section

(

"END_PRIVATE_SECTION"

)

end_public_section()

const std::string end_public_section

(

"END_PUBLIC_SECTION"

)

find_cpp_method_implementation()

OksMethodImplementation * find_cpp_method_implementation

(

const OksMethod *

method

)

Definition at line 785 of file utils.cpp.

{
  return find_method_implementation(method, { "c++", "C++" });
}

find_method_implementation()

static OksMethodImplementation * find_method_implementation ( const OksMethod * method, std::initializer_list< std::string > names )

static

Definition at line 772 of file utils.cpp.

{
  for (const auto& name : names)
    {
      if (OksMethodImplementation * mi = method->find_implementation(name))
        if (mi->get_prototype().empty() == false)
          return mi;
    }
 
  return nullptr;
}

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 )

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";
}

get_add_algo_1()

bool get_add_algo_1

(

OksMethodImplementation *

mi

)

Definition at line 724 of file utils.cpp.

{
  return (mi->get_body().find(has_add_algo_1, 0) != std::string::npos);
}

get_add_algo_n()

bool get_add_algo_n

(

OksMethodImplementation *

mi

)

Definition at line 730 of file utils.cpp.

{
  return (mi->get_body().find(has_add_algo_n, 0) != std::string::npos);
}

get_full_cpp_class_name()

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

The function get_full_cpp_class_name() returns name of class with it's namespace (e.g. "NAMESPACE_A::CLASS_X")

Definition at line 404 of file utils.cpp.

{
  std::string s;
  ClassInfo::Map::const_iterator idx = cl_info.find(c);
 
  if (idx != cl_info.end())
    s = (*idx).second.get_namespace();
  else
    s = cpp_ns_name;
 
  if (!s.empty())
    s += "::";
 
  s += alnum_name(c->get_name());
 
  return s;
}

get_include_dir()

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

Definition at line 424 of file utils.cpp.

{
  std::string s;
 
  ClassInfo::Map::const_iterator idx = cl_info.find(c);
 
  if (idx != cl_info.end())
    {
      const std::string include_prefix = (*idx).second.get_include_prefix();
      if (!include_prefix.empty())
        {
          s = include_prefix;
          s += '/';
        }
    }
  else if (!cpp_hdr_dir.empty())
    {
      s = cpp_hdr_dir;
      s += '/';
    }
 
  s += alnum_name(c->get_name());
 
  return s;
}

get_member_initializer_list()

std::string get_member_initializer_list

(

OksMethodImplementation *

mi

)

Definition at line 718 of file utils.cpp.

{
  return get_method_header_x_logue(mi, begin_member_initializer_list, end_member_initializer_list);
}

get_method_header_epilogue()

std::string get_method_header_epilogue

(

OksMethodImplementation *

mi

)

Definition at line 700 of file utils.cpp.

{
  return get_method_header_x_logue(mi, begin_header_epilogue, end_header_epilogue);
}

get_method_header_prologue()

std::string get_method_header_prologue

(

OksMethodImplementation *

mi

)

Definition at line 694 of file utils.cpp.

{
  return get_method_header_x_logue(mi, begin_header_prologue, end_header_prologue);
}

get_method_header_x_logue()

static std::string get_method_header_x_logue ( OksMethodImplementation * mi, const std::string & begin, const std::string & end )

static

Definition at line 682 of file utils.cpp.

{
  std::string::size_type begix_idx = mi->get_body().find(begin, 0);
  if (begix_idx == std::string::npos)
    return "";
  std::string::size_type end_idx = mi->get_body().find(end, begix_idx + begin.size());
  if (end_idx == std::string::npos)
    return "";
  return mi->get_body().substr(begix_idx + begin.size(), end_idx - begix_idx - begin.size());
}

get_method_implementation_body()

std::string get_method_implementation_body

(

OksMethodImplementation *

mi

)

Definition at line 754 of file utils.cpp.

{
  std::string s = mi->get_body();
  remove_string_section(s, begin_header_prologue, end_header_prologue);
  remove_string_section(s, begin_header_epilogue, end_header_epilogue);
  remove_string_section(s, begin_public_section, end_public_section);
  remove_string_section(s, begin_private_section, end_private_section);
  remove_string_section(s, begin_member_initializer_list, end_member_initializer_list);
  remove_string_section(s, has_add_algo_1, "");
  remove_string_section(s, has_add_algo_n, "");
 
  if(std::all_of(s.begin(),s.end(),isspace))
    return "";
  else
    return s;
}

get_private_section()

std::string get_private_section

(

OksMethodImplementation *

mi

)

Definition at line 712 of file utils.cpp.

{
  return get_method_header_x_logue(mi, begin_private_section, end_private_section);
}

get_public_section()

std::string get_public_section

(

OksMethodImplementation *

mi

)

Definition at line 706 of file utils.cpp.

{
  return get_method_header_x_logue(mi, begin_public_section, end_public_section);
}

get_type()

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

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_add_algo_1()

const std::string has_add_algo_1

(

"ADD_ALGO_1"

)

has_add_algo_n()

const std::string has_add_algo_n

(

"ADD_ALGO_N"

)

int2dx()

std::string int2dx

(

int

level

)

Definition at line 629 of file utils.cpp.

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

open_cpp_namespace()

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

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;
}

print_description()

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

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 )

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 OksClass *	c,
		const std::list< std::string > &	include_dirs,
		const std::list< std::string > &	user_classes,
		bool	verbose )

Definition at line 469 of file utils.cpp.

{
  if (cl_info.find(c) != cl_info.end())
    return true;
 
  // process list of user-defined classes first
 
  for (const auto &s : user_classes)
    {
      std::string::size_type idx = s.find("::");
      std::string::size_type idx2 = s.find("@", idx + 2);
 
      std::string cpp_ns_name;
      std::string class_name;
      std::string cpp_dir_name;
 
      if (idx == std::string::npos)
        {
          class_name = s.substr(0, idx2);
        }
      else
        {
          cpp_ns_name = s.substr(0, idx);
          class_name = s.substr(idx + 2, idx2 - idx - 2);
        }
 
      if (idx2 != std::string::npos)
        cpp_dir_name = s.substr(idx2 + 1);
 
      if (class_name == c->get_name())
        {
          cl_info[c] = ClassInfo(cpp_ns_name, cpp_dir_name);
          if (verbose)
            {
              std::cout << " * class " << c->get_name() << " is defined by user in ";
 
              if (cpp_ns_name.empty())
                std::cout << "global namespace";
              else
                std::cout << "namespace \"" << cpp_ns_name << '\"';
 
              if (!cpp_dir_name.empty())
                std::cout << " with \"" << cpp_dir_name << "\" include prefix";
 
              std::cout << std::endl;
            }
 
          return true;
        }
    }
 
  // process oksdalgen files
 
  if (verbose)
    std::cout << "Looking for oksdalgen info files ...\n";
 
  bool found_class_declaration = false;
 
  for (const auto& i : include_dirs)
    {
      std::string file_name(i);
      file_name += "/oksdalgen.info";
 
      std::ifstream f(file_name.c_str());
 
      if (f)
        {
          if (verbose)
            std::cout << " *** found file \"" << file_name << "\" ***\n";
 
          std::string cpp_ns_name;
          std::string cpp_dir_name;
          // std::string java_pname;
          bool is_class = false;
 
          std::string s;
          while (std::getline(f, s))
            {
              if (s.find("//") != std::string::npos)
                {
                  if (verbose)
                    std::cout << " - skip comment \"" << s << "\"\n";
                }
              else if (s.find("classes:") != std::string::npos)
                {
                  if (verbose)
                    std::cout << " - found classes keyword\n";
                  is_class = true;
                }
              else
                {
                  const char s1[] = "c++-namespace=";
                  std::string::size_type idx = s.find(s1);
                  if (idx != std::string::npos)
                    {
                      cpp_ns_name = s.substr(sizeof(s1) - 1);
                      if (verbose)
                        std::cout << " - c++ namespace = \"" << cpp_ns_name << "\"\n";
                    }
                  else
                    {
                      const char s2[] = "c++-header-dir-prefix=";
                      std::string::size_type idx = s.find(s2);
                      if (idx != std::string::npos)
                        {
                          cpp_dir_name = s.substr(sizeof(s2) - 1);
                          if (verbose)
                            std::cout << " - c++ header dir prefix name = \"" << cpp_dir_name << "\"\n";
                        }
                      // else
                        // {
                        //   const char s3[] = "java-package-name=";
                        //   std::string::size_type idx = s.find(s3);
                        //   if (idx != std::string::npos)
                        //     {
                        //       java_pname = s.substr(sizeof(s3) - 1);
                        //       if (verbose)
                        //         std::cout << " - java package name = \"" << java_pname << "\"\n";
                        //     }
                          else if (is_class)
                            {
                              std::string cname = s.substr(2);
                              OksClass * cl = c->get_kernel()->find_class(cname);
                              if (cl && cl_info.find(cl) == cl_info.end())
                                {
                                  cl_info[cl] = ClassInfo(cpp_ns_name, cpp_dir_name);
                                  if (verbose)
                                    std::cout << " * class " << cl->get_name() << " is defined by " << file_name << " in namespace \"" << cpp_ns_name << "\" with include prefix \"" << cpp_dir_name << "\"\n";
                                  if (cl == c)
                                    found_class_declaration = true;
                                }
                              else if (verbose)
                                {
                                  std::cout << " - skip class \"" << cname << "\" declaration\n";
                                }
                            }
                          else
                            {
                              std::cerr << "Failed to parse line \"" << s << "\"\n";
                            }
                        // }
                    }
                }
            }
        }
      else if (verbose)
        {
          std::cout << " *** file \"" << file_name << "\" does not exist ***\n";
        }
    }
 
  return found_class_declaration;
}

remove_string_section()

static void remove_string_section ( std::string & s, const std::string & begin, const std::string & end )

static

Definition at line 736 of file utils.cpp.

{
  std::string::size_type begix_idx = s.find(begin, 0);
  if (begix_idx == std::string::npos)
    return;
 
  std::string::size_type end_idx = (end.empty() ? (begix_idx + begin.size()) : s.find(end, begix_idx + begin.size()));
  if (end_idx == std::string::npos)
    return;
 
  end_idx += end.size();
  while (s[end_idx] == '\n')
    end_idx++;
 
  s.erase(begix_idx, end_idx - begix_idx);
}

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 OksClass *, std::less< const OksClass * > > &	classes )

Definition at line 378 of file utils.cpp.

{
  std::time_t now = std::time(nullptr);
 
  s << "// the file is generated " << std::put_time(std::localtime(&now), "%F %T %Z") << " by oksdalgen utility\n"
      "// *** do not modify the file ***\n"
      "c++-namespace=" << cpp_namespace << "\n"
      "c++-header-dir-prefix=" << cpp_header_dir << "\n"
      // "java-package-name=" << java_pname << "\n"
      "classes:\n";
 
  for (const auto& i : classes)
    s << "  " << i->get_name() << std::endl;
}