Saf/Collection/Triplet.h

Go to the documentation of this file.

/*
    This file is part of Simple Application Framework (Saf) library.
    Copyright (C) 2010 - 2012 Ondrej Danek <ondrej.danek@gmail.com>

    This library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published 
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Saf 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Simple Application Framework library. If not, 
    see <http://www.gnu.org/licenses/>.
*/

#ifndef SAF_COLLECTION_TRIPLET_H
#define SAF_COLLECTION_TRIPLET_H

#include "Pair.h"

namespace Saf
{
    namespace Collection
    {
        template <class T1, class T2, class T3> 
        class Triplet
            : public Pair<T1,T2>
        {
        public:
            typedef T3 ThirdMemberType;

        public:
            T3 m_third;

        public:
            Triplet()
            {}

            explicit Triplet(const T1& v1)
                : m_first(v1)
            {}

            Triplet(const T1& v1, const T2& v2)
                : m_first(v1), m_second(v2)
            {}

            Triplet(const T1& v1, const T2& v2, const T3& v3)
                : Pair<T1,T2>(v1, v2), m_third(v3)
            {}

            Triplet(const Triplet<T1,T2,T3>& t)
                : Pair<T1,T2>(t), m_third(t.m_third)
            {}

            Triplet<T1,T2,T3>& operator=(const Triplet<T1,T2,T3>& t)
            {
                if (this != &t)
                {
                    Pair<T1,T2>::operator=(t);
                    m_third = t.m_third;
                }
                return *this;
            }

            void Swap(Triplet<T1,T2,T3>& t)
            {
                if (this != &t)
                {
                    Pair<T1,T2>::Swap(t);
                    Algo::Swap(m_third, t.m_third);
                }
            }
        };
    }

    namespace Algo
    {
        // Swap specialization for triplet container.
        template <class T1, class T2, class T3>
        struct SwapFunc< Collection::Triplet<T1,T2,T3> >
        {
            void operator()(Collection::Triplet<T1,T2,T3>& x, Collection::Triplet<T1,T2,T3>& y)
            {
                x.Swap(y);
            }
        };
    }

    namespace Type
    {
        // Traits specialization for triplet container
        template <class T1, class T2, class T3>
        class Traits< Collection::Triplet<T1,T2,T3> >
        {
        public:
            static bool IsPod()
            {
                return Traits<T1>::IsPod() && Traits<T2>::IsPod() && Traits<T3>::IsPod();
            }
        };
    }
}

#endif