DictionaryContainer.h

Go to the documentation of this file.

/******************************************************************************
*
* Copyright Saab AB, 2004-2015, 2022, 2024 (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/ContainerBase.h>
#include <Safir/Dob/Typesystem/Exceptions.h>
#include <Safir/Dob/Typesystem/ObjectContainer.h>
#include <Safir/Dob/Typesystem/Utilities.h>
#include <memory>
#include <map>
#include <stdexcept>
#include <typeinfo>
#include <type_traits>
 
namespace Safir
{
namespace Dob
{
namespace Typesystem
{
    class DictionaryContainerBase : public ContainerBase
    {
    public:
        DictionaryContainerBase()
            :ContainerBase()
        {
        }

        bool IsChangedHere() const
        {
            return m_bIsChanged;
        }

        void SetChangedHere(const bool changed)
        {
            m_bIsChanged = changed;
        }

        virtual size_t size() const = 0;

        virtual bool empty() const = 0;


        template<class KeyT>
        ContainerBase& InsertNull(const KeyT& key)
        {
            return InsertNullInternal(static_cast<const void*>(&key), typeid (key));
        }

        template<class KeyT>
        const KeyT& GetKeyAt(const size_t index) const
        {
            return *static_cast<const KeyT*>(GetKeyAtInternal(index));
        }

        virtual ContainerBase& GetValueContainerAt(const size_t index) = 0;

        virtual const ContainerBase& GetValueContainerAt(const size_t index) const = 0;

 
    protected:
        virtual ContainerBase& InsertNullInternal(const void* key, const std::type_info& typeInfo) = 0;
        virtual const void* GetKeyAtInternal(const size_t index) const = 0;
 
    private:
        friend void Utilities::MergeChanges(ObjectPtr into, const ObjectConstPtr& from);

        virtual void Merge(const DictionaryContainerBase& other) = 0;
    };

    template <class KeyT, class ValT>
    class DictionaryContainer : public DictionaryContainerBase
    {
    public:
 
        typedef KeyT KeyType;
        typedef ValT ValueContainerType;
        typedef typename ValueContainerType::ContainedType ContainedType;
        typedef std::map<KeyType, ValueContainerType> StorageType;
        typedef typename StorageType::const_iterator const_iterator;
        typedef typename StorageType::iterator iterator;
        typedef typename StorageType::value_type value_type;

        DictionaryContainer()
            : DictionaryContainerBase()
            , m_values()
        {
        }
 
        bool IsNull() const override {return empty();}
 
        bool HasVal() const override {return !empty();}
 
        void SetNull() override
        {
            clear();
        }
 
        iterator begin() {return m_values.begin();}
        const_iterator begin() const {return m_values.begin();}
 
        iterator end() {return m_values.end();}
        const_iterator end() const {return m_values.end();}
 
        iterator find(const KeyType& key) {return m_values.find(key);}
        const_iterator find(const KeyType& key) const {return m_values.find(key);}
 
        size_t size() const override {return m_values.size();}
 
        bool empty() const override {return m_values.empty();}
 
        size_t count(const KeyType& key) const {return m_values.count(key);}
 
        ValueContainerType& operator[](const KeyType& key)
        {
            iterator it=m_values.find(key);
            if (it!=m_values.end())
            {
                return it->second;
            }
            else
            {
                m_bIsChanged=true;
                ValueContainerType& ct=m_values[key];
                return ct;
            }
        }

        ValueContainerType& at(const KeyType& key)
        {
            iterator it=m_values.find(key);
            if (it!=m_values.end())
            {
                return it->second;
            }
            else
            {
                throw std::out_of_range("Key is not in dictionary");
            }
        }

        const ValueContainerType& at(const KeyType& key) const
        {
            return const_cast<DictionaryContainer&>(*this).at(key);
        }

        bool IsChanged() const override
        {
            if (m_bIsChanged)
            {
                return true; //top level change flag is set
            }
 
            for (const_iterator it=m_values.begin(); it!=m_values.end(); ++it)
            {
                if (it->second.IsChanged()) //a value container has changed flag set
                    return true;
            }
 
            return false; //if we get here nothing is changed
        }

        void SetChanged(const bool changed) override
        {
            m_bIsChanged=changed;
            for (iterator it=m_values.begin(); it!=m_values.end(); ++it)
            {
                it->second.SetChanged(changed);
            }
        }
 

        void clear()
        {
            m_bIsChanged=true;
            m_values.clear();
        }
 
 
        void Insert(const KeyType& key, const ContainedType& val)
        {
            m_bIsChanged=true;
            ValueContainerType container;
            InsertHelper<ContainedType, ValueContainerType>::SetVal(val, container);
            m_values.insert(value_type(key, container));
        }
 
        size_t erase(const KeyType& key)
        {
            size_t count=m_values.erase(key);
            if (count>0)
            {
                m_bIsChanged=true;
            }
            return count;
        }

        void Copy(const ContainerBase& that) override
        {
            if (this != &that)
            {
                const DictionaryContainer<KeyT, ValT>& other = Cast(that);
 
                clear();
                m_bIsChanged=other.m_bIsChanged;
 
                for (const_iterator it=other.begin(); it!=other.end(); ++it)
                {
                    ValueContainerType val;
                    val.Copy(it->second);
                    m_values.insert(std::make_pair(it->first, val));
                }
            }
        }

        const ContainerBase& GetValueContainerAt(const size_t index) const override
        {
            return const_cast<DictionaryContainer*>(this)->GetValueContainerAt(index);
        }
 
        ContainerBase& GetValueContainerAt(const size_t index) override
        {
            if (index >= size())
            {
                throw SoftwareViolationException
                    (L"DictionaryContainer::GetKey: Index outside range!", __WFILE__, __LINE__);
            }
            return std::next(m_values.begin(),index)->second;
        }

 
    protected:
 
        ContainerBase& InsertNullInternal(const void* key, const std::type_info& typeInfo) override
        {
            if (typeInfo == typeid(KeyType) || std::is_enum_v<KeyType> )
            {
                m_bIsChanged=true;
                ValueContainerType container;
                auto result = m_values.insert(value_type(*static_cast<const KeyType*>(key), container));
                return result.first->second;
            }
 
            std::wostringstream os;
            os << L"DictionaryContainer::InsertNull: The supplied key has wrong type! "
               << L"Expected type: " << typeid(KeyType).name() << L", got type: "
               << typeInfo.name() << std::endl;
            throw SoftwareViolationException(os.str(), __WFILE__, __LINE__);
        }
 
 
        const void* GetKeyAtInternal(const size_t index) const override
        {
            if (index >= size())
            {
                throw SoftwareViolationException
                    (L"DictionaryContainer::GetKeyAt: Index outside range!", __WFILE__, __LINE__);
            }
            return &(std::next(m_values.begin(),index)->first);
        }
 
    private:
 
        void Merge(const DictionaryContainerBase& that) override
        {
            const DictionaryContainer<KeyT, ValT>& other = Cast(that);
 
            for (const_iterator it = other.begin(); it != other.end(); ++it)
            {
                const ObjectContainerBase* fromContainerOB =
                    dynamic_cast<const ObjectContainerBase*>(&it->second);
                //is it an object member?
                if (fromContainerOB != NULL)
                {
                    if (fromContainerOB->IsChangedHere())
                    {
                        iterator findIt = find(it->first);
                        if (findIt == end())
                        {
                            throw SoftwareViolationException
                                (L"DictionaryContainer::Merge: Changed key not found in target!",
                                 __WFILE__, __LINE__);
                        }
 
                        findIt->second.Copy(*fromContainerOB);
                    }
                    else if (fromContainerOB->IsChanged())
                    {
                        iterator findIt = find(it->first);
                        if (findIt == end())
                        {
                            throw SoftwareViolationException
                                (L"DictionaryContainer::Merge: Changed key not found in target!",
                                 __WFILE__, __LINE__);
                        }
                        ObjectContainerBase* intoContainerOB = dynamic_cast<ObjectContainerBase*>(&findIt->second);
 
                        ObjectPtr into = intoContainerOB->GetObjectPointer();
                        ObjectConstPtr from = fromContainerOB->GetObjectPointer();
 
                        //recurse
                        Utilities::MergeChanges(into,from);
                    }
                }
                else
                {
                    if (it->second.IsChanged())
                    {
                        iterator findIt = find(it->first);
                        if (findIt == end())
                        {
                            throw SoftwareViolationException
                                (L"DictionaryContainer::Merge: Changed key not found in target!",
                                 __WFILE__, __LINE__);
                        }
 
                        findIt->second.Copy(it->second);
                    }
                }
            }
        }
 
        std::map<KeyT, ValT> m_values;
 
        template <class V, class C> struct InsertHelper
        {
            static void SetVal(const V& v, C& c) {c.SetVal(v);}
        };
 
        template <class V, class C> struct InsertHelper< std::shared_ptr<V>, C >
        {
            static void SetVal(const std::shared_ptr<V>& v, C& c) {c.SetPtr(v);}
        };
 
        static DictionaryContainer<KeyT,ValT>& Cast(ContainerBase& base)
        {
#ifndef NDEBUG
            if (typeid(DictionaryContainer<KeyT,ValT>) != typeid(base))
            {
                throw SoftwareViolationException(L"Invalid call to Copy or Merge, containers are not of same type",
                                                 __WFILE__,__LINE__);
            }
#endif
            return static_cast<DictionaryContainer<KeyT, ValT>&>(base);
        }
 
        static const DictionaryContainer<KeyT,ValT>& Cast(const ContainerBase& base)
        {
            return Cast(const_cast<ContainerBase&>(base));
        }
    };
}
}
}