key_value_pair.hpp

Go to the documentation of this file.

 
#pragma once
#include <utility>
#include "../../is.hpp"
#include "../../object.hpp"
#include "../../iequatable.hpp"
#include "../../static.hpp"
#define __XTD_CORE_INTERNAL__
#include "../../internal/__key_value_pair_definition.hpp"
#undef  __XTD_CORE_INTERNAL__
 
namespace xtd {
  namespace collections {
    namespace generic {
      template <typename key_t, typename value_t>
      class key_value_pair : public xtd::object, public xtd::iequatable<key_value_pair<key_t, value_t>> {
      public:
        
        using base_type = std::pair<key_t, value_t>;
        using key_type = key_t;
        using value_type = value_t;
        using first_type  = key_type;
        using second_type = value_type;
        
        
        key_value_pair() = default;
        key_value_pair(const key_t& key, const value_t& value) : first {key}, second {value} {}
        key_value_pair(const std::pair<key_t, value_t>& value) : first {value.first}, second {value.second} {} // Can't be explicit by design.
        
        
        key_t first = key_t {};
        value_t second = value_t {};
        
        const key_t& key() const noexcept {
          return first;
        };
        
        const value_t& value() const noexcept {
          return second;
        };
        
        
        xtd::string to_string() const noexcept override;
        
        bool equals(const key_value_pair& value) const noexcept override {return first == value.first && second == value.second;}
        
        bool equals(const object& obj) const noexcept override {return is<key_value_pair>(obj) && equals(static_cast<const key_value_pair&>(obj));}
        
        
        operator std::pair<key_t, value_t>() const noexcept {return {first, second};}
      };
      
      template <>
      class key_value_pair<> static_ {
      public:
        
        template<typename key_t, typename value_t>
        static key_value_pair<key_t, value_t> create(key_t key, value_t value) {return key_value_pair<key_t, value_t>(key, value);}
      };
    }
  }
}