4rkal/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2024-12-13 11:56:31 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Reduce compilation time of epee/portable_storage.h

Browse Source
This commit is contained in:
mj-xmr 2020-11-09 20:49:11 +01:00
parent cb70ae9450
commit dc48de74e8
14 changed files with 290 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
contrib/epee/include/misc_language.h
View File

@ -28,9 +28,11 @@
#pragma once #pragma once
#include <limits>
#include <boost/thread.hpp>
#include <boost/utility/value_init.hpp> #include <boost/utility/value_init.hpp>
#include <boost/shared_ptr.hpp>
#include <limits>
#include <functional>
#include <vector>
namespace epee namespace epee
{ {
#define STD_TRY_BEGIN() try { #define STD_TRY_BEGIN() try {
@ -95,16 +97,7 @@ namespace misc_utils
return memcmp(&_Left, &_Right, sizeof(_Left)) < 0; return memcmp(&_Left, &_Right, sizeof(_Left)) < 0;
} }
bool sleep_no_w(long ms );
inline
bool sleep_no_w(long ms )
{
boost::this_thread::sleep(
boost::get_system_time() +
boost::posix_time::milliseconds( std::max<long>(ms,0) ) );
return true;
}
template <typename T> template <typename T>
T get_mid(const T &a, const T &b) T get_mid(const T &a, const T &b)

1
contrib/epee/include/net/abstract_tcp_server2.inl
View File

@ -40,6 +40,7 @@
#include <boost/date_time/posix_time/posix_time.hpp> // TODO #include <boost/date_time/posix_time/posix_time.hpp> // TODO
#include <boost/thread/condition_variable.hpp> // TODO #include <boost/thread/condition_variable.hpp> // TODO
#include <boost/make_shared.hpp> #include <boost/make_shared.hpp>
#include <boost/thread.hpp>
#include "warnings.h" #include "warnings.h"
#include "string_tools.h" #include "string_tools.h"
#include "misc_language.h" #include "misc_language.h"

202
contrib/epee/include/storages/portable_storage.h
View File

@ -24,20 +24,12 @@
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
#pragma once #pragma once
#include <type_traits>
#include "misc_language.h"
#include "portable_storage_base.h" #include "portable_storage_base.h"
#include "portable_storage_from_bin.h"
#include "portable_storage_to_json.h"
#include "portable_storage_from_json.h"
#include "portable_storage_val_converters.h" #include "portable_storage_val_converters.h"
#include "misc_log_ex.h"
#include "span.h" #include "span.h"
#include "int-util.h"
namespace epee namespace epee
{ {
@ -92,7 +84,7 @@ namespace epee
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
bool store_to_binary(byte_slice& target, std::size_t initial_buffer_size = 8192); bool store_to_binary(byte_slice& target, std::size_t initial_buffer_size = 8192);
bool load_from_binary(const epee::span<const uint8_t> target, const limits_t *limits = NULL); bool load_from_binary(const epee::span<const uint8_t> target, const limits_t *limits = NULL);
bool load_from_binary(const std::string& target, const limits_t *limits = NULL) { return load_from_binary(epee::strspan<uint8_t>(target), limits); } bool load_from_binary(const std::string& target, const limits_t *limits = NULL);
template<class trace_policy> template<class trace_policy>
bool dump_as_xml(std::string& targetObj, const std::string& root_name = ""); 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 dump_as_json(std::string& targetObj, size_t indent = 0, bool insert_newlines = true);
@ -117,85 +109,13 @@ namespace epee
}; };
#pragma pack(pop) #pragma pack(pop)
}; };
inline
bool portable_storage::dump_as_json(std::string& buff, size_t indent, bool insert_newlines)
{
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)
}
inline
bool portable_storage::load_from_json(const std::string& source)
{
TRY_ENTRY();
return json::load_from_json(source, *this);
CATCH_ENTRY("portable_storage::load_from_json", false)
}
template<class trace_policy> template<class trace_policy>
bool portable_storage::dump_as_xml(std::string& targetObj, const std::string& root_name) bool portable_storage::dump_as_xml(std::string& targetObj, const std::string& root_name)
{ {
return false;//TODO: don't think i ever again will use xml - ambiguous and "overtagged" format return false;//TODO: don't think i ever again will use xml - ambiguous and "overtagged" format
} }
inline
bool portable_storage::load_from_binary(const epee::span<const uint8_t> source, const limits_t *limits)
{
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));
if (limits)
buf_reader.set_limits(limits->n_objects, limits->n_fields, limits->n_strings);
buf_reader.read(m_root);
return true;//TODO:
CATCH_ENTRY("portable_storage::load_from_binary", false);
}
//---------------------------------------------------------------------------------------------------------------
inline
hsection portable_storage::open_section(const std::string& section_name, hsection hparent_section, bool create_if_notexist)
{
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);
}
//---------------------------------------------------------------------------------------------------------------
template<class to_type> template<class to_type>
struct get_value_visitor: boost::static_visitor<void> struct get_value_visitor: boost::static_visitor<void>
{ {
@ -221,20 +141,6 @@ namespace epee
//CATCH_ENTRY("portable_storage::template<>get_value", false); //CATCH_ENTRY("portable_storage::template<>get_value", false);
} }
//--------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------
inline
bool portable_storage::get_value(const std::string& value_name, storage_entry& val, hsection hparent_section)
{
//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);
}
//---------------------------------------------------------------------------------------------------------------
template<class t_value> template<class t_value>
bool portable_storage::set_value(const std::string& value_name, t_value&& v, hsection hparent_section) bool portable_storage::set_value(const std::string& value_name, t_value&& v, hsection hparent_section)
{ {
@ -256,19 +162,6 @@ namespace epee
CATCH_ENTRY("portable_storage::template<>set_value", false); CATCH_ENTRY("portable_storage::template<>set_value", false);
} }
//--------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------
inline
storage_entry* portable_storage::find_storage_entry(const std::string& pentry_name, hsection psection)
{
TRY_ENTRY();
CHECK_AND_ASSERT(psection, nullptr);
auto it = psection->m_entries.find(pentry_name);
if(it == psection->m_entries.end())
return nullptr;
return &it->second;
CATCH_ENTRY("portable_storage::find_storage_entry", nullptr);
}
//---------------------------------------------------------------------------------------------------------------
template<class entry_type> template<class entry_type>
storage_entry* portable_storage::insert_new_entry_get_storage_entry(const std::string& pentry_name, hsection psection, entry_type&& entry) storage_entry* portable_storage::insert_new_entry_get_storage_entry(const std::string& pentry_name, hsection psection, entry_type&& entry)
{ {
@ -281,16 +174,6 @@ namespace epee
CATCH_ENTRY("portable_storage::insert_new_entry_get_storage_entry", nullptr); CATCH_ENTRY("portable_storage::insert_new_entry_get_storage_entry", nullptr);
} }
//--------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------
inline
hsection portable_storage::insert_new_section(const std::string& pentry_name, hsection psection)
{
TRY_ENTRY();
storage_entry* pse = insert_new_entry_get_storage_entry(pentry_name, psection, section());
if(!pse) return nullptr;
return &boost::get<section>(*pse);
CATCH_ENTRY("portable_storage::insert_new_section", nullptr);
}
//---------------------------------------------------------------------------------------------------------------
template<class to_type> template<class to_type>
struct get_first_value_visitor: boost::static_visitor<bool> struct get_first_value_visitor: boost::static_visitor<bool>
{ {
@ -344,7 +227,6 @@ namespace epee
} }
}; };
template<class t_value> template<class t_value>
bool portable_storage::get_next_value(harray hval_array, t_value& target) bool portable_storage::get_next_value(harray hval_array, t_value& target)
{ {
@ -402,83 +284,5 @@ namespace epee
return true; return true;
CATCH_ENTRY("portable_storage::insert_next_value", false); CATCH_ENTRY("portable_storage::insert_next_value", false);
} }
//---------------------------------------------------------------------------------------------------------------
//sections
inline
harray portable_storage::get_first_section(const std::string& sec_name, hsection& h_child_section, hsection hparent_section)
{
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);
}
//---------------------------------------------------------------------------------------------------------------
inline
bool portable_storage::get_next_section(harray hsec_array, hsection& h_child_section)
{
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);
}
//---------------------------------------------------------------------------------------------------------------
inline
harray portable_storage::insert_first_section(const std::string& sec_name, hsection& hinserted_childsection, hsection hparent_section)
{
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);
}
//---------------------------------------------------------------------------------------------------------------
inline
bool portable_storage::insert_next_section(harray hsec_array, hsection& hinserted_childsection)
{
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);
}
//---------------------------------------------------------------------------------------------------------------
} }
} }

2
contrib/epee/include/storages/portable_storage_base.h
View File

@ -29,10 +29,10 @@
#pragma once #pragma once
#include <boost/variant.hpp> #include <boost/variant.hpp>
#include <boost/any.hpp>
#include <string> #include <string>
#include <vector> #include <vector>
#include <deque> #include <deque>
#include <map>
#define PORTABLE_STORAGE_SIGNATUREA 0x01011101 #define PORTABLE_STORAGE_SIGNATUREA 0x01011101
#define PORTABLE_STORAGE_SIGNATUREB 0x01020101 // bender's nightmare #define PORTABLE_STORAGE_SIGNATUREB 0x01020101 // bender's nightmare

1
contrib/epee/include/storages/portable_storage_from_json.h
View File

@ -26,6 +26,7 @@
#pragma once #pragma once
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <boost/utility/string_ref.hpp>
#include <boost/algorithm/string/predicate.hpp> #include <boost/algorithm/string/predicate.hpp>
#include "parserse_base_utils.h" #include "parserse_base_utils.h"
#include "file_io_utils.h" #include "file_io_utils.h"

1
contrib/epee/include/storages/portable_storage_template_helper.h
View File

@ -32,6 +32,7 @@
#include "parserse_base_utils.h" #include "parserse_base_utils.h"
#include "portable_storage.h" #include "portable_storage.h"
#include "file_io_utils.h" #include "file_io_utils.h"
#include "span.h"
namespace epee namespace epee
{ {

1
contrib/epee/include/storages/portable_storage_to_bin.h
View File

@ -32,6 +32,7 @@
#include "misc_language.h" #include "misc_language.h"
#include "portable_storage_base.h" #include "portable_storage_base.h"
#include "portable_storage_bin_utils.h" #include "portable_storage_bin_utils.h"
#include "misc_log_ex.h"
namespace epee namespace epee
{ {

7
contrib/epee/include/storages/portable_storage_val_converters.h
View File

@ -28,12 +28,17 @@
#pragma once #pragma once
#include <time.h>
#include <boost/regex.hpp> #include <boost/regex.hpp>
#include "misc_language.h" #include "misc_language.h"
#include "portable_storage_base.h" #include "portable_storage_base.h"
#include "parserse_base_utils.h"
#include "warnings.h" #include "warnings.h"
#include "misc_log_ex.h"
#include <boost/lexical_cast.hpp>
#include <typeinfo>
#include <iomanip>
namespace epee namespace epee
{ {

7
contrib/epee/src/CMakeLists.txt
View File

@ -29,7 +29,9 @@
add_library(epee STATIC byte_slice.cpp byte_stream.cpp hex.cpp abstract_http_client.cpp http_auth.cpp mlog.cpp net_helper.cpp net_utils_base.cpp string_tools.cpp add_library(epee STATIC byte_slice.cpp byte_stream.cpp hex.cpp abstract_http_client.cpp http_auth.cpp mlog.cpp net_helper.cpp net_utils_base.cpp string_tools.cpp
wipeable_string.cpp levin_base.cpp memwipe.c connection_basic.cpp network_throttle.cpp network_throttle-detail.cpp mlocker.cpp buffer.cpp net_ssl.cpp wipeable_string.cpp levin_base.cpp memwipe.c connection_basic.cpp network_throttle.cpp network_throttle-detail.cpp mlocker.cpp buffer.cpp net_ssl.cpp
int-util.cpp portable_storage.cpp) int-util.cpp portable_storage.cpp
misc_language.cpp
)
if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW))) if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
add_library(epee_readline STATIC readline_buffer.cpp) add_library(epee_readline STATIC readline_buffer.cpp)
@ -71,3 +73,6 @@ if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
PRIVATE PRIVATE
${GNU_READLINE_LIBRARY}) ${GNU_READLINE_LIBRARY})
endif() endif()
target_include_directories(epee PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../include")

44
contrib/epee/src/misc_language.cpp Normal file
View File

@ -0,0 +1,44 @@
// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the Andrey N. Sabelnikov nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include "misc_language.h"
#include <boost/thread.hpp>
namespace epee
{
namespace misc_utils
{
bool sleep_no_w(long ms )
{
boost::this_thread::sleep(
boost::get_system_time() +
boost::posix_time::milliseconds( std::max<long>(ms,0) ) );
return true;
}
}
}

215
contrib/epee/src/portable_storage.cpp
View File

@ -1,10 +1,43 @@
// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the Andrey N. Sabelnikov nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include "byte_slice.h" #include "byte_slice.h"
#include "byte_stream.h" #include "byte_stream.h"
#include "misc_log_ex.h" #include "misc_log_ex.h"
#include "span.h" #include "span.h"
#include "storages/portable_storage.h" #include "storages/portable_storage.h"
#include "storages/portable_storage_to_json.h"
#include "storages/portable_storage_from_json.h"
#include "storages/portable_storage_to_bin.h" #include "storages/portable_storage_to_bin.h"
#include "storages/portable_storage_from_bin.h"
#include <boost/utility/string_ref.hpp>
#include <string>
#include <sstream>
namespace epee namespace epee
{ {
@ -25,5 +58,187 @@ namespace serialization
return true; return true;
CATCH_ENTRY("portable_storage::store_to_binary", false) CATCH_ENTRY("portable_storage::store_to_binary", false)
} }
bool portable_storage::dump_as_json(std::string& buff, size_t indent, bool insert_newlines)
{
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)
}
bool portable_storage::load_from_json(const std::string& source)
{
TRY_ENTRY();
return json::load_from_json(source, *this);
CATCH_ENTRY("portable_storage::load_from_json", false)
}
bool portable_storage::load_from_binary(const std::string& target, const limits_t *limits)
{
return load_from_binary(epee::strspan<uint8_t>(target), limits);
}
bool portable_storage::load_from_binary(const epee::span<const uint8_t> source, const limits_t *limits)
{
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));
if (limits)
buf_reader.set_limits(limits->n_objects, limits->n_fields, limits->n_strings);
buf_reader.read(m_root);
return true;//TODO:
CATCH_ENTRY("portable_storage::load_from_binary", false);
}
hsection portable_storage::open_section(const std::string& section_name, hsection hparent_section, bool create_if_notexist)
{
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);
}
bool portable_storage::get_value(const std::string& value_name, storage_entry& val, hsection hparent_section)
{
//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);
}
storage_entry* portable_storage::find_storage_entry(const std::string& pentry_name, hsection psection)
{
TRY_ENTRY();
CHECK_AND_ASSERT(psection, nullptr);
auto it = psection->m_entries.find(pentry_name);
if(it == psection->m_entries.end())
return nullptr;
return &it->second;
CATCH_ENTRY("portable_storage::find_storage_entry", nullptr);
}
hsection portable_storage::insert_new_section(const std::string& pentry_name, hsection psection)
{
TRY_ENTRY();
storage_entry* pse = insert_new_entry_get_storage_entry(pentry_name, psection, section());
if(!pse) return nullptr;
return &boost::get<section>(*pse);
CATCH_ENTRY("portable_storage::insert_new_section", nullptr);
}
harray portable_storage::get_first_section(const std::string& sec_name, hsection& h_child_section, hsection hparent_section)
{
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);
}
bool portable_storage::get_next_section(harray hsec_array, hsection& h_child_section)
{
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);
}
harray portable_storage::insert_first_section(const std::string& sec_name, hsection& hinserted_childsection, hsection hparent_section)
{
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);
}
bool portable_storage::insert_next_section(harray hsec_array, hsection& hinserted_childsection)
{
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);
}
} }
} }

2
src/wallet/node_rpc_proxy.cpp
View File

@ -32,6 +32,8 @@
#include "rpc/rpc_payment_costs.h" #include "rpc/rpc_payment_costs.h"
#include "storages/http_abstract_invoke.h" #include "storages/http_abstract_invoke.h"
#include <boost/thread.hpp>
#define RETURN_ON_RPC_RESPONSE_ERROR(r, error, res, method) \ #define RETURN_ON_RPC_RESPONSE_ERROR(r, error, res, method) \
do { \ do { \
CHECK_AND_ASSERT_MES(error.code == 0, error.message, error.message); \ CHECK_AND_ASSERT_MES(error.code == 0, error.message, error.message); \

1
src/wallet/node_rpc_proxy.h
View File

@ -30,6 +30,7 @@
#include <string> #include <string>
#include <boost/thread/mutex.hpp> #include <boost/thread/mutex.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include "include_base_utils.h" #include "include_base_utils.h"
#include "net/abstract_http_client.h" #include "net/abstract_http_client.h"
#include "rpc/core_rpc_server_commands_defs.h" #include "rpc/core_rpc_server_commands_defs.h"

1
tests/unit_tests/epee_serialization.cpp
View File

@ -30,6 +30,7 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "storages/portable_storage.h" #include "storages/portable_storage.h"
#include "span.h"
TEST(epee_binary, two_keys) TEST(epee_binary, two_keys)
{ {