UT_Pair.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_Pair.h ( UT Library, C++)
 *
 * COMMENTS:    Simple templated pair of variables.
 */

#ifndef __UT_Pair__
#define __UT_Pair__

#ifdef WIN32
    #pragma warning(disable:4251)
    #pragma warning(disable:4275)
#endif

#include <SYS/SYS_Deprecated.h>
#include <utility>

template <class T1, class T2>
class SYS_DEPRECATED_REPLACE(18.5, "std::pair") UT_Pair
{
public:
    SYS_DEPRECATED_REPLACE(18.5, "std::pair")
    UT_Pair()
        : myFirst(T1()), mySecond(T2()) { }
    SYS_DEPRECATED_REPLACE(18.5, "std::pair")
    UT_Pair(const T1 &v1, const T2 &v2)
        : myFirst(v1), mySecond(v2) { }

    template <class U1 = T1, class U2 = T2>
    SYS_DEPRECATED_REPLACE(18.5, "std::pair")
    UT_Pair(U1 &&v1, U2 &&v2)
        : myFirst(std::forward<U1>(v1))
        , mySecond(std::forward<U2>(v2))
    { }

    bool        operator==(const UT_Pair<T1, T2> &p) const
                {
                    return (myFirst == p.myFirst) && (mySecond == p.mySecond);
                }
    bool        operator!=(const UT_Pair<T1, T2> &p) const
                {
                    return (myFirst != p.myFirst) || (mySecond != p.mySecond);
                }

    T1           myFirst;
    T2           mySecond;
};

SYS_DEPRECATED_PUSH_DISABLE()

/// Common types
typedef UT_Pair<int,int> UT_IntPair;

template<typename OS, typename T1, typename T2>
inline OS &
operator<<(OS &os, const UT_Pair<T1, T2> &p)
{
    os << "UT_Pair(" << p.myFirst << ", " << p.mySecond << ")";
    return os;
}

// For UT::ArraySet.
namespace UT
{
    template <typename T>
    struct DefaultClearer;

    template <typename S0, typename S1>
    struct DefaultClearer<UT_Pair<S0, S1>>
    {
        using Type = UT_Pair<S0, S1>;

        static void clear(Type &v)
        {
            DefaultClearer<S0>::clear(v.myFirst);
            DefaultClearer<S1>::clear(v.mySecond);
        }

        static bool isClear(const Type& v)
        {
            return DefaultClearer<S0>::isClear(v.myFirst) &&
                    DefaultClearer<S1>::isClear(v.mySecond);
        }

        static void clearConstruct(Type *p)
        {
            DefaultClearer<S0>::clearConstruct(&p->myFirst);
            DefaultClearer<S1>::clearConstruct(&p->mySecond);
        }

        static const bool clearNeedsDestruction =
                                DefaultClearer<S0>::clearNeedsDestruction ||
                                DefaultClearer<S1>::clearNeedsDestruction;
    };
}

SYS_DEPRECATED_POP_DISABLE()

#endif