Node.h

Go to the documentation of this file.

 
#pragma once
#include "NodeRoles.h"
#include "catapult/model/NetworkInfo.h"
#include "catapult/utils/Hashers.h"
#include <unordered_set>
 
namespace catapult { namespace ionet {
 
    struct NodeVersion_tag {};
 
    using NodeVersion = utils::BaseValue<uint32_t, NodeVersion_tag>;
 
    struct NodeEndpoint {
        std::string Host;
 
        unsigned short Port;
    };
 
    struct NodeMetadata {
    public:
        NodeMetadata() : NodeMetadata(model::NetworkIdentifier::Zero)
        {}
 
        explicit NodeMetadata(model::NetworkIdentifier networkIdentifier) : NodeMetadata(networkIdentifier, "")
        {}
 
        NodeMetadata(model::NetworkIdentifier networkIdentifier, const std::string& name)
                : NodeMetadata(networkIdentifier, name, NodeVersion(), NodeRoles::None)
        {}
 
        NodeMetadata(model::NetworkIdentifier networkIdentifier, const std::string& name, NodeVersion version, NodeRoles roles)
                : NetworkIdentifier(networkIdentifier)
                , Name(name)
                , Version(version)
                , Roles(roles)
        {}
 
    public:
        model::NetworkIdentifier NetworkIdentifier;
 
        std::string Name;
 
        NodeVersion Version;
 
        NodeRoles Roles;
    };
 
    class Node {
    public:
        Node();
 
        Node(const Key& identityKey, const NodeEndpoint& endpoint, const NodeMetadata& metadata);
 
    public:
        const Key& identityKey() const;
 
        const NodeEndpoint& endpoint() const;
 
        const NodeMetadata& metadata() const;
 
    public:
        bool operator==(const Node& rhs) const;
 
        bool operator!=(const Node& rhs) const;
 
    public:
        friend std::ostream& operator<<(std::ostream& out, const Node& node);
 
    private:
        Key m_identityKey;
        NodeEndpoint m_endpoint;
        NodeMetadata m_metadata;
 
        std::string m_printableName;
    };
 
    struct NodeHasher {
        size_t operator()(const Node& node) const {
            return utils::ArrayHasher<Key>()(node.identityKey());
        }
    };
 
    using NodeSet = std::unordered_set<Node, NodeHasher>;
}}