keyvalue_pair.h

 
#pragma once
 
#include "system/get_hash_code.h"
#include <system/boxed_value.h>
 
#include <utility>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename TKey, typename TValue>
class ASPOSECPP_SHARED_CLASS KeyValuePair
{
public:
    std::pair<TKey, TValue> m_pair;
 
    KeyValuePair() {}
    KeyValuePair(const TKey& key, const TValue& value) : m_pair(key, value) {}
    template <typename OtherK, typename OtherV>
    KeyValuePair(const std::pair<OtherK, OtherV>& pair) : m_pair(pair) {}
 
    const TKey& get_Key() const { return m_pair.first; }
    const TValue& get_Value() const { return m_pair.second; }
 
    bool IsNull() const { return false; }
 
    bool operator < (const KeyValuePair& kvp) const
    {
        return false;
    }
    String ToString() const
    {
        return u"[" + ToStringHelper(get_Key()) + u", " + ToStringHelper(get_Value()) + u"]";
    }
    int GetHashCode() const
    {
        return (System::GetHashCode(get_Key()) ^ System::GetHashCode(get_Value()));
    }
 
#ifdef ASPOSE_GET_SHARED_MEMBERS
    void PopulateSharedMembers(Object::shared_members_type& result) const
    {
        result.Add("KeyValuePair::Key", this->m_pair.first);
        result.Add("KeyValuePair::Value", this->m_pair.second);
    }
#endif
 
private:
    template<class C>
    static typename std::enable_if<std::is_arithmetic<C>::value || std::is_enum<C>::value, String>::type
    ToStringHelper(const C& value)
    {
        return String::Format(u"{0}", value);
    }
    template<typename C>
    static typename std::enable_if<(!std::is_arithmetic<C>::value && !std::is_enum<C>::value && !IsSmartPtr<C>::value), String>::type
    ToStringHelper(const C& obj)
    {
        return obj.ToString();
    }
    template<typename C>
    static typename std::enable_if<IsSmartPtr<C>::value, String>::type
    ToStringHelper(const C& obj)
    {
        if (obj == nullptr)
            return u"nullptr";
        return obj.GetObjectOrNull()->ToString();
    }
    static String ToStringHelper(const String& s)
    {
        return s;
    }
 
};
 
template<typename TKey, typename TValue>
bool operator==(const KeyValuePair<TKey,TValue>& left, const KeyValuePair<TKey,TValue>& right)
{
    return System::Details::AreEqual(left.get_Key(), right.get_Key()) && System::Details::AreEqual(left.get_Value(), right.get_Value());
}
 
template<typename TKey, typename TValue>
bool operator!=(const KeyValuePair<TKey,TValue>& left, const KeyValuePair<TKey,TValue>& right)
{
    return ! (left == right);
}
 
template<typename TKey, typename TValue>
std::ostream& operator<<(std::ostream& stream, const KeyValuePair<TKey, TValue>& pair)
{
    stream << pair.ToString();
    return stream;
}
 
template<typename TKey, typename TValue>
std::wostream& operator<<(std::wostream& stream, const KeyValuePair<TKey, TValue>& pair)
{
    stream << pair.ToString();
    return stream;
}
 
} // namespace Generic
} // namespace Collections
} // namespace System
 
 
namespace System
{
 
 
template<typename TKey, typename TValue> struct IsBoxable<Collections::Generic::KeyValuePair<TKey, TValue>> : std::true_type {};
 
template<typename TKey, typename TValue>
class BoxedValue<System::Collections::Generic::KeyValuePair<TKey, TValue>> : public DefaultBoxedValue<System::Collections::Generic::KeyValuePair<TKey, TValue>>
{
public:
    BoxedValue(const System::Collections::Generic::KeyValuePair<TKey, TValue>& value)
        : DefaultBoxedValue<System::Collections::Generic::KeyValuePair<TKey, TValue>>(value)
    {}
};
 
 
}
 
namespace std{
 
template<typename TKey, typename TValue>
struct hash<System::Collections::Generic::KeyValuePair<TKey, TValue> >
{
    std::size_t operator()(const System::Collections::Generic::KeyValuePair<TKey, TValue> & kvp) const
    {
        return (System::GetHashCode(kvp.get_Key()) ^ System::GetHashCode(kvp.get_Value()));
    }
};
 
}