Saf/Collection/Pair.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_PAIR_H
#define SAF_COLLECTION_PAIR_H

#include "../Algo/Swap.h"
#include "../Type/Traits.h"

namespace Saf
{
    namespace Collection
    {
        template <class T1, class T2> 
        class Pair
        {
        public:
            typedef T1 FirstMemberType;
            typedef T2 SecondMemberType;

        public:
            T1 m_first;
            T2 m_second;

        public:
            Pair()
            {}

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

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

            Pair(const Pair<T1,T2>& p)
                : m_first(p.m_first), m_second(p.m_second)
            {}

            Pair<T1,T2>& operator=(const Pair<T1,T2>& p)
            {
                if (this != &p)
                {
                    m_first = p.m_first;
                    m_second = p.m_second;
                }
                return *this;
            }

            void Swap(Pair<T1,T2>& p)
            {
                if (this != &p)
                {
                    Algo::Swap(m_first, p.m_first);
                    Algo::Swap(m_second, p.m_second);
                }
            }
        };
    }

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

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

#endif