AttributeStore.h

Go to the documentation of this file.

#ifndef ATTRIBUTE_STORE_H_INCLUDED
#define ATTRIBUTE_STORE_H_INCLUDED
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
// WARNING: FILE ALSO GETS PROCESSED BY SWIG. SWIG (VERSIONS EARLY 2013)  //
// DOES NOT ACCEPT TWO CONSECUTIVE >> TEMPLATE TYPE PARAMETERLIST ENDING  //
// BRACKETS WITHOUT INTERVENING BLANK (EVEN THOUGH C++11 DOES ACCPT THIS) //

#include <boost/property_tree/ptree.hpp>
#include <algorithm>
#include <cstddef>
#include <functional>
#include <map>
#include <stdexcept>
#include <string>
#include <tuple>
#include <vector>

namespace SimPT_Sim {

class AttributeStore
{
public:
        AttributeStore() = default;

        AttributeStore(const boost::property_tree::ptree& pt);

        template<typename T>
        std::vector<T>& Container(const std::string& name);

        template<typename T>
        const std::vector<T>& Container(const std::string& name) const;

        boost::property_tree::ptree GetAttributeValues(std::size_t pos) const;

        template<typename T>
        T  GetDefaultValue(const std::string& name) const;

        template<typename T>
        std::vector<std::string> GetAttributeNames() const;

        boost::property_tree::ptree GetIndexPtree() const;

        boost::property_tree::ptree GetIndexDump() const;

        template<typename T>
        void Initialize(const std::string& name, const std::vector<T>& values);

        template<typename T>
        void Initialize(const std::string& name, std::vector<T>&& values);

        template<typename T>
        bool IsAttribute(const std::string& name) const;

        bool IsEmpty() const;

        std::tuple<bool, std::size_t> IsStrictSizeConsistent() const;

        bool IsWeakSizeConsistent(std::size_t N) const;

private:
        template<typename T>
        bool SizeCheckStrict(std::size_t N) const;

        template<typename T>
        bool SizeCheckWeak(std::size_t N) const;

private:
        template<typename T>
        using MapType = std::map<std::string, std::pair<std::vector<T>, T> >;

        template<typename T>
        MapType<T>& IndexMap();

        template<typename T>
        const MapType<T>& IndexMap() const;

