SequenceContainer.h

Go to the documentation of this file.

/******************************************************************************
*
* Copyright Saab AB, 2004-2015 (http://safirsdkcore.com)
*
* Created by: Joel Ottosson / joot
*
*******************************************************************************
*
* This file is part of Safir SDK Core.
*
* Safir SDK Core is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU General Public License as
* published by the Free Software Foundation.
*
* Safir SDK Core 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 Internals.
*
* You should have received a copy of the GNU General Public License
* along with Safir SDK Core.  If not, see <http://www.gnu.org/licenses/>.
*
******************************************************************************/
#pragma once
 
#include <Safir/Dob/Typesystem/ChannelId.h>
#include <Safir/Dob/Typesystem/ContainerBase.h>
#include <Safir/Dob/Typesystem/EntityId.h>
#include <Safir/Dob/Typesystem/HandlerId.h>
#include <Safir/Dob/Typesystem/Object.h>
#include <Safir/Dob/Typesystem/Utilities.h>
#include <deque>
#include <stdexcept>
#include <typeinfo>
#include <vector>
 
namespace Safir
{
namespace Dob
{
namespace Typesystem
{
    template <class T>
    class SequenceContainer : public ContainerBase
    {
    public:
 
        typedef T ContainedType;
        typedef std::deque<T> StorageType; //we use std::deque instead of std::vector, to avoid std::vector<bool> specialization
        typedef typename StorageType::const_iterator const_iterator;
 
        SequenceContainer()
            :ContainerBase()
            ,m_values()
        {
        }
 
        bool IsNull() const override {return empty();}
 
        void SetNull() override
        {
            clear();
        }
 
        size_t size() const {return m_values.size();}
 
        bool empty() const {return m_values.empty();}
 
        const ContainedType& front() const {return m_values.front();}
 
        const ContainedType& back() const {return m_values.back();}
 
        const_iterator begin() const {return m_values.begin();}
 
        const_iterator end() const {return m_values.end();}
 
        void clear()
        {
            m_bIsChanged=true;
            m_values.clear();
        }
 
        const ContainedType& operator [](const size_t index) const
        {
            return m_values[index];
        }
 
        const ContainedType& at(const size_t index) const
        {
            return m_values.at(index);
        }
 
        void push_back(const ContainedType& val)
        {
            m_bIsChanged=true;
            m_values.push_back(val);
        }
 
        void SetVal(const size_t index, const ContainedType& val)
        {
            if (index >= m_values.size())
            {
                throw std::out_of_range("Index out of range.");
            }
            m_bIsChanged=true;
            m_values[index]=val;
        }
 
        const ContainedType& GetVal(const size_t index) const
        {
            return m_values.at(index);
        }
 
        void InsertAt(const size_t index, const ContainedType& value)
        {
            m_bIsChanged=true;
            m_values.insert(m_values.begin()+index, value);
        }
 
        void EraseAt(const size_t index)
        {
            m_bIsChanged=true;
            m_values.erase(m_values.begin()+index);
        }
 
        void Copy(const ContainerBase& that) override
        {
            if (this != &that)
            {
                if (typeid(*this) != typeid(that))
                {
                    throw SoftwareViolationException(L"Invalid call to Copy, containers are not of same type",__WFILE__,__LINE__);
                }
 
                const SequenceContainer<ContainedType>& other=
                    static_cast<const SequenceContainer<ContainedType>& >(that);
 
                m_bIsChanged=other.m_bIsChanged;
                m_values.clear();
                for (typename StorageType::const_iterator it=other.m_values.begin(); it!=other.m_values.end(); ++it)
                {
                    m_values.push_back(SequenceCopyHelper<ContainedType>::Copy(*it));
                }
            }
        }
 
    private:
        template <class U> struct SequenceCopyHelper
        {
            static U Copy(const U& val) {return val;}
        };
 
        template <class U> struct SequenceCopyHelper< std::shared_ptr<U> >
        {
            static std::shared_ptr<U> Copy(const std::shared_ptr<U> & val) {return std::static_pointer_cast<U>(val->Clone());}
        };
 
        StorageType m_values;
    };
 
    class EnumerationSequenceContainerBase : public ContainerBase
    {
    public:
        EnumerationSequenceContainerBase()
            : ContainerBase()
        {
        }
 
        bool IsNull() const override {return empty();}
 
        void SetNull() override
        {
            clear();
        }
 
        virtual size_t size() const = 0;
 
        virtual bool empty() const = 0;
 
        virtual void clear() = 0;
 
        virtual void PushBackOrdinal(const EnumerationValue val) = 0;
 
