key_value_pair.hpp

Go to the documentation of this file.

 
#pragma once
#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__
#include <utility>
#include <tuple>
 
namespace xtd {
  namespace collections {
    namespace generic {
      template <class key_t, class value_t>
      struct key_value_pair : xtd::object, xtd::iequatable<key_value_pair<key_t, value_t>> {
        
        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} {}
        template <class key_type_t, class value_type_t>
        key_value_pair(key_type_t&& key, value_type_t&& value) : first(std::move(key)), second(std::move(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_value_pair(std::pair<key_t, value_t>&& value) : first {std::move(value.first)}, second {std::move(value.second)} {}
        template<class... args1_t, class... args2_t>
        key_value_pair(std::piecewise_construct_t, std::tuple<args1_t...> first_args, std::tuple<args2_t...> second_args) : first {first_args}, second {second_args} {}
 
        key_value_pair(key_value_pair&&) = default;
        key_value_pair(const key_value_pair&) = default;
        key_value_pair& operator =(key_value_pair&&) = default;
        key_value_pair& operator =(const key_value_pair&) = default;
 
        
        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;}
        
        
        bool equals(const object& obj) const noexcept override {return is<key_value_pair>(obj) && equals(static_cast<const key_value_pair&>(obj));}
        
        bool equals(const key_value_pair& value) const noexcept override {return first == value.first && second == value.second;}
 
        xtd::string to_string() const noexcept override; // defined in "../../string.hpp"
        
        
        operator std::pair<key_t, value_t>() const noexcept {return {first, second};}
      };
      
      template <>
      struct key_value_pair<> static_ {
        
        template<class key_t, class 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);}
      };
      
      // C++17 deduction guides for xtd::collections::generic::key_value_pair
      // {
      template<class key_t, class value_t>
      key_value_pair(key_t, value_t) -> key_value_pair<key_t, value_t>;
      // }
  }
  }
}