PropertyContainer.hpp

Go to the documentation of this file.

/* 
 * PropertyContainer.hpp 
 *
 * This file is part of the Chemical Data Processing Toolkit
 *
 * Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
 *
 * This library 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 2 of the License, or (at your option) any later version.
 *
 * This library 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 this library; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifndef CDPL_BASE_PROPERTYCONTAINER_HPP
#define CDPL_BASE_PROPERTYCONTAINER_HPP
 
#include <utility>
#include <unordered_map>
 
#include "CDPL/Base/APIPrefix.hpp"
#include "CDPL/Base/LookupKey.hpp"
#include "CDPL/Base/Any.hpp"
#include "CDPL/Base/Exceptions.hpp"
 
 
namespace CDPL
{
 
    namespace Base
    {
 
        class CDPL_BASE_API PropertyContainer
        {
 
            typedef std::unordered_map<LookupKey, Any, LookupKey::HashFunc> PropertyMap;
 
          public:
            typedef PropertyMap::value_type PropertyEntry;
 
            typedef PropertyMap::const_iterator ConstPropertyIterator;
 
            std::size_t getNumProperties() const;
 
            template <typename T>
            void setProperty(const LookupKey& key, T&& val);
 
            template <typename T>
            const T& getProperty(const LookupKey& key) const;
 
            template <typename T>
            const T& getPropertyOrDefault(const LookupKey& key, const T& def_val) const;
 
            inline const Any& getProperty(const LookupKey& key, bool throw_ = false) const;
 
            inline bool isPropertySet(const LookupKey& key) const;
 
            ConstPropertyIterator getPropertiesBegin() const;
 
            ConstPropertyIterator getPropertiesEnd() const;
 
            ConstPropertyIterator begin() const;
 
            ConstPropertyIterator end() const;
 
            bool removeProperty(const LookupKey& key);
 
            void clearProperties();
 
            void addProperties(const PropertyContainer& cntnr);
 
            void copyProperties(const PropertyContainer& cntnr);
 
            void swap(PropertyContainer& cntnr);
 
            inline const PropertyContainer& getProperties() const;
 
          protected:
            PropertyContainer() {}
 
            PropertyContainer(const PropertyContainer& cntnr);
 
            virtual ~PropertyContainer();
 
            PropertyContainer& operator=(const PropertyContainer& cntnr);
 
          private:
            inline bool isEmptyAny(const Any& val) const;
 
            template <typename T>
            bool isEmptyAny(const T& val) const;
 
            PropertyMap properties;
        };
    } // namespace Base
} // namespace CDPL
 
 
// Implementation of template members
 
template <typename T>
const T& CDPL::Base::PropertyContainer::getProperty(const LookupKey& key) const
{
    return getProperty(key, true).template getData<T>();
}
 
template <typename T>
const T& CDPL::Base::PropertyContainer::getPropertyOrDefault(const LookupKey& key, const T& def_val) const
{
    const Any& val = getProperty(key, false);
 
    return (val.isEmpty() ? def_val : val.template getData<T>());
}
 
const CDPL::Base::Any& CDPL::Base::PropertyContainer::getProperty(const LookupKey& key, bool throw_ex) const
{
    static const Any NOT_FOUND;
 
    ConstPropertyIterator it = properties.find(key);
 
    if (it != properties.end())
        return it->second;
 
    if (throw_ex)
        throw ItemNotFound("PropertyContainer: property " + key.getName() + " not found");
 
    return NOT_FOUND;
}
 
template <typename T>
void CDPL::Base::PropertyContainer::setProperty(const LookupKey& key, T&& val)
{
    if (isEmptyAny(val)) {
        properties.erase(key);
        return;
    }
 
    properties[key] = std::forward<T>(val);
}
 
bool CDPL::Base::PropertyContainer::isPropertySet(const LookupKey& key) const
{
    return (properties.find(key) != properties.end());
}
 
bool CDPL::Base::PropertyContainer::isEmptyAny(const Any& val) const
{
    return val.isEmpty();
}
 
template <typename T>
bool CDPL::Base::PropertyContainer::isEmptyAny(const T&) const
{
    return false;
}
 
const CDPL::Base::PropertyContainer& CDPL::Base::PropertyContainer::getProperties() const
{
    return *this;
}
 
#endif // CDPL_BASE_PROPERTYCONTAINER_HPP