From cc0b26cd92368de58ef272356057286e1031aad2 Mon Sep 17 00:00:00 2001 From: serkixenos Date: Mon, 28 Feb 2022 12:39:09 -0400 Subject: [PATCH] Code formatting --- .../chain/betting_market_group_object.cpp | 60 +- libraries/chain/betting_market_object.cpp | 48 +- libraries/chain/event_object.cpp | 1017 ++++++++--------- libraries/chain/game_object.cpp | 58 +- .../graphene/chain/betting_market_object.hpp | 192 ++-- .../include/graphene/chain/event_object.hpp | 316 ++--- .../include/graphene/chain/game_object.hpp | 98 +- .../include/graphene/chain/match_object.hpp | 98 +- .../graphene/chain/tournament_object.hpp | 98 +- libraries/chain/match_object.cpp | 32 +- libraries/chain/tournament_object.cpp | 65 +- 11 files changed, 1041 insertions(+), 1041 deletions(-) diff --git a/libraries/chain/betting_market_group_object.cpp b/libraries/chain/betting_market_group_object.cpp index 14c65626..778c756e 100644 --- a/libraries/chain/betting_market_group_object.cpp +++ b/libraries/chain/betting_market_group_object.cpp @@ -542,37 +542,37 @@ void betting_market_group_object::dispatch_new_status(database& db, betting_mark } } // graphene::chain namespace fc { -// Manually reflect betting_market_group_object to variant to properly reflect "state" -void to_variant(const graphene::chain::betting_market_group_object& betting_market_group_obj, fc::variant& v, uint32_t max_depth) -{ - fc::mutable_variant_object o; - o("id", fc::variant(betting_market_group_obj.id, max_depth)) - ("description", fc::variant(betting_market_group_obj.description, max_depth)) - ("event_id", fc::variant(betting_market_group_obj.event_id, max_depth)) - ("rules_id", fc::variant(betting_market_group_obj.rules_id, max_depth)) - ("asset_id", fc::variant(betting_market_group_obj.asset_id, max_depth)) - ("total_matched_bets_amount", fc::variant(betting_market_group_obj.total_matched_bets_amount, max_depth)) - ("never_in_play", fc::variant(betting_market_group_obj.never_in_play, max_depth)) - ("delay_before_settling", fc::variant(betting_market_group_obj.delay_before_settling, max_depth)) - ("settling_time", fc::variant(betting_market_group_obj.settling_time, max_depth)) - ("status", fc::variant(betting_market_group_obj.get_status(), max_depth)); + // Manually reflect betting_market_group_object to variant to properly reflect "state" + void to_variant(const graphene::chain::betting_market_group_object& betting_market_group_obj, fc::variant& v, uint32_t max_depth) + { + fc::mutable_variant_object o; + o("id", fc::variant(betting_market_group_obj.id, max_depth)) + ("description", fc::variant(betting_market_group_obj.description, max_depth)) + ("event_id", fc::variant(betting_market_group_obj.event_id, max_depth)) + ("rules_id", fc::variant(betting_market_group_obj.rules_id, max_depth)) + ("asset_id", fc::variant(betting_market_group_obj.asset_id, max_depth)) + ("total_matched_bets_amount", fc::variant(betting_market_group_obj.total_matched_bets_amount, max_depth)) + ("never_in_play", fc::variant(betting_market_group_obj.never_in_play, max_depth)) + ("delay_before_settling", fc::variant(betting_market_group_obj.delay_before_settling, max_depth)) + ("settling_time", fc::variant(betting_market_group_obj.settling_time, max_depth)) + ("status", fc::variant(betting_market_group_obj.get_status(), max_depth)); - v = o; -} + v = o; + } -// Manually reflect betting_market_group_object to variant to properly reflect "state" -void from_variant(const fc::variant& v, graphene::chain::betting_market_group_object& betting_market_group_obj, uint32_t max_depth) -{ - betting_market_group_obj.id = v["id"].as( max_depth ); - betting_market_group_obj.description = v["description"].as( max_depth ); - betting_market_group_obj.event_id = v["event_id"].as( max_depth ); - betting_market_group_obj.asset_id = v["asset_id"].as( max_depth ); - betting_market_group_obj.total_matched_bets_amount = v["total_matched_bets_amount"].as( max_depth ); - betting_market_group_obj.never_in_play = v["never_in_play"].as( max_depth ); - betting_market_group_obj.delay_before_settling = v["delay_before_settling"].as( max_depth ); - betting_market_group_obj.settling_time = v["settling_time"].as>( max_depth ); - graphene::chain::betting_market_group_status status = v["status"].as( max_depth ); - const_cast(betting_market_group_obj.my->state_machine.current_state())[0] = (int)status; -} + // Manually reflect betting_market_group_object to variant to properly reflect "state" + void from_variant(const fc::variant& v, graphene::chain::betting_market_group_object& betting_market_group_obj, uint32_t max_depth) + { + betting_market_group_obj.id = v["id"].as( max_depth ); + betting_market_group_obj.description = v["description"].as( max_depth ); + betting_market_group_obj.event_id = v["event_id"].as( max_depth ); + betting_market_group_obj.asset_id = v["asset_id"].as( max_depth ); + betting_market_group_obj.total_matched_bets_amount = v["total_matched_bets_amount"].as( max_depth ); + betting_market_group_obj.never_in_play = v["never_in_play"].as( max_depth ); + betting_market_group_obj.delay_before_settling = v["delay_before_settling"].as( max_depth ); + betting_market_group_obj.settling_time = v["settling_time"].as>( max_depth ); + graphene::chain::betting_market_group_status status = v["status"].as( max_depth ); + const_cast(betting_market_group_obj.my->state_machine.current_state())[0] = (int)status; + } } //end namespace fc diff --git a/libraries/chain/betting_market_object.cpp b/libraries/chain/betting_market_object.cpp index 62ed883a..bd940862 100644 --- a/libraries/chain/betting_market_object.cpp +++ b/libraries/chain/betting_market_object.cpp @@ -467,29 +467,29 @@ void betting_market_object::on_canceled_event(database& db) } } // graphene::chain namespace fc { -// Manually reflect betting_market_object to variant to properly reflect "state" -void to_variant(const graphene::chain::betting_market_object& event_obj, fc::variant& v, uint32_t max_depth) -{ - fc::mutable_variant_object o; - o("id", fc::variant(event_obj.id, max_depth) ) - ("group_id", fc::variant(event_obj.group_id, max_depth)) - ("description", fc::variant(event_obj.description, max_depth)) - ("payout_condition", fc::variant(event_obj.payout_condition, max_depth)) - ("resolution", fc::variant(event_obj.resolution, max_depth)) - ("status", fc::variant(event_obj.get_status(), max_depth)); + // Manually reflect betting_market_object to variant to properly reflect "state" + void to_variant(const graphene::chain::betting_market_object& event_obj, fc::variant& v, uint32_t max_depth) + { + fc::mutable_variant_object o; + o("id", fc::variant(event_obj.id, max_depth) ) + ("group_id", fc::variant(event_obj.group_id, max_depth)) + ("description", fc::variant(event_obj.description, max_depth)) + ("payout_condition", fc::variant(event_obj.payout_condition, max_depth)) + ("resolution", fc::variant(event_obj.resolution, max_depth)) + ("status", fc::variant(event_obj.get_status(), max_depth)); - v = o; -} + v = o; + } -// Manually reflect betting_market_object to variant to properly reflect "state" -void from_variant(const fc::variant& v, graphene::chain::betting_market_object& event_obj, uint32_t max_depth) -{ - event_obj.id = v["id"].as( max_depth ); - event_obj.group_id = v["name"].as( max_depth ); - event_obj.description = v["description"].as( max_depth ); - event_obj.payout_condition = v["payout_condition"].as( max_depth ); - event_obj.resolution = v["resolution"].as>( max_depth ); - graphene::chain::betting_market_status status = v["status"].as( max_depth ); - const_cast(event_obj.my->state_machine.current_state())[0] = (int)status; -} -} //end namespace fc \ No newline at end of file + // Manually reflect betting_market_object to variant to properly reflect "state" + void from_variant(const fc::variant& v, graphene::chain::betting_market_object& event_obj, uint32_t max_depth) + { + event_obj.id = v["id"].as( max_depth ); + event_obj.group_id = v["name"].as( max_depth ); + event_obj.description = v["description"].as( max_depth ); + event_obj.payout_condition = v["payout_condition"].as( max_depth ); + event_obj.resolution = v["resolution"].as>( max_depth ); + graphene::chain::betting_market_status status = v["status"].as( max_depth ); + const_cast(event_obj.my->state_machine.current_state())[0] = (int)status; + } +} //end namespace fc diff --git a/libraries/chain/event_object.cpp b/libraries/chain/event_object.cpp index b46d1e7b..2040ad4b 100644 --- a/libraries/chain/event_object.cpp +++ b/libraries/chain/event_object.cpp @@ -1,26 +1,26 @@ /* -* Copyright (c) 2018 Peerplays Blockchain Standards Association, and contributors. -* -* The MIT License -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -*/ + * Copyright (c) 2018 Peerplays Blockchain Standards Association, and contributors. + * + * The MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ #define DEFAULT_LOGGER "betting" #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS @@ -36,549 +36,548 @@ #include namespace graphene { namespace chain { -enum class event_state { - upcoming, - frozen_upcoming, - in_progress, - frozen_in_progress, - finished, - canceled, - settled -}; + enum class event_state { + upcoming, + frozen_upcoming, + in_progress, + frozen_in_progress, + finished, + canceled, + settled + }; } } FC_REFLECT_ENUM(graphene::chain::event_state, - (upcoming) - (frozen_upcoming) - (in_progress) - (frozen_in_progress) - (finished) - (canceled) - (settled)) + (upcoming) + (frozen_upcoming) + (in_progress) + (frozen_in_progress) + (finished) + (canceled) + (settled)) namespace graphene { namespace chain { -namespace msm = boost::msm; -namespace mpl = boost::mpl; + namespace msm = boost::msm; + namespace mpl = boost::mpl; -namespace -{ + namespace + { -// Events -- most events happen when the witnesses publish an event_update operation with a new -// status, so if they publish an event with the status set to `frozen`, we'll generate a `frozen_event` -struct upcoming_event -{ - database& db; - upcoming_event(database& db) : db(db) {} -}; -struct in_progress_event -{ - database& db; - in_progress_event(database& db) : db(db) {} -}; -struct frozen_event -{ - database& db; - frozen_event(database& db) : db(db) {} -}; -struct finished_event -{ - database& db; - finished_event(database& db) : db(db) {} -}; -struct canceled_event -{ - database& db; - canceled_event(database& db) : db(db) {} -}; + // Events -- most events happen when the witnesses publish an event_update operation with a new + // status, so if they publish an event with the status set to `frozen`, we'll generate a `frozen_event` + struct upcoming_event + { + database& db; + upcoming_event(database& db) : db(db) {} + }; + struct in_progress_event + { + database& db; + in_progress_event(database& db) : db(db) {} + }; + struct frozen_event + { + database& db; + frozen_event(database& db) : db(db) {} + }; + struct finished_event + { + database& db; + finished_event(database& db) : db(db) {} + }; + struct canceled_event + { + database& db; + canceled_event(database& db) : db(db) {} + }; -// event triggered when a betting market group in this event is resolved, -// when we get this, check and see if all betting market groups are now -// canceled/settled; if so, transition the event to canceled/settled, -// otherwise remain in the current state -struct betting_market_group_resolved_event -{ - database& db; - betting_market_group_id_type resolved_group; - bool was_canceled; - betting_market_group_resolved_event(database& db, betting_market_group_id_type resolved_group, bool was_canceled) : db(db), resolved_group(resolved_group), was_canceled(was_canceled) {} -}; + // event triggered when a betting market group in this event is resolved, + // when we get this, check and see if all betting market groups are now + // canceled/settled; if so, transition the event to canceled/settled, + // otherwise remain in the current state + struct betting_market_group_resolved_event + { + database& db; + betting_market_group_id_type resolved_group; + bool was_canceled; + betting_market_group_resolved_event(database& db, betting_market_group_id_type resolved_group, bool was_canceled) : db(db), resolved_group(resolved_group), was_canceled(was_canceled) {} + }; -// event triggered when a betting market group is closed. When we get this, -// if all child betting market groups are closed, transition to finished -struct betting_market_group_closed_event -{ - database& db; - betting_market_group_id_type closed_group; - betting_market_group_closed_event(database& db, betting_market_group_id_type closed_group) : db(db), closed_group(closed_group) {} -}; + // event triggered when a betting market group is closed. When we get this, + // if all child betting market groups are closed, transition to finished + struct betting_market_group_closed_event + { + database& db; + betting_market_group_id_type closed_group; + betting_market_group_closed_event(database& db, betting_market_group_id_type closed_group) : db(db), closed_group(closed_group) {} + }; -// Events -struct event_state_machine_ : public msm::front::state_machine_def + // Events + struct event_state_machine_ : public msm::front::state_machine_def -{ - // disable a few state machine features we don't use for performance - typedef int no_exception_thrown; - typedef int no_message_queue; + { + // disable a few state machine features we don't use for performance + typedef int no_exception_thrown; + typedef int no_message_queue; - // States - struct upcoming : public msm::front::state<> { - void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self - void on_entry(const upcoming_event& event, event_state_machine_& fsm) { - dlog("event ${id} -> upcoming", ("id", fsm.event_obj->id)); - auto& betting_market_group_index = event.db.get_index_type().indices().get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(fsm.event_obj->id))) - try - { - event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { - betting_market_group_obj.on_upcoming_event(event.db); - }); - } - catch (const graphene::chain::no_transition&) - { - // it's possible a betting market group has already been closed or canceled, - // in which case we can't freeze the group. just ignore the exception - } - } - }; - struct in_progress : public msm::front::state<> { - void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self - void on_entry(const in_progress_event& event, event_state_machine_& fsm) { - dlog("event ${id} -> in_progress", ("id", fsm.event_obj->id)); - auto& betting_market_group_index = event.db.get_index_type().indices().get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(fsm.event_obj->id))) - try - { - event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { - betting_market_group_obj.on_in_play_event(event.db); - }); - } - catch (const graphene::chain::no_transition&) - { - // it's possible a betting market group has already been closed or canceled, - // in which case we can't freeze the group. just ignore the exception - } - } - }; - struct frozen_upcoming : public msm::front::state<> { - void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self - template - void on_entry(const Event& event, event_state_machine_& fsm) { - dlog("event ${id} -> frozen_upcoming", ("id", fsm.event_obj->id)); - } - }; - struct frozen_in_progress : public msm::front::state<> { - void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self - template - void on_entry(const Event& event, event_state_machine_& fsm) { - dlog("event ${id} -> frozen_in_progress", ("id", fsm.event_obj->id)); - } - }; - struct finished : public msm::front::state<> { - template - void on_entry(const Event& event, event_state_machine_& fsm) { - dlog("event ${id} -> finished", ("id", fsm.event_obj->id)); - } - }; - struct settled : public msm::front::state<>{ - template - void on_entry(const Event& event, event_state_machine_& fsm) { - dlog("event ${id} -> settled", ("id", fsm.event_obj->id)); - } - }; - struct canceled : public msm::front::state<> { - template - void on_entry(const Event& event, event_state_machine_& fsm) { - dlog("event ${id} -> canceled", ("id", fsm.event_obj->id)); - } - }; + // States + struct upcoming : public msm::front::state<> { + void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self + void on_entry(const upcoming_event& event, event_state_machine_& fsm) { + dlog("event ${id} -> upcoming", ("id", fsm.event_obj->id)); + auto& betting_market_group_index = event.db.get_index_type().indices().get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(fsm.event_obj->id))) + try + { + event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { + betting_market_group_obj.on_upcoming_event(event.db); + }); + } + catch (const graphene::chain::no_transition&) + { + // it's possible a betting market group has already been closed or canceled, + // in which case we can't freeze the group. just ignore the exception + } + } + }; + struct in_progress : public msm::front::state<> { + void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self + void on_entry(const in_progress_event& event, event_state_machine_& fsm) { + dlog("event ${id} -> in_progress", ("id", fsm.event_obj->id)); + auto& betting_market_group_index = event.db.get_index_type().indices().get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(fsm.event_obj->id))) + try + { + event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { + betting_market_group_obj.on_in_play_event(event.db); + }); + } + catch (const graphene::chain::no_transition&) + { + // it's possible a betting market group has already been closed or canceled, + // in which case we can't freeze the group. just ignore the exception + } + } + }; + struct frozen_upcoming : public msm::front::state<> { + void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self + template + void on_entry(const Event& event, event_state_machine_& fsm) { + dlog("event ${id} -> frozen_upcoming", ("id", fsm.event_obj->id)); + } + }; + struct frozen_in_progress : public msm::front::state<> { + void on_entry(const betting_market_group_resolved_event& event, event_state_machine_& fsm) {} // transition to self + template + void on_entry(const Event& event, event_state_machine_& fsm) { + dlog("event ${id} -> frozen_in_progress", ("id", fsm.event_obj->id)); + } + }; + struct finished : public msm::front::state<> { + template + void on_entry(const Event& event, event_state_machine_& fsm) { + dlog("event ${id} -> finished", ("id", fsm.event_obj->id)); + } + }; + struct settled : public msm::front::state<>{ + template + void on_entry(const Event& event, event_state_machine_& fsm) { + dlog("event ${id} -> settled", ("id", fsm.event_obj->id)); + } + }; + struct canceled : public msm::front::state<> { + template + void on_entry(const Event& event, event_state_machine_& fsm) { + dlog("event ${id} -> canceled", ("id", fsm.event_obj->id)); + } + }; - // actions - void record_whether_group_settled_or_canceled(const betting_market_group_resolved_event& event) { - if (!event.was_canceled) - event_obj->at_least_one_betting_market_group_settled = true; - } + // actions + void record_whether_group_settled_or_canceled(const betting_market_group_resolved_event& event) { + if (!event.was_canceled) + event_obj->at_least_one_betting_market_group_settled = true; + } - void freeze_betting_market_groups(const frozen_event& event) { - auto& betting_market_group_index = event.db.get_index_type().indices().get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) - { - try - { - event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { - betting_market_group_obj.on_frozen_event(event.db); - }); - } - catch (const graphene::chain::no_transition&) - { - // it's possible a betting market group has already been closed or canceled, - // in which case we can't freeze the group. just ignore the exception - } - } - } + void freeze_betting_market_groups(const frozen_event& event) { + auto& betting_market_group_index = event.db.get_index_type().indices().get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) + { + try + { + event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { + betting_market_group_obj.on_frozen_event(event.db); + }); + } + catch (const graphene::chain::no_transition&) + { + // it's possible a betting market group has already been closed or canceled, + // in which case we can't freeze the group. just ignore the exception + } + } + } - void close_all_betting_market_groups(const finished_event& event) { - auto& betting_market_group_index = event.db.get_index_type().indices().get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) - { - try - { - event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { - betting_market_group_obj.on_closed_event(event.db, true); - }); - } - catch (const graphene::chain::no_transition&) - { - // it's possible a betting market group has already been closed or canceled, - // in which case we can't close the group. just ignore the exception - } - } - } + void close_all_betting_market_groups(const finished_event& event) { + auto& betting_market_group_index = event.db.get_index_type().indices().get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) + { + try + { + event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { + betting_market_group_obj.on_closed_event(event.db, true); + }); + } + catch (const graphene::chain::no_transition&) + { + // it's possible a betting market group has already been closed or canceled, + // in which case we can't close the group. just ignore the exception + } + } + } - void cancel_all_betting_market_groups(const canceled_event& event) { - auto& betting_market_group_index = event.db.template get_index_type().indices().template get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) - event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { - betting_market_group_obj.on_canceled_event(event.db, true); - }); - } + void cancel_all_betting_market_groups(const canceled_event& event) { + auto& betting_market_group_index = event.db.template get_index_type().indices().template get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) + event.db.modify(betting_market_group, [&event](betting_market_group_object& betting_market_group_obj) { + betting_market_group_obj.on_canceled_event(event.db, true); + }); + } - // Guards - bool all_betting_market_groups_are_closed(const betting_market_group_closed_event& event) - { - auto& betting_market_group_index = event.db.get_index_type().indices().get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) - if (betting_market_group.id != event.closed_group) - { - betting_market_group_status status = betting_market_group.get_status(); - if (status != betting_market_group_status::closed && - status != betting_market_group_status::graded && - status != betting_market_group_status::re_grading && - status != betting_market_group_status::settled && - status != betting_market_group_status::canceled) - return false; - } - return true; - } + // Guards + bool all_betting_market_groups_are_closed(const betting_market_group_closed_event& event) + { + auto& betting_market_group_index = event.db.get_index_type().indices().get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) + if (betting_market_group.id != event.closed_group) + { + betting_market_group_status status = betting_market_group.get_status(); + if (status != betting_market_group_status::closed && + status != betting_market_group_status::graded && + status != betting_market_group_status::re_grading && + status != betting_market_group_status::settled && + status != betting_market_group_status::canceled) + return false; + } + return true; + } - bool all_betting_market_groups_are_canceled(const betting_market_group_resolved_event& event) - { - // if the bmg that just resolved was settled, obviously all didn't cancel - if (!event.was_canceled) - return false; - // if a previously-resolved group was settled, all didn't cancel - if (event_obj->at_least_one_betting_market_group_settled) - return false; - auto& betting_market_group_index = event.db.get_index_type().indices().get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) - if (betting_market_group.id != event.resolved_group) - if (betting_market_group.get_status() != betting_market_group_status::canceled) - return false; - return true; - } + bool all_betting_market_groups_are_canceled(const betting_market_group_resolved_event& event) + { + // if the bmg that just resolved was settled, obviously all didn't cancel + if (!event.was_canceled) + return false; + // if a previously-resolved group was settled, all didn't cancel + if (event_obj->at_least_one_betting_market_group_settled) + return false; + auto& betting_market_group_index = event.db.get_index_type().indices().get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) + if (betting_market_group.id != event.resolved_group) + if (betting_market_group.get_status() != betting_market_group_status::canceled) + return false; + return true; + } - bool all_betting_market_groups_are_resolved(const betting_market_group_resolved_event& event) - { - if (!event.was_canceled) - event_obj->at_least_one_betting_market_group_settled = true; + bool all_betting_market_groups_are_resolved(const betting_market_group_resolved_event& event) + { + if (!event.was_canceled) + event_obj->at_least_one_betting_market_group_settled = true; - auto& betting_market_group_index = event.db.get_index_type().indices().get(); - for (const betting_market_group_object& betting_market_group : - boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) { - if (betting_market_group.id != event.resolved_group) { - betting_market_group_status status = betting_market_group.get_status(); - if (status != betting_market_group_status::canceled && status != betting_market_group_status::settled) - return false; - } - } - return true; - } + auto& betting_market_group_index = event.db.get_index_type().indices().get(); + for (const betting_market_group_object& betting_market_group : + boost::make_iterator_range(betting_market_group_index.equal_range(event_obj->id))) { + if (betting_market_group.id != event.resolved_group) { + betting_market_group_status status = betting_market_group.get_status(); + if (status != betting_market_group_status::canceled && status != betting_market_group_status::settled) + return false; + } + } + return true; + } - typedef upcoming initial_state; - typedef event_state_machine_ x; // makes transition table cleaner + typedef upcoming initial_state; + typedef event_state_machine_ x; // makes transition table cleaner - // Transition table for tournament - struct transition_table : mpl::vector< - // Start Event Next Action Guard - // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ - _row < upcoming, in_progress_event, in_progress >, - a_row< upcoming, finished_event, finished, &x::close_all_betting_market_groups >, - a_row< upcoming, frozen_event, frozen_upcoming, &x::freeze_betting_market_groups >, - a_row< upcoming, canceled_event, canceled, &x::cancel_all_betting_market_groups >, - a_row< upcoming, betting_market_group_resolved_event,upcoming, &x::record_whether_group_settled_or_canceled >, - g_row< upcoming, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, - // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ - _row < frozen_upcoming, upcoming_event, upcoming >, - _row < frozen_upcoming, in_progress_event, in_progress >, - a_row< frozen_upcoming, finished_event, finished, &x::close_all_betting_market_groups >, - a_row< frozen_upcoming, canceled_event, canceled, &x::cancel_all_betting_market_groups >, - a_row< frozen_upcoming, betting_market_group_resolved_event,frozen_upcoming, &x::record_whether_group_settled_or_canceled >, - g_row< frozen_upcoming, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, - // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ - a_row< in_progress, frozen_event, frozen_in_progress, &x::freeze_betting_market_groups >, - a_row< in_progress, finished_event, finished, &x::close_all_betting_market_groups >, - a_row< in_progress, canceled_event, canceled, &x::cancel_all_betting_market_groups >, - a_row< in_progress, betting_market_group_resolved_event,in_progress, &x::record_whether_group_settled_or_canceled >, - g_row< in_progress, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, - // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ - _row < frozen_in_progress, in_progress_event, in_progress >, - a_row< frozen_in_progress, finished_event, finished, &x::close_all_betting_market_groups >, - a_row< frozen_in_progress, canceled_event, canceled, &x::cancel_all_betting_market_groups >, - a_row< frozen_in_progress, betting_market_group_resolved_event,frozen_in_progress, &x::record_whether_group_settled_or_canceled >, - g_row< frozen_in_progress, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, - // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ - a_row< finished, canceled_event, canceled, &x::cancel_all_betting_market_groups >, - g_row< finished, betting_market_group_resolved_event,settled, &x::all_betting_market_groups_are_resolved >, - g_row< finished, betting_market_group_resolved_event,canceled, &x::all_betting_market_groups_are_canceled > - > {}; + // Transition table for tournament + struct transition_table : mpl::vector< + // Start Event Next Action Guard + // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ + _row < upcoming, in_progress_event, in_progress >, + a_row< upcoming, finished_event, finished, &x::close_all_betting_market_groups >, + a_row< upcoming, frozen_event, frozen_upcoming, &x::freeze_betting_market_groups >, + a_row< upcoming, canceled_event, canceled, &x::cancel_all_betting_market_groups >, + a_row< upcoming, betting_market_group_resolved_event,upcoming, &x::record_whether_group_settled_or_canceled >, + g_row< upcoming, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, + // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ + _row < frozen_upcoming, upcoming_event, upcoming >, + _row < frozen_upcoming, in_progress_event, in_progress >, + a_row< frozen_upcoming, finished_event, finished, &x::close_all_betting_market_groups >, + a_row< frozen_upcoming, canceled_event, canceled, &x::cancel_all_betting_market_groups >, + a_row< frozen_upcoming, betting_market_group_resolved_event,frozen_upcoming, &x::record_whether_group_settled_or_canceled >, + g_row< frozen_upcoming, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, + // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ + a_row< in_progress, frozen_event, frozen_in_progress, &x::freeze_betting_market_groups >, + a_row< in_progress, finished_event, finished, &x::close_all_betting_market_groups >, + a_row< in_progress, canceled_event, canceled, &x::cancel_all_betting_market_groups >, + a_row< in_progress, betting_market_group_resolved_event,in_progress, &x::record_whether_group_settled_or_canceled >, + g_row< in_progress, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, + // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ + _row < frozen_in_progress, in_progress_event, in_progress >, + a_row< frozen_in_progress, finished_event, finished, &x::close_all_betting_market_groups >, + a_row< frozen_in_progress, canceled_event, canceled, &x::cancel_all_betting_market_groups >, + a_row< frozen_in_progress, betting_market_group_resolved_event,frozen_in_progress, &x::record_whether_group_settled_or_canceled >, + g_row< frozen_in_progress, betting_market_group_closed_event, finished, &x::all_betting_market_groups_are_closed >, + // +---------------------+-----------------------------+--------------------+--------------------------------+----------------------+ + a_row< finished, canceled_event, canceled, &x::cancel_all_betting_market_groups >, + g_row< finished, betting_market_group_resolved_event,settled, &x::all_betting_market_groups_are_resolved >, + g_row< finished, betting_market_group_resolved_event,canceled, &x::all_betting_market_groups_are_canceled > + > {}; - template - void no_transition(Event const& e, Fsm&, int state) - { - FC_THROW_EXCEPTION(graphene::chain::no_transition, "No transition"); - } + template + void no_transition(Event const& e, Fsm&, int state) + { + FC_THROW_EXCEPTION(graphene::chain::no_transition, "No transition"); + } + template + void no_transition(canceled_event const& e, Fsm&, int state) + { + //ignore transitions from settled to canceled state + //and from canceled to canceled state + } - template - void no_transition(canceled_event const& e, Fsm&, int state) - { - //ignore transitions from settled to canceled state - //and from canceled to canceled state - } + event_object* event_obj; + event_state_machine_(event_object* event_obj) : event_obj(event_obj) {} + }; + typedef msm::back::state_machine event_state_machine; - event_object* event_obj; - event_state_machine_(event_object* event_obj) : event_obj(event_obj) {} -}; -typedef msm::back::state_machine event_state_machine; + } // end anonymous namespace -} // end anonymous namespace + class event_object::impl { + public: + event_state_machine state_machine; -class event_object::impl { -public: - event_state_machine state_machine; + impl(event_object* self) : state_machine(self) {} + }; - impl(event_object* self) : state_machine(self) {} -}; + event_object::event_object() : + at_least_one_betting_market_group_settled(false), + my(new impl(this)) + { + } -event_object::event_object() : - at_least_one_betting_market_group_settled(false), - my(new impl(this)) -{ -} + event_object::event_object(const event_object& rhs) : + graphene::db::abstract_object(rhs), + name(rhs.name), + season(rhs.season), + start_time(rhs.start_time), + event_group_id(rhs.event_group_id), + at_least_one_betting_market_group_settled(rhs.at_least_one_betting_market_group_settled), + scores(rhs.scores), + my(new impl(this)) + { + my->state_machine = rhs.my->state_machine; + my->state_machine.event_obj = this; + } -event_object::event_object(const event_object& rhs) : - graphene::db::abstract_object(rhs), - name(rhs.name), - season(rhs.season), - start_time(rhs.start_time), - event_group_id(rhs.event_group_id), - at_least_one_betting_market_group_settled(rhs.at_least_one_betting_market_group_settled), - scores(rhs.scores), - my(new impl(this)) -{ - my->state_machine = rhs.my->state_machine; - my->state_machine.event_obj = this; -} + event_object& event_object::operator=(const event_object& rhs) + { + //graphene::db::abstract_object::operator=(rhs); + id = rhs.id; + name = rhs.name; + season = rhs.season; + start_time = rhs.start_time; + event_group_id = rhs.event_group_id; + at_least_one_betting_market_group_settled = rhs.at_least_one_betting_market_group_settled; + scores = rhs.scores; -event_object& event_object::operator=(const event_object& rhs) -{ - //graphene::db::abstract_object::operator=(rhs); - id = rhs.id; - name = rhs.name; - season = rhs.season; - start_time = rhs.start_time; - event_group_id = rhs.event_group_id; - at_least_one_betting_market_group_settled = rhs.at_least_one_betting_market_group_settled; - scores = rhs.scores; + my->state_machine = rhs.my->state_machine; + my->state_machine.event_obj = this; - my->state_machine = rhs.my->state_machine; - my->state_machine.event_obj = this; + return *this; + } - return *this; -} + event_object::~event_object() + { + } -event_object::~event_object() -{ -} + namespace { -namespace { + bool verify_event_status_constants() + { + unsigned error_count = 0; + typedef msm::back::generate_state_set::type all_states; + static char const* filled_state_names[mpl::size::value]; + mpl::for_each > + (msm::back::fill_state_names(filled_state_names)); + for (unsigned i = 0; i < mpl::size::value; ++i) + { + try + { + // this is an approximate test, the state name provided by typeinfo will be mangled, but should + // at least contain the string we're looking for + const char* fc_reflected_value_name = fc::reflector::to_string((event_state)i); + if (!strstr(filled_state_names[i], fc_reflected_value_name)) + { + fc_elog(fc::logger::get("default"), + "Error, state string mismatch between fc and boost::msm for int value ${int_value}: boost::msm -> ${boost_string}, fc::reflect -> ${fc_string}", + ("int_value", i)("boost_string", filled_state_names[i])("fc_string", fc_reflected_value_name)); + ++error_count; + } + } + catch (const fc::bad_cast_exception&) + { + fc_elog(fc::logger::get("default"), + "Error, no reflection for value ${int_value} in enum event_status", + ("int_value", i)); + ++error_count; + } + } + if (error_count == 0) + dlog("Event status constants are correct"); + else + wlog("There were ${count} errors in the event status constants", ("count", error_count)); -bool verify_event_status_constants() -{ - unsigned error_count = 0; - typedef msm::back::generate_state_set::type all_states; - static char const* filled_state_names[mpl::size::value]; - mpl::for_each > - (msm::back::fill_state_names(filled_state_names)); - for (unsigned i = 0; i < mpl::size::value; ++i) - { - try - { - // this is an approximate test, the state name provided by typeinfo will be mangled, but should - // at least contain the string we're looking for - const char* fc_reflected_value_name = fc::reflector::to_string((event_state)i); - if (!strstr(filled_state_names[i], fc_reflected_value_name)) - { - fc_elog(fc::logger::get("default"), - "Error, state string mismatch between fc and boost::msm for int value ${int_value}: boost::msm -> ${boost_string}, fc::reflect -> ${fc_string}", - ("int_value", i)("boost_string", filled_state_names[i])("fc_string", fc_reflected_value_name)); - ++error_count; - } - } - catch (const fc::bad_cast_exception&) - { - fc_elog(fc::logger::get("default"), - "Error, no reflection for value ${int_value} in enum event_status", - ("int_value", i)); - ++error_count; - } - } - if (error_count == 0) - dlog("Event status constants are correct"); - else - wlog("There were ${count} errors in the event status constants", ("count", error_count)); + return error_count == 0; + } + } // end anonymous namespace - return error_count == 0; -} -} // end anonymous namespace + event_status event_object::get_status() const + { + static bool state_constants_are_correct = verify_event_status_constants(); + (void)&state_constants_are_correct; + event_state state = (event_state)my->state_machine.current_state()[0]; -event_status event_object::get_status() const -{ - static bool state_constants_are_correct = verify_event_status_constants(); - (void)&state_constants_are_correct; - event_state state = (event_state)my->state_machine.current_state()[0]; + ddump((state)); - ddump((state)); + switch (state) + { + case event_state::upcoming: + return event_status::upcoming; + case event_state::frozen_upcoming: + case event_state::frozen_in_progress: + return event_status::frozen; + case event_state::in_progress: + return event_status::in_progress; + case event_state::finished: + return event_status::finished; + case event_state::canceled: + return event_status::canceled; + case event_state::settled: + return event_status::settled; + default: + FC_THROW("Unexpected event state"); + }; + } - switch (state) - { - case event_state::upcoming: - return event_status::upcoming; - case event_state::frozen_upcoming: - case event_state::frozen_in_progress: - return event_status::frozen; - case event_state::in_progress: - return event_status::in_progress; - case event_state::finished: - return event_status::finished; - case event_state::canceled: - return event_status::canceled; - case event_state::settled: - return event_status::settled; - default: - FC_THROW("Unexpected event state"); - }; -} + void event_object::pack_impl(std::ostream& stream) const + { + boost::archive::binary_oarchive oa(stream, boost::archive::no_header|boost::archive::no_codecvt|boost::archive::no_xml_tag_checking); + oa << my->state_machine; + } -void event_object::pack_impl(std::ostream& stream) const -{ - boost::archive::binary_oarchive oa(stream, boost::archive::no_header|boost::archive::no_codecvt|boost::archive::no_xml_tag_checking); - oa << my->state_machine; -} + void event_object::unpack_impl(std::istream& stream) + { + boost::archive::binary_iarchive ia(stream, boost::archive::no_header|boost::archive::no_codecvt|boost::archive::no_xml_tag_checking); + ia >> my->state_machine; + } -void event_object::unpack_impl(std::istream& stream) -{ - boost::archive::binary_iarchive ia(stream, boost::archive::no_header|boost::archive::no_codecvt|boost::archive::no_xml_tag_checking); - ia >> my->state_machine; -} + void event_object::on_upcoming_event(database& db) + { + my->state_machine.process_event(upcoming_event(db)); + } -void event_object::on_upcoming_event(database& db) -{ - my->state_machine.process_event(upcoming_event(db)); -} + void event_object::on_in_progress_event(database& db) + { + my->state_machine.process_event(in_progress_event(db)); + } -void event_object::on_in_progress_event(database& db) -{ - my->state_machine.process_event(in_progress_event(db)); -} + void event_object::on_frozen_event(database& db) + { + my->state_machine.process_event(frozen_event(db)); + } -void event_object::on_frozen_event(database& db) -{ - my->state_machine.process_event(frozen_event(db)); -} + void event_object::on_finished_event(database& db) + { + my->state_machine.process_event(finished_event(db)); + } -void event_object::on_finished_event(database& db) -{ - my->state_machine.process_event(finished_event(db)); -} + void event_object::on_canceled_event(database& db) + { + my->state_machine.process_event(canceled_event(db)); + } -void event_object::on_canceled_event(database& db) -{ - my->state_machine.process_event(canceled_event(db)); -} + void event_object::on_betting_market_group_resolved(database& db, betting_market_group_id_type resolved_group, bool was_canceled) + { + my->state_machine.process_event(betting_market_group_resolved_event(db, resolved_group, was_canceled)); + } -void event_object::on_betting_market_group_resolved(database& db, betting_market_group_id_type resolved_group, bool was_canceled) -{ - my->state_machine.process_event(betting_market_group_resolved_event(db, resolved_group, was_canceled)); -} + void event_object::on_betting_market_group_closed(database& db, betting_market_group_id_type closed_group) + { + my->state_machine.process_event(betting_market_group_closed_event(db, closed_group)); + } -void event_object::on_betting_market_group_closed(database& db, betting_market_group_id_type closed_group) -{ - my->state_machine.process_event(betting_market_group_closed_event(db, closed_group)); -} - -// These are the only statuses that can be explicitly set by witness operations. The missing -// status, 'settled', is automatically set when all of the betting market groups have -// settled/canceled -void event_object::dispatch_new_status(database& db, event_status new_status) -{ - switch (new_status) { - case event_status::upcoming: // by witnesses to unfreeze a frozen event - on_upcoming_event(db); - break; - case event_status::in_progress: // by witnesses when the event starts - on_in_progress_event(db); - break; - case event_status::frozen: // by witnesses when the event needs to be frozen - on_frozen_event(db); - break; - case event_status::finished: // by witnesses when the event is complete - on_finished_event(db); - break; - case event_status::canceled: // by witnesses to cancel the event - on_canceled_event(db); - break; - default: - FC_THROW("Status ${new_status} cannot be explicitly set", ("new_status", new_status)); - } -} + // These are the only statuses that can be explicitly set by witness operations. The missing + // status, 'settled', is automatically set when all of the betting market groups have + // settled/canceled + void event_object::dispatch_new_status(database& db, event_status new_status) + { + switch (new_status) { + case event_status::upcoming: // by witnesses to unfreeze a frozen event + on_upcoming_event(db); + break; + case event_status::in_progress: // by witnesses when the event starts + on_in_progress_event(db); + break; + case event_status::frozen: // by witnesses when the event needs to be frozen + on_frozen_event(db); + break; + case event_status::finished: // by witnesses when the event is complete + on_finished_event(db); + break; + case event_status::canceled: // by witnesses to cancel the event + on_canceled_event(db); + break; + default: + FC_THROW("Status ${new_status} cannot be explicitly set", ("new_status", new_status)); + } + } } } // graphene::chain namespace fc { -// Manually reflect event_object to variant to properly reflect "state" -void to_variant(const graphene::chain::event_object& event_obj, fc::variant& v, uint32_t max_depth) -{ - fc::mutable_variant_object o; - o("id", fc::variant(event_obj.id, max_depth)) - ("name", fc::variant(event_obj.name, max_depth)) - ("season", fc::variant(event_obj.season, max_depth)) - ("start_time", fc::variant(event_obj.start_time, max_depth)) - ("event_group_id", fc::variant(event_obj.event_group_id, max_depth)) - ("scores", fc::variant(event_obj.scores, max_depth)) - ("status", fc::variant(event_obj.get_status(), max_depth)); + // Manually reflect event_object to variant to properly reflect "state" + void to_variant(const graphene::chain::event_object& event_obj, fc::variant& v, uint32_t max_depth) + { + fc::mutable_variant_object o; + o("id", fc::variant(event_obj.id, max_depth)) + ("name", fc::variant(event_obj.name, max_depth)) + ("season", fc::variant(event_obj.season, max_depth)) + ("start_time", fc::variant(event_obj.start_time, max_depth)) + ("event_group_id", fc::variant(event_obj.event_group_id, max_depth)) + ("scores", fc::variant(event_obj.scores, max_depth)) + ("status", fc::variant(event_obj.get_status(), max_depth)); - v = o; -} + v = o; + } -// Manually reflect event_object to variant to properly reflect "state" -void from_variant(const fc::variant& v, graphene::chain::event_object& event_obj, uint32_t max_depth) -{ - event_obj.id = v["id"].as( max_depth ); - event_obj.name = v["name"].as( max_depth ); - event_obj.season = v["season"].as( max_depth ); - event_obj.start_time = v["start_time"].as >( max_depth ); - event_obj.event_group_id = v["event_group_id"].as( max_depth ); - event_obj.scores = v["scores"].as>( max_depth ); - graphene::chain::event_status status = v["status"].as( max_depth ); - const_cast(event_obj.my->state_machine.current_state())[0] = (int)status; -} + // Manually reflect event_object to variant to properly reflect "state" + void from_variant(const fc::variant& v, graphene::chain::event_object& event_obj, uint32_t max_depth) + { + event_obj.id = v["id"].as( max_depth ); + event_obj.name = v["name"].as( max_depth ); + event_obj.season = v["season"].as( max_depth ); + event_obj.start_time = v["start_time"].as >( max_depth ); + event_obj.event_group_id = v["event_group_id"].as( max_depth ); + event_obj.scores = v["scores"].as>( max_depth ); + graphene::chain::event_status status = v["status"].as( max_depth ); + const_cast(event_obj.my->state_machine.current_state())[0] = (int)status; + } } //end namespace fc diff --git a/libraries/chain/game_object.cpp b/libraries/chain/game_object.cpp index 88c0cf3c..4a35abfc 100644 --- a/libraries/chain/game_object.cpp +++ b/libraries/chain/game_object.cpp @@ -548,34 +548,36 @@ namespace graphene { namespace chain { } } // graphene::chain namespace fc { -// Manually reflect game_object to variant to properly reflect "state" -void to_variant(const graphene::chain::game_object& game_obj, fc::variant& v, uint32_t max_depth) -{ - fc_elog(fc::logger::get("tournament"), "In game_obj to_variant"); - elog("In game_obj to_variant"); - fc::mutable_variant_object o; - o("id", fc::variant(game_obj.id, max_depth )) - ("match_id", fc::variant(game_obj.match_id, max_depth )) - ("players", fc::variant(game_obj.players, max_depth )) - ("winners", fc::variant(game_obj.winners, max_depth )) - ("game_details", fc::variant(game_obj.game_details, max_depth )) - ("next_timeout", fc::variant(game_obj.next_timeout, max_depth )) - ("state", fc::variant(game_obj.get_state(), max_depth )); + // Manually reflect game_object to variant to properly reflect "state" + void to_variant(const graphene::chain::game_object& game_obj, fc::variant& v, uint32_t max_depth) + { + fc_elog(fc::logger::get("tournament"), "In game_obj to_variant"); + elog("In game_obj to_variant"); + fc::mutable_variant_object o; + o("id", fc::variant(game_obj.id, max_depth )) + ("match_id", fc::variant(game_obj.match_id, max_depth )) + ("players", fc::variant(game_obj.players, max_depth )) + ("winners", fc::variant(game_obj.winners, max_depth )) + ("game_details", fc::variant(game_obj.game_details, max_depth )) + ("next_timeout", fc::variant(game_obj.next_timeout, max_depth )) + ("state", fc::variant(game_obj.get_state(), max_depth )); - v = o; -} + v = o; + } -// Manually reflect game_object to variant to properly reflect "state" -void from_variant(const fc::variant& v, graphene::chain::game_object& game_obj, uint32_t max_depth) -{ - fc_elog(fc::logger::get("tournament"), "In game_obj from_variant"); - game_obj.id = v["id"].as( max_depth ); - game_obj.match_id = v["match_id"].as( max_depth ); - game_obj.players = v["players"].as >( max_depth ); - game_obj.winners = v["winners"].as >( max_depth ); - game_obj.game_details = v["game_details"].as( max_depth ); - game_obj.next_timeout = v["next_timeout"].as >( max_depth ); - graphene::chain::game_state state = v["state"].as( max_depth ); - const_cast(game_obj.my->state_machine.current_state())[0] = (int)state; -} + // Manually reflect game_object to variant to properly reflect "state" + void from_variant(const fc::variant& v, graphene::chain::game_object& game_obj, uint32_t max_depth) + { + fc_elog(fc::logger::get("tournament"), "In game_obj from_variant"); + game_obj.id = v["id"].as( max_depth ); + game_obj.match_id = v["match_id"].as( max_depth ); + game_obj.players = v["players"].as >( max_depth ); + game_obj.winners = v["winners"].as >( max_depth ); + game_obj.game_details = v["game_details"].as( max_depth ); + game_obj.next_timeout = v["next_timeout"].as >( max_depth ); + graphene::chain::game_state state = v["state"].as( max_depth ); + const_cast(game_obj.my->state_machine.current_state())[0] = (int)state; + } } //end namespace fc + + diff --git a/libraries/chain/include/graphene/chain/betting_market_object.hpp b/libraries/chain/include/graphene/chain/betting_market_object.hpp index e2d2d6e1..c16fe53d 100644 --- a/libraries/chain/include/graphene/chain/betting_market_object.hpp +++ b/libraries/chain/include/graphene/chain/betting_market_object.hpp @@ -31,15 +31,15 @@ #include namespace graphene { namespace chain { -class betting_market_object; -class betting_market_group_object; + class betting_market_object; + class betting_market_group_object; } } namespace fc { -void to_variant(const graphene::chain::betting_market_object& betting_market_obj, fc::variant& v, uint32_t max_depth = 1); -void from_variant(const fc::variant& v, graphene::chain::betting_market_object& betting_market_obj, uint32_t max_depth = 1); -void to_variant(const graphene::chain::betting_market_group_object& betting_market_group_obj, fc::variant& v, uint32_t max_depth = 1); -void from_variant(const fc::variant& v, graphene::chain::betting_market_group_object& betting_market_group_obj, uint32_t max_depth = 1); + void to_variant(const graphene::chain::betting_market_object& betting_market_obj, fc::variant& v, uint32_t max_depth = 1); + void from_variant(const fc::variant& v, graphene::chain::betting_market_object& betting_market_obj, uint32_t max_depth = 1); + void to_variant(const graphene::chain::betting_market_group_object& betting_market_group_obj, fc::variant& v, uint32_t max_depth = 1); + void from_variant(const fc::variant& v, graphene::chain::betting_market_group_object& betting_market_group_obj, uint32_t max_depth = 1); } //end namespace fc namespace graphene { namespace chain { @@ -722,100 +722,100 @@ FC_REFLECT_DERIVED( graphene::chain::betting_market_position_object, (graphene:: namespace fc { -template<> -template<> -inline void if_enum::from_variant(const variant &vo, graphene::chain::betting_market_object &v, uint32_t max_depth) { - from_variant(vo, v, max_depth); -} - -template<> -template<> -inline void if_enum::to_variant(const graphene::chain::betting_market_object &v, variant &vo, uint32_t max_depth) { - to_variant(v, vo, max_depth); -} - -namespace raw { namespace detail { - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::unpack(fc::datastream &s, graphene::chain::betting_market_object &v, uint32_t) { - s >> v; -} - -} } - -template <> -struct get_typename { - static const char *name() { - return "graphene::chain::betting_market_object"; + template<> + template<> + inline void if_enum::from_variant(const variant &vo, graphene::chain::betting_market_object &v, uint32_t max_depth) { + from_variant(vo, v, max_depth); } -}; -template <> -struct reflector { - typedef graphene::chain::betting_market_object type; - typedef fc::true_type is_defined; - typedef fc::false_type is_enum; -}; + + template<> + template<> + inline void if_enum::to_variant(const graphene::chain::betting_market_object &v, variant &vo, uint32_t max_depth) { + to_variant(v, vo, max_depth); + } + + namespace raw { namespace detail { + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::unpack(fc::datastream &s, graphene::chain::betting_market_object &v, uint32_t) { + s >> v; + } + + } } // namespace fc::raw::detail + + template <> + struct get_typename { + static const char *name() { + return "graphene::chain::betting_market_object"; + } + }; + template <> + struct reflector { + typedef graphene::chain::betting_market_object type; + typedef fc::true_type is_defined; + typedef fc::false_type is_enum; + }; } // namespace fc namespace fc { -template<> -template<> -inline void if_enum::from_variant(const variant &vo, graphene::chain::betting_market_group_object &v, uint32_t max_depth) { - from_variant(vo, v, max_depth); -} - -template<> -template<> -inline void if_enum::to_variant(const graphene::chain::betting_market_group_object &v, variant &vo, uint32_t max_depth) { - to_variant(v, vo, max_depth); -} - -namespace raw { namespace detail { - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_group_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_group_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::unpack(fc::datastream &s, graphene::chain::betting_market_group_object &v, uint32_t) { - s >> v; -} - -} } - -template <> -struct get_typename { - static const char *name() { - return "graphene::chain::betting_market_group_object"; + template<> + template<> + inline void if_enum::from_variant(const variant &vo, graphene::chain::betting_market_group_object &v, uint32_t max_depth) { + from_variant(vo, v, max_depth); } -}; -template <> -struct reflector { - typedef graphene::chain::betting_market_group_object type; - typedef fc::true_type is_defined; - typedef fc::false_type is_enum; -}; + + template<> + template<> + inline void if_enum::to_variant(const graphene::chain::betting_market_group_object &v, variant &vo, uint32_t max_depth) { + to_variant(v, vo, max_depth); + } + + namespace raw { namespace detail { + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_group_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::betting_market_group_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::unpack(fc::datastream &s, graphene::chain::betting_market_group_object &v, uint32_t) { + s >> v; + } + + } } // namespace fc::raw:detail + + template <> + struct get_typename { + static const char *name() { + return "graphene::chain::betting_market_group_object"; + } + }; + template <> + struct reflector { + typedef graphene::chain::betting_market_group_object type; + typedef fc::true_type is_defined; + typedef fc::false_type is_enum; + }; } // namespace fc diff --git a/libraries/chain/include/graphene/chain/event_object.hpp b/libraries/chain/include/graphene/chain/event_object.hpp index 30c6d5ca..ff75c286 100644 --- a/libraries/chain/include/graphene/chain/event_object.hpp +++ b/libraries/chain/include/graphene/chain/event_object.hpp @@ -1,26 +1,26 @@ /* -* Copyright (c) 2018 Peerplays Blockchain Standards Association, and contributors. -* -* The MIT License -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -*/ + * Copyright (c) 2018 Peerplays Blockchain Standards Association, and contributors. + * + * The MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ #pragma once #include @@ -32,12 +32,12 @@ #include namespace graphene { namespace chain { -class event_object; + class event_object; } } namespace fc { -void to_variant(const graphene::chain::event_object& event_obj, fc::variant& v, uint32_t max_depth = 1); -void from_variant(const fc::variant& v, graphene::chain::event_object& event_obj, uint32_t max_depth = 1); + void to_variant(const graphene::chain::event_object& event_obj, fc::variant& v, uint32_t max_depth = 1); + void from_variant(const fc::variant& v, graphene::chain::event_object& event_obj, uint32_t max_depth = 1); } //end namespace fc namespace graphene { namespace chain { @@ -46,165 +46,165 @@ class database; class event_object : public graphene::db::abstract_object< event_object > { -public: - static const uint8_t space_id = protocol_ids; - static const uint8_t type_id = event_object_type; + public: + static const uint8_t space_id = protocol_ids; + static const uint8_t type_id = event_object_type; - event_object(); - event_object(const event_object& rhs); - ~event_object(); - event_object& operator=(const event_object& rhs); + event_object(); + event_object(const event_object& rhs); + ~event_object(); + event_object& operator=(const event_object& rhs); - internationalized_string_type name; + internationalized_string_type name; - internationalized_string_type season; + internationalized_string_type season; - optional start_time; + optional start_time; - event_group_id_type event_group_id; + event_group_id_type event_group_id; - bool at_least_one_betting_market_group_settled; + bool at_least_one_betting_market_group_settled; - event_status get_status() const; - vector scores; + event_status get_status() const; + vector scores; - // serialization functions: - // for serializing to raw, go through a temporary sstream object to avoid - // having to implement serialization in the header file - template - friend Stream& operator<<( Stream& s, const event_object& event_obj ); + // serialization functions: + // for serializing to raw, go through a temporary sstream object to avoid + // having to implement serialization in the header file + template + friend Stream& operator<<( Stream& s, const event_object& event_obj ); - template - friend Stream& operator>>( Stream& s, event_object& event_obj ); + template + friend Stream& operator>>( Stream& s, event_object& event_obj ); - friend void ::fc::to_variant(const graphene::chain::event_object& event_obj, fc::variant& v, uint32_t max_depth); - friend void ::fc::from_variant(const fc::variant& v, graphene::chain::event_object& event_obj, uint32_t max_depth); + friend void ::fc::to_variant(const graphene::chain::event_object& event_obj, fc::variant& v, uint32_t max_depth); + friend void ::fc::from_variant(const fc::variant& v, graphene::chain::event_object& event_obj, uint32_t max_depth); - void pack_impl(std::ostream& stream) const; - void unpack_impl(std::istream& stream); + void pack_impl(std::ostream& stream) const; + void unpack_impl(std::istream& stream); - void on_upcoming_event(database& db); - void on_in_progress_event(database& db); - void on_frozen_event(database& db); - void on_finished_event(database& db); - void on_canceled_event(database& db); - void on_settled_event(database& db); - void on_betting_market_group_resolved(database& db, betting_market_group_id_type resolved_group, bool was_canceled); - void on_betting_market_group_closed(database& db, betting_market_group_id_type closed_group); - void dispatch_new_status(database& db, event_status new_status); -private: - class impl; - std::unique_ptr my; + void on_upcoming_event(database& db); + void on_in_progress_event(database& db); + void on_frozen_event(database& db); + void on_finished_event(database& db); + void on_canceled_event(database& db); + void on_settled_event(database& db); + void on_betting_market_group_resolved(database& db, betting_market_group_id_type resolved_group, bool was_canceled); + void on_betting_market_group_closed(database& db, betting_market_group_id_type closed_group); + void dispatch_new_status(database& db, event_status new_status); + private: + class impl; + std::unique_ptr my; }; struct by_event_group_id; struct by_event_status; typedef multi_index_container< - event_object, - indexed_by< - ordered_unique< tag, member< object, object_id_type, &object::id > >, - ordered_unique< tag, composite_key, - member > >, - ordered_unique< tag, composite_key, - member > > > > event_object_multi_index_type; + event_object, + indexed_by< + ordered_unique< tag, member< object, object_id_type, &object::id > >, + ordered_unique< tag, composite_key, + member > >, + ordered_unique< tag, composite_key, + member > > > > event_object_multi_index_type; typedef generic_index event_object_index; -template -inline Stream& operator<<( Stream& s, const event_object& event_obj ) -{ - fc_elog(fc::logger::get("event"), "In event_obj to_raw"); - // pack all fields exposed in the header in the usual way - // instead of calling the derived pack, just serialize the one field in the base class - // fc::raw::pack >(s, event_obj); - fc::raw::pack(s, event_obj.id); - fc::raw::pack(s, event_obj.name); - fc::raw::pack(s, event_obj.season); - fc::raw::pack(s, event_obj.start_time); - fc::raw::pack(s, event_obj.event_group_id); - fc::raw::pack(s, event_obj.at_least_one_betting_market_group_settled); - fc::raw::pack(s, event_obj.scores); + template + inline Stream& operator<<( Stream& s, const event_object& event_obj ) + { + fc_elog(fc::logger::get("event"), "In event_obj to_raw"); + // pack all fields exposed in the header in the usual way + // instead of calling the derived pack, just serialize the one field in the base class + // fc::raw::pack >(s, event_obj); + fc::raw::pack(s, event_obj.id); + fc::raw::pack(s, event_obj.name); + fc::raw::pack(s, event_obj.season); + fc::raw::pack(s, event_obj.start_time); + fc::raw::pack(s, event_obj.event_group_id); + fc::raw::pack(s, event_obj.at_least_one_betting_market_group_settled); + fc::raw::pack(s, event_obj.scores); - // fc::raw::pack the contents hidden in the impl class - std::ostringstream stream; - event_obj.pack_impl(stream); - std::string stringified_stream(stream.str()); - fc::raw::pack(s, stream.str()); + // fc::raw::pack the contents hidden in the impl class + std::ostringstream stream; + event_obj.pack_impl(stream); + std::string stringified_stream(stream.str()); + fc::raw::pack(s, stream.str()); - return s; -} -template -inline Stream& operator>>( Stream& s, event_object& event_obj ) -{ - fc_elog(fc::logger::get("event"), "In event_obj from_raw"); - // unpack all fields exposed in the header in the usual way - //fc::raw::unpack >(s, event_obj); - fc::raw::unpack(s, event_obj.id); - fc::raw::unpack(s, event_obj.name); - fc::raw::unpack(s, event_obj.season); - fc::raw::unpack(s, event_obj.start_time); - fc::raw::unpack(s, event_obj.event_group_id); - fc::raw::unpack(s, event_obj.at_least_one_betting_market_group_settled); - fc::raw::unpack(s, event_obj.scores); + return s; + } + template + inline Stream& operator>>( Stream& s, event_object& event_obj ) + { + fc_elog(fc::logger::get("event"), "In event_obj from_raw"); + // unpack all fields exposed in the header in the usual way + //fc::raw::unpack >(s, event_obj); + fc::raw::unpack(s, event_obj.id); + fc::raw::unpack(s, event_obj.name); + fc::raw::unpack(s, event_obj.season); + fc::raw::unpack(s, event_obj.start_time); + fc::raw::unpack(s, event_obj.event_group_id); + fc::raw::unpack(s, event_obj.at_least_one_betting_market_group_settled); + fc::raw::unpack(s, event_obj.scores); - // fc::raw::unpack the contents hidden in the impl class - std::string stringified_stream; - fc::raw::unpack(s, stringified_stream); - std::istringstream stream(stringified_stream); - event_obj.unpack_impl(stream); + // fc::raw::unpack the contents hidden in the impl class + std::string stringified_stream; + fc::raw::unpack(s, stringified_stream); + std::istringstream stream(stringified_stream); + event_obj.unpack_impl(stream); - return s; -} + return s; + } } } // graphene::chain namespace fc { -template<> -template<> -inline void if_enum::from_variant(const variant &vo, graphene::chain::event_object &v, uint32_t max_depth) { - from_variant(vo, v, max_depth); -} - -template<> -template<> -inline void if_enum::to_variant(const graphene::chain::event_object &v, variant &vo, uint32_t max_depth) { - to_variant(v, vo, max_depth); -} - -namespace raw { namespace detail { - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::event_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::event_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::unpack(fc::datastream &s, graphene::chain::event_object &v, uint32_t) { - s >> v; -} - -} } - -template <> -struct get_typename { - static const char *name() { - return "graphene::chain::event_object"; + template<> + template<> + inline void if_enum::from_variant(const variant &vo, graphene::chain::event_object &v, uint32_t max_depth) { + from_variant(vo, v, max_depth); } -}; -template <> -struct reflector { - typedef graphene::chain::event_object type; - typedef fc::true_type is_defined; - typedef fc::false_type is_enum; -}; -} // namespace fc \ No newline at end of file + + template<> + template<> + inline void if_enum::to_variant(const graphene::chain::event_object &v, variant &vo, uint32_t max_depth) { + to_variant(v, vo, max_depth); + } + + namespace raw { namespace detail { + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::event_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::event_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::unpack(fc::datastream &s, graphene::chain::event_object &v, uint32_t) { + s >> v; + } + + } } // namespace fc::raw::detail + + template <> + struct get_typename { + static const char *name() { + return "graphene::chain::event_object"; + } + }; + template <> + struct reflector { + typedef graphene::chain::event_object type; + typedef fc::true_type is_defined; + typedef fc::false_type is_enum; + }; +} // namespace fc diff --git a/libraries/chain/include/graphene/chain/game_object.hpp b/libraries/chain/include/graphene/chain/game_object.hpp index cca9ea5e..cf31e49d 100644 --- a/libraries/chain/include/graphene/chain/game_object.hpp +++ b/libraries/chain/include/graphene/chain/game_object.hpp @@ -30,12 +30,12 @@ #include namespace graphene { namespace chain { -class game_object; + class game_object; } } namespace fc { -void to_variant(const graphene::chain::game_object& game_obj, fc::variant& v, uint32_t max_depth = 1); -void from_variant(const fc::variant& v, graphene::chain::game_object& game_obj, uint32_t max_depth = 1); + void to_variant(const graphene::chain::game_object& game_obj, fc::variant& v, uint32_t max_depth = 1); + void from_variant(const fc::variant& v, graphene::chain::game_object& game_obj, uint32_t max_depth = 1); } //end namespace fc namespace graphene { namespace chain { @@ -164,50 +164,50 @@ FC_REFLECT_ENUM(graphene::chain::game_state, namespace fc { -template<> -template<> -inline void if_enum::from_variant(const variant &vo, graphene::chain::game_object &v, uint32_t max_depth) { - from_variant(vo, v, max_depth); -} - -template<> -template<> -inline void if_enum::to_variant(const graphene::chain::game_object &v, variant &vo, uint32_t max_depth) { - to_variant(v, vo, max_depth); -} - -namespace raw { namespace detail { - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::game_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::game_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::unpack(fc::datastream &s, graphene::chain::game_object &v, uint32_t) { - s >> v; -} - -} } - -template <> -struct get_typename { - static const char *name() { - return "graphene::chain::game_object"; + template<> + template<> + inline void if_enum::from_variant(const variant &vo, graphene::chain::game_object &v, uint32_t max_depth) { + from_variant(vo, v, max_depth); } -}; -template <> -struct reflector { - typedef graphene::chain::game_object type; - typedef fc::true_type is_defined; - typedef fc::false_type is_enum; -}; -} // namespace fc \ No newline at end of file + + template<> + template<> + inline void if_enum::to_variant(const graphene::chain::game_object &v, variant &vo, uint32_t max_depth) { + to_variant(v, vo, max_depth); + } + + namespace raw { namespace detail { + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::game_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::game_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::unpack(fc::datastream &s, graphene::chain::game_object &v, uint32_t) { + s >> v; + } + + } } // namespace fc::raw::detail + + template <> + struct get_typename { + static const char *name() { + return "graphene::chain::game_object"; + } + }; + template <> + struct reflector { + typedef graphene::chain::game_object type; + typedef fc::true_type is_defined; + typedef fc::false_type is_enum; + }; +} // namespace fc diff --git a/libraries/chain/include/graphene/chain/match_object.hpp b/libraries/chain/include/graphene/chain/match_object.hpp index e1194e1e..33df4d01 100644 --- a/libraries/chain/include/graphene/chain/match_object.hpp +++ b/libraries/chain/include/graphene/chain/match_object.hpp @@ -5,12 +5,12 @@ #include namespace graphene { namespace chain { -class match_object; + class match_object; } } namespace fc { -void to_variant(const graphene::chain::match_object& match_obj, fc::variant& v, uint32_t max_depth = 1); -void from_variant(const fc::variant& v, graphene::chain::match_object& match_obj, uint32_t max_depth = 1); + void to_variant(const graphene::chain::match_object& match_obj, fc::variant& v, uint32_t max_depth = 1); + void from_variant(const fc::variant& v, graphene::chain::match_object& match_obj, uint32_t max_depth = 1); } //end namespace fc @@ -162,50 +162,50 @@ FC_REFLECT_ENUM(graphene::chain::match_state, namespace fc { -template<> -template<> -inline void if_enum::from_variant(const variant &vo, graphene::chain::match_object &v, uint32_t max_depth) { - from_variant(vo, v, max_depth); -} - -template<> -template<> -inline void if_enum::to_variant(const graphene::chain::match_object &v, variant &vo, uint32_t max_depth) { - to_variant(v, vo, max_depth); -} - -namespace raw { namespace detail { - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::match_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::match_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::unpack(fc::datastream &s, graphene::chain::match_object &v, uint32_t) { - s >> v; -} - -} } - -template <> -struct get_typename { - static const char *name() { - return "graphene::chain::match_object"; + template<> + template<> + inline void if_enum::from_variant(const variant &vo, graphene::chain::match_object &v, uint32_t max_depth) { + from_variant(vo, v, max_depth); } -}; -template <> -struct reflector { - typedef graphene::chain::match_object type; - typedef fc::true_type is_defined; - typedef fc::false_type is_enum; -}; -} // namespace fc \ No newline at end of file + + template<> + template<> + inline void if_enum::to_variant(const graphene::chain::match_object &v, variant &vo, uint32_t max_depth) { + to_variant(v, vo, max_depth); + } + + namespace raw { namespace detail { + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::match_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::match_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::unpack(fc::datastream &s, graphene::chain::match_object &v, uint32_t) { + s >> v; + } + + } } // namespace fc::raw::detail + + template <> + struct get_typename { + static const char *name() { + return "graphene::chain::match_object"; + } + }; + template <> + struct reflector { + typedef graphene::chain::match_object type; + typedef fc::true_type is_defined; + typedef fc::false_type is_enum; + }; +} // namespace fc diff --git a/libraries/chain/include/graphene/chain/tournament_object.hpp b/libraries/chain/include/graphene/chain/tournament_object.hpp index f3c8e610..53ac3876 100644 --- a/libraries/chain/include/graphene/chain/tournament_object.hpp +++ b/libraries/chain/include/graphene/chain/tournament_object.hpp @@ -7,12 +7,12 @@ #include namespace graphene { namespace chain { -class tournament_object; + class tournament_object; } } namespace fc { -void to_variant(const graphene::chain::tournament_object& tournament_obj, fc::variant& v, uint32_t max_depth = 1); -void from_variant(const fc::variant& v, graphene::chain::tournament_object& tournament_obj, uint32_t max_depth = 1); + void to_variant(const graphene::chain::tournament_object& tournament_obj, fc::variant& v, uint32_t max_depth = 1); + void from_variant(const fc::variant& v, graphene::chain::tournament_object& tournament_obj, uint32_t max_depth = 1); } //end namespace fc namespace graphene { namespace chain { @@ -247,50 +247,50 @@ FC_REFLECT_ENUM(graphene::chain::tournament_state, namespace fc { -template<> -template<> -inline void if_enum::from_variant(const variant &vo, graphene::chain::tournament_object &v, uint32_t max_depth) { - from_variant(vo, v, max_depth); -} - -template<> -template<> -inline void if_enum::to_variant(const graphene::chain::tournament_object &v, variant &vo, uint32_t max_depth) { - to_variant(v, vo, max_depth); -} - -namespace raw { namespace detail { - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::tournament_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::pack(fc::datastream &s, const graphene::chain::tournament_object &v, uint32_t) { - s << v; -} - -template<> -template<> -inline void if_enum::unpack(fc::datastream &s, graphene::chain::tournament_object &v, uint32_t) { - s >> v; -} - -} } - -template <> -struct get_typename { - static const char *name() { - return "graphene::chain::tournament_object"; + template<> + template<> + inline void if_enum::from_variant(const variant &vo, graphene::chain::tournament_object &v, uint32_t max_depth) { + from_variant(vo, v, max_depth); } -}; -template <> -struct reflector { - typedef graphene::chain::tournament_object type; - typedef fc::true_type is_defined; - typedef fc::false_type is_enum; -}; -} // namespace fc \ No newline at end of file + + template<> + template<> + inline void if_enum::to_variant(const graphene::chain::tournament_object &v, variant &vo, uint32_t max_depth) { + to_variant(v, vo, max_depth); + } + + namespace raw { namespace detail { + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::tournament_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::pack(fc::datastream &s, const graphene::chain::tournament_object &v, uint32_t) { + s << v; + } + + template<> + template<> + inline void if_enum::unpack(fc::datastream &s, graphene::chain::tournament_object &v, uint32_t) { + s >> v; + } + + } } // namespace fc::raw::detail + + template <> + struct get_typename { + static const char *name() { + return "graphene::chain::tournament_object"; + } + }; + template <> + struct reflector { + typedef graphene::chain::tournament_object type; + typedef fc::true_type is_defined; + typedef fc::false_type is_enum; + }; +} // namespace fc diff --git a/libraries/chain/match_object.cpp b/libraries/chain/match_object.cpp index 46313bff..c9e8ccb9 100644 --- a/libraries/chain/match_object.cpp +++ b/libraries/chain/match_object.cpp @@ -363,30 +363,30 @@ namespace graphene { namespace chain { } } // graphene::chain namespace fc { -// Manually reflect match_object to variant to properly reflect "state" -void to_variant(const graphene::chain::match_object& match_obj, fc::variant& v, uint32_t max_depth) -{ try { + // Manually reflect match_object to variant to properly reflect "state" + void to_variant(const graphene::chain::match_object& match_obj, fc::variant& v, uint32_t max_depth) + { try { fc_elog(fc::logger::get("tournament"), "In match_obj to_variant"); elog("In match_obj to_variant"); fc::mutable_variant_object o; o("id", fc::variant(match_obj.id, max_depth)) - ("tournament_id", fc::variant(match_obj.tournament_id, max_depth)) - ("players", fc::variant(match_obj.players, max_depth)) - ("games", fc::variant(match_obj.games, max_depth)) - ("game_winners", fc::variant(match_obj.game_winners, max_depth)) - ("number_of_wins", fc::variant(match_obj.number_of_wins, max_depth)) - ("number_of_ties", fc::variant(match_obj.number_of_ties, max_depth)) - ("match_winners", fc::variant(match_obj.match_winners, max_depth)) - ("start_time", fc::variant(match_obj.start_time, max_depth)) - ("end_time", fc::variant(match_obj.end_time, max_depth)) - ("state", fc::variant(match_obj.get_state(), max_depth)); + ("tournament_id", fc::variant(match_obj.tournament_id, max_depth)) + ("players", fc::variant(match_obj.players, max_depth)) + ("games", fc::variant(match_obj.games, max_depth)) + ("game_winners", fc::variant(match_obj.game_winners, max_depth)) + ("number_of_wins", fc::variant(match_obj.number_of_wins, max_depth)) + ("number_of_ties", fc::variant(match_obj.number_of_ties, max_depth)) + ("match_winners", fc::variant(match_obj.match_winners, max_depth)) + ("start_time", fc::variant(match_obj.start_time, max_depth)) + ("end_time", fc::variant(match_obj.end_time, max_depth)) + ("state", fc::variant(match_obj.get_state(), max_depth)); v = o; } FC_RETHROW_EXCEPTIONS(warn, "") } -// Manually reflect match_object to variant to properly reflect "state" -void from_variant(const fc::variant& v, graphene::chain::match_object& match_obj, uint32_t max_depth) -{ try { + // Manually reflect match_object to variant to properly reflect "state" + void from_variant(const fc::variant& v, graphene::chain::match_object& match_obj, uint32_t max_depth) + { try { fc_elog(fc::logger::get("tournament"), "In match_obj from_variant"); match_obj.id = v["id"].as( max_depth ); match_obj.tournament_id = v["tournament_id"].as( max_depth ); diff --git a/libraries/chain/tournament_object.cpp b/libraries/chain/tournament_object.cpp index 680943bd..0d9ef969 100644 --- a/libraries/chain/tournament_object.cpp +++ b/libraries/chain/tournament_object.cpp @@ -722,41 +722,40 @@ namespace graphene { namespace chain { } } // graphene::chain namespace fc { -// Manually reflect tournament_object to variant to properly reflect "state" -void to_variant(const graphene::chain::tournament_object& tournament_obj, fc::variant& v, uint32_t max_depth) -{ - fc_elog(fc::logger::get("tournament"), "In tournament_obj to_variant"); - elog("In tournament_obj to_variant"); - fc::mutable_variant_object o; - o("id", fc::variant(tournament_obj.id, max_depth)) - ("creator", fc::variant(tournament_obj.creator, max_depth)) - ("options", fc::variant(tournament_obj.options, max_depth)) - ("start_time", fc::variant(tournament_obj.start_time, max_depth)) - ("end_time", fc::variant(tournament_obj.end_time, max_depth)) - ("prize_pool", fc::variant(tournament_obj.prize_pool, max_depth)) - ("registered_players", fc::variant(tournament_obj.registered_players, max_depth)) - ("tournament_details_id", fc::variant(tournament_obj.tournament_details_id, max_depth)) - ("state", fc::variant(tournament_obj.get_state(), max_depth)); + // Manually reflect tournament_object to variant to properly reflect "state" + void to_variant(const graphene::chain::tournament_object& tournament_obj, fc::variant& v, uint32_t max_depth) + { + fc_elog(fc::logger::get("tournament"), "In tournament_obj to_variant"); + elog("In tournament_obj to_variant"); + fc::mutable_variant_object o; + o("id", fc::variant(tournament_obj.id, max_depth)) + ("creator", fc::variant(tournament_obj.creator, max_depth)) + ("options", fc::variant(tournament_obj.options, max_depth)) + ("start_time", fc::variant(tournament_obj.start_time, max_depth)) + ("end_time", fc::variant(tournament_obj.end_time, max_depth)) + ("prize_pool", fc::variant(tournament_obj.prize_pool, max_depth)) + ("registered_players", fc::variant(tournament_obj.registered_players, max_depth)) + ("tournament_details_id", fc::variant(tournament_obj.tournament_details_id, max_depth)) + ("state", fc::variant(tournament_obj.get_state(), max_depth)); - v = o; -} + v = o; + } -// Manually reflect tournament_object to variant to properly reflect "state" -void from_variant(const fc::variant& v, graphene::chain::tournament_object& tournament_obj, uint32_t max_depth) -{ - fc_elog(fc::logger::get("tournament"), "In tournament_obj from_variant"); - tournament_obj.id = v["id"].as( max_depth ); - tournament_obj.creator = v["creator"].as( max_depth ); - tournament_obj.options = v["options"].as( max_depth ); - tournament_obj.start_time = v["start_time"].as >( max_depth ); - tournament_obj.end_time = v["end_time"].as >( max_depth ); - tournament_obj.prize_pool = v["prize_pool"].as( max_depth ); - tournament_obj.registered_players = v["registered_players"].as( max_depth ); - tournament_obj.tournament_details_id = v["tournament_details_id"].as( max_depth ); - graphene::chain::tournament_state state = v["state"].as( max_depth ); - const_cast(tournament_obj.my->state_machine.current_state())[0] = (int)state; -} + // Manually reflect tournament_object to variant to properly reflect "state" + void from_variant(const fc::variant& v, graphene::chain::tournament_object& tournament_obj, uint32_t max_depth) + { + fc_elog(fc::logger::get("tournament"), "In tournament_obj from_variant"); + tournament_obj.id = v["id"].as( max_depth ); + tournament_obj.creator = v["creator"].as( max_depth ); + tournament_obj.options = v["options"].as( max_depth ); + tournament_obj.start_time = v["start_time"].as >( max_depth ); + tournament_obj.end_time = v["end_time"].as >( max_depth ); + tournament_obj.prize_pool = v["prize_pool"].as( max_depth ); + tournament_obj.registered_players = v["registered_players"].as( max_depth ); + tournament_obj.tournament_details_id = v["tournament_details_id"].as( max_depth ); + graphene::chain::tournament_state state = v["state"].as( max_depth ); + const_cast(tournament_obj.my->state_machine.current_state())[0] = (int)state; + } } //end namespace fc -