Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

Merge branch 'check_reflection' into develop #562

Browse source
This commit is contained in:
theoreticalbts 2016-02-09 11:00:24 -05:00
commit 2eaa1b553b
3 changed files with 355 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
programs/build_helpers/CMakeLists.txt
View file

@ -6,3 +6,12 @@ endif()
# we only actually need Boost, but link against FC for now so we don't duplicate it.
target_link_libraries( cat-parts PRIVATE fc ${CMAKE_DL_LIBS} ${PLATFORM_SPECIFIC_LIBS} )
add_executable( member_enumerator member_enumerator.cpp )
if( UNIX AND NOT APPLE )
set(rt_library rt )
endif()
# we only actually need Boost, but link against FC for now so we don't duplicate it.
target_link_libraries( member_enumerator PRIVATE fc graphene_app graphene_net graphene_chain graphene_egenesis_brief graphene_utilities graphene_wallet ${CMAKE_DL_LIBS} ${PLATFORM_SPECIFIC_LIBS} )

132
programs/build_helpers/check_reflect.py Executable file
View file

@ -0,0 +1,132 @@
#!/usr/bin/env python3
import json
import os
import re
import xml.etree.ElementTree as etree
def process_node(path, node):
"""
if node.tag == "TestCase":
if node.attrib.get("result", "UNKNOWN") != "passed":
failset.add(node)
return
if node.tag in ["TestResult", "TestSuite"]:
for child in node:
cpath = path+"/"+child.attrib["name"]
process_node(cpath, child)
return
"""
#print("unknown node", node.tag)
print(node.tag)
return
name2members_doxygen = {}
def process_class_node(node):
result = {"name":"", "vmembers":[]}
for child in node:
if child.tag == "name":
result["name"] = child.text
elif child.tag == "member":
kind = child.attrib.get("kind")
if kind == "variable":
result["vmembers"].append(child[0].text)
name2members_doxygen[result["name"]] = result["vmembers"]
return
tree = etree.parse("doxygen/xml/index.xml")
root = tree.getroot()
for child in root:
if (child.tag == "compound") and (child.attrib.get("kind") in ["struct", "class"]):
process_class_node(child)
s_static_names = set(["space_id", "type_id"])
for k, v in name2members_doxygen.items():
name2members_doxygen[k] = [x for x in v if x not in s_static_names]
#with open("stuff/member_enumerator.out", "r") as f:
# name2members_fc = json.load(f)
# scan for FC_REFLECT( graphene::... in all cpp,hpp files under libraries/ programs/ tests/
re_reflect = re.compile(r"""
FC_REFLECT\s*[(]
\s*(graphene::[a-zA-Z0-9_:]+)
\s*,
((?:\s*[(]\s*[a-zA-Z0-9_]+\s*[)])*)
""", re.VERBOSE)
re_reflect_derived = re.compile(r"""
FC_REFLECT_DERIVED\s*[(]
\s*(graphene::[a-zA-Z0-9_:]+)
\s*,
\s*[(]\s*(graphene::[a-zA-Z0-9_:]+)\s*[)]
\s*,
((?:\s*[(]\s*[a-zA-Z0-9_]+\s*[)])*)
""", re.VERBOSE)
re_bubble_item = re.compile(r"\s*[(]\s*([a-zA-Z0-9_]+)\s*")
def bubble_list(x):
return [re_bubble_item.match(e).group(1) for e in x.split(")")[:-1]]
name2members_re = {}
for root, dirs, files in os.walk("."):
if root == ".":
dirs[:] = ["libraries", "programs", "tests"]
for filename in files:
if not (filename.endswith(".cpp") or filename.endswith(".hpp")):
continue
try:
with open( os.path.join(root, filename), "r" ) as f:
content = f.read()
for m in re_reflect.finditer(content):
cname = m.group(1)
members = bubble_list(m.group(2))
name2members_re[cname] = members
for m in re_reflect_derived.finditer(content):
cname = m.group(1)
members = bubble_list(m.group(3))
name2members_re[cname] = members
except OSError as e:
pass
def validate_members(name2members_ref, name2members_test):
ok_items = []
ne_items = []
error_items = []
for name in sorted(name2members_ref.keys()):
if name not in name2members_test:
ne_items.append(name)
elif sorted(name2members_ref[name]) != sorted(name2members_test[name]):
error_items.append(name)
print("")
print("error in", name)
print("doxygen:", name2members_ref[name])
print("fc :", name2members_test[name])
else:
ok_items.append(name)
return
"""
print("")
print("ok:")
for item in ok_items:
print(item)
print("")
print("not evaluated:")
for item in ne_items:
print(item)
print("")
print("error:")
for item in error_items:
print(item)
"""
validate_members(name2members_doxygen, name2members_re)

214
programs/build_helpers/member_enumerator.cpp Normal file
View file

