triplet.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */

#pragma once

#ifndef _TRIPLET_H_
#define _TRIPLET_H_

#include <utility>

namespace mbo
{

/****************************************************************************/

template<typename _Ty1, typename _Ty2, typename _Ty3>
struct triplet: public std::pair<_Ty1, _Ty2>
{
    typedef std::pair<_Ty1, _Ty2>     _Mybase;
    typedef triplet<_Ty1, _Ty2, _Ty3> _Myt;
    typedef _Ty3 third_type;

    triplet()
        : _Mybase()
        , third(_Ty3())
    {
    }

    triplet(const _Ty1& val1, const _Ty2& val2, const _Ty3& val3)
        : _Mybase(val1, val2)
        , third(val3)
    {
    }

    template<typename _O1, typename _O2, typename _O3>
    triplet(const triplet<_O1, _O2, _O3>& rhs)
        : _Mybase(rhs.first, rhs.second)
        , third(rhs.third)
    {
    }

    void swap(_Myt& rhs)
    {
        std::swap(first,  rhs.first);
        std::swap(second, rhs.second);
        std::swap(third,  rhs.third);
    }

    third_type   third;
};

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline bool __cdecl operator == (const triplet<_Ty1, _Ty2, _Ty3>& lhs, const triplet<_Ty1, _Ty2, _Ty3>& rhs)
{
    return (lhs.first == rhs.first && lsh.second == rhs.second && lsh.third == rhs.third);
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline bool __cdecl operator != (const triplet<_Ty1, _Ty2, _Ty3>& lhs, const triplet<_Ty1, _Ty2, _Ty3>& rhs)
{
    return (!(lhs == rhs));
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline bool __cdecl operator < (const triplet<_Ty1, _Ty2, _Ty3>& lhs, const triplet<_Ty1, _Ty2, _Ty3>& rhs)
{
    return lhs::pair < rhs::pair  ||
        (!(rhs.first < lhs.first) && lhs.second < rhs.second) ||
        (!(rhs.first < lhs.first) && !(rhs.second < lhs.second) && lhs.third < rhs.third)
        ;
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline bool __cdecl operator > (const triplet<_Ty1, _Ty2, _Ty3>& lhs, const triplet<_Ty1, _Ty2, _Ty3>& rhs)
{
    return (rhs < lhs);
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline bool __cdecl operator <= (const triplet<_Ty1, _Ty2, _Ty3>& lhs, const triplet<_Ty1, _Ty2, _Ty3>& rhs)
{
    return (!(rhs < lhs));
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline bool __cdecl operator >= (const triplet<_Ty1, _Ty2, _Ty3>& lhs, const triplet<_Ty1, _Ty2, _Ty3>& rhs)
{
    return (!(lhs < rhs));
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline triplet<_Ty1, _Ty2, _Ty3> __cdecl make_triplet(_Ty1 val1, _Ty2 val2, _Ty3 val3)
{
    return (triplet<_Ty1, _Ty2, _Ty3>(val1, val2, val3));
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline void swap(triplet<_Ty1, _Ty2, _Ty3>& lhs, triplet<_Ty1, _Ty2, _Ty3>& rhs)
{
    lhs.swap(rhs);
}

} // namespace mbo

#endif // _TRIPLET_H_

---