        virtual void SetOrdinal(const size_t index, const EnumerationValue val) = 0;
 
        virtual EnumerationValue GetOrdinal(const size_t index) const = 0;
 
        virtual void InsertOrdinalAt(const size_t index, EnumerationValue value) = 0;
 
        virtual void EraseAt(const size_t index) = 0;
    };
 
    template <class T>
    class EnumerationSequenceContainer : public EnumerationSequenceContainerBase
    {
    public:
        typedef typename T::Enumeration ContainedType;
        typedef std::deque<ContainedType> StorageType; //we use std::deque instead of std::vector, to avoid std::vector<bool> specialization
        typedef typename StorageType::const_iterator const_iterator;
 
        EnumerationSequenceContainer()
            :EnumerationSequenceContainerBase()
            ,m_values()
        {
        }
 
        size_t size() const override {return m_values.size();}
 
        bool empty() const override {return m_values.empty();}
 
        ContainedType front() const {return m_values.front();}
 
        ContainedType back() const {return m_values.back();}
 
        const_iterator begin() const {return m_values.begin();}
 
        const_iterator end() const {return m_values.end();}
 
        void clear() override
        {
            m_bIsChanged=true;
            m_values.clear();
        }
 
        ContainedType operator[](const size_t index) const
        {
            T::CheckForMismatch();
            return m_values[index];
        }
 
        ContainedType at(const size_t index) const
        {
            T::CheckForMismatch();
            return m_values.at(index);
        }
 
        void push_back(const ContainedType val)
        {
            T::CheckForMismatch();
            PushBackOrdinal(val);
        }
 
        void PushBackOrdinal(const EnumerationValue val) override
        {
            if (val < T::FirstOrdinal() || val > T::LastOrdinal())
            {
                throw Safir::Dob::Typesystem::IllegalValueException(L"The enumerated type DotsTest.TestEnum does not have such a value",__WFILE__,__LINE__);
            }
            m_bIsChanged=true;
            m_values.push_back(static_cast<ContainedType>(val));
        }
 
 
        void SetVal(const size_t index, const ContainedType val)
        {
            T::CheckForMismatch();
            SetOrdinal(index, val);
        }
 
        ContainedType GetVal(const size_t index) const
        {
            T::CheckForMismatch();
            return m_values.at(index);
        }
 
        void SetOrdinal(const size_t index, const EnumerationValue val) override
        {
            if (index >= m_values.size())
            {
                throw std::out_of_range("Index out of range.");
            }
 
            if (val < T::FirstOrdinal() || val > T::LastOrdinal())
            {
                throw Safir::Dob::Typesystem::IllegalValueException(L"The enumerated type DotsTest.TestEnum does not have such a value",__WFILE__,__LINE__);
            }
 
            m_bIsChanged=true;
            m_values[index]=static_cast<ContainedType>(val);
        }
 
        EnumerationValue GetOrdinal(const size_t index) const override
        {
            return m_values.at(index);
        }
 
        void InsertAt(const size_t index, ContainedType value)
        {
            T::CheckForMismatch();
            InsertOrdinalAt(index, value);
        }
 
        void InsertOrdinalAt(const size_t index, EnumerationValue value) override
        {
            if (value < T::FirstOrdinal() || value > T::LastOrdinal())
            {
                throw Safir::Dob::Typesystem::IllegalValueException(L"The enumerated type DotsTest.TestEnum does not have such a value",__WFILE__,__LINE__);
            }
 
            m_bIsChanged=true;
            m_values.insert(m_values.begin()+index, static_cast<ContainedType>(value));
        }
 
        void EraseAt(const size_t index) override
        {
            m_bIsChanged=true;
            m_values.erase(m_values.begin()+index);
        }
 
        void Copy(const ContainerBase& that) override
        {
            if (this != &that)
            {
                if (typeid(*this) != typeid(that))
                {
                    throw SoftwareViolationException(L"Invalid call to Copy, containers are not of same type",__WFILE__,__LINE__);
                }
 
                const auto& other=
                    static_cast<const EnumerationSequenceContainer<T>& >(that);
 
                m_bIsChanged = other.m_bIsChanged;
                m_values = other.m_values;
            }
        }
 
    private:
        StorageType m_values;
    };
 
 
    class GenericObjectSequenceContainerBase
    {
    public:
        virtual bool IsChangedHere() const = 0;
 
        virtual void SetChangedHere(const bool changed) = 0;
 
        virtual size_t size() const = 0;
 
#ifndef SAFIR_NO_DEPRECATED
        virtual ObjectPtr GetObj(const size_t index) = 0;
 
