vote.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cryptonomex, Inc., 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 <graphene/protocol/types.hpp>
 
namespace graphene { namespace protocol {
 
struct vote_id_type
{
   uint32_t content = 0;
 
   friend size_t hash_value( vote_id_type v ) { return std::hash<uint32_t>()(v.content); }
   enum vote_type
   {
      committee,
      witness,
      worker,
      VOTE_TYPE_COUNT
   };
 
   vote_id_type() = default;
   explicit vote_id_type(vote_type type, uint32_t instance = 0)
      : content(instance<<8 | type)
   {}
   explicit vote_id_type(const std::string& serial)
   { try {
      auto colon = serial.find(':');
      FC_ASSERT( colon != std::string::npos );
      *this = vote_id_type( vote_type( std::stoul(serial.substr(0, colon)) ),
                            uint32_t( std::stoul(serial.substr(colon+1)) ) );
   } FC_CAPTURE_AND_RETHROW( (serial) ) }
 
   void set_type(vote_type type)
   {
      content &= 0xffffff00;
      content |= type & 0xff;
   }
   vote_type type()const
   {
      return vote_type(content & 0xff);
   }
 
   void set_instance(uint32_t instance)
   {
      assert(instance < 0x01000000);
      content &= 0xff;
      content |= instance << 8;
   }
   uint32_t instance()const
   {
      return content >> 8;
   }
 
   vote_id_type& operator =(vote_id_type other)
   {
      content = other.content;
      return *this;
   }
   vote_id_type& operator =(uint32_t instance)
   {
      set_instance(instance);
      return *this;
   }
   operator uint32_t()const
   {
      return instance();
   }
 
   explicit operator std::string()const
   {
      return std::to_string(type()) + ":" + std::to_string(instance());
   }
};
 
} } // graphene::protocol
 
namespace fc
{
 
class variant;
 
void to_variant( const graphene::protocol::vote_id_type& var, fc::variant& vo, uint32_t max_depth = 1 );
void from_variant( const fc::variant& var, graphene::protocol::vote_id_type& vo, uint32_t max_depth = 1 );
 
} // fc
 
FC_REFLECT_TYPENAME( fc::flat_set<graphene::protocol::vote_id_type> )
 
FC_REFLECT_ENUM( graphene::protocol::vote_id_type::vote_type, (witness)(committee)(worker)(VOTE_TYPE_COUNT) )
FC_REFLECT( graphene::protocol::vote_id_type, (content) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::vote_id_type )