Saf/Collection/TreeMap.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_TREEMAP_H
#define SAF_COLLECTION_TREEMAP_H

#include "Pair.h"
#include "../Algo/Struct/RedBlackTree.h"
#include "../Algo/Predicate.h"
#include "../Algo/Selector.h"
#include "../IndexOutOfRangeException.h"

namespace Saf
{
    namespace Collection
    {
        template <class KeyType, class ValType, class CompType = Algo::Predicate::Less<KeyType> > 
        class TreeMap
            : public Algo::Struct::RedBlackTree<KeyType,Pair<const KeyType,ValType>, 
                Algo::Selector::FirstMember<Pair<const KeyType,ValType> >,CompType>
        {
        protected:
            typedef Pair<const KeyType,ValType> RecType;
            typedef Algo::Struct::RedBlackTree<KeyType,RecType,Algo::Selector::FirstMember<RecType>,CompType> BaseType;
            typedef TreeMap<KeyType,ValType,CompType> MyType;

        public:
            typedef typename BaseType::Iterator Iterator;
            typedef typename BaseType::ConstIterator ConstIterator;

        public:
            TreeMap()
                : BaseType()
            {}

            TreeMap(const MyType &m) 
                : BaseType(m)
            {}

            MyType& operator=(const MyType& m)
            {
                BaseType::operator=(m);
                return *this;
            }

            MyType& Swap(MyType& m)
            {
                BaseType::Swap(m);
                return *this;
            }

            ValType& operator[](const KeyType& key)
            {
                Iterator iter = Find(key);

                if (iter == this->End())
                {
                    return Insert(RecType(key, ValType())).m_first->m_second;
                }

                return iter->m_second;
            }

            Iterator Update(const KeyType& key, const ValType& val)
            {
                Pair<Iterator,bool> ins = Insert(RecType(key, val));

                if (!ins.m_second)
                {
                    ins.m_first->m_second = val.m_second;
                }

                return ins.m_first;
            }

            ValType& At(const KeyType& key)
            {
                Iterator iter = Find(key);

                if (iter == this->End())
                {
                    throw IndexOutOfRangeException(SAF_SOURCE_LOCATION, "Key does not exist in the map.");
                }
                
                return iter->m_second;
            }

            const ValType& At(const KeyType& key) const
            {
                ConstIterator iter = Find(key);

                if (iter == this->End())
                {
                    throw IndexOutOfRangeException(SAF_SOURCE_LOCATION, "Key does not exist in the map.");
                }
                
                return iter->m_second;
            }
        };
    }

    namespace Algo
    {
        // Swap specialization for map container.
        template <class KeyType, class ValType, class CompType>
        struct SwapFunc< Collection::TreeMap<KeyType,ValType,CompType> >
        {
            void operator()(Collection::TreeMap<KeyType,ValType,CompType>& x, 
                Collection::TreeMap<KeyType,ValType,CompType>& y)
            {
                x.Swap(y);
            }
        };
    }
}

#endif