steem_chain/steem_objects.cpp at master · Unhackables/steem_chain · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include <steemit/chain/steem_objects.hpp>
#include <steemit/chain/database.hpp>
#include <steemit/chain/hardfork.hpp>

#include <fc/uint128.hpp>

namespace steemit { namespace chain {

/*set< string > account_member_index::get_account_members( const account_object& a ) const
{
   set< string > result;
   for( auto auth : a.owner.account_auths )
      result.insert( auth.first );
   for( auto auth : a.active.account_auths )
      result.insert( auth.first );
   for( auto auth : a.posting.account_auths )
      result.insert( auth.first );
   return result;
}

set< public_key_type > account_member_index::get_key_members( const account_object& a ) const
{
   set< public_key_type > result;
   for( auto auth : a.owner.key_auths )
      result.insert( auth.first );
   for( auto auth : a.active.key_auths )
      result.insert( auth.first );
   for( auto auth : a.posting.key_auths )
      result.insert( auth.first );
   result.insert( a.memo_key );
   return result;
}

void account_member_index::object_inserted( const object& obj )
{
    assert( dynamic_cast< const account_object* >( &obj ) ); // for debug only
    const account_object& a = static_cast< const account_object& >( obj );

    auto account_members = get_account_members( a );
    for( auto item : account_members )
       account_to_account_memberships[item].insert( a.name );

    auto key_members = get_key_members( a );
    for( auto item : key_members )
       account_to_key_memberships[item].insert( a.name );

}

void account_member_index::object_removed( const object& obj )
{
    assert( dynamic_cast<const account_object*>( &obj ) ); // for debug only
    const account_object& a = static_cast< const account_object& >( obj );

    auto key_members = get_key_members( a );
    for( auto item : key_members )
       account_to_key_memberships[item].erase( a.name );


    auto account_members = get_account_members( a );
    for( auto item : account_members )
       account_to_account_memberships[item].erase( a.name );
}

void account_member_index::about_to_modify( const object& before )
{
   before_key_members.clear();
   before_account_members.clear();
   assert( dynamic_cast< const account_object* >( &before ) ); // for debug only
   const account_object& a = static_cast< const account_object& >( before );
   before_key_members     = get_key_members( a );
   before_account_members = get_account_members( a );
}

void account_member_index::object_modified( const object& after )
{
    assert( dynamic_cast< const account_object* >( &after ) ); // for debug only
    const account_object& a = static_cast< const account_object& >( after );

    {
       set< string > after_account_members = get_account_members( a );
       vector< string > removed;
       removed.reserve( before_account_members.size() );
       std::set_difference( before_account_members.begin(), before_account_members.end(),
                            after_account_members.begin(), after_account_members.end(),
                            std::inserter(removed, removed.end() ) );

       for( auto itr = removed.begin(); itr != removed.end(); ++itr )
          account_to_account_memberships[*itr].erase( a.name );

       vector<string> added;
       added.reserve( after_account_members.size() );
       std::set_difference( after_account_members.begin(), after_account_members.end(),
                            before_account_members.begin(), before_account_members.end(),
                            std::inserter(added, added.end() ) );

       for( auto itr = added.begin(); itr != added.end(); ++itr )
          account_to_account_memberships[*itr].insert( a.name );
    }


    {
       set<public_key_type> after_key_members = get_key_members( a );

       vector<public_key_type> removed;
       removed.reserve( before_key_members.size() );
       std::set_difference( before_key_members.begin(), before_key_members.end(),
                            after_key_members.begin(), after_key_members.end(),
                            std::inserter(removed, removed.end() ) );

       for( auto itr = removed.begin(); itr != removed.end(); ++itr )
          account_to_key_memberships[*itr].erase( a.name );

       vector<public_key_type> added;
       added.reserve(after_key_members.size());
       std::set_difference( after_key_members.begin(), after_key_members.end(),
                            before_key_members.begin(), before_key_members.end(),
                            std::inserter(added, added.end() ) );

       for( auto itr = added.begin(); itr != added.end(); ++itr )
          account_to_key_memberships[*itr].insert( a.name );
    }
}*/

} } // steemit::chain