midas::odb Class Reference

#include <odbxx.h>

Collaboration diagram for midas::odb:

Classes
class	iterator

Public Types
enum	odb_source { ONLINE = 0 , STRING , FILE }

Public Member Functions
	odb ()
	~odb ()
	odb (const odb &o)
odb	operator= (odb &&o)=delete
template<typename T >
	odb (T v)
	odb (std::initializer_list< std::pair< const char *, midas::odb > > list)
template<typename T >
	odb (std::initializer_list< T > list)
template<typename T , size_t SIZE>
	odb (const std::array< T, SIZE > &arr)
template<size_t SIZE>
	odb (const std::array< std::string, SIZE > &arr)
	odb (const std::string &path, bool init_via_xml=false)
	odb (const char *s)
	odb (std::initializer_list< const char * > list)
template<typename T >
int	detect_type (const T &)
template<typename T >
const T &	operator= (const T &v)
template<typename T >
const std::vector< T > &	operator= (const std::vector< T > &v)
template<typename T , size_t SIZE>
const std::array< T, SIZE > &	operator= (const std::array< T, SIZE > &arr)
	operator std::string ()
template<typename T >
	operator std::vector< T > ()
	operator std::vector< std::string > ()
template<typename T , typename std::enable_if< std::is_same< T, uint8_t >::value||std::is_same< T, int8_t >::value||std::is_same< T, uint16_t >::value||std::is_same< T, int16_t >::value||std::is_same< T, uint32_t >::value||std::is_same< T, int32_t >::value||std::is_same< T, uint64_t >::value||std::is_same< T, int64_t >::value||std::is_same< T, bool >::value||std::is_same< T, float >::value||std::is_same< T, double >::value, T >::type * = nullptr>
	operator T ()
u_odb &	operator[] (int index)
odb &	operator[] (std::string str)
odb &	operator[] (const char *str)
template<typename T >
odb &	operator() (T v)
int	get_last_index ()
void	set_last_index (int i)
iterator	begin () const
iterator	end () const
template<typename T >
T	operator+ (T i)
template<typename T >
T	operator- (T i)
template<typename T >
T	operator* (const T i)
template<typename T >
T	operator/ (const T i)
odb &	operator++ ()
odb	operator++ (int)
odb &	operator-- ()
odb	operator-- (int)
odb &	operator+= (double d)
odb &	operator-= (double d)
odb &	operator*= (double d)
odb &	operator/= (double d)
void	deep_copy (odb &d, const odb &s)
bool	is_preserve_string_size () const
void	set_preserve_string_size (bool f)
bool	is_auto_refresh_read () const
void	set_auto_refresh_read (bool f)
bool	is_auto_refresh_write () const
void	set_auto_refresh_write (bool f)
bool	is_dirty () const
void	set_dirty (bool f)
bool	is_auto_create () const
void	set_auto_create (bool f)
bool	is_auto_enlarge_array () const
void	set_auto_enlarge_array (bool f)
bool	is_write_protect () const
void	set_write_protect (bool f)
bool	is_trigger_hotlink () const
void	set_trigger_hotlink (bool f)
void	odb_from_xml_remote (const std::string &str)
void	odb_from_xml_string (const std::string &str, const std::string &subkey)
void	odb_from_json_string (const std::string &str, const std::string &subkey)
void	connect (const std::string &path, const std::string &name, bool write_defaults, bool delete_keys_not_in_defaults=false)
void	connect (std::string str, bool write_defaults=false, bool delete_keys_not_in_defaults=false)
void	connect_and_fix_structure (std::string path)
void	read ()
void	read (int index)
void	write (int str_size=0)
void	write (int index, int str_size)
std::string	print ()
std::string	dump ()
void	print (std::string &s, int indent=0)
void	dump (std::string &s, int indent=0)
void	save (const std::string &filename)
void	delete_key ()
int	size ()
void	resize (int size)
void	resize (int size, bool b)
void	watch (std::function< void(midas::odb &)> f)
void	unwatch ()
void	set (std::string str)
void	set (std::string s, int i)
void	set_odb (odb *o, int i)
void	set_string_size (std::string s, int size)
bool	is_subkey (std::string str)
HNDLE	get_hkey ()
std::string	get_full_path ()
std::string	get_parent_path ()
int	get_tid ()
int	get_num_values ()
std::string	get_name ()
odb &	items ()
std::string	s ()
void	fix_order (std::vector< std::string > target_subkey_order)
void	set_mode (int mode)
int	get_mode ()
unsigned int	get_last_written ()

Static Public Member Functions
static midas::odb *	odb_from_xml (PMXML_NODE node, odb *o)
static std::string	node_to_string (const MJsonNode *node)
static midas::odb *	odb_from_json (const MJsonNode *node, std::string name, int tid, odb *o)
static void	set_debug (bool flag)
static bool	get_debug ()
static int	create (const char *name, int type=TID_KEY)
static bool	exists (const std::string &name)
static int	delete_key (const std::string &name)
static void	load (const std::string &filename, const std::string &odb_path)
static odb::odb_source	get_odb_source ()
static void	set_odb_source (odb::odb_source s)
static void	set_odb_source (odb::odb_source s, std::string str)
static void	odb_from_xml_string (const std::string &str)
static void	odb_from_json_string (const std::string &str)
static bool	is_connected_odb ()

Private Member Functions
void	set_flags_recursively (uint32_t f)
void	resize_mdata (int size)
template<typename T >
T	get ()
template<typename T >
void	get (T &v)
void	get (std::string &s, bool quotes=false, bool refresh=true)
u_odb &	get_mdata (int index=0)
odb &	get_subkey (std::string str)
int	get_subkeys (std::vector< std::string > &name)
bool	read_key (const std::string &path)
bool	write_key (std::string &path, bool write_defaults)
void	set_hkey (HNDLE hKey)
void	set_flags (uint32_t f)
uint32_t	get_flags ()
bool	is_deleted () const
void	set_deleted (bool f)
void	set_tid (int tid)
void	set_num_values (int n)
void	set_name (std::string s)
void	set_parent (midas::odb *p)
midas::odb *	get_parent ()

Static Private Member Functions
static void	init_hdb ()
static midas::odb *	search_hkey (midas::odb *po, int hKey)
static void	watch_callback (int hDB, int hKey, int index, void *info)
static void	unwatch_all ()

Private Attributes
std::bitset< 9 >	m_flags
int	m_tid
u_odb *	m_data
std::string	m_name
int	m_num_values
int	m_last_index
HNDLE	m_hKey
std::function< void(midas::odb &)>	m_watch_callback
midas::odb *	m_parent

Static Private Attributes
static thread_local odb_source	s_odb_source = odb::ONLINE
static thread_local std::string	s_odb_source_str = std::string("")
static thread_local odb *	s_odb = nullptr
static HNDLE	s_hDB = 0
static bool	s_debug = false
static bool	s_connected_odb = false
static std::vector< midas::odb >	m_watch

Friends
std::ostream &	operator<< (std::ostream &output, odb &o)
template<typename T >
bool	operator== (const midas::odb &o, const T &d)
template<typename T >
bool	operator== (const T &d, const midas::odb &o)
template<typename T >
bool	operator!= (const midas::odb &o, const T &d)
template<typename T >
bool	operator!= (const T &d, const midas::odb &o)
template<typename T >
bool	operator< (const midas::odb &o, const T &d)
template<typename T >
bool	operator< (const T &d, const midas::odb &o)
template<typename T >
bool	operator<= (const midas::odb &o, const T &d)
template<typename T >
bool	operator<= (const T &d, const midas::odb &o)
template<typename T >
bool	operator> (const midas::odb &o, const T &d)
template<typename T >
bool	operator> (const T &d, const midas::odb &o)
template<typename T >
bool	operator>= (const midas::odb &o, const T &d)
template<typename T >
bool	operator>= (const T &d, const midas::odb &o)

Detailed Description

Definition at line 410 of file odbxx.h.

Member Enumeration Documentation

odb_source

enum midas::odb::odb_source

Enumerator
ONLINE
STRING
FILE

Definition at line 413 of file odbxx.h.

                      {
         ONLINE = 0,
         STRING,
         FILE
      };

Constructor & Destructor Documentation

odb() [1/10]

midas::odb::odb ( )

inline

Definition at line 544 of file odbxx.h.

            :
              m_flags{(1 << odb_flags::AUTO_REFRESH_READ) |
                      (1 << odb_flags::AUTO_REFRESH_WRITE) |
                      (1 << odb_flags::AUTO_ENLARGE_ARRAY) |
                      (1 << odb_flags::AUTO_CREATE) |
                      (1 << odb_flags::TRIGGER_HOTLINK)},
              m_tid{0},
              m_data{nullptr},
              m_name{},
              m_num_values{0},
              m_last_index{-1},
              m_hKey{},
              m_parent{} {}

~odb()

midas::odb::~odb ( )

inline

Definition at line 559 of file odbxx.h.

             {
         delete[] m_data;
      }

odb() [2/10]

midas::odb::odb

(

const odb &

o

)

Definition at line 307 of file odbxx.cxx.

                        : odb() {
      m_tid = o.m_tid;
      m_name = o.m_name;
      m_num_values = o.m_num_values;
      m_hKey = o.m_hKey;
      m_watch_callback = o.m_watch_callback;
      m_data = new midas::u_odb[m_num_values]{};
      for (int i = 0; i < m_num_values; i++) {
         m_data[i].set_tid(m_tid);
         m_data[i].set_parent(this);
         if (m_tid == TID_STRING || m_tid == TID_LINK) {
            // set_string() creates a copy of our string
            m_data[i].set_string(o.m_data[i]);
         } else if (m_tid == TID_KEY) {
            // recursive call to create a copy of the odb object
            midas::odb *po = o.m_data[i].get_podb();
            midas::odb *pc = new midas::odb(*po);
            pc->set_parent(this);
            m_data[i].set(pc);
         } else {
            // simply pass basic types
            m_data[i] = o.m_data[i];
            m_data[i].set_parent(this);
         }
      }
   }

Here is the call graph for this function:

odb() [3/10]

template<typename T >

midas::odb::odb ( T  v )

inline

Definition at line 571 of file odbxx.h.

              :odb() {
         m_num_values = 1;
         m_data = new u_odb[1]{v};
         m_tid = m_data[0].get_tid();
         m_data[0].set_parent(this);
      }

Here is the call graph for this function:

odb() [4/10]

midas::odb::odb ( std::initializer_list< std::pair< const char *, midas::odb > >  list )

inline

Definition at line 579 of file odbxx.h.

                                                                     : odb() {
         m_tid = TID_KEY;
         m_num_values = list.size();
         m_data = new u_odb[m_num_values];
         int i = 0;
         for (auto &element: list) {
            // check if name exists already
            for (int j=0 ; j<i ; j++) {
               if (strcasecmp(element.first, m_data[j].get_odb().get_name().c_str()) == 0) {
                  if (element.first == m_data[j].get_odb().get_name().c_str()) {
                     mthrow("ODB key with name \"" + m_data[j].get_odb().get_name() + "\" exists already");
                  } else {
                     mthrow("ODB key \"" + std::string(element.first) + "\" exists already as \"" +
                            m_data[j].get_odb().get_name() + "\" (only case differs)");
                  }
               }
            }
            auto o = new midas::odb(element.second);
            o->set_name(element.first);
            o->set_parent(this);
            m_data[i].set_tid(TID_KEY);
            m_data[i].set_parent(this);
            m_data[i].set(o);
            i++;
         }
      }

Here is the call graph for this function:

odb() [5/10]

template<typename T >

midas::odb::odb ( std::initializer_list< T >  list )

inline

Definition at line 608 of file odbxx.h.

                                       : odb() {
         m_num_values = list.size();
         m_data = new u_odb[m_num_values]{};
         int i = 0;
         for (auto &element : list) {
            u_odb u(element);
            m_data[i].set_tid(u.get_tid());
            m_data[i].set_parent(this);
            m_data[i].set(element);
            i++;
         }
         m_tid = m_data[0].get_tid();
      }

Here is the call graph for this function:

odb() [6/10]

template<typename T , size_t SIZE>

midas::odb::odb ( const std::array< T, SIZE > &  arr )

inline

Definition at line 624 of file odbxx.h.

                                        : odb() {
         m_num_values = SIZE;
         m_data = new u_odb[m_num_values]{};
         for (int i = 0; i < (int)SIZE; i++) {
            u_odb u(arr[i]);
            m_data[i].set_tid(u.get_tid());
            m_data[i].set_parent(this);
            m_data[i].set(arr[i]);
         }
         m_tid = m_data[0].get_tid();
      }

Here is the call graph for this function:

odb() [7/10]

template<size_t SIZE>

midas::odb::odb ( const std::array< std::string, SIZE > &  arr )

inline

Definition at line 638 of file odbxx.h.

                                                : odb() {
         m_num_values = SIZE;
         m_data = new u_odb[m_num_values]{};
         for (int i = 0; i < (int)SIZE; i++) {
            std::string * mystring = new std::string(arr[i]);
            u_odb u(mystring);
            m_data[i].set_tid(u.get_tid());
            m_data[i].set_parent(this);
            m_data[i].set(arr[i]);
         }
         m_tid = m_data[0].get_tid();
      }

Here is the call graph for this function:

odb() [8/10]

midas::odb::odb ( const std::string &  path, bool  init_via_xml = false  )

inline