@ -0,0 +1,214 @@
/*
* Copyright (c) 2015 Cryptonomex, Inc., and contributors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Any modified source or binaries are used only with the BitShares network.
*
* 2. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 3. 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.
*
* 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 HOLDER OR
* CONTRIBUTORS 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 <graphene/chain/protocol/protocol.hpp>
#include <graphene/chain/protocol/fee_schedule.hpp>
#include <graphene/chain/vesting_balance_object.hpp>
#include <graphene/chain/withdraw_permission_object.hpp>
#include <graphene/chain/proposal_object.hpp>
#include <graphene/chain/witness_object.hpp>
#include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/account_object.hpp>
#include <graphene/chain/balance_object.hpp>
#include <graphene/chain/committee_member_object.hpp>
#include <fc/smart_ref_impl.hpp>
#include <iostream>
using namespace graphene::chain;
namespace graphene { namespace member_enumerator {
struct class_processor
{
class_processor( std::map< std::string, std::vector< std::string > >& r ) : result(r) {}
template< typename T >
void process_class( const T* dummy );
template< typename... T >
void process_class( const static_variant< T... >* dummy );
template< typename T >
void process_class( const std::vector< T >* dummy );
template< typename K, typename V >
void process_class( const std::map< K, V >* dummy );
template< typename T >
void process_class( const fc::flat_set< T >* dummy );
template< typename K, typename V >
void process_class( const fc::flat_map< K, V >* dummy );
template< typename T >
void process_class( const fc::optional< T >* dummy );
template< typename T >
static void process_class( std::map< std::string, std::vector< std::string > >& result );
std::map< std::string, std::vector< std::string > >& result;
};
template< typename T >
struct member_visitor
{
member_visitor( class_processor* p ) : proc(p) {}
template<typename Member, class Class, Member (Class::*member)>
void operator()( const char* name )const
{
members.emplace_back( name );
proc->process_class( (const Member*) nullptr );
}
class_processor* proc;
mutable std::vector< std::string > members;
};
struct static_variant_visitor
{
static_variant_visitor( class_processor* p ) : proc(p) {}
typedef void result_type;
template<typename T>
void operator()( const T& element )const
{
proc->process_class( (const T*) nullptr );
}
class_processor* proc;
};
template< typename... T >
void class_processor::process_class( const static_variant< T... >* dummy )
{
static_variant<T...> dummy2;
static_variant_visitor vtor( this );
for( int w=0; w<dummy2.count(); w++ )
{
dummy2.set_which(w);
dummy2.visit( vtor );
}
}
template<typename IsReflected=fc::false_type>
struct if_reflected
{
template< typename T >
static void process_class( class_processor* proc, const T* dummy )
{
std::string tname = fc::get_typename<T>::name();
std::cerr << "skipping non-reflected class " << tname << std::endl;
}
};
template<>
struct if_reflected<fc::true_type>
{
template< typename T >
static void process_class( class_processor* proc, const T* dummy )
{
std::string tname = fc::get_typename<T>::name();
if( proc->result.find( tname ) != proc->result.end() )
return;
ilog( "processing class ${c}", ("c", tname) );
// need this to keep from recursing on same class
proc->result.emplace( tname, std::vector< std::string >() );
member_visitor<T> vtor( proc );
fc::reflector<T>::visit( vtor );
ilog( "members of class ${c} are ${m}", ("c", tname)("m", vtor.members) );
proc->result[tname] = vtor.members;
}
};
template< typename T >
void class_processor::process_class( const T* dummy )
{
if_reflected< typename fc::reflector<T>::is_defined >::process_class( this, dummy );
}
template< typename T >
void class_processor::process_class( const std::vector< T >* dummy )
{
process_class( (T*) nullptr );
}
template< typename K, typename V >
void class_processor::process_class( const std::map< K, V >* dummy )
{
process_class( (K*) nullptr );
process_class( (V*) nullptr );
}
template< typename T >
void class_processor::process_class( const fc::flat_set< T >* dummy )
{
process_class( (T*) nullptr );
}
template< typename K, typename V >
void class_processor::process_class( const fc::flat_map< K, V >* dummy )
{
process_class( (K*) nullptr );
process_class( (V*) nullptr );
}
template< typename T >
void class_processor::process_class( const fc::optional< T >* dummy )
{
process_class( (T*) nullptr );
}
template< typename T >
void class_processor::process_class( std::map< std::string, std::vector< std::string > >& result )
{
class_processor proc(result);
proc.process_class( (T*) nullptr );
}
} }
int main( int argc, char** argv )
{
try
{
std::map< std::string, std::vector< std::string > > result;
graphene::member_enumerator::class_processor::process_class<signed_block>(result);
//graphene::member_enumerator::process_class<transfer_operation>(result);
fc::mutable_variant_object mvo;
for( const std::pair< std::string, std::vector< std::string > >& e : result )
{
variant v;
to_variant( e.second, v );
mvo.set( e.first, v );
}
std::cout << fc::json::to_string( mvo ) << std::endl;
}
catch ( const fc::exception& e )
{
edump((e.to_detail_string()));
}
return 0;
}