KeyValuePair.h

//========================================================================================
// 
// $File$
// 
// Owner: Mat Marcus (mmarcus)
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// Purpose: clone of std::K2Pair based on STLPort 4.0 
// 
//========================================================================================

#ifndef __KEYVALUEPAIR__
#define __KEYVALUEPAIR__

#include <adobe/move.hpp>
#include <adobe/typeinfo.hpp>

template <class _T1, class _T2>
struct KeyValuePair {
 typedef object_type data_type; 

 typedef _T1 key_type;
 typedef _T2 value_type;

 KeyValuePair() : fKey(), fValue() {}
 
 KeyValuePair(adobe::move_from<KeyValuePair> other)
 : fKey(adobe::move(other.source.fKey)), fValue(adobe::move(other.source.fValue)) {}
 
 KeyValuePair(_T1 __a, _T2 __b)
 : fKey(adobe::move(__a)), fValue(adobe::move(__b)) {}

 KeyValuePair(const KeyValuePair &other) = default;
 KeyValuePair(KeyValuePair &&other) = default;
 KeyValuePair& operator=(const KeyValuePair &other) = default;
 KeyValuePair& operator=(KeyValuePair &&other) = default;

 friend inline void swap(KeyValuePair<_T1, _T2>& a, KeyValuePair<_T1, _T2>& b)
 {
 using std::swap;
 swap(a.fKey, b.fKey);
 swap(a.fValue, b.fValue);
 }

 _T1 fKey;
 _T2 fValue;
 
 _T1& Key() { return fKey; }
 
 _T2& Value() { return fValue; }

 const _T1& Key() const { return fKey; }

 const _T2& Value() const { return fValue; }
 
 void SetValue(const _T2& val) { fValue = val; }
};

// specialize adobe::type_info<> to avoid typeid problems across DLL boundaries
ADOBE_NAME_TYPE_2("keyvaluepair:indesign:adobe",KeyValuePair<T0,T1>)


template <class _T1, class _T2>
inline bool operator==(const KeyValuePair<_T1, _T2>& __x, const KeyValuePair<_T1, _T2>& __y)
{ 
 return __x.Key() == __y.Key() && __x.Value() == __y.Value(); 
}

template <class _T1, class _T2>
inline bool operator==(const KeyValuePair<_T1, _T2>& __x, const _T1& __y)
{ 
 return __x.Key() == __y; 
}

template <class _T1, class _T2>
inline bool operator==(const _T1& __y, const KeyValuePair<_T1, _T2>& __x)
{ 
 return __x.Key() == __y; 
}

template <class _T1, class _T2>
inline bool operator<(const KeyValuePair<_T1, _T2>& __x, const KeyValuePair<_T1, _T2>& __y)
{ 
 return __x.Key() < __y.Key(); 
}

template <class _T1, class _T2>
inline bool operator<(const KeyValuePair<_T1, _T2>& __x, const _T1& __y)
{ 
 return __x.Key() < __y; 
}

template <class _T1, class _T2>
inline bool operator<(const _T1& __y, const KeyValuePair<_T1, _T2>& __x)
{ 
 return __y < __x.Key(); 
}

template <class _T1, class _T2>
inline bool operator!=(const KeyValuePair<_T1, _T2>& __x, const KeyValuePair<_T1, _T2>& __y) {
 return !(__x == __y);
}

template <class _T1, class _T2>
inline bool operator>(const KeyValuePair<_T1, _T2>& __x, const KeyValuePair<_T1, _T2>& __y) {
 return __y < __x;
}

template <class _T1, class _T2>
inline bool operator<=(const KeyValuePair<_T1, _T2>& __x, const KeyValuePair<_T1, _T2>& __y) {
 return !(__y < __x);
}

template <class _T1, class _T2>
inline bool operator>=(const KeyValuePair<_T1, _T2>& __x, const KeyValuePair<_T1, _T2>& __y) {
 return !(__x < __y);
}

template <class _T1, class _T2>
inline KeyValuePair<_T1, _T2> K2make_keyvalue_pair(const _T1& __x, const _T2& __y)
{
 return KeyValuePair<_T1, _T2>(__x, __y);
}

// For sorted KeyValue vectors
template <class T>
struct KeyValueLess {
 bool operator()(const T& lhs, const T& rhs)
{
 return lhs.fKey < rhs.fKey;
}
}; 

template <class Key, class Value>
struct KeyMatchPredicate {
 KeyMatchPredicate(const Key& key) : fKey(key) {}
 
 bool operator()(const KeyValuePair<Key,Value>& x) { return x.Key() == fKey; }
 Key fKey;
};


template <class Key, class Container>
int32 FindLocation(const Container& cont, const Key& key)
{
 typedef typename Container::value_type KVP;
 typedef typename KVP::value_type Value;

 typename Container::const_iterator p = std::find_if(cont.begin(), cont.end(), KeyMatchPredicate<Key, Value>(key));
 return cont.end() == p ? -1 : p - cont.begin();
}


template <class Key, class Value>
struct ValueMatchPredicate {
 ValueMatchPredicate(const Value& value) : fValue(value) {}
 bool operator()(const KeyValuePair<Key,Value>& x) { return x.Value() == fValue; }
 Value fValue;
};


template <class Value, class Container>
int32 FindLocationByValue(const Container& cont, const Value& value)
{
 typedef typename Container::value_type KVP;
 typedef typename KVP::key_type Key;

 typename Container::const_iterator p = std::find_if(cont.begin(), cont.end(), ValueMatchPredicate<Key, Value>(value));
 return cont.end() == p ? -1 : p - cont.begin();
}


template <class Key, class Value, class Container>
void InsertKeyValue(Container& cont, const Key& key, const Value& val)
{
 cont.push_back(KeyValuePair<Key, Value>(key, val));
}



template <class Key, class Value, class Container>
void InsertOrReplaceKeyValue(Container& cont, const Key& key, const Value& val)
{
 typename Container::iterator p = K2find(cont.begin(), cont.end(), key);
 if (p == cont.end())
 cont.push_back(KeyValuePair<Key, Value>(key, val));
 else
 p->SetValue(val);
}


template <class Value, class Container>
int32 InsertInSorted(Container& c, const Value& t)
{
 typename Container::iterator i = std::lower_bound(c.begin(), c.end(), t);
 i = c.insert(i, t);
 return i - c.begin();
}

template <class Key, class Value, class Container>
int32 InsertKeyValueInSorted(Container& c,const Key& k,const Value& v)
{
 const KeyValuePair<Key, Value> el(k,v);
 
 typename Container::iterator i = std::lower_bound(c.begin(), c.end(), el);
 ASSERT(i == c.end() || *i != el);
 i = c.insert(i, el);
 return i - c.begin();
}

template <class Key, class Value, class Container>
int32 InsertOrReplaceKeyValueInSorted(Container& c, const Key& k, const Value& v)
{
 typename Container::iterator i = std::lower_bound(c.begin(), c.end(), k);
 if (i == c.end() || i->Key() != k)
 i = c.insert( i, KeyValuePair<Key, Value>(k, v));
 else
 i->SetValue(v);
 return i - c.begin();
}

template <class Key, class Container>
int32 FindLocationInSorted(const Container& c, const Key& k)
{
 typename Container::const_iterator i = std::lower_bound(c.begin(), c.end(), k);
 return (i != c.end() && *i == k) ? (i - c.begin()) : -1;
}

#endif /* __KEYVALUEPAIR__ */