        MapType<bool>                  m_map_b;   
        MapType<int>                   m_map_i;   
        MapType<double>                m_map_d;   
        MapType<std::string>           m_map_s;   
        boost::property_tree::ptree    m_ptree;   
};

std::ostream& operator<<(std::ostream& os, const AttributeStore& a);

// IMPLEMENTATION OF PRIVATE ACCESS METHODS (need to be seen by compiler prior to first use).

template<>
inline AttributeStore::MapType<bool>& AttributeStore::IndexMap<bool>()
{
        return m_map_b;
}


template<>
inline const AttributeStore::MapType<bool>& AttributeStore::IndexMap<bool>() const
{
        return m_map_b;
}


template<>
inline AttributeStore::MapType<int>& AttributeStore::IndexMap<int>()
{
        return m_map_i;
}


template<>
inline const AttributeStore::MapType<int>& AttributeStore::IndexMap<int>() const
{
        return m_map_i;
}


template<>
inline AttributeStore::MapType<double>& AttributeStore::IndexMap<double>()
{
        return m_map_d;
}


template<>
inline const AttributeStore::MapType<double>& AttributeStore::IndexMap<double>() const
{
        return m_map_d;
}


template<>
inline AttributeStore::MapType<std::string>& AttributeStore::IndexMap<std::string>()
{
        return m_map_s;
}


template<>
inline const AttributeStore::MapType<std::string>& AttributeStore::IndexMap<std::string>() const
{
        return m_map_s;
}

// IMPLEMENTATION OF PUBLIC METHODS

template<typename T>
inline std::vector<T>& AttributeStore::Container(const std::string& name)
{
        const auto c = IndexMap<T>().find(name);
        if (c == IndexMap<T>().end()) {
                throw std::runtime_error("AttributeStore::Attributes(const std::string& name): name not in index: " + name);
        }
        return c->second.first;
}


template<typename T>
inline const std::vector<T>& AttributeStore::Container(const std::string& name) const
{
        const auto c = IndexMap<T>().find(name);
        if (c == IndexMap<T>().end()) {
                throw std::runtime_error("AttributeStore::Attributes(const std::string& name): name not in index: " + name);
        }
        return c->second.first;
}


template<typename T>
inline std::vector<std::string> AttributeStore::GetAttributeNames() const
{
        std::vector<std::string> names;
        for (const auto& c : IndexMap<T>()) {
                names.push_back(c.first);
        }
        return names;
}

inline boost::property_tree::ptree AttributeStore::GetIndexPtree() const
{
        return m_ptree;
}


template<typename T>
inline T AttributeStore::GetDefaultValue(const std::string& name) const
{
        const auto c = IndexMap<T>().find(name);
        if (c == IndexMap<T>().end()) {
                throw std::runtime_error("AttributeStore::GetDefaultValue(const std::string& name): name not in index: " + name);
        }
        return c->second.second;
}


template<typename T>
inline void AttributeStore::Initialize(const std::string& name, const std::vector<T>& values)
{
        if ( IsWeakSizeConsistent(values.size()) ) {
                Container<T>(name) = values;
        } else {
                throw std::runtime_error("AttributeStore::Initialize: name not in index or size inconsistent " + name);
        }
}


template<typename T>
inline void AttributeStore::Initialize(const std::string& name, std::vector<T>&& values)
{
        if ( IsWeakSizeConsistent(values.size()) ) {
                Container<T>(name) = std::move(values);
        } else {
                throw std::runtime_error("AttributeStore::Initialize: name not in index or size inconsistent " + name);
        }
}


template<typename T>
inline bool AttributeStore::IsAttribute(const std::string& name) const
{
        return IndexMap<T>().find(name) != IndexMap<T>().end();
}


inline std::tuple<bool, std::size_t> AttributeStore::IsStrictSizeConsistent() const
{
        bool status = true;
        size_t s = 0;

        if (!IndexMap<bool>().empty()) {
                s = IndexMap<bool>().cbegin()->second.first.size();
                status = SizeCheckStrict<bool>(s) && SizeCheckStrict<int>(s)
                        && SizeCheckStrict<double>(s) && SizeCheckStrict<std::string>(s);
        } else  if (!IndexMap<int>().empty()) {
                s = IndexMap<int>().cbegin()->second.first.size();
                status = SizeCheckStrict<int>(s) && SizeCheckStrict<double>(s) && SizeCheckStrict<std::string>(s);
        } else if (!IndexMap<double>().empty()) {
                s = IndexMap<int>().cbegin()->second.first.size();
                status = SizeCheckStrict<double>(s) && SizeCheckStrict<std::string>(s);
        } else if (!IndexMap<std::string>().empty()){
                s = IndexMap<int>().cbegin()->second.first.size();
                status = SizeCheckStrict<std::string>(s);
        }

        return std::make_tuple(status, s);
}


inline bool AttributeStore::IsWeakSizeConsistent(std::size_t N) const
{
        // Short circuit avoids redundant evaluations.
        return SizeCheckWeak<int>(N) && SizeCheckWeak<double>(N) && SizeCheckWeak<std::string>(N);
}

// IMPLEMENTATION OF PRIVATE METHODS.

template<typename T>
inline bool AttributeStore::SizeCheckStrict(std::size_t N) const
{
        bool status = true;
        for (const auto& e : IndexMap<T>()) {
                const auto s = e.second.first.size();
                if ( s != N ) {
                        status = false;
                        break;
                }
        }
        return status;
}


template<typename T>
inline bool AttributeStore::SizeCheckWeak(std::size_t N) const
{
        bool status = true;
        for (const auto& e : IndexMap<T>()) {
                const auto s = e.second.first.size();
                if ( !( s == N || s == 0) ) {
                        status = false;
                        break;
                }
        }
        return status;
}

} // namespace

#endif // include guard