CRNMap.h

Go to the documentation of this file.

/* Copyright 2006-2016 Yann LEYDIER, CoReNum, INSA-Lyon, Université Paris Descartes, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn 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 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn 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 libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNMap.h
 * \author Yann LEYDIER
 */

#ifndef CRNMAP_H
#define CRNMAP_H

#include <CRNString.h>
#include <CRNIO/CRNPath.h>
#include <map>
#include <CRNData/CRNMapPtr.h>
#include <CRNData/CRNForeach.h>
#include <set>

namespace crn
{
    /****************************************************************************/
    class Map: public Object
    {
        public:
            Map();
            virtual ~Map() override;

            Map(const Map &other);
            Map& operator=(const Map &other);
            Map(Map &&) = default;
            Map& operator=(Map &&) = default;

            size_t Size() const noexcept { return data.size(); }
            bool IsEmpty() const noexcept { return data.empty(); }

            SObject& operator[](const String &s) { return data[s]; }
            SObject Get(const String &s);
            SCObject Get(const String &s) const;
            void Set(const String &key, SObject value);

            using iterator = std::map<String, SObject>::iterator;

            void Remove(const String &key);
            void Remove(const SObject &obj);
            void Remove(iterator it);
            void Remove(iterator first, iterator end_);
            void Clear() noexcept { data.clear(); }

            iterator begin() { return data.begin(); }
            iterator end() { return data.end(); }
            iterator Find(const String &key) { return data.find(key); }

            using const_iterator = std::map<String, SObject>::const_iterator;
            const_iterator begin() const { return data.begin(); }
            const_iterator end() const { return data.end(); }
            const_iterator cbegin() const { return data.cbegin(); }
            const_iterator cend() const { return data.cend(); }
            const_iterator Find(const String &key) const { return data.find(key); }

            using reverse_iterator = std::map<String, SObject>::reverse_iterator;
            reverse_iterator rbegin() { return data.rbegin(); }
            reverse_iterator rend() { return data.rend(); }

            using const_reverse_iterator = std::map<String, SObject>::const_reverse_iterator;
            const_reverse_iterator rbegin() const { return data.rbegin(); }
            const_reverse_iterator rend() const { return data.rend(); }

            using pair = std::pair<const crn::String, SObject>;

            std::set<String> GetKeys() const;
            String FirstKey() const;
            String LastKey() const;

            void Swap(Map &other) noexcept;

            std::map<String, SObject> Std() && { return std::move(data); }

            void Deserialize(xml::Element &el);
            xml::Element Serialize(xml::Element &parent) const;

            void Load(const Path &fname);
            void Save(const Path &fname) const;

        private:
            std::map<String, SObject> data; 
        CRN_DECLARE_CLASS_CONSTRUCTOR(Map)
        public: Map(xml::Element &el) { Deserialize(el); }
    };
    template<> struct IsSerializable<Map> : public std::true_type {};
    template<> struct IsClonable<Map> : public std::true_type {};

    inline void Swap(Map &m1, Map &m2) noexcept { m1.Swap(m2); }
}
CRN_ADD_RANGED_FOR_TO_POINTERS(crn::Map)
CRN_ADD_RANGED_FOR_TO_CONST_POINTERS(crn::Map)

namespace std
{
    inline void swap(crn::Map &m1, crn::Map &m2) noexcept { m1.Swap(m2); }
}
#endif