Definition at line 652 of file odbxx.h.

                                                            : odb() {
         if (path[0] == '/') {
            // ODB path
            if (s_odb_source == ONLINE) {
               if (init_via_xml) {
                  if (!exists(path))
                     odb::create(path.c_str(), TID_KEY);
                  odb_from_xml_remote(path);
               } else {
                  if (!read_key(path))
                     // create subdir if key does not exist
                     odb::create(path.c_str(), TID_KEY);
 
                  if (!read_key(path))
                     mthrow("ODB key \"" + path + "\" not found in ODB");
 
                  if (m_tid != TID_KEY)
                     read();
               }
            } else if (s_odb_source == STRING || s_odb_source == FILE) {
 
               // split path
               std::stringstream ss(path.substr(1));
               std::string item;
               std::vector<std::string> arr;
               while (std::getline(ss, item, '/'))
                  arr.push_back(item);
 
               // extract subkey from root odb
               odb *o = s_odb;
               for (size_t i = 0; i < arr.size(); i++)
                  o = &(*o)[arr[i]];
 
               // do a deep copy from "o" to "this"
               m_tid = o->m_tid;
               m_tid = o->m_tid;
               m_name = o->m_name;
               m_num_values = o->m_num_values;
               m_hKey = o->m_hKey;
               m_watch_callback = o->m_watch_callback;
               m_data = new midas::u_odb[m_num_values]{};
               for (int i = 0; i < m_num_values; i++) {
                  m_data[i].set_tid(m_tid);
                  m_data[i].set_parent(this);
                  if (m_tid == TID_STRING || m_tid == TID_LINK) {
                     // set_string() creates a copy of our string
                     m_data[i].set_string(o->m_data[i]);
                  } else if (m_tid == TID_KEY) {
                     // recursive call to create a copy of the odb object
                     auto *po= o->m_data[i].get_podb();
                     auto *pc = new midas::odb(*po);
                     pc->set_parent(this);
                     m_data[i].set(pc);
                  } else {
                     // simply pass basic types
                     m_data[i] = o->m_data[i];
                     m_data[i].set_parent(this);
                  }
               }
 
            } else
               mthrow("Unknown ODB source: " + std::to_string(s_odb_source));
 
         } else {
            // simple string
 
            // Construct object from initializer_list
            m_num_values = 1;
            m_data = new u_odb[1]{new std::string{path}};
            m_tid = m_data[0].get_tid();
            m_data[0].set_parent(this);
         }
      }

Here is the call graph for this function:

odb() [9/10]

midas::odb::odb ( const char *  s )

inline

Definition at line 727 of file odbxx.h.

                         : odb(std::string(s)) {
      }

odb() [10/10]

midas::odb::odb ( std::initializer_list< const char * >  list )

inline

Definition at line 731 of file odbxx.h.

                                                  : odb() {
         m_num_values = list.size();
         m_data = new u_odb[m_num_values]{};
         int i = 0;
         for (auto &element : list) {
            m_data[i].set_tid(TID_STRING);
            m_data[i].set_parent(this);
            m_data[i].set(element);
            i++;
         }
         m_tid = m_data[0].get_tid();
      }

Here is the call graph for this function:

Member Function Documentation

begin()

iterator midas::odb::begin ( ) const

inline

Definition at line 1018 of file odbxx.h.

{ return iterator(m_data); }

connect() [1/2]

void midas::odb::connect	(	const std::string &	path,
		const std::string &	name,
		bool	write_defaults,
		bool	delete_keys_not_in_defaults = false
	)

Definition at line 1377 of file odbxx.cxx.

                                                                                                                     {
      init_hdb();
 
      if (!name.empty())
         m_name = name;
      std::string path(p);
 
      if (path.empty())
         mthrow("odb::connect() cannot be called with an empty ODB path");
 
      if (path[0] != '/')
         mthrow("odb::connect(\"" + path + "\"): path must start with leading \"/\"");
 
      if (path.back() != '/')
         path += "/";
 
      path += m_name;
 
      HNDLE hKey;
      int status = db_find_key(s_hDB, 0, path.c_str(), &hKey);
      bool key_exists = (status == DB_SUCCESS);
      bool created = false;
 
      if (key_exists && delete_keys_not_in_defaults) {
         // Recurse down to delete keys as needed.
         // We need to do this recursively BEFORE calling read/read_key for the first time
         // to ensure that subdirectories get handled correctly.
         recurse_del_keys_not_in_defaults(path, s_hDB, hKey, *this);
      }
 
      if (!key_exists || write_defaults) {
         created = write_key(path, write_defaults);
      } else {
         read_key(path);
      }
 
      // correct wrong parent ODB from initializer_list
      for (int i = 0; i < m_num_values; i++)
         m_data[i].set_parent(this);
 
      if (m_tid == TID_KEY) {
         for (int i = 0; i < m_num_values; i++)
            m_data[i].get_odb().connect(get_full_path(), m_data[i].get_odb().get_name(), write_defaults);
      } else if (created || write_defaults) {
         write();
      } else {
         read();
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

connect() [2/2]

void midas::odb::connect	(	std::string	str,
		bool	write_defaults = false,
		bool	delete_keys_not_in_defaults = false
	)

Definition at line 1428 of file odbxx.cxx.

                                                                                         {
 
      if (str.empty())
         mthrow("odb::connect() cannot be called with an empty ODB path");
 
      if (str[0] != '/')
         mthrow("odb::connect(\"" + str + "\"): path must start with leading \"/\"");
 
      if (str == "/")
         mthrow("odb::connect(\"" + str + "\"): root ODB tree is not allowed");
 
      if (s_odb_source == odb::FILE || s_odb_source == odb::STRING)
         mthrow("odb::connect(\"" + str + "\"): not allowed in STRING or FILE mode");
 
      if (str.back() == '/')
         str = str.substr(0, str.size()-1);
 
      // separate ODB path and key nam
      std::string name;
      std::string path;
      name = str.substr(str.find_last_of('/') + 1);
      path = str.substr(0, str.find_last_of('/') + 1);
 
      connect(path, name, write_defaults, delete_keys_not_in_defaults);
   }

Here is the call graph for this function:

connect_and_fix_structure()

void midas::odb::connect_and_fix_structure

(

std::string

path

)

Definition at line 1459 of file odbxx.cxx.

                                                     {
      // Store the order the user specified.
      // Need to do this recursively before calling connect(), as the first
      // read() in that function merges user keys and existing keys.
      std::map<std::string, std::vector<std::string> > user_order;
      recurse_get_defaults_order(path, *this, user_order);
 
      // Main connect() that adds/deletes/updates keys as needed.
      connect(path, false, true);
 
      // Fix order in ODB (and memory)
      recurse_fix_order(*this, user_order);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

create()

int midas::odb::create ( const char *  name, int  type = TID_KEY  )

static

Definition at line 140 of file odbxx.cxx.

                                             {
      init_hdb();
      int status = -1;
      if (is_connected_odb())
         status = db_create_key(s_hDB, 0, name, type);
      if (status != DB_SUCCESS && status != DB_KEY_EXIST)
         mthrow("Cannot create key " + std::string(name) + ", db_create_key() status = " + std::to_string(status));
      return status;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

deep_copy()

void midas::odb::deep_copy	(	odb &	d,
		const odb &	s
	)

Definition at line 334 of file odbxx.cxx.

                                           {
      d.m_tid = s.m_tid;
      d.m_name = s.m_name;
      d.m_num_values = s.m_num_values;
      d.m_hKey = s.m_hKey;
      d.m_watch_callback = s.m_watch_callback;
      d.m_data = new midas::u_odb[d.m_num_values]{};
      for (int i = 0; i < d.m_num_values; i++) {
         d.m_data[i].set_tid(d.m_tid);
         d.m_data[i].set_parent(&d);
         if (d.m_tid == TID_STRING || d.m_tid == TID_LINK) {
            // set_string() creates a copy of our string
            d.m_data[i].set_string(s.m_data[i]);
         } else if (d.m_tid == TID_KEY) {
            // recursive call to create a copy of the odb object
            midas::odb *po = s.m_data[i].get_podb();
            midas::odb *pc = new midas::odb(*po);
            pc->set_parent(&d);
            d.m_data[i].set(pc);
         } else {
            // simply pass basic types
            d.m_data[i] = s.m_data[i];
            d.m_data[i].set_parent(this);
         }
      }
   }

Here is the call graph for this function:

delete_key() [1/2]

void midas::odb::delete_key

(

)

Definition at line 1473 of file odbxx.cxx.

                        {
      init_hdb();
 
      m_name = get_full_path();
 
      if (this->is_write_protect())
         mthrow("Cannot modify write protected key \"" + m_name + "\"");
 
 
      // delete key in ODB
      int status = db_delete_key(s_hDB, m_hKey);
      if (status != DB_SUCCESS && status != DB_INVALID_HANDLE)
         mthrow("db_delete_key for ODB key \"" + m_name +
                "\" returnd error code " + std::to_string(status));
 
      if (s_debug)
         std::cout << "Deleted ODB key \"" + m_name + "\"" << std::endl;
 
      // invalidate this object
      delete[] m_data;
      m_data = nullptr;
      m_num_values = 0;
      m_tid = 0;
      m_hKey = 0;
 
      // set flag that this object has been deleted
      set_deleted(true);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

delete_key() [2/2]

int midas::odb::delete_key ( const std::string &  name )

static

Definition at line 85 of file odbxx.cxx.

                                            {
      init_hdb();
      if (!odb::is_connected_odb())
         return false;
      HNDLE hkey;
      auto status = db_find_key(s_hDB, 0, name.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         if (s_debug)
            std::cout << "Delete key " + name << " not found in ODB" << std::endl;
         return status;
      }
      if (s_debug)
         std::cout << "Delete ODB key " + name << std::endl;
      return db_delete_key(s_hDB, hkey);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

detect_type()

template<typename T >

int midas::odb::detect_type ( const T &  )

inline

Definition at line 745 of file odbxx.h.

                                 {
         if (std::is_same<T, uint8_t>::value)
            return TID_UINT8;
         else if (std::is_same<T, int8_t>::value)
            return TID_INT8;
         else if (std::is_same<T, uint16_t>::value)
            return TID_UINT16;
         else if (std::is_same<T, int16_t>::value)
            return TID_INT16;
         else if (std::is_same<T, uint32_t>::value)
            return TID_UINT32;
         else if (std::is_same<T, unsigned long>::value && sizeof(long) == 4)
            return TID_UINT32;
         else if (std::is_same<T, int32_t>::value)
            return TID_INT32;
         else if (std::is_same<T, long>::value && sizeof(long) == 4)
            return TID_INT32;
         else if (std::is_same<T, uint64_t>::value)
            return TID_UINT64;
         else if (std::is_same<T, unsigned long>::value && sizeof(long) == 8)
            return TID_UINT64;
         else if (std::is_same<T, int64_t>::value)
            return TID_INT64;
         else if (std::is_same<T, long>::value && sizeof(long) == 8)
            return TID_INT64;
         else if (std::is_same<T, bool>::value)
            return TID_BOOL;
         else if (std::is_same<T, float>::value)
            return TID_FLOAT;
         else if (std::is_same<T, double>::value)
            return TID_DOUBLE;
         else
            return TID_STRING;
      }

Here is the caller graph for this function:

dump() [1/2]

std::string midas::odb::dump

(

)

Definition at line 427 of file odbxx.cxx.

                       {
      std::string s;
      s = "{\n";
      dump(s, 1);
      s += "\n}";
      return s;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

dump() [2/2]

void midas::odb::dump	(	std::string &	s,
		int	indent = 0
	)

Definition at line 469 of file odbxx.cxx.

                                          {
      if (m_name != "root")
         for (int i = 0; i < indent; i++)
            s += "   ";
      if (m_tid == TID_KEY) {
         if (m_name == "root")
            indent--;
         else {
            s += "\"" + m_name + "\": {\n";
         }
         for (int i = 0; i < m_num_values; i++) {
            std::string v;
            m_data[i].get_odb().dump(v, indent + 1);
            s += v;
            if (i < m_num_values - 1)
               s += ",\n";
            else
               s += "\n";
         }
         if (m_name != "root") {
            for (int i = 0; i < indent; i++)
               s += "   ";
            s += "}";
         }
      } else {
         s += "\"" + m_name + "/key\": ";
         s += "{ \"type\": " + std::to_string(m_tid) + ", ";
 
         if (s_odb_source == midas::odb::ONLINE) {
            KEY key;
            db_get_key(s_hDB, m_hKey, &key);
            s += "\"access_mode\": " + std::to_string(key.access_mode) + ", ";
            s += "\"last_written\": " + std::to_string(key.last_written) + "},\n";
         }
 
         for (int i = 0; i < indent; i++)
            s += "   ";
         s += "\"" + m_name + "\": ";
         if (m_num_values > 1)
            s += "[";
         std::string v;
         get(v, m_tid == TID_STRING || m_tid == TID_LINK);
         s += v;
         if (m_num_values > 1)
            s += "]";
      }
   }

Here is the call graph for this function:

end()

iterator midas::odb::end ( ) const

inline

Definition at line 1019 of file odbxx.h.

{ return iterator(m_data + m_num_values); }

exists()

bool midas::odb::exists ( const std::string &  name )

static

Definition at line 76 of file odbxx.cxx.

                                         {
      init_hdb();
      if (!odb::is_connected_odb())
         return false;
      HNDLE hkey;
      return db_find_key(s_hDB, 0, name.c_str(), &hkey) == DB_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

fix_order()

void midas::odb::fix_order

(

std::vector< std::string >

target_subkey_order

)

Definition at line 1314 of file odbxx.cxx.

                                                        {
      // Fix the order of ODB keys to match that specified in target_order.
      // The in-ODB representation is simple, as we can just use db_reorder_key()
      // on anything that's in the wrong place.
      // The in-memory representation is a little trickier, but we just copy raw
      // memory into a temporary array, so we don't have to delete/recreate the
      // u_odb objects.
      std::vector<std::string> curr_order;
 
      if (get_subkeys(curr_order) <= 0) {
         // Not a TID_KEY (or no keys)
         return;
      }
 
      if (target_order.size() != curr_order.size() || (int)target_order.size() != m_num_values) {
         return;
      }
 
      HNDLE hKey = get_hkey();
      bool force_order = false;
 
      // Temporary location where we'll store in-memory u_odb objects in th
      // correct order.
      u_odb* new_m_data = new u_odb[m_num_values];
 
      for (int i = 0; i < m_num_values; i++) {
         if (force_order || curr_order[i] != target_order[i]) {
            force_order = true;
            HNDLE hSubKey;
 
            // Fix the order in the ODB
            db_find_key(s_hDB, hKey, target_order[i].c_str(), &hSubKey);
            db_reorder_key(s_hDB, hSubKey, i);
         }
 
         // Fix the order in memory
         auto curr_it = std::find(curr_order.begin(), curr_order.end(), target_order[i]);
 
         if (curr_it == curr_order.end()) {
            // Logic error - bail to avoid doing any damage to the in-memory version.
            delete[] new_m_data;
            return;
         }
 
         int curr_idx = curr_it - curr_order.begin();
         new_m_data[i] = m_data[curr_idx];
      }
 
      // Final update of the in-memory version so they are in the correct order
      for (int i = 0; i < m_num_values; i++) {
         m_data[i] = new_m_data[i];
 
         // Nullify pointers that point to the same object in
         // m_data and new_m_data, so the underlying object doesn't
         // get destroyed when we delete new_m_data.
         new_m_data[i].set_string_ptr(nullptr);
         new_m_data[i].set_odb(nullptr);
      }
 
      delete[] new_m_data;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

get() [1/3]

template<typename T >

T midas::odb::get ( )

inlineprivate

Definition at line 494 of file odbxx.h.

              {
         if (m_num_values > 1)
            mthrow("ODB key \"" + get_full_path() +
                   "[0..." + std::to_string(m_num_values - 1) +
                   "]\" contains array. Please assign to std::vector.");
         if (is_auto_refresh_read())
            read();
         return (T) m_data[0];
      }

Here is the call graph for this function:

Here is the caller graph for this function:

get() [2/3]

void midas::odb::get ( std::string &  s, bool  quotes = false, bool  refresh = true  )

private

Definition at line 285 of file odbxx.cxx.

                                                        {
      if (refresh && is_auto_refresh_read())
         read();
 
      // put value into quotes
      s = "";
      std::string sd;
      for (int i = 0; i < m_num_values; i++) {
         m_data[i].get(sd);
         if (quotes)
            s += "\"";
         s += sd;
         if (quotes)
            s += "\"";
         if (i < m_num_values - 1)
            s += ",";
      }
   }

Here is the call graph for this function:

get() [3/3]

template<typename T >

void midas::odb::get ( T &  v )

inlineprivate

Definition at line 506 of file odbxx.h.

                     {
         if (m_num_values > 1)
            mthrow("ODB key \"" + get_full_path() + "\" contains array. Please assign to std::vector.");
         if (is_auto_refresh_read())
            read();
         v = (T) m_data[0];
      }

Here is the call graph for this function:

get_debug()

static bool midas::odb::get_debug ( )

inlinestatic

Definition at line 1402 of file odbxx.h.

{ return s_debug; }

Here is the caller graph for this function:

get_flags()

uint32_t midas::odb::get_flags ( )

inlineprivate

Definition at line 528 of file odbxx.h.

{ return static_cast<uint32_t>(m_flags.to_ulong()); }

Here is the caller graph for this function:

get_full_path()

std::string midas::odb::get_full_path

(

)

Definition at line 362 of file odbxx.cxx.

                                {
      if (m_name[0] == '/')
         return m_name;
      if (m_parent)
         return m_parent->get_full_path() + "/" + m_name;
 
      if (!is_connected_odb() || m_hKey == -1)
         return m_name;
 
      std::string str = db_get_path(s_hDB, m_hKey);
      if (str == "/") // change "/" to ""
         str = "";
      return str;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

get_hkey()

HNDLE midas::odb::get_hkey ( )

inline

Definition at line 1451 of file odbxx.h.

{ return m_hKey; }

Here is the caller graph for this function:

get_last_index()

int midas::odb::get_last_index ( )

inline

Definition at line 1014 of file odbxx.h.

{ return m_last_index; }

get_last_written()

unsigned int midas::odb::get_last_written

(

)

Definition at line 1533 of file odbxx.cxx.

                                      {
      init_hdb();
 
      // set mode in ODB
      KEY key;
      int status = db_get_key(s_hDB, m_hKey, &key);
 
      if (status != DB_SUCCESS && status != DB_INVALID_HANDLE)
         mthrow("db_get_key for ODB key \"" + get_full_path() +
                "\" returnd error code " + std::to_string(status));
 
      return (unsigned int) (key.last_written);
   }

Here is the call graph for this function:

get_mdata()

u_odb & midas::odb::get_mdata ( int  index = 0 )

inlineprivate

Definition at line 518 of file odbxx.h.

{ return m_data[index]; }

get_mode()

int midas::odb::get_mode

(

)

Definition at line 1519 of file odbxx.cxx.

                     {
      init_hdb();
 
      // set mode in ODB
      KEY key;
      int status = db_get_key(s_hDB, m_hKey, &key);
 
      if (status != DB_SUCCESS && status != DB_INVALID_HANDLE)
         mthrow("db_get_key for ODB key \"" + get_full_path() +
                "\" returnd error code " + std::to_string(status));
 
      return key.access_mode;
   }

Here is the call graph for this function:

get_name()

std::string midas::odb::get_name ( )

inline

Definition at line 1456 of file odbxx.h.

{ return m_name; }

Here is the caller graph for this function:

get_num_values()

int midas::odb::get_num_values ( )

inline

Definition at line 1455 of file odbxx.h.

{ return m_num_values; }

get_odb_source()

static odb::odb_source midas::odb::get_odb_source ( )

inlinestatic

Definition at line 1415 of file odbxx.h.

{ return s_odb_source; }

get_parent()

midas::odb * midas::odb::get_parent ( )

inlineprivate

Definition at line 539 of file odbxx.h.

{ return m_parent; }

get_parent_path()

std::string midas::odb::get_parent_path

(

)

Definition at line 378 of file odbxx.cxx.

                                  {
      std::string s = get_full_path();
      std::size_t i = s.find_last_of("/");
      s = s.substr(0, i);
      return s;
   }

Here is the call graph for this function:

get_subkey()

odb & midas::odb::get_subkey ( std::string  str )

private

Definition at line 568 of file odbxx.cxx.

                                     {
      if (m_tid == 0) {
         if (is_auto_create()) {
            m_tid = TID_KEY;
            int status = db_create_key(s_hDB, 0, m_name.c_str(), m_tid);
            if (status != DB_SUCCESS && status != DB_CREATED && status != DB_KEY_EXIST)
               mthrow("Cannot create ODB key \"" + m_name + "\", status" + std::to_string(status));
            db_find_key(s_hDB, 0, m_name.c_str(), &m_hKey);
            if (s_debug) {
               if (m_name[0] == '/')
                  std::cout << "Created ODB key \"" + m_name + "\"" << std::endl;
               else
                  std::cout << "Created ODB key \"" + get_full_path() + "\"" << std::endl;
            }
            // strip path from name
            if (m_name.find_last_of('/') != std::string::npos)
               m_name = m_name.substr(m_name.find_last_of('/') + 1);
         } else
            mthrow("Invalid key \"" + m_name + "\" does not have subkeys");
 
      }
      if (m_tid != TID_KEY)
         mthrow("ODB key \"" + get_full_path() + "\" does not have subkeys");
 
      std::string first = str;
      std::string tail{};
      if (str.find('/') != std::string::npos) {
         first = str.substr(0, str.find('/'));
         tail = str.substr(str.find('/') + 1);
      }
 
      int i;
      for (i = 0; i < m_num_values; i++)
         if (equal_ustring(first.c_str(), m_data[i].get_odb().get_name().c_str()))
            break;
      if (i == m_num_values) {
         if (is_auto_create()) {
            if (m_num_values == 0) {
               m_num_values = 1;
               m_data = new u_odb[1]{};
               i = 0;
            } else {
               // resize array
               resize_mdata(m_num_values + 1);
               i = m_num_values - 1;
            }
            midas::odb *o = new midas::odb();
            m_data[i].set_tid(TID_KEY);
            m_data[i].set_parent(this);
            o->set_name(get_full_path() + "/" + str);
            o->set_tid(0); // tid is currently undefined
            o->set_flags(get_flags());
            o->set_parent(this);
            m_data[i].set(o);
         } else
            mthrow("ODB key \"" + get_full_path() + "\" does not contain subkey \"" + first + "\"");
      }
      if (!tail.empty())
         return m_data[i].get_odb().get_subkey(tail);
 
      return *m_data[i].get_podb();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

get_subkeys()

int midas::odb::get_subkeys ( std::vector< std::string > &  name )

private

Definition at line 632 of file odbxx.cxx.

                                                  {
      if (m_tid != TID_KEY)
         return 0;
      if (m_hKey == 0 || m_hKey == -1)
         mthrow("get_sub-keys called with invalid m_hKey for ODB key \"" + m_name + "\"");
 
      // count number of subkeys in ODB
      std::vector<HNDLE> hlist;
      int n = 0;
      for (int i = 0;; i++) {
         HNDLE h;
         int status = db_enum_key(s_hDB, m_hKey, i, &h);
         if (status != DB_SUCCESS)
            break;
         KEY key;
         db_get_key(s_hDB, h, &key);
         hlist.push_back(h);
         name.push_back(key.name);
         n = i + 1;
      }
 
      return n;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

get_tid()

int midas::odb::get_tid ( )

inline

Definition at line 1454 of file odbxx.h.

{ return m_tid; }

Here is the caller graph for this function:

init_hdb()

void midas::odb::init_hdb ( )

staticprivate

Definition at line 50 of file odbxx.cxx.

                      {
      if (s_odb_source != odb::ONLINE)
         mthrow("Operation only possible if connected to an online ODB");
 
      if (s_hDB == 0)
         cm_get_experiment_database(&s_hDB, nullptr);
      if (s_hDB == 0)
         mthrow("Please call cm_connect_experiment() before accessing the ODB");
      s_connected_odb = true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

is_auto_create()

bool midas::odb::is_auto_create ( ) const

inline

Definition at line 1376 of file odbxx.h.

{ return m_flags[odb_flags::AUTO_CREATE]; }

Here is the caller graph for this function:

is_auto_enlarge_array()

bool midas::odb::is_auto_enlarge_array ( ) const

inline

Definition at line 1382 of file odbxx.h.

{ return m_flags[odb_flags::AUTO_ENLARGE_ARRAY]; }

Here is the caller graph for this function:

is_auto_refresh_read()

bool midas::odb::is_auto_refresh_read ( ) const

inline

Definition at line 1361 of file odbxx.h.

{ return m_flags[odb_flags::AUTO_REFRESH_READ]; }

Here is the caller graph for this function:

is_auto_refresh_write()

bool midas::odb::is_auto_refresh_write ( ) const

inline

Definition at line 1367 of file odbxx.h.

{ return m_flags[odb_flags::AUTO_REFRESH_WRITE]; }

Here is the caller graph for this function:

is_connected_odb()

static bool midas::odb::is_connected_odb ( )

inlinestatic

Definition at line 1428 of file odbxx.h.

{ return s_connected_odb; }

Here is the caller graph for this function:

is_deleted()

bool midas::odb::is_deleted ( ) const

inlineprivate

Definition at line 530 of file odbxx.h.

{ return m_flags[odb_flags::DELETED]; }

Here is the caller graph for this function:

is_dirty()

bool midas::odb::is_dirty ( ) const

inline

Definition at line 1373 of file odbxx.h.

{ return m_flags[odb_flags::DIRTY]; }

is_preserve_string_size()

bool midas::odb::is_preserve_string_size ( ) const

inline

Definition at line 1355 of file odbxx.h.

{ return m_flags[odb_flags::PRESERVE_STRING_SIZE]; }

Here is the caller graph for this function:

is_subkey()

bool midas::odb::is_subkey

(

std::string

str

)

Definition at line 544 of file odbxx.cxx.

                                    {
      if (m_tid != TID_KEY)
         return false;
 
      std::string first = str;
      std::string tail{};
      if (str.find('/') != std::string::npos) {
         first = str.substr(0, str.find('/'));
         tail = str.substr(str.find('/') + 1);
      }
 
      int i;
      for (i = 0; i < m_num_values; i++)
         if (m_data[i].get_odb().get_name() == first)
            break;
      if (i == m_num_values)
         return false;
 
      if (!tail.empty())
         return m_data[i].get_odb().is_subkey(tail);
 
      return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

is_trigger_hotlink()

bool midas::odb::is_trigger_hotlink ( ) const

inline

Definition at line 1394 of file odbxx.h.

{ return m_flags[odb_flags::TRIGGER_HOTLINK]; }

Here is the caller graph for this function:

is_write_protect()

bool midas::odb::is_write_protect ( ) const

inline

Definition at line 1388 of file odbxx.h.

{ return m_flags[odb_flags::WRITE_PROTECT]; }

Here is the caller graph for this function:

items()

odb & midas::odb::items ( )

inline

Definition at line 1457 of file odbxx.h.

{ return *this; }

load()

void midas::odb::load ( const std::string &  filename, const std::string &  odb_path  )

static

Definition at line 102 of file odbxx.cxx.

                                                                      {
      init_hdb();
      if (!odb::is_connected_odb())
         mthrow("Cannot connect to ODB");
 
      HNDLE hkey;
      auto status = db_find_key(s_hDB, 0, odb_path.c_str(), &hkey);
      if (status == DB_NO_KEY)
         db_create_key(s_hDB, 0, odb_path.c_str(), TID_KEY);
      status = db_find_key(s_hDB, 0, odb_path.c_str(), &hkey);
      if (status != DB_SUCCESS)
         mthrow("ODB path " + odb_path + " not found in ODB");
 
      KEY key;
      db_get_key(s_hDB, hkey, &key);
      if (key.type != TID_KEY)
         mthrow("ODB path " + odb_path + " does not point to a directory");
 
      db_load(s_hDB, hkey, filename.c_str(), false);
   }

Here is the call graph for this function:

node_to_string()

static std::string midas::odb::node_to_string ( const MJsonNode *  node )

inlinestatic

Definition at line 1254 of file odbxx.h.

                                                             {
         std::string value;
 
         switch (node->GetType()) {
            case MJSON_STRING:
               value = node->GetString();
               break;
            case MJSON_INT:
               value = std::to_string(node->GetInt());
               break;
            case MJSON_NUMBER:
               value = std::to_string(node->GetDouble());
               break;
            case MJSON_BOOL:
               value = std::to_string(node->GetBool());
               break;
            default:
               mthrow("Invalid MJSON type \"" + std::to_string(node->GetType()) + "\"");
         }
 
         return value;
      };

Here is the caller graph for this function:

odb_from_json()

static midas::odb * midas::odb::odb_from_json ( const MJsonNode *  node, std::string  name, int  tid, odb *  o  )

inlinestatic

Definition at line 1278 of file odbxx.h.

                                                                                             {
         int type = node->GetType();
 
         if (type == MJSON_OBJECT) { // subdir
            const MJsonStringVector* names = node->GetObjectNames();
            const MJsonNodeVector* nodes = node->GetObjectNodes();
            if (names == nullptr || nodes==nullptr || names->size() != nodes->size())
               mthrow("Invalid JSON format");
 
            if (o == nullptr)
               o = new midas::odb();
            o->set_tid(TID_KEY);
            o->set_name(name);
            o->set_hkey(0);
 
            // count subkeys
            int n=0;
            for (int i=0 ; i<(int)names->size() ; i++) {
               const char *name = (*names)[i].c_str();
 
               if (strchr(name, '/'))// skip special entries
                  continue;
               n++;
            }
            o->set_num_values(n);
 
            for (int i=n=0 ; i<(int)names->size() ; i++) {
               const char *name = (*names)[i].c_str();
 
               if (strchr(name, '/'))// skip special entries
                  continue;
 
               int t = 0;
               auto key = node->FindObjectNode((std::string(name) + "/key").c_str());
               if (key)
                  t = key->FindObjectNode("type")->GetInt();
               else
                  t = TID_KEY;
 
               midas::odb *os = odb_from_json((*nodes)[i], (*names)[i].c_str(), t, nullptr);
               os->set_parent(o);
               o->set_odb(os, n);
               n++;
            }
 
            o->set_num_values(n);
 
         } else { // key
 
            if (o == nullptr)
               o = new midas::odb();
 
            o->set_name(name);
            o->set_tid(tid);
            o->set_hkey(0);
 
            if (node->GetType() == MJSON_ARRAY) {
               const MJsonNodeVector* a = node->GetArray();
               o->set_num_values(a->size());
               for (int i=0 ; i<(int)a->size() ; i++) {
                  MJsonNode *n = (*a)[i];
                  auto value = node_to_string(n);
                  o->set(value, i);
               }
            } else {
               auto value = node_to_string(node);
               o->set(value);
            }
         }
 
         return o;
      };

Here is the call graph for this function:

Here is the caller graph for this function:

odb_from_json_string() [1/2]

void midas::odb::odb_from_json_string ( const std::string &  str )

static

Definition at line 240 of file odbxx.cxx.

                                                      {
 
      MJsonNode* node = MJsonNode::Parse(str.c_str());
      if (node->GetType() == MJSON_ERROR)
         mthrow("Error parsing JSON: " + node->GetError());
 
      // node->Dump();
 
      odb_from_json(node, "root", TID_KEY, s_odb);
 
      delete node;
 
      s_odb->set_auto_create(false);
      s_odb->set_auto_refresh_read(false);
      s_odb->set_auto_refresh_write(false);
      s_odb->set_auto_enlarge_array(false);
      s_odb->set_write_protect(true);
      s_odb->set_trigger_hotlink(false);
   }

Here is the call graph for this function:

odb_from_json_string() [2/2]

void midas::odb::odb_from_json_string	(	const std::string &	str,
		const std::string &	subkey
	)

Here is the caller graph for this function:

odb_from_xml()

static midas::odb * midas::odb::odb_from_xml ( PMXML_NODE  node, odb *  o  )

inlinestatic

Definition at line 1201 of file odbxx.h.

                                                             {
         std::string type(mxml_get_name(node));
 
         unsigned int tid = 0;
         if (type == "dir" || type == "odb")
            tid = TID_KEY;
         else {
            for (tid = 0; tid < TID_LAST; tid++) {
               if (equal_ustring(rpc_tid_name(tid), mxml_get_attribute(node, "type")))
                  break;
            }
         }
         if (tid == TID_LAST)
            mthrow("Wrong key type in XML file");
 
         if (o == nullptr)
            o = new midas::odb();
         o->set_tid(tid);
         if (type == "odb") {
            o->set_name("root");
            o->set_hkey(0);
         } else {
            o->set_name(mxml_get_attribute(node, "name"));
            if (mxml_get_attribute(node, "handle") == nullptr)
               mthrow("No \"handle\" attribute found in XML data");
            o->set_hkey(std::stoi(std::string(mxml_get_attribute(node, "handle"))));
         }
 
         if (type == "key") {
            std::string value(mxml_get_value(node));
            o->set(value);
         } else if (type == "keyarray") {
            int n = std::atoi(mxml_get_attribute(node, "num_values"));
            o->set_num_values(n);
            for (int i=0 ; i<n ; i++) {
               std::string value(mxml_get_value(mxml_subnode(node, i)));
               o->set(value, i);
            }
         } else if (type == "dir" || type == "odb") {
            int n = mxml_get_number_of_children(node);
            o->set_num_values(n);
            for (int i = 0; i < n; i++) {
               midas::odb *os = odb_from_xml(mxml_subnode(node, i), nullptr);
               os->set_parent(o);
               o->set_odb(os, i);
            }
         } else
            mthrow("Unexpected XML element " + std::string(mxml_get_name(node)));
 
         return o;
      };

Here is the call graph for this function:

Here is the caller graph for this function:

odb_from_xml_remote()

void midas::odb::odb_from_xml_remote

(

const std::string &

str

)

Definition at line 160 of file odbxx.cxx.

                                                     {
      init_hdb();
 
      HNDLE hKey;
      int status = db_find_key(s_hDB, 0, str.c_str(), &hKey);
      if (status != DB_SUCCESS)
         mthrow("ODB key \"" + str + "\" not found in ODB");
 
      int bsize = 1000000;
      char *buffer = (char *)malloc(bsize);
      do {
         int size = bsize;
         status = db_copy_xml(s_hDB, hKey, buffer, &size, false);
         if (status == DB_TRUNCATED) {
            bsize *= 2;
            buffer = (char *)realloc(buffer, bsize);
         }
      } while (status == DB_TRUNCATED);
 
      if (status != DB_SUCCESS)
         mthrow("Cannot retrieve XML data, status = " + std::to_string(status));
 
      if (s_debug)
         std::cout << "Retrieved XML tree for \"" + str + "\"" << std::endl;
 
      char error[256] = "";
      PMXML_NODE tree = mxml_parse_buffer(buffer, error, sizeof(error), NULL);
      if (error[0]) {
         std::cout << "MXML error, buffer =\n" << buffer << std::endl;
         mthrow("MXML error: " + std::string(error));
      }
      free(buffer);
 
      odb_from_xml(&tree->child[2], this);
      m_hKey = hKey;
 
      mxml_free_tree(tree);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

odb_from_xml_string() [1/2]

void midas::odb::odb_from_xml_string ( const std::string &  str )

static

Definition at line 199 of file odbxx.cxx.

                                                     {
      char error[256] = "";
      PMXML_NODE tree = mxml_parse_buffer(str.c_str(), error, sizeof(error), NULL);
      if (error[0]) {
         std::cout << "MXML error, buffer =\n" << str << std::endl;
         mthrow("MXML error: " + std::string(error));
      }
 
      PMXML_NODE root;
      root = &tree->child[2];
 
      odb_from_xml(root, s_odb);
 
      mxml_free_tree(tree);
 
      s_odb->set_auto_create(false);
      s_odb->set_auto_refresh_read(false);
      s_odb->set_auto_refresh_write(false);
      s_odb->set_auto_enlarge_array(false);
      s_odb->set_write_protect(true);
      s_odb->set_trigger_hotlink(false);
   }

Here is the call graph for this function:

odb_from_xml_string() [2/2]

void midas::odb::odb_from_xml_string	(	const std::string &	str,
		const std::string &	subkey
	)

Here is the caller graph for this function:

operator std::string()

midas::odb::operator std::string ( )

inline

Definition at line 887 of file odbxx.h.

                           {
         std::string s;
         if (m_tid == TID_KEY)
            print(s, 0);
         else
            get(s); // forward to get(std::string)
         return s;
      }

Here is the call graph for this function:

operator std::vector< std::string >()

midas::odb::operator std::vector< std::string > ( )

inline

Definition at line 907 of file odbxx.h.

                                      {
         if (is_auto_refresh_read())
            read();
         std::vector<std::string> v(m_num_values);
         for (int i = 0; i < m_num_values; i++)
            v[i] = m_data[i].get();
         return v;
      }

Here is the call graph for this function:

operator std::vector< T >()

template<typename T >

midas::odb::operator std::vector< T > ( )

inline

Definition at line 898 of file odbxx.h.

                              {
         if (is_auto_refresh_read())
            read();
         std::vector<T> v(m_num_values);
         for (int i = 0; i < m_num_values; i++)
            v[i] = m_data[i];
         return v;
      }

Here is the call graph for this function:

operator T()

template<typename T , typename std::enable_if< std::is_same< T, uint8_t >::value||std::is_same< T, int8_t >::value||std::is_same< T, uint16_t >::value||std::is_same< T, int16_t >::value||std::is_same< T, uint32_t >::value||std::is_same< T, int32_t >::value||std::is_same< T, uint64_t >::value||std::is_same< T, int64_t >::value||std::is_same< T, bool >::value||std::is_same< T, float >::value||std::is_same< T, double >::value, T >::type * = nullptr>

midas::odb::operator T ( )

inline

Definition at line 929 of file odbxx.h.

                   {
         if (m_tid == 0)
            mthrow("Element \"" + m_name + "\" not found");
         return get<T>(); // forward to get<T>()
      }

operator()()

template<typename T >

odb & midas::odb::operator() ( T  v )

inline

Definition at line 991 of file odbxx.h.

                           {
         if (m_tid == 0) {
            if (m_num_values == 0) {
               // initialize this
               m_num_values = 1;
               m_tid = detect_type(v);
               m_data = new u_odb[1]{};
               m_data[0].set_tid(m_tid);
               m_data[0].set_parent(this);
               m_data[0].set(v);
               if (this->is_auto_refresh_write())
                  write();
            } else {
               for (int i = 0; i < m_num_values; i++)
                  m_data[i].set(v);
               if (this->is_auto_refresh_write())
                  write();
            }
         }
         return *this;
      }

Here is the call graph for this function:

operator*()

template<typename T >

T midas::odb::operator* ( const T  i )

inline

Definition at line 1067 of file odbxx.h.

                             {
         if (m_num_values > 1)
            mthrow("ODB key \"" + get_full_path() +
                   "\" contains array which cannot be used in basic arithmetic operation.");
         if (is_auto_refresh_read())
            read();
         T s = (T) m_data[0];
         return s * i;
      }

Here is the call graph for this function:

operator*=()

odb & midas::odb::operator*= ( double  d )

inline

Definition at line 1152 of file odbxx.h.

                                {
         if (is_auto_refresh_read())
            read();
         for (int i = 0; i < m_num_values; i++)
            m_data[i].mult(d, false);
         if (this->is_auto_refresh_write())
            write();
         return *this;
      }

Here is the call graph for this function:

operator+()

template<typename T >

T midas::odb::operator+ ( T  i )

inline

Definition at line 1023 of file odbxx.h.

                       {
         if (m_num_values > 1)
            mthrow("ODB key \"" + get_full_path() +
                   "\" contains array which cannot be used in basic arithmetic operation.");
         if (std::is_same<T, midas::odb>::value) {
            if (is_auto_refresh_read()) {
               read();
               i.read();
            }
            // adding two midas::odb objects is best done in double
            double s1 = static_cast<double>(m_data[0]);
            double s2 = static_cast<double>(i.m_data[0]);
            return s1 + s2;
         } else {
            if (is_auto_refresh_read())
               read();
            T s = (T) m_data[0];
            return s + i;
         }
      }

Here is the call graph for this function:

operator++() [1/2]

odb & midas::odb::operator++ ( )

inline

Definition at line 1088 of file odbxx.h.

                        {
         if (is_auto_refresh_read())
            read();
         for (int i = 0; i < m_num_values; i++)
            m_data[i].add(1, false);
         if (this->is_auto_refresh_write())
            write();
         return *this;
      }

Here is the call graph for this function:

operator++() [2/2]

odb midas::odb::operator++ ( int  )

inline

Definition at line 1098 of file odbxx.h.

                          {
         // create temporary object
         odb o(this);
         if (is_auto_refresh_read())
            read();
         for (int i = 0; i < m_num_values; i++)
            m_data[i].add(1, false);
         if (this->is_auto_refresh_write())
            write();
         return o;
      }

Here is the call graph for this function:

operator+=()

odb & midas::odb::operator+= ( double  d )

inline

Definition at line 1132 of file odbxx.h.

                                {
         if (is_auto_refresh_read())
            read();
         for (int i = 0; i < m_num_values; i++)
            m_data[i].add(d, false);
         if (this->is_auto_refresh_write())
            write();
         return *this;
      }

Here is the call graph for this function:

operator-()

template<typename T >

T midas::odb::operator- ( T  i )

inline

Definition at line 1045 of file odbxx.h.

                       {
         if (m_num_values > 1)
            mthrow("ODB key \"" + get_full_path() +
                   "\" contains array which cannot be used in basic arithmetic operation.");
         if (std::is_same<T, midas::odb>::value) {
            if (is_auto_refresh_read()) {
               read();
               i.read();
            }
            // subtracting two midas::odb objects is best done in double
            double s1 = static_cast<double>(m_data[0]);
            double s2 = static_cast<double>(i.m_data[0]);
            return s1 - s2;
         } else {
            if (is_auto_refresh_read())
               read();
            T s = (T) m_data[0];
            return s - i;
         }
      }

Here is the call graph for this function:

operator--() [1/2]

odb & midas::odb::operator-- ( )

inline

Definition at line 1110 of file odbxx.h.

                        {
         if (is_auto_refresh_read())
            read();
         for (int i = 0; i < m_num_values; i++)
            m_data[i].add(-1, false);
         if (this->is_auto_refresh_write())
            write();
         return *this;
      }

Here is the call graph for this function:

operator--() [2/2]

odb midas::odb::operator-- ( int  )

inline

Definition at line 1120 of file odbxx.h.

                          {
         // create temporary object
         odb o(this);
         if (is_auto_refresh_read())
            read();
         for (int i = 0; i < m_num_values; i++)
            m_data[i].add(-1, false);
         if (this->is_auto_refresh_write())
            write();
         return o;
      }

Here is the call graph for this function:

operator-=()

odb & midas::odb::operator-= ( double  d )

inline

Definition at line 1142 of file odbxx.h.

                                {
         if (is_auto_refresh_read())
            read();
         for (int i = 0; i < m_num_values; i++)
            m_data[i].add(-d, false);
         if (this->is_auto_refresh_write())
            write();
         return *this;
      }

Here is the call graph for this function:

operator/()

template<typename T >

T midas::odb::operator/ ( const T  i )

inline

Definition at line 1078 of file odbxx.h.

                             {
         if (m_num_values > 1)
            mthrow("ODB key \"" + get_full_path() +
                   "\" contains array which cannot be used in basic arithmetic operation.");
         if (is_auto_refresh_read())
            read();
         T s = (T) m_data[0];
         return s / i;
      }

Here is the call graph for this function:

operator/=()

odb & midas::odb::operator/= ( double  d )

inline

Definition at line 1162 of file odbxx.h.

                                {
         if (is_auto_refresh_read())
            read();
         if (d == 0)
            mthrow("Division by zero");
         for (int i = 0; i < m_num_values; i++)
            m_data[i].mult(1 / d, false);
         if (this->is_auto_refresh_write())
            write();
         return *this;
      }

Here is the call graph for this function:

operator=() [1/4]

template<typename T , size_t SIZE>

const std::array< T, SIZE > & midas::odb::operator= ( const std::array< T, SIZE > &  arr )

inline

Definition at line 855 of file odbxx.h.

                                                                       {
 
         if (this->is_write_protect())
            mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
         if (m_num_values == 0) {
            // initialize this
            m_num_values = SIZE;
            m_tid = detect_type(arr[0]);
            m_data = new u_odb[m_num_values]{};
            for (int i = 0; i < m_num_values; i++) {
               m_data[i].set_tid(m_tid);
               m_data[i].set_parent(this);
            }
 
         } else {
 
            // resize internal array if different
            if (SIZE != m_num_values) {
               resize_mdata(SIZE);
            }
         }
 
         for (int i = 0; i < m_num_values; i++)
            m_data[i].set(arr[i]);
 
         if (this->is_auto_refresh_write())
            write();
         return arr;
      }

Here is the call graph for this function:

operator=() [2/4]

template<typename T >

const std::vector< T > & midas::odb::operator= ( const std::vector< T > &  v )

inline

Definition at line 809 of file odbxx.h.

                                                           {
 
         if (this->is_write_protect())
            mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
         if (m_num_values == 0) {
            // initialize this
            m_num_values = v.size();
            if (std::is_same<T, bool>::value) {
               // Special logic for vector<bool>, which may not be a true 
               // container: it's often optimized to be a bitfield, with 
               // references to elements being masked bits rather than bools. 
               // So T is a bool here, but typeof(v[0]) may not be bool!
               // "Fake container optimization" only applies to vector<bool>,
               // not array<bool> or any other vector<T>.
               m_tid = TID_BOOL;
            } else {
               // Every other type can be detected using ref to first element.
               m_tid = detect_type(v[0]);
            }
 
            m_data = new u_odb[m_num_values]{};
            for (int i = 0; i < m_num_values; i++) {
               m_data[i].set_tid(m_tid);
               m_data[i].set_parent(this);
            }
 
         } else {
 
            // resize internal array if different
            if ((int)v.size() != m_num_values) {
               resize_mdata(v.size());
            }
         }
 
         for (int i = 0; i < m_num_values; i++)
            m_data[i].set(v[i]);
 
         if (this->is_auto_refresh_write())
            write();
 
         return v;
      }

Here is the call graph for this function:

operator=() [3/4]

template<typename T >

const T & midas::odb::operator= ( const T &  v )

inline

Definition at line 782 of file odbxx.h.

                                     {
 
         if (this->is_write_protect())
            mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
         if (m_num_values == 0) {
            // initialize this
            m_num_values = 1;
            m_tid = detect_type(v);
            m_data = new u_odb[1]{};
            m_data[0].set_tid(m_tid);
            m_data[0].set_parent(this);
            m_data[0].set(v);
            if (this->is_auto_refresh_write())
               write();
         } else {
            for (int i = 0; i < m_num_values; i++)
               m_data[i].set(v);
 
            if (this->is_auto_refresh_write())
               write();
         }
         return v;
      }

Here is the call graph for this function:

operator=() [4/4]

odb midas::odb::operator= ( odb &&  o )

delete

operator[]() [1/3]

odb & midas::odb::operator[] ( const char *  str )

inline

Definition at line 985 of file odbxx.h.

                                       {
         return get_subkey(std::string(str));
      }

Here is the call graph for this function:

operator[]() [2/3]

u_odb & midas::odb::operator[] ( int  index )

inline

Definition at line 947 of file odbxx.h.

                                   {
         if (this->is_write_protect())
            mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
         if (index < 0)
            throw std::out_of_range("Index \"" + std::to_string(index) + "\" out of range for ODB key \"" + get_full_path() + "[0..." + std::to_string(m_num_values - 1) + "]\"");
 
         if (index == 0 && m_num_values == 0) {
            // initialize this
            m_num_values = 1;
            m_tid = 0;
            m_data = new u_odb[1]{};
            m_data[0].set_tid(m_tid);
            m_data[0].set_parent(this);
            m_last_index = 0;
            return m_data[0];
         } else if (index >= m_num_values) {
            if (is_auto_enlarge_array()) {
               resize_mdata(index+1);
               if (this->is_auto_refresh_write())
                  write(index, 0);
            } else {
               throw std::out_of_range("Index \"" + std::to_string(index) + "\" out of range for ODB key \"" + get_full_path() + "[0..." + std::to_string(m_num_values - 1) + "]\", please consider set_auto_enlarge_array(true)");
            }
         }
 
         if (is_auto_refresh_read())
            read(index);
 
         m_last_index = index;
         return m_data[index];
      }

Here is the call graph for this function:

operator[]() [3/3]

odb & midas::odb::operator[] ( std::string  str )

inline

Definition at line 981 of file odbxx.h.

                                     {
         return get_subkey(str);
      }

Here is the call graph for this function:

print() [1/2]

std::string midas::odb::print

(

)

Definition at line 419 of file odbxx.cxx.

                        {
      std::string s;
      s = "{\n";
      print(s, 1);
      s += "\n}";
      return s;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

print() [2/2]

void midas::odb::print	(	std::string &	s,
		int	indent = 0
	)

Definition at line 436 of file odbxx.cxx.

                                           {
      for (int i = 0; i < indent; i++)
         s += "   ";
      if (m_tid == TID_KEY) {
         s += "\"" + m_name + "\": {\n";
         for (int i = 0; i < m_num_values; i++) {
            std::string v;
            // recursive call
            m_data[i].get_odb().print(v, indent + 1);
            s += v;
            if (i < m_num_values - 1)
               s += ",\n";
            else
               s += "\n";
         }
         for (int i = 0; i < indent; i++)
            s += "   ";
         s += "}";
      } else {
         s += "\"" + m_name + "\": ";
         if (m_num_values > 1)
            s += "[";
         std::string v;
         get(v, m_tid == TID_STRING || m_tid == TID_LINK);
         if (m_tid == TID_LINK)
            s += " -> ";
         s += v;
         if (m_num_values > 1)
            s += "]";
      }
   }

Here is the call graph for this function:

read() [1/2]

void midas::odb::read

(

)

Definition at line 802 of file odbxx.cxx.

                  {
      if (!is_connected_odb())
         return;
 
      // check if deleted
      if (is_deleted())
         mthrow("ODB key \"" + m_name + "\" cannot be pulled because it has been deleted");
 
      if (m_hKey == 0)
         return; // needed to print un-connected objects
 
      if (m_tid == 0)
         mthrow("Read of invalid ODB key \"" + m_name + "\"");
 
      if (m_hKey == -1) {
         // connect un-connected object (crated via XML)
         std::string path = get_full_path();
 
         int status = db_find_key(s_hDB, 0, path.c_str(), &m_hKey);
         if (status != DB_SUCCESS)
            mthrow("Cannot connect key \"" + path + "\" to ODB");
      }
 
      int status{};
      if (m_tid == TID_STRING) {
         KEY key;
         db_get_key(s_hDB, m_hKey, &key);
         char *str = (char *) malloc(key.total_size);
         int size = key.total_size;
         status = db_get_data(s_hDB, m_hKey, str, &size, m_tid);
         for (int i = 0; i < m_num_values; i++)
            m_data[i].set(str + i * key.item_size);
         free(str);
      } else if (m_tid == TID_KEY) {
         std::vector<std::string> name;
         int n = get_subkeys(name);
         if (n != m_num_values) {
            // if subdirs have changed, rebuild it
            delete[] m_data;
            m_num_values = n;
            m_data = new midas::u_odb[m_num_values]{};
            for (int i = 0; i < m_num_values; i++) {
               std::string k(get_full_path());
               k += "/" + name[i];
               midas::odb *o = new midas::odb(k.c_str());
               o->set_parent(this);
               m_data[i].set_tid(TID_KEY);
               m_data[i].set_parent(this);
               m_data[i].set(o);
            }
         }
         for (int i = 0; i < m_num_values; i++)
            m_data[i].get_odb().read();
         status = DB_SUCCESS;
      } else {
         // resize local array if number of values has changed
         KEY key;
         status = db_get_key(s_hDB, m_hKey, &key);
         if (key.num_values != m_num_values) {
            delete[] m_data;
            m_num_values = key.num_values;
            m_data = new midas::u_odb[m_num_values]{};
            for (int i = 0; i < m_num_values; i++) {
               m_data[i].set_tid(m_tid);
               m_data[i].set_parent(this);
            }
         }
 
         int size = rpc_tid_size(m_tid) * m_num_values;
         void *buffer = malloc(size);
         void *p = buffer;
         status = db_get_data(s_hDB, m_hKey, p, &size, m_tid);
         for (int i = 0; i < m_num_values; i++) {
            if (m_tid == TID_UINT8)
               m_data[i].set(*static_cast<uint8_t *>(p));
            else if (m_tid == TID_INT8)
               m_data[i].set(*static_cast<int8_t *>(p));
            else if (m_tid == TID_UINT16)
               m_data[i].set(*static_cast<uint16_t *>(p));
            else if (m_tid == TID_INT16)
               m_data[i].set(*static_cast<int16_t *>(p));
            else if (m_tid == TID_UINT32)
               m_data[i].set(*static_cast<uint32_t *>(p));
            else if (m_tid == TID_INT32)
               m_data[i].set(*static_cast<int32_t *>(p));
            else if (m_tid == TID_UINT64)
               m_data[i].set(*static_cast<uint64_t *>(p));
            else if (m_tid == TID_INT64)
               m_data[i].set(*static_cast<int64_t *>(p));
            else if (m_tid == TID_BOOL)
               m_data[i].set(*static_cast<bool *>(p));
            else if (m_tid == TID_FLOAT)
               m_data[i].set(*static_cast<float *>(p));
            else if (m_tid == TID_DOUBLE)
               m_data[i].set(*static_cast<double *>(p));
            else if (m_tid == TID_STRING)
               m_data[i].set(std::string(static_cast<const char *>(p)));
            else if (m_tid == TID_LINK)
               m_data[i].set(std::string(static_cast<const char *>(p)));
            else
               mthrow("Invalid type ID " + std::to_string(m_tid));
 
            p = static_cast<char *>(p) + rpc_tid_size(m_tid);
         }
         free(buffer);
      }
 
      if (status != DB_SUCCESS)
         mthrow("db_get_data for ODB key \"" + get_full_path() +
                "\" failed with status " + std::to_string(status));
      if (s_debug) {
         if (m_tid == TID_KEY) {
            std::cout << "Get ODB key \"" + get_full_path() + "[0..." +
                         std::to_string(m_num_values - 1) + "]\"" << std::endl;
         } else {
            std::string s;
            get(s, false, false);
            if (m_num_values > 1) {
               if (m_tid == TID_STRING || m_tid == TID_LINK)
                  std::cout << "Get ODB key \"" + get_full_path() + "[0..." +
                               std::to_string(m_num_values - 1) + "]\": [\"" + s + "\"]" << std::endl;
               else
                  std::cout << "Get ODB key \"" + get_full_path() + "[0..." +
                               std::to_string(m_num_values - 1) + "]\": [" + s + "]" << std::endl;
            } else {
               if (m_tid == TID_STRING || m_tid == TID_LINK)
                  std::cout << "Get ODB key \"" + get_full_path() + "\": \"" + s + "\"" << std::endl;
               else
                  std::cout << "Get ODB key \"" + get_full_path() + "\": " + s << std::endl;
            }
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

read() [2/2]

void midas::odb::read

(

int

index

)

Definition at line 937 of file odbxx.cxx.

                           {
      if (!is_connected_odb())
         return;
 
      if (m_hKey == 0 || m_hKey == -1)
         return; // needed to print un-connected objects
 
      if (m_tid == 0)
         mthrow("Pull of invalid ODB key \"" + m_name + "\"");
 
      int status{};
      if (m_tid == TID_STRING || m_tid == TID_LINK) {
         KEY key;
         db_get_key(s_hDB, m_hKey, &key);
         char *str = (char *) malloc(key.item_size);
         int size = key.item_size;
         status = db_get_data_index(s_hDB, m_hKey, str, &size, index, m_tid);
         m_data[index].set(str);
         free(str);
      } else if (m_tid == TID_KEY) {
         m_data[index].get_odb().read();
         status = DB_SUCCESS;
      } else {
         int size = rpc_tid_size(m_tid);
         void *buffer = malloc(size);
         void *p = buffer;
         status = db_get_data_index(s_hDB, m_hKey, p, &size, index, m_tid);
         if (m_tid == TID_UINT8)
            m_data[index].set(*static_cast<uint8_t *>(p));
         else if (m_tid == TID_INT8)
            m_data[index].set(*static_cast<int8_t *>(p));
         else if (m_tid == TID_UINT16)
            m_data[index].set(*static_cast<uint16_t *>(p));
         else if (m_tid == TID_INT16)
            m_data[index].set(*static_cast<int16_t *>(p));
         else if (m_tid == TID_UINT32)
            m_data[index].set(*static_cast<uint32_t *>(p));
         else if (m_tid == TID_INT32)
            m_data[index].set(*static_cast<int32_t *>(p));
         else if (m_tid == TID_UINT64)
            m_data[index].set(*static_cast<uint64_t *>(p));
         else if (m_tid == TID_INT64)
            m_data[index].set(*static_cast<int64_t *>(p));
         else if (m_tid == TID_BOOL)
            m_data[index].set(*static_cast<bool *>(p));
         else if (m_tid == TID_FLOAT)
            m_data[index].set(*static_cast<float *>(p));
         else if (m_tid == TID_DOUBLE)
            m_data[index].set(*static_cast<double *>(p));
         else if (m_tid == TID_STRING)
            m_data[index].set(std::string(static_cast<const char *>(p)));
         else if (m_tid == TID_LINK)
            m_data[index].set(std::string(static_cast<const char *>(p)));
         else
            mthrow("Invalid type ID " + std::to_string(m_tid));
 
         free(buffer);
      }
 
      if (status != DB_SUCCESS)
         mthrow("db_get_data for ODB key \"" + get_full_path() +
                "\" failed with status " + std::to_string(status));
      if (s_debug) {
         std::string s;
         m_data[index].get(s);
         if (m_tid == TID_STRING || m_tid == TID_LINK)
            std::cout << "Get ODB key \"" + get_full_path() + "[" +
                         std::to_string(index) + "]\": [\"" + s + "\"]" << std::endl;
         else
            std::cout << "Get ODB key \"" + get_full_path() + "[" +
                         std::to_string(index) + "]\": [" + s + "]" << std::endl;
      }
   }

Here is the call graph for this function:

read_key()

bool midas::odb::read_key ( const std::string &  path )

private

Definition at line 657 of file odbxx.cxx.

                                           {
      init_hdb();
 
      int status = db_find_key(s_hDB, 0, path.c_str(), &m_hKey);
      if (status != DB_SUCCESS)
         return false;
 
      KEY key;
      status = db_get_key(s_hDB, m_hKey, &key);
      if (status != DB_SUCCESS)
         mthrow("db_get_key for ODB key \"" + path +
                "\" failed with status " + std::to_string(status));
 
      // check for correct type if given as parameter
      if (m_tid > 0 && m_tid != (int) key.type)
         mthrow("ODB key \"" + get_full_path() +
                "\" has different type than specified");
 
      if (s_debug)
         std::cout << "Get definition for ODB key \"" + get_full_path() + "\"" << std::endl;
 
      m_tid = key.type;
      m_name = key.name;
      if (m_tid == TID_KEY) {
 
         // merge ODB keys with local keys
         for (int i = 0; i < m_num_values; i++) {
            std::string p(path);
            if (p.back() != '/')
               p += "/";
            p += m_data[i].get_odb().get_name();
            HNDLE h;
            status = db_find_key(s_hDB, 0, p.c_str(), &h);
            if (status != DB_SUCCESS) {
               // if key does not exist in ODB write it
               m_data[i].get_odb().write_key(p, true);
               m_data[i].get_odb().write();
            } else {
               // check key type
               KEY key;
               status = db_get_key(s_hDB, h, &key);
               if (status != DB_SUCCESS)
                  mthrow("db_get_key for ODB key \"" + get_full_path() +
                         "\" failed with status " + std::to_string(status));
               if (m_data[i].get_odb().get_tid() != (int)key.type) {
                  // write key if different
                  m_data[i].get_odb().write_key(p, true);
                  m_data[i].get_odb().write();
               }
               if (m_data[i].get_odb().get_tid() == TID_KEY) {
                  // update subkey structure
                  m_data[i].get_odb().read_key(p);
               }
            }
         }
 
         // read back everything from ODB
         std::vector<std::string> name;
         m_num_values = get_subkeys(name);
         delete[] m_data;
         m_data = new midas::u_odb[m_num_values]{};
         for (int i = 0; i < m_num_values; i++) {
            std::string p(path);
            if (p.back() != '/')
               p += "/";
            p += name[i];
            midas::odb *o = new midas::odb(p.c_str());
            o->set_parent(this);
            m_data[i].set_tid(TID_KEY);
            m_data[i].set_parent(this);
            m_data[i].set(o);
         }
      } else  {
         m_num_values = key.num_values;
         delete[] m_data;
         m_data = new midas::u_odb[m_num_values]{};
         for (int i = 0; i < m_num_values; i++) {
            m_data[i].set_tid(m_tid);
            m_data[i].set_parent(this);
         }
      }
 
      return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

resize() [1/2]

void midas::odb::resize

(

int

size

)

Definition at line 391 of file odbxx.cxx.

                            {
      resize_mdata(size);
      if (this->is_auto_refresh_write()) {
         int status = db_set_num_values(s_hDB, m_hKey, size);
         if (status != DB_SUCCESS)
            mthrow("db_set_num_values for ODB key \"" + get_full_path() +
                   "\" failed with status " + std::to_string(status));
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

resize() [2/2]

void midas::odb::resize	(	int	size,
		bool	b
	)

Definition at line 402 of file odbxx.cxx.

                                    {
      int old_size = m_num_values;
      resize_mdata(size);
      if (this->is_auto_refresh_write()) {
         int status = db_set_num_values(s_hDB, m_hKey, size);
         if (status != DB_SUCCESS)
            mthrow("db_set_num_values for ODB key \"" + get_full_path() +
                   "\" failed with status " + std::to_string(status));
      }
      if (size > old_size) {
         for (int i=old_size ; i<size ; i++)
            m_data[i] = b;
         if (this->is_auto_refresh_write())
            write();
      }
   }

Here is the call graph for this function:

resize_mdata()

void midas::odb::resize_mdata ( int  size )

private

Definition at line 261 of file odbxx.cxx.

                                  {
      auto new_array = new u_odb[size]{};
      int i;
      for (i = 0; i < m_num_values && i < size; i++) {
         new_array[i] = m_data[i];
         if (m_tid == TID_KEY)
            m_data[i].set_odb(nullptr); // move odb*
         if (m_tid == TID_STRING || m_tid == TID_LINK)
            m_data[i].set_string_ptr(nullptr); // move std::string*
      }
      for (; i < size; i++) {
         if (m_tid == TID_STRING || m_tid == TID_LINK)
            new_array[i].set_string(""); // allocates new string
      }
      delete[] m_data;
      m_data = new_array;
      m_num_values = size;
      for (i = 0; i < m_num_values; i++) {
         m_data[i].set_tid(m_tid);
         m_data[i].set_parent(this);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

s()

std::string midas::odb::s ( )

inline

Definition at line 1459 of file odbxx.h.

                    {
         std::string s;
         get(s);
         return s;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

save()

void midas::odb::save

(

const std::string &

filename

)

Definition at line 518 of file odbxx.cxx.

                                           {
      std::string buffer;
 
      std::string header = "{\n";
      header += "  \"/MIDAS version\" : \"2.1\",\n";
      header += "  \"/filename\" : \"" + filename + "\",\n";
 
      std::string path = get_full_path();
      if (path == "")
         path = "/";
      header += "  \"/ODB path\" : \"" + path + "\",\n\n";
 
      odb::dump(buffer, 1);
 
      buffer += "\n}\n";
 
      std::ofstream f(filename);
      if (!f.is_open())
         mthrow("Cannot open file \"" + filename);
 
      f << header << buffer;
      f.close();
   }

Here is the call graph for this function:

search_hkey()

midas::odb * midas::odb::search_hkey ( midas::odb *  po, int  hKey  )

staticprivate

Definition at line 62 of file odbxx.cxx.

                                                    {
      if (po->m_hKey == hKey)
         return po;
      if (po->m_tid == TID_KEY) {
         for (int i = 0; i < po->m_num_values; i++) {
            midas::odb *pot = search_hkey(po->m_data[i].get_podb(), hKey);
            if (pot != nullptr)
               return pot;
         }
      }
      return nullptr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

set() [1/2]

void midas::odb::set	(	std::string	s,
		int	i
	)

Definition at line 1599 of file odbxx.cxx.

   {
      if (this->is_write_protect())
         mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
      if (m_tid == TID_BOOL)
         s = (s == "y" || s == "1") ? "1" : "0";
 
      if (m_data == nullptr)
         m_data = new u_odb[m_num_values];
      m_data[i].set_parent(this);
      m_data[i].set_tid(m_tid);
      m_data[i].set(s);
   }

Here is the call graph for this function:

set() [2/2]

void midas::odb::set

(

std::string

str

)

Definition at line 1584 of file odbxx.cxx.

   {
      if (this->is_write_protect())
         mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
      if (m_tid == TID_BOOL)
         s = (s == "y" || s == "1") ? "1" : "0";
 
      m_num_values = 1;
      m_data = new u_odb[1];
      m_data[0].set_parent(this);
      m_data[0].set_tid(m_tid);
      m_data[0].set(s);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

set_auto_create()

void midas::odb::set_auto_create ( bool  f )

inline

Definition at line 1377 of file odbxx.h.

                                   {
         m_flags[odb_flags::AUTO_CREATE] = f;
         set_flags_recursively(get_flags());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

set_auto_enlarge_array()

void midas::odb::set_auto_enlarge_array ( bool  f )

inline

Definition at line 1383 of file odbxx.h.

                                          {
         m_flags[odb_flags::AUTO_ENLARGE_ARRAY] = f;
         set_flags_recursively(get_flags());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

set_auto_refresh_read()

void midas::odb::set_auto_refresh_read ( bool  f )

inline

Definition at line 1362 of file odbxx.h.

                                         {
         m_flags[odb_flags::AUTO_REFRESH_READ] = f;
         set_flags_recursively(get_flags());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

set_auto_refresh_write()

void midas::odb::set_auto_refresh_write ( bool  f )

inline

Definition at line 1368 of file odbxx.h.

                                          {
         m_flags[odb_flags::AUTO_REFRESH_WRITE] = f;
         set_flags_recursively(get_flags());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

set_debug()

static void midas::odb::set_debug ( bool  flag )

inlinestatic

Definition at line 1401 of file odbxx.h.

{ s_debug = flag; }

Here is the caller graph for this function:

set_deleted()

void midas::odb::set_deleted ( bool  f )

inlineprivate

Definition at line 531 of file odbxx.h.

{ m_flags[odb_flags::DELETED] = f; }

Here is the caller graph for this function:

set_dirty()

void midas::odb::set_dirty ( bool  f )

inline

Definition at line 1374 of file odbxx.h.

{ m_flags[odb_flags::DIRTY] = f; }

set_flags()

void midas::odb::set_flags ( uint32_t  f )

inlineprivate

Definition at line 527 of file odbxx.h.

{ m_flags = f; }

Here is the caller graph for this function:

set_flags_recursively()

void midas::odb::set_flags_recursively ( uint32_t  f )

private

Definition at line 152 of file odbxx.cxx.

                                             {
      m_flags = f;
      if (m_tid == TID_KEY) {
         for (int i = 0; i < m_num_values; i++)
            m_data[i].get_odb().set_flags_recursively(f);
      }
   }

Here is the caller graph for this function:

set_hkey()

void midas::odb::set_hkey ( HNDLE  hKey )

inlineprivate

Definition at line 525 of file odbxx.h.

{ m_hKey = hKey; }

Here is the caller graph for this function:

set_last_index()

void midas::odb::set_last_index ( int  i )

inline

Definition at line 1015 of file odbxx.h.

{ m_last_index = i; }

Here is the caller graph for this function:

set_mode()

void midas::odb::set_mode

(

int

mode

)

Definition at line 1502 of file odbxx.cxx.

                              {
      // set mode of ODB key
      // default is MODE_READ | MODE_WRITE | MODE_DELETE
 
      init_hdb();
 
      // set mode in ODB
      int status = db_set_mode(s_hDB, m_hKey, mode, TRUE);
 
      if (status != DB_SUCCESS && status != DB_INVALID_HANDLE)
         mthrow("db_set_mode for ODB key \"" + get_full_path() +
                "\" returnd error code " + std::to_string(status));
 
      if (s_debug)
         std::cout << "Set mode of ODB key \"" + get_full_path() + "\" to " << mode << std::endl;
   }

Here is the call graph for this function:

set_name()

void midas::odb::set_name ( std::string  s )

inlineprivate

Definition at line 536 of file odbxx.h.

{ m_name = s; }

Here is the call graph for this function:

Here is the caller graph for this function:

set_num_values()

void midas::odb::set_num_values ( int  n )

inlineprivate

Definition at line 534 of file odbxx.h.

{ m_num_values = n; }

Here is the caller graph for this function:

set_odb()

void midas::odb::set_odb	(	odb *	o,
		int	i
	)

Definition at line 1628 of file odbxx.cxx.

   {
      if (this->is_write_protect())
         mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
      if (m_data == nullptr)
         m_data = new u_odb[m_num_values];
      m_data[i].set_parent(this);
      m_data[i].set_tid(m_tid);
      m_data[i].set_odb(o);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

set_odb_source() [1/2]

static void midas::odb::set_odb_source ( odb::odb_source  s )

inlinestatic

Definition at line 1416 of file odbxx.h.

                                                  {
         if (s == STRING)
            mthrow1("ODB source STRING requires a string");
         if (s == FILE)
            mthrow1("ODB source FILE requires a filename");
         s_odb_source = s;
      }

Here is the call graph for this function:

set_odb_source() [2/2]

void midas::odb::set_odb_source ( odb::odb_source  s, std::string  str  )

static

Definition at line 1640 of file odbxx.cxx.

                                                                      {
 
      s_odb_source = s;
      s_odb_source_str = str;
 
      if (s_odb != nullptr)
         delete s_odb;
      s_odb = nullptr;
 
      if (s == odb::FILE) {
         // check file contents
         std::ifstream file(str);
         if (!file)
            mthrow("File \"" + str + "\" not found");
         std::ostringstream ss;
         ss << file.rdbuf();
         file.close();
 
         // create new root ODB object
         s_odb = new midas::odb();
 
         // populate object from file string
         if (s_odb_source_str.find(".xml") != std::string::npos ||
             s_odb_source_str.find(".XML") != std::string::npos)
            odb_from_xml_string(ss.str());
         else if (s_odb_source_str.find(".json") != std::string::npos ||
                  s_odb_source_str.find(".JSON") != std::string::npos)
            odb_from_json_string(ss.str());
         else
            mthrow("File type of \"" +s_odb_source_str + "\" is not supported");
      }
 
      if (s == odb::STRING) {
 
         // create new root ODB object
         s_odb = new midas::odb();
 
         // populate object from string
         if (s_odb_source_str.substr(0, 19) == "<?xml version=\"1.0\"")
            odb_from_xml_string(s_odb_source_str);
         else if (s_odb_source_str.substr(0, 1) == "{")
            odb_from_json_string(s_odb_source_str);
         else
            mthrow("Unknown string format: \"" + s_odb_source_str + "\"");
      }
 
      // std::cout << s_odb->dump() << std::endl;
   }

Here is the call graph for this function:

set_parent()

void midas::odb::set_parent ( midas::odb *  p )

inlineprivate

Definition at line 538 of file odbxx.h.

{ m_parent = p; }

Here is the caller graph for this function:

set_preserve_string_size()

void midas::odb::set_preserve_string_size ( bool  f )

inline

Definition at line 1356 of file odbxx.h.

                                            {
         m_flags[odb_flags::PRESERVE_STRING_SIZE] = f;
         set_flags_recursively(get_flags());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

set_string_size()

void midas::odb::set_string_size	(	std::string	s,
		int	size
	)

Definition at line 1614 of file odbxx.cxx.

   {
      if (this->is_write_protect())
         mthrow("Cannot modify write protected key \"" + get_full_path() + "\"");
 
      m_num_values = 1;
      m_tid = TID_STRING;
      m_data = new u_odb[1];
      m_data[0].set_parent(this);
      m_data[0].set_tid(m_tid);
      m_data[0].set_string_size(s, size);
      set_preserve_string_size(true);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

set_tid()

void midas::odb::set_tid ( int  tid )

inlineprivate

Definition at line 533 of file odbxx.h.

{ m_tid = tid; }

Here is the caller graph for this function:

set_trigger_hotlink()

void midas::odb::set_trigger_hotlink ( bool  f )

inline

Definition at line 1395 of file odbxx.h.

                                       {
         m_flags[odb_flags::TRIGGER_HOTLINK] = f;
         set_flags_recursively(get_flags());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

set_write_protect()

void midas::odb::set_write_protect ( bool  f )

inline

Definition at line 1389 of file odbxx.h.

                                     {
         m_flags[odb_flags::WRITE_PROTECT] = f;
         set_flags_recursively(get_flags());
      }

Here is the call graph for this function:

Here is the caller graph for this function:

size()

int midas::odb::size

(

)

Definition at line 386 of file odbxx.cxx.

                 {
      return m_num_values;
   }

Here is the caller graph for this function:

unwatch()

void midas::odb::unwatch

(

)

Definition at line 1563 of file odbxx.cxx.

   {
      for (int i=0 ; i<(int) g_watchlist.size() ; i++) {
         if (g_watchlist[i]->get_hkey() == this->get_hkey()) {
            db_unwatch(s_hDB, g_watchlist[i]->get_hkey());
            delete g_watchlist[i];
            g_watchlist.erase(g_watchlist.begin() + i);
            i--;
         }
      }
   }

Here is the call graph for this function:

unwatch_all()

void midas::odb::unwatch_all ( )

staticprivate

Definition at line 1575 of file odbxx.cxx.

   {
      for (int i=0 ; i<(int) g_watchlist.size() ; i++) {
         db_unwatch(s_hDB, g_watchlist[i]->get_hkey());
         delete g_watchlist[i];
      }
      g_watchlist.clear();
   }

Here is the call graph for this function:

watch()

void midas::odb::watch

(

std::function< void(midas::odb &)>

f

)

Definition at line 1547 of file odbxx.cxx.

                                                  {
      if (m_hKey == 0 || m_hKey == -1)
         mthrow("watch() called for ODB key \"" + m_name +
                "\" which is not connected to ODB");
 
      // create a deep copy of current object in case it
      // goes out of scope
      midas::odb* ow = new midas::odb(*this);
 
      ow->m_watch_callback = f;
      db_watch(s_hDB, m_hKey, midas::odb::watch_callback, ow);
 
      // put object into watchlist
      g_watchlist.push_back(ow);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

watch_callback()

void midas::odb::watch_callback ( int  hDB, int  hKey, int  index, void *  info  )

staticprivate

Definition at line 124 of file odbxx.cxx.

                                                                    {
      midas::odb *po = static_cast<midas::odb *>(info);
      if (po->m_data == nullptr)
         mthrow("Callback received for a midas::odb object which went out of scope");
      midas::odb *poh = search_hkey(po, hKey);
      if (poh == nullptr) {
         auto s = db_get_path(hDB, hKey);
         mthrow("New key  \"" + s + "\" has been created in ODB after calling watch()");
      }
 
      poh->m_last_index = index;
      po->m_watch_callback(*poh);
      poh->m_last_index = -1;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

write() [1/2]

void midas::odb::write	(	int	index,
		int	str_size
	)

Definition at line 1012 of file odbxx.cxx.

                                          {
      if (!is_connected_odb())
         return;
 
      if (m_hKey == -1) {
         // connect un-connected object (crated via XML)
         std::string path = get_full_path();
 
         int status = db_find_key(s_hDB, 0, path.c_str(), &m_hKey);
         if (status != DB_SUCCESS)
            mthrow("Cannot connect key \"" + path + "\" to ODB");
 
      } else if (m_hKey == 0) {
         if (is_auto_create()) {
            std::string to_create = m_name[0] == '/' ? m_name : get_full_path();
            int status = db_create_key(s_hDB, 0, to_create.c_str(), m_tid);
            if (status != DB_SUCCESS && status != DB_CREATED && status != DB_KEY_EXIST)
               mthrow("Cannot create ODB key \"" + to_create + "\", status =" + std::to_string(status));
            db_find_key(s_hDB, 0, to_create.c_str(), &m_hKey);
            if (s_debug) {
               std::cout << "Created ODB key \"" + to_create + "\"" << std::endl;
            }
            // strip path from name
            if (m_name.find_last_of('/') != std::string::npos)
               m_name = m_name.substr(m_name.find_last_of('/') + 1);
         } else
            mthrow("Write of un-connected ODB key \"" + m_name + "\" not possible");
      }
 
      // don't write keys
      if (m_tid == TID_KEY)
         return;
 
      int status{};
      if (m_tid == TID_STRING || m_tid == TID_LINK) {
         KEY key;
         db_get_key(s_hDB, m_hKey, &key);
         std::string s;
         m_data[index].get(s);
         if (m_num_values == 1) {
            int size = key.item_size;
            if (key.item_size == 0 || !is_preserve_string_size())
               size = s.size() + 1;
            if (str_size > 0)
               size = str_size;
            char *ss = (char *)malloc(size+1);
            mstrlcpy(ss, s.c_str(), size);
            if (is_trigger_hotlink())
               status = db_set_data(s_hDB, m_hKey, ss, size, 1, m_tid);
            else
               status = db_set_data1(s_hDB, m_hKey, ss, size, 1, m_tid);
            free(ss);
         } else {
            if (key.item_size == 0)
               key.item_size = s.size() + 1;
            if (str_size > 0) {
               if (key.item_size > 0 && key.item_size != str_size) {
                  std::cout << "ODB string size mismatch for \"" << get_full_path() <<
                  "\" (" << key.item_size << " vs " << str_size << "). ODB key recreated."
                            << std::endl;
                  if (is_trigger_hotlink())
                     status = db_set_data(s_hDB, m_hKey, s.c_str(), str_size, 1, m_tid);
                  else
                     status = db_set_data1(s_hDB, m_hKey, s.c_str(), str_size, 1, m_tid);
               }
               key.item_size = str_size;
            }
            status = db_set_data_index1(s_hDB, m_hKey, s.c_str(), key.item_size, index, m_tid, is_trigger_hotlink());
         }
         if (s_debug) {
            if (m_num_values > 1)
               std::cout << "Set ODB key \"" + get_full_path() + "[" + std::to_string(index) + "]\" = \"" + s
                         + "\"" << std::endl;
            else
               std::cout << "Set ODB key \"" + get_full_path() + "\" = \"" + s + "\""<< std::endl;
         }
      } else {
         u_odb u = m_data[index];
         if (m_tid == TID_BOOL) {
            u.set_parent(nullptr);
            BOOL b = static_cast<bool>(u); // "bool" is only 1 Byte, BOOL is 4 Bytes
            status = db_set_data_index1(s_hDB, m_hKey, &b, rpc_tid_size(m_tid), index, m_tid, is_trigger_hotlink());
         } else {
            status = db_set_data_index1(s_hDB, m_hKey, &u, rpc_tid_size(m_tid), index, m_tid, is_trigger_hotlink());
         }
         if (s_debug) {
            std::string s;
            u.get(s);
            if (m_num_values > 1)
               std::cout << "Set ODB key \"" + get_full_path() + "[" + std::to_string(index) + "]\" = " + s
                         << std::endl;
            else
               std::cout << "Set ODB key \"" + get_full_path() + "\" = " + s << std::endl;
         }
      }
      if (status != DB_SUCCESS)
         mthrow("db_set_data_index for ODB key \"" + get_full_path() +
                "\" failed with status " + std::to_string(status));
   }

Here is the call graph for this function:

write() [2/2]

void midas::odb::write

(

int

str_size = 0

)

Definition at line 1113 of file odbxx.cxx.

                               {
 
      // check if deleted
      if (is_deleted())
         mthrow("ODB key \"" + m_name + "\" cannot be written because it has been deleted");
 
      // write subkeys
      if (m_tid == TID_KEY) {
         for (int i = 0; i < m_num_values; i++)
            m_data[i].get_odb().write();
         return;
      }
 
      if (m_tid == 0 && m_data[0].get_tid() != 0)
         m_tid = m_data[0].get_tid();
 
      if (m_tid < 1 || m_tid >= TID_LAST)
         mthrow("Invalid TID for ODB key \"" + get_full_path() + "\"");
 
      if ((m_hKey == 0  || m_hKey == -1) && !is_auto_create())
         mthrow("Writing ODB key \"" + m_name +
                "\" is not possible because of invalid key handle");
 
      // if index operator [] returned previously a certain index, write only this one
      if (m_last_index != -1) {
         write(m_last_index, str_size);
         m_last_index = -1;
         return;
      }
 
      if (m_num_values == 1) {
         write(0, str_size);
         return;
      }
 
      if (m_hKey == -1) {
         // connect un-connected object (crated via XML)
         std::string path = get_full_path();
 
         int status = db_find_key(s_hDB, 0, path.c_str(), &m_hKey);
         if (status != DB_SUCCESS)
            mthrow("Cannot connect key \"" + path + "\" to ODB");
 
      } else if (m_hKey == 0) {
         if (is_auto_create()) {
            std::string to_create = m_name[0] == '/' ? m_name : get_full_path();
            int status = db_create_key(s_hDB, 0, to_create.c_str(), m_tid);
            if (status != DB_SUCCESS && status != DB_CREATED && status != DB_KEY_EXIST)
               mthrow("Cannot create ODB key \"" + to_create + "\", status" + std::to_string(status));
            db_find_key(s_hDB, 0, to_create.c_str(), &m_hKey);
            if (s_debug) {
               std::cout << "Created ODB key \"" + to_create + "\"" << std::endl;
            }
            // strip path from name
            if (m_name.find_last_of('/') != std::string::npos)
               m_name = m_name.substr(m_name.find_last_of('/') + 1);
         } else
            mthrow("Write of un-connected ODB key \"" + m_name + "\" not possible");
      }
 
      int status{};
      if (m_tid == TID_STRING || m_tid == TID_LINK) {
         if (is_preserve_string_size() || m_num_values > 1) {
            KEY key;
            db_get_key(s_hDB, m_hKey, &key);
            if (key.item_size == 0 || key.total_size == 0) {
               int size = 1;
               for (int i = 0; i < m_num_values; i++) {
                  std::string d;
                  m_data[i].get(d);
                  if ((int) d.size() + 1 > size)
                     size = d.size() + 1;
               }
               // round up to multiples of 32
               size = (((size - 1) / 32) + 1) * 32;
               key.item_size = size;
               key.total_size = size * m_num_values;
            }
            char *str = (char *) calloc(m_num_values, key.item_size);
            for (int i = 0; i < m_num_values; i++) {
               std::string d;
               m_data[i].get(d);
               strncpy(str + i * key.item_size, d.c_str(), key.item_size);
            }
            if (is_trigger_hotlink())
               status = db_set_data(s_hDB, m_hKey, str, key.item_size * m_num_values, m_num_values, m_tid);
            else
               status = db_set_data1(s_hDB, m_hKey, str, key.item_size * m_num_values, m_num_values, m_tid);
            free(str);
            if (s_debug) {
               std::string s;
               get(s, true, false);
               std::cout << "Set ODB key \"" + get_full_path() +
                            "[0..." + std::to_string(m_num_values - 1) + "]\" = [" + s + "]" << std::endl;
            }
         } else {
            std::string s;
            m_data[0].get(s);
            if (is_trigger_hotlink())
               status = db_set_data(s_hDB, m_hKey, s.c_str(), s.length() + 1, 1, m_tid);
            else
               status = db_set_data1(s_hDB, m_hKey, s.c_str(), s.length() + 1, 1, m_tid);
            if (s_debug)
               std::cout << "Set ODB key \"" + get_full_path() + "\" = " + s << std::endl;
         }
      } else {
         int size = rpc_tid_size(m_tid) * m_num_values;
         uint8_t *buffer = (uint8_t *) malloc(size);
         uint8_t *p = buffer;
         for (int i = 0; i < m_num_values; i++) {
            if (m_tid == TID_BOOL) {
               // bool has 1 Byte, BOOL has 4 Bytes
               BOOL b = static_cast<bool>(m_data[i]);
               memcpy(p, &b, rpc_tid_size(m_tid));
            } else {
               memcpy(p, (void*)&m_data[i], rpc_tid_size(m_tid));
            }
            p += rpc_tid_size(m_tid);
         }
         if (is_trigger_hotlink())
            status = db_set_data(s_hDB, m_hKey, buffer, size, m_num_values, m_tid);
         else
            status = db_set_data1(s_hDB, m_hKey, buffer, size, m_num_values, m_tid);
         free(buffer);
         if (s_debug) {
            std::string s;
            get(s, false, false);
            if (m_num_values > 1)
               std::cout << "Set ODB key \"" + get_full_path() + "[0..." + std::to_string(m_num_values - 1) +
                            "]\" = [" + s + "]" << std::endl;
            else
               std::cout << "Set ODB key \"" + get_full_path() + "\" = " + s << std::endl;
         }
      }
 
      if (status != DB_SUCCESS)
         mthrow("db_set_data for ODB key \"" + get_full_path() +
                "\" failed with status " + std::to_string(status));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

write_key()

bool midas::odb::write_key ( std::string &  path, bool  write_defaults  )

private

Definition at line 743 of file odbxx.cxx.

                                                        {
      int status = db_find_key(s_hDB, 0, path.c_str(), &m_hKey);
      if (status != DB_SUCCESS) {
         if (m_tid == 0) // auto-create subdir
            m_tid = TID_KEY;
         if (m_tid > 0 && m_tid < TID_LAST) {
            status = db_create_key(s_hDB, 0, path.c_str(), m_tid);
            if (status != DB_SUCCESS)
               mthrow("ODB key \"" + path + "\" cannot be created");
            status = db_find_key(s_hDB, 0, path.c_str(), &m_hKey);
            if (status != DB_SUCCESS)
               mthrow("ODB key \"" + path + "\" not found after creation");
            if (s_debug) {
               if (path[0] == '/')
                  std::cout << "Created ODB key \"" + path + "\"" << std::endl;
               else
                  std::cout << "Created ODB key \"" + get_full_path() + "\"" << std::endl;
            }
         } else
            mthrow("ODB key \"" + path + "\" cannot be found");
         return true;
      } else {
         KEY key;
         status = db_get_key(s_hDB, m_hKey, &key);
         if (status != DB_SUCCESS)
            mthrow("db_get_key for ODB key \"" + path +
                   "\" failed with status " + std::to_string(status));
         if (m_tid == 0)
            m_tid = key.type;
 
         // check for correct type
         if (m_tid > 0 && m_tid != (int) key.type) {
            if (force_write) {
               // delete and recreate key
               status = db_delete_key(s_hDB, m_hKey);
               if (status != DB_SUCCESS)
                  mthrow("db_delete_key for ODB key \"" + path +
                         "\" failed with status " + std::to_string(status));
               status = db_create_key(s_hDB, 0, path.c_str(), m_tid);
               if (status != DB_SUCCESS)
                  mthrow("ODB key \"" + path + "\" cannot be created");
               status = db_find_key(s_hDB, 0, path.c_str(), &m_hKey);
               if (status != DB_SUCCESS)
                  mthrow("ODB key \"" + path + "\" not found after creation");
               if (s_debug)
                  std::cout << "Re-created ODB key \"" + get_full_path() << "\" with different type" << std::endl;
            } else
               // abort
               mthrow("ODB key \"" + get_full_path() +
                      "\" has differnt type than specified");
         } else if (s_debug)
            std::cout << "Validated ODB key \"" + get_full_path() + "\"" << std::endl;
 
         return false;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator!= [1/2]

template<typename T >

bool operator!= ( const midas::odb &  o, const T &  d  )

friend

Definition at line 1495 of file odbxx.h.

                                                  {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return v != d;
   }

operator!= [2/2]

template<typename T >

bool operator!= ( const T &  d, const midas::odb &  o  )

friend

Definition at line 1503 of file odbxx.h.

                                                  {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return d != v;
   }

operator< [1/2]

template<typename T >

bool operator< ( const midas::odb &  o, const T &  d  )

friend

Definition at line 1511 of file odbxx.h.

                                                 {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return v < d;
   }

operator< [2/2]

template<typename T >

bool operator< ( const T &  d, const midas::odb &  o  )

friend

Definition at line 1519 of file odbxx.h.

                                                 {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return d < v;
   }

operator<<

std::ostream & operator<< ( std::ostream &  output, odb &  o  )

friend

Definition at line 936 of file odbxx.h.

                                                                {
         std::string s;
         if (o.m_tid == TID_KEY)
            o.print(s, 0);
         else
            o.get(s);
         output << s;
         return output;
      };

operator<= [1/2]

template<typename T >

bool operator<= ( const midas::odb &  o, const T &  d  )

friend

Definition at line 1527 of file odbxx.h.

                                                  {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return v <= d;
   }

operator<= [2/2]

template<typename T >

bool operator<= ( const T &  d, const midas::odb &  o  )

friend

Definition at line 1535 of file odbxx.h.

                                                  {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return d <= v;
   }

operator== [1/2]

template<typename T >

bool operator== ( const midas::odb &  o, const T &  d  )

friend

Definition at line 1477 of file odbxx.h.

                                                  {
      // the operator needs a "const midas::odb" reference,
      // so we have to make a non-const copy
      T v;
      midas::odb oc(o);
      oc.get(v);
      return v == d;
   }

operator== [2/2]

template<typename T >

bool operator== ( const T &  d, const midas::odb &  o  )

friend

Definition at line 1487 of file odbxx.h.

                                                  {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return d == v;
   }

operator> [1/2]

template<typename T >

bool operator> ( const midas::odb &  o, const T &  d  )

friend

Definition at line 1543 of file odbxx.h.

                                                 {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return v > d;
   }

operator> [2/2]

template<typename T >

bool operator> ( const T &  d, const midas::odb &  o  )

friend

Definition at line 1551 of file odbxx.h.

                                                 {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return d > v;
   }

operator>= [1/2]

template<typename T >

bool operator>= ( const midas::odb &  o, const T &  d  )

friend

Definition at line 1559 of file odbxx.h.

                                                  {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return v >= d;
   }

operator>= [2/2]

template<typename T >

bool operator>= ( const T &  d, const midas::odb &  o  )

friend

Definition at line 1567 of file odbxx.h.

                                                  {
      T v;
      midas::odb oc(o);
      oc.get(v);
      return d >= v;
   }

Member Data Documentation

m_data

u_odb* midas::odb::m_data

private

Definition at line 465 of file odbxx.h.

m_flags

std::bitset<9> midas::odb::m_flags

private

Definition at line 461 of file odbxx.h.

m_hKey

HNDLE midas::odb::m_hKey

private

Definition at line 473 of file odbxx.h.

m_last_index

int midas::odb::m_last_index

private

Definition at line 471 of file odbxx.h.

m_name

std::string midas::odb::m_name

private

Definition at line 467 of file odbxx.h.

m_num_values

int midas::odb::m_num_values

private

Definition at line 469 of file odbxx.h.

m_parent

midas::odb* midas::odb::m_parent

private

Definition at line 477 of file odbxx.h.

m_tid

int midas::odb::m_tid

private

Definition at line 463 of file odbxx.h.

m_watch

std::vector<midas::odb> midas::odb::m_watch

staticprivate

Definition at line 458 of file odbxx.h.

m_watch_callback

std::function<void(midas::odb &)> midas::odb::m_watch_callback

private

Definition at line 475 of file odbxx.h.

s_connected_odb

bool midas::odb::s_connected_odb = false

staticprivate

Definition at line 456 of file odbxx.h.

s_debug

bool midas::odb::s_debug = false

staticprivate

Definition at line 454 of file odbxx.h.

s_hDB

HNDLE midas::odb::s_hDB = 0

staticprivate

Definition at line 452 of file odbxx.h.

s_odb

thread_local odb * midas::odb::s_odb = nullptr

staticprivate

Definition at line 450 of file odbxx.h.

s_odb_source

thread_local odb::odb_source midas::odb::s_odb_source = odb::ONLINE

staticprivate

Definition at line 447 of file odbxx.h.

s_odb_source_str

thread_local std::string midas::odb::s_odb_source_str = std::string("")

staticprivate

Definition at line 448 of file odbxx.h.

---

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

• include/odbxx.h
• src/odbxx.cxx