        virtual ObjectConstPtr GetObj(const size_t index) const = 0;
#endif
        virtual ObjectPtr GetObjectPointer(const size_t index) = 0;
 
        virtual ObjectConstPtr GetObjectPointer(const size_t index) const = 0;
 
        virtual void SetObjectPointer(const size_t index, const ObjectPtr& ptr) = 0;
 
        virtual void PushBackObjectPointer(const ObjectPtr& ptr) = 0;
 
    private:
        friend void Utilities::MergeChanges(ObjectPtr into, const ObjectConstPtr& from);
 
        virtual void Merge(const GenericObjectSequenceContainerBase& other) = 0;
    };
 
 
    template <class T>
    class GenericObjectSequenceContainer
        : public SequenceContainer<std::shared_ptr<T> >
        , public GenericObjectSequenceContainerBase
    {
        typedef SequenceContainer<std::shared_ptr<T> > Base;
    public:
        typedef std::shared_ptr<T> T_Ptr;
 
        bool IsChanged() const override
        {
            if (Base::m_bIsChanged)
            {
                return true;
            }
 
            for (typename Base::const_iterator it=Base::begin(); it!=Base::end(); ++it)
            {
                if ((*it)->IsChanged()) //something in an object has changed
                {
                    return true;
                }
            }
 
            return false;
        }
 
        bool IsChangedHere() const override
        {
            return Base::m_bIsChanged;
        }
 
        void SetChanged(const bool changed) override
        {
            Base::m_bIsChanged = changed;
 
            for (typename Base::const_iterator it=Base::begin(); it!=Base::end(); ++it)
            {
                (*it)->SetChanged(changed);
            }
        }
 
        void SetChangedHere(const bool changed) override
        {
            Base::m_bIsChanged = changed;
        }
 
        size_t size() const override {return Base::size();}
#ifndef SAFIR_NO_DEPRECATED
        ObjectPtr GetObj(const size_t index) override {return Base::operator[](index);}
        ObjectConstPtr GetObj(const size_t index) const override {return Base::operator[](index);}
#endif
        T_Ptr GetPtr(const size_t index)
        {
            return Base::at(index);
        }
 
        ObjectPtr GetObjectPointer(const size_t index) override
        {
            return GetPtr(index);
        }
 
        std::shared_ptr<const T> GetPtr(const size_t index) const
        {
            return Base::at(index);
        }
 
        ObjectConstPtr GetObjectPointer(const size_t index) const override
        {
            return GetPtr(index);
        }
 
        void SetPtr(const size_t index, const T_Ptr& ptr)
        {
            Base::SetVal(index, ptr);
        }
 
        void SetObjectPointer(const size_t index, const ObjectPtr& ptr) override
        {
            const auto tptr = std::dynamic_pointer_cast<T>(ptr);
            if (tptr == nullptr)
            {
                throw SoftwareViolationException(L"Invalid call to SetPtr, incompatible types!", __WFILE__,__LINE__);
            }
            SetPtr(index, tptr);
        }
 
        void PushBackObjectPointer(const ObjectPtr& ptr) override
        {
            const auto tptr = std::dynamic_pointer_cast<T>(ptr);
            if (tptr == nullptr)
            {
                throw SoftwareViolationException(L"Invalid call to PushBackObjectPointer, incompatible types!", __WFILE__,__LINE__);
            }
            Base::push_back(tptr);
        }
 
    private:
#ifdef SAFIR_NO_DEPRECATED
        void SetVal(const size_t index, const typename Base::ContainedType& val) = delete;
        const typename Base::ContainedType& GetVal(const size_t index) const = delete;
#endif
 
        void Merge(const GenericObjectSequenceContainerBase& that) override
        {
#ifndef NDEBUG
            if (typeid(GenericObjectSequenceContainer<T>) != typeid(that))
            {
                throw SoftwareViolationException(L"Invalid call to Merge, containers are not of same type",
                                                 __WFILE__,__LINE__);
            }
#endif
 
            const GenericObjectSequenceContainer<T>& other =
                static_cast<const GenericObjectSequenceContainer<T>&>(that);
 
            //Note: this function only gets called when IsChangedHere() == false
 
            if (!other.IsChanged())
            {
                return;
            }
 
            if (Base::size() != other.size())
            {
                throw SoftwareViolationException(L"It is not possible to merge two object sequences of different sizes.",
                                                 __WFILE__,__LINE__);
            }
 
            for (size_t i = 0; i < Base::size(); ++i)
            {
                if (other.at(i)->IsChanged())
                {
                    //recurse
                    Utilities::MergeChanges(Base::at(i),other.at(i));
                }
            }
        }
    };
 
 
    typedef SequenceContainer<std::wstring> StringSequenceContainer;
 
    typedef SequenceContainer<bool> BooleanSequenceContainer;
 
    typedef SequenceContainer<Int32> Int32SequenceContainer;
 
    typedef SequenceContainer<Int64> Int64SequenceContainer;
 
    typedef SequenceContainer<Float32> Float32SequenceContainer;
 
    typedef SequenceContainer<Float64> Float64SequenceContainer;
 
    typedef SequenceContainer<TypeId> TypeIdSequenceContainer;
 
    typedef SequenceContainer<InstanceId> InstanceIdSequenceContainer;
 
    typedef SequenceContainer<EntityId> EntityIdSequenceContainer;
 
    typedef SequenceContainer<ChannelId> ChannelIdSequenceContainer;
 
    typedef SequenceContainer<HandlerId> HandlerIdSequenceContainer;
 
    typedef SequenceContainer<Binary> BinarySequenceContainer;
 
    typedef GenericObjectSequenceContainer<Object> ObjectSequenceContainer;
 
    //--------------------------------------------------
    // SI-types (32-bits)
    //--------------------------------------------------
    namespace Si32
    {
        typedef SequenceContainer<Ampere> AmpereSequenceContainer;
 
        typedef SequenceContainer<CubicMeter> CubicMeterSequenceContainer;
 
        typedef SequenceContainer<Hertz> HertzSequenceContainer;
 
        typedef SequenceContainer<Joule> JouleSequenceContainer;
 
        typedef SequenceContainer<Kelvin> KelvinSequenceContainer;
 
        typedef SequenceContainer<Kilogram> KilogramSequenceContainer;
 
        typedef SequenceContainer<Meter> MeterSequenceContainer;
 
        typedef SequenceContainer<MeterPerSecond> MeterPerSecondSequenceContainer;
 
        typedef SequenceContainer<MeterPerSecondSquared> MeterPerSecondSquaredSequenceContainer;
 
        typedef SequenceContainer<Newton> NewtonSequenceContainer;
 
        typedef SequenceContainer<Pascal> PascalSequenceContainer;
 
        typedef SequenceContainer<Radian> RadianSequenceContainer;
 
        typedef SequenceContainer<RadianPerSecond> RadianPerSecondSequenceContainer;
 
        typedef SequenceContainer<RadianPerSecondSquared> RadianPerSecondSquaredSequenceContainer;
 
        typedef SequenceContainer<Second> SecondSequenceContainer;
 
        typedef SequenceContainer<SquareMeter> SquareMeterSequenceContainer;
 
        typedef SequenceContainer<Steradian> SteradianSequenceContainer;
 
        typedef SequenceContainer<Volt> VoltSequenceContainer;
 
        typedef SequenceContainer<Watt> WattSequenceContainer;
    }
 
    //--------------------------------------------------
    // SI-types (64-bits)
    //--------------------------------------------------
    namespace Si64
    {
        typedef SequenceContainer<Ampere> AmpereSequenceContainer;
 
        typedef SequenceContainer<CubicMeter> CubicMeterSequenceContainer;
 
        typedef SequenceContainer<Hertz> HertzSequenceContainer;
 
        typedef SequenceContainer<Joule> JouleSequenceContainer;
 
        typedef SequenceContainer<Kelvin> KelvinSequenceContainer;
 
        typedef SequenceContainer<Kilogram> KilogramSequenceContainer;
 
        typedef SequenceContainer<Meter> MeterSequenceContainer;
 
        typedef SequenceContainer<MeterPerSecond> MeterPerSecondSequenceContainer;
 
        typedef SequenceContainer<MeterPerSecondSquared> MeterPerSecondSquaredSequenceContainer;
 
        typedef SequenceContainer<Newton> NewtonSequenceContainer;
 
        typedef SequenceContainer<Pascal> PascalSequenceContainer;
 
        typedef SequenceContainer<Radian> RadianSequenceContainer;
 
        typedef SequenceContainer<RadianPerSecond> RadianPerSecondSequenceContainer;
 
        typedef SequenceContainer<RadianPerSecondSquared> RadianPerSecondSquaredSequenceContainer;
 
        typedef SequenceContainer<Second> SecondSequenceContainer;
 
        typedef SequenceContainer<SquareMeter> SquareMeterSequenceContainer;
 
        typedef SequenceContainer<Steradian> SteradianSequenceContainer;
 
        typedef SequenceContainer<Volt> VoltSequenceContainer;
 
        typedef SequenceContainer<Watt> WattSequenceContainer;
    }
}
}
}