CRNVector.h

Go to the documentation of this file.

/* Copyright 2006-2016 Yann LEYDIER, INSA-Lyon, CoReNum, 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: CRNVector.h
 * \author Yann LEYDIER
 */

#ifndef CRNVECTOR_HEADER
#define CRNVECTOR_HEADER

#include <CRNString.h>
#include <algorithm>
#include <cstddef>
#include <CRNData/CRNVectorPtr.h>
#include <CRNData/CRNForeach.h>
#include <CRNData/CRNData.h>

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

            Vector(const Vector &);
            Vector(Vector &&) = default;
            Vector& operator=(const Vector &);
            Vector& operator=(Vector &&) = default;

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

            SObject& operator[](size_t i) { return data[i]; }
            SCObject operator[](size_t i) const { return data[i]; }
            SObject& At(size_t i) { return data[i]; }
            SCObject At(size_t i) const { return data[i]; }

            SObject& Front() { return data.front(); }
            SCObject Front() const { return data.front(); }
            SObject& Back() { return data.back(); }
            SCObject Back() const { return data.back(); }
            bool Contains(const SCObject &o) const;
            void PushBack(const SObject &d);
            void Insert(const SObject &d, size_t pos);

            void ReorderFrom(const std::vector<size_t> &from);
            void ReorderTo(const std::vector<size_t> &to);

            void PopBack() { data.pop_back(); }
            void Remove(size_t index);
            void Remove(const SCObject &obj);
            void Clear() noexcept { data.clear(); }

#include <CRNData/CRNVectorIterator.h>
            iterator begin() { return data.begin(); }
            iterator end() { return data.end(); }
            const_iterator begin() const { return data.begin(); }
            const_iterator end() const { return data.end(); }
            const_iterator cbegin() const { return data.begin(); }
            const_iterator cend() const { return data.end(); }

            void Remove(iterator it);
            void Remove(iterator begin, iterator end);
            template<class Predicate> void RemoveIf(Predicate pred) { Remove(std::remove_if(begin(), end(), pred), end()); }

            const_iterator Find(const SCObject &o) const;
            iterator Find(const SCObject &o);

            template<typename T> std::vector<std::shared_ptr<T>> ToStd()
            {
                std::vector<std::shared_ptr<T>> v;
                for (iterator it = begin(); it != end(); ++it)
                    v.push_back(std::dynamic_pointer_cast<T>(*it));
                return v;
            }
            template<typename T> std::vector<std::shared_ptr<const T>> ToStd() const
            {
                std::vector<std::shared_ptr<const T>> v;
                for (const_iterator it = begin(); it != end(); ++it)
                    v.push_back(std::dynamic_pointer_cast<const T>(*it));
                return v;
            }
            std::vector<SObject> Std() && { return std::move(data); }

            void Swap(Vector &other) noexcept;

            void ShrinkToFit();

            void Deserialize(xml::Element &el);
            xml::Element Serialize(xml::Element &parent) const;
        private:
            virtual std::string getClassName() const { return "Vector"; }

            std::vector<SObject> data; 
        CRN_DECLARE_CLASS_CONSTRUCTOR(Vector)
        public: Vector(xml::Element &el) { Deserialize(el); }
    };
    template<> struct IsSerializable<Vector> : public std::true_type {};
    template<> struct IsClonable<Vector> : public std::true_type {};
    template<> struct IsMetric<Vector> : public std::true_type {};

    double Distance(const Vector &v1, const Vector &v2);

    inline size_t Size(const Vector &v) noexcept { return v.Size(); }
    inline void Swap(Vector &v1, Vector &v2) noexcept { v1.Swap(v2); }
}
CRN_ADD_RANGED_FOR_TO_POINTERS(crn::Vector)
CRN_ADD_RANGED_FOR_TO_CONST_POINTERS(crn::Vector)

namespace std
{
    inline void swap(crn::Vector &v1, crn::Vector &v2) noexcept { v1.Swap(v2); }
}
#endif