epee::serialization::portable_storage Class Reference

#include <portable_storage.h>

Public Types
typedef epee::serialization::hsection	hsection
typedef epee::serialization::harray	harray
typedef storage_entry	meta_entry

Public Member Functions
	portable_storage ()
virtual	~portable_storage ()
hsection	open_section (const std::string &section_name, hsection hparent_section, bool create_if_notexist=false)
template<class t_value>
bool	get_value (const std::string &value_name, t_value &val, hsection hparent_section)
bool	get_value (const std::string &value_name, storage_entry &val, hsection hparent_section)
template<class t_value>
bool	set_value (const std::string &value_name, const t_value &target, hsection hparent_section)
template<class t_value>
harray	get_first_value (const std::string &value_name, t_value &target, hsection hparent_section)
template<class t_value>
bool	get_next_value (harray hval_array, t_value &target)
template<class t_value>
harray	insert_first_value (const std::string &value_name, const t_value &target, hsection hparent_section)
template<class t_value>
bool	insert_next_value (harray hval_array, const t_value &target)
harray	get_first_section (const std::string &pSectionName, hsection &h_child_section, hsection hparent_section)
bool	get_next_section (harray hSecArray, hsection &h_child_section)
harray	insert_first_section (const std::string &pSectionName, hsection &hinserted_childsection, hsection hparent_section)
bool	insert_next_section (harray hSecArray, hsection &hinserted_childsection)
bool	delete_entry (const std::string &pentry_name, hsection hparent_section=nullptr)
bool	store_to_binary (binarybuffer &target)
bool	load_from_binary (const epee::span< const uint8_t > target)
bool	load_from_binary (const std::string &target)
template<class trace_policy>
bool	dump_as_xml (std::string &targetObj, const std::string &root_name="")
bool	dump_as_json (std::string &targetObj, size_t indent=0, bool insert_newlines=true)
bool	load_from_json (const std::string &source)

Detailed Description

Definition at line 50 of file portable_storage.h.

Member Typedef Documentation

harray

typedef epee::serialization::harray epee::serialization::portable_storage::harray

Definition at line 54 of file portable_storage.h.

hsection

typedef epee::serialization::hsection epee::serialization::portable_storage::hsection

Definition at line 53 of file portable_storage.h.

meta_entry

typedef storage_entry epee::serialization::portable_storage::meta_entry

Definition at line 55 of file portable_storage.h.

Constructor & Destructor Documentation

portable_storage()

epee::serialization::portable_storage::portable_storage ( )

inline

Definition at line 57 of file portable_storage.h.

{}

~portable_storage()

virtual epee::serialization::portable_storage::~portable_storage ( )

inlinevirtual

Definition at line 58 of file portable_storage.h.

{}

Member Function Documentation

delete_entry()

bool epee::serialization::portable_storage::delete_entry	(	const std::string &	pentry_name,
		hsection	hparent_section = nullptr )

dump_as_json()

bool epee::serialization::portable_storage::dump_as_json ( std::string & targetObj, size_t indent = 0, bool insert_newlines = true )

inline

Definition at line 114 of file portable_storage.h.

    {
      TRY_ENTRY();
      std::stringstream ss;
      epee::serialization::dump_as_json(ss, m_root, indent, insert_newlines);
      buff = ss.str();
      return true;
      CATCH_ENTRY("portable_storage::dump_as_json", false)
    }

Here is the call graph for this function:

Here is the caller graph for this function:

dump_as_xml()

template<class trace_policy>

bool epee::serialization::portable_storage::dump_as_xml	(	std::string &	targetObj,
		const std::string &	root_name = "" )

Definition at line 132 of file portable_storage.h.

    {
      return false;//TODO: don't think i ever again will use xml - ambiguous and "overtagged" format
    }

get_first_section()

harray epee::serialization::portable_storage::get_first_section ( const std::string & pSectionName, hsection & h_child_section, hsection hparent_section )

inline

Definition at line 408 of file portable_storage.h.

    {
      TRY_ENTRY();
      if(!hparent_section) hparent_section = &m_root;
      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
      if(!pentry)
        return nullptr;
      if(pentry->type() != typeid(array_entry))
        return nullptr;
      array_entry& ar_entry = boost::get<array_entry>(*pentry);
      if(ar_entry.type() != typeid(array_entry_t<section>))
        return nullptr;
      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
      section* psec = sec_array.get_first_val();
      if(!psec)
        return nullptr;
      h_child_section = psec;
      return &ar_entry;
      CATCH_ENTRY("portable_storage::get_first_section", nullptr);
    }

Here is the call graph for this function:

get_first_value()

template<class t_value>

harray epee::serialization::portable_storage::get_first_value	(	const std::string &	value_name,
		t_value &	target,
		hsection	hparent_section )

Definition at line 315 of file portable_storage.h.

    {
      BOOST_MPL_ASSERT(( boost::mpl::contains<storage_entry::types, t_value> )); 
      //TRY_ENTRY();
      if(!hparent_section) hparent_section = &m_root;
      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
      if(!pentry)
        return nullptr;
      if(pentry->type() != typeid(array_entry))
        return nullptr;
      array_entry& ar_entry = boost::get<array_entry>(*pentry);
      
      get_first_value_visitor<t_value> gfv(target);
      if(!boost::apply_visitor(gfv, ar_entry))
        return nullptr;
      return &ar_entry;
      //CATCH_ENTRY("portable_storage::get_first_value", nullptr);
    }

get_next_section()

bool epee::serialization::portable_storage::get_next_section ( harray hSecArray, hsection & h_child_section )

inline

Definition at line 430 of file portable_storage.h.

    {
      TRY_ENTRY();
      CHECK_AND_ASSERT(hsec_array, false);
      if(hsec_array->type() != typeid(array_entry_t<section>))
        return false;
      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
      h_child_section = sec_array.get_next_val();
      if(!h_child_section)
        return false;
      return true;
      CATCH_ENTRY("portable_storage::get_next_section", false);
    }

Here is the call graph for this function:

get_next_value()

template<class t_value>

bool epee::serialization::portable_storage::get_next_value	(	harray	hval_array,
		t_value &	target )

Definition at line 353 of file portable_storage.h.

    {
      BOOST_MPL_ASSERT(( boost::mpl::contains<storage_entry::types, t_value> )); 
      //TRY_ENTRY();
      CHECK_AND_ASSERT(hval_array, false);
      array_entry& ar_entry = *hval_array;
      get_next_value_visitor<t_value> gnv(target);
      if(!boost::apply_visitor(gnv, ar_entry))
        return false;
      return true;
      //CATCH_ENTRY("portable_storage::get_next_value", false);
    } 

get_value() [1/2]

bool epee::serialization::portable_storage::get_value ( const std::string & value_name, storage_entry & val, hsection hparent_section )

inline

Definition at line 232 of file portable_storage.h.

    {
      //TRY_ENTRY();
      if(!hparent_section) hparent_section = &m_root;
      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
      if(!pentry)
        return false;
 
      val = *pentry;
      return true;
      //CATCH_ENTRY("portable_storage::template<>get_value", false);
    }

get_value() [2/2]

template<class t_value>

bool epee::serialization::portable_storage::get_value	(	const std::string &	value_name,
		t_value &	val,
		hsection	hparent_section )

Definition at line 216 of file portable_storage.h.

    {
      BOOST_MPL_ASSERT(( boost::mpl::contains<storage_entry::types, t_value> )); 
      //TRY_ENTRY();
      if(!hparent_section) hparent_section = &m_root;
      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
      if(!pentry)
        return false;
 
      get_value_visitor<t_value> gvv(val);
      boost::apply_visitor(gvv, *pentry);
      return true;
      //CATCH_ENTRY("portable_storage::template<>get_value", false);
    }

Here is the caller graph for this function:

insert_first_section()

harray epee::serialization::portable_storage::insert_first_section ( const std::string & pSectionName, hsection & hinserted_childsection, hsection hparent_section )

inline

Definition at line 445 of file portable_storage.h.

    {
      TRY_ENTRY();
      if(!hparent_section) hparent_section = &m_root;
      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
      if(!pentry)
      {
        pentry = insert_new_entry_get_storage_entry(sec_name, hparent_section, array_entry(array_entry_t<section>()));
        if(!pentry)
          return nullptr;
      }
      if(pentry->type() != typeid(array_entry))
        *pentry = storage_entry(array_entry(array_entry_t<section>()));
 
      array_entry& ar_entry = boost::get<array_entry>(*pentry);
      if(ar_entry.type() != typeid(array_entry_t<section>))
        ar_entry = array_entry(array_entry_t<section>());
 
      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
      hinserted_childsection = &sec_array.insert_first_val(section());
      return &ar_entry;
      CATCH_ENTRY("portable_storage::insert_first_section", nullptr);
    }

Here is the call graph for this function:

insert_first_value()

template<class t_value>

harray epee::serialization::portable_storage::insert_first_value	(	const std::string &	value_name,
		const t_value &	target,
		hsection	hparent_section )

Definition at line 367 of file portable_storage.h.

    {
      TRY_ENTRY();
      if(!hparent_section) hparent_section = &m_root;
      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
      if(!pentry)
      {
        pentry = insert_new_entry_get_storage_entry(value_name, hparent_section, array_entry(array_entry_t<t_value>()));
        if(!pentry)
          return nullptr;
      }
      if(pentry->type() != typeid(array_entry))
        *pentry = storage_entry(array_entry(array_entry_t<t_value>()));
 
      array_entry& arr = boost::get<array_entry>(*pentry);
      if(arr.type() != typeid(array_entry_t<t_value>))
        arr = array_entry(array_entry_t<t_value>());
 
      array_entry_t<t_value>& arr_typed = boost::get<array_entry_t<t_value> >(arr);
      arr_typed.insert_first_val(target);
      return &arr;
      CATCH_ENTRY("portable_storage::insert_first_value", nullptr);
    }

Here is the call graph for this function:

insert_next_section()

bool epee::serialization::portable_storage::insert_next_section ( harray hSecArray, hsection & hinserted_childsection )

inline

Definition at line 470 of file portable_storage.h.

    {
      TRY_ENTRY();
      CHECK_AND_ASSERT(hsec_array, false);
      CHECK_AND_ASSERT_MES(hsec_array->type() == typeid(array_entry_t<section>), 
        false, "unexpected type(not 'section') in insert_next_section, type: " << hsec_array->type().name());
 
      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
      hinserted_childsection = &sec_array.insert_next_value(section());
      return true;
      CATCH_ENTRY("portable_storage::insert_next_section", false);
    }

Here is the call graph for this function:

insert_next_value()

template<class t_value>

bool epee::serialization::portable_storage::insert_next_value	(	harray	hval_array,
		const t_value &	target )

Definition at line 392 of file portable_storage.h.

    {
      TRY_ENTRY();
      CHECK_AND_ASSERT(hval_array, false);
 
      CHECK_AND_ASSERT_MES(hval_array->type() == typeid(array_entry_t<t_value>), 
        false, "unexpected type in insert_next_value: " << typeid(array_entry_t<t_value>).name());
 
      array_entry_t<t_value>& arr_typed = boost::get<array_entry_t<t_value> >(*hval_array);
      arr_typed.insert_next_value(target);
      return true;
      CATCH_ENTRY("portable_storage::insert_next_value", false);
    }

Here is the call graph for this function:

load_from_binary() [1/2]

bool epee::serialization::portable_storage::load_from_binary ( const epee::span< const uint8_t > target )

inline

Definition at line 153 of file portable_storage.h.

    {
      m_root.m_entries.clear();
      if(source.size() < sizeof(storage_block_header))
      {
        LOG_ERROR("portable_storage: wrong binary format, packet size = " << source.size() << " less than expected sizeof(storage_block_header)=" << sizeof(storage_block_header));
        return false;
      }
      storage_block_header* pbuff = (storage_block_header*)source.data();
      if(pbuff->m_signature_a != SWAP32LE(PORTABLE_STORAGE_SIGNATUREA) ||
        pbuff->m_signature_b != SWAP32LE(PORTABLE_STORAGE_SIGNATUREB)
        )
      {
        LOG_ERROR("portable_storage: wrong binary format - signature mismatch");
        return false;
      }
      if(pbuff->m_ver != PORTABLE_STORAGE_FORMAT_VER)
      {
        LOG_ERROR("portable_storage: wrong binary format - unknown format ver = " << pbuff->m_ver);
        return false;
      }
      TRY_ENTRY();
      throwable_buffer_reader buf_reader(source.data()+sizeof(storage_block_header), source.size()-sizeof(storage_block_header));
      buf_reader.read(m_root);
      return true;//TODO:
      CATCH_ENTRY("portable_storage::load_from_binary", false);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_binary() [2/2]

bool epee::serialization::portable_storage::load_from_binary ( const std::string & target )

inline

Definition at line 88 of file portable_storage.h.

{ return load_from_binary(epee::strspan<uint8_t>(target)); }

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_json()

bool epee::serialization::portable_storage::load_from_json ( const std::string & source )

inline

Definition at line 124 of file portable_storage.h.

    {
      TRY_ENTRY();
      return json::load_from_json(source, *this);
      CATCH_ENTRY("portable_storage::load_from_json", false)
    }

Here is the caller graph for this function:

open_section()

hsection epee::serialization::portable_storage::open_section ( const std::string & section_name, hsection hparent_section, bool create_if_notexist = false )

inline

Definition at line 182 of file portable_storage.h.

    {
      TRY_ENTRY();
      hparent_section = hparent_section ? hparent_section:&m_root;
      storage_entry* pentry = find_storage_entry(section_name, hparent_section);
      if(!pentry)
      {
        if(!create_if_notexist)
          return nullptr;
        return insert_new_section(section_name, hparent_section);
      }
      CHECK_AND_ASSERT(pentry , nullptr);
      //check that section_entry we find is real "CSSection"
      if(pentry->type() != typeid(section))
      {
        if(create_if_notexist)
          *pentry = storage_entry(section());//replace
        else
          return nullptr;
      }
      return &boost::get<section>(*pentry);
      CATCH_ENTRY("portable_storage::open_section", nullptr);
    }

Here is the caller graph for this function:

set_value()

template<class t_value>

bool epee::serialization::portable_storage::set_value	(	const std::string &	value_name,
		const t_value &	target,
		hsection	hparent_section )

Definition at line 246 of file portable_storage.h.

    {
      BOOST_MPL_ASSERT(( boost::mpl::contains<boost::mpl::push_front<storage_entry::types, storage_entry>::type, t_value> )); 
      TRY_ENTRY();
      if(!hparent_section)
        hparent_section = &m_root;
      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
      if(!pentry)
      {
        pentry = insert_new_entry_get_storage_entry(value_name, hparent_section, v);
        if(!pentry)
          return false;
        return true;
      }
      *pentry = storage_entry(v);
      return true;
      CATCH_ENTRY("portable_storage::template<>set_value", false);
    }

Here is the caller graph for this function:

store_to_binary()

bool epee::serialization::portable_storage::store_to_binary ( binarybuffer & target )

inline

Definition at line 138 of file portable_storage.h.

    {
      TRY_ENTRY();
      std::stringstream ss;
      storage_block_header sbh = AUTO_VAL_INIT(sbh);
      sbh.m_signature_a = SWAP32LE(PORTABLE_STORAGE_SIGNATUREA);
      sbh.m_signature_b = SWAP32LE(PORTABLE_STORAGE_SIGNATUREB);
      sbh.m_ver = PORTABLE_STORAGE_FORMAT_VER;
      ss.write((const char*)&sbh, sizeof(storage_block_header));
      pack_entry_to_buff(ss, m_root);
      target = ss.str();
      return true;
      CATCH_ENTRY("portable_storage::store_to_binary", false)
    }

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/contrib/epee/include/storages/portable_storage.h