ControlParameterContainer.hpp

Go to the documentation of this file.

/* 
 * ControlParameterContainer.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_CONTROLPARAMETERCONTAINER_HPP
#define CDPL_BASE_CONTROLPARAMETERCONTAINER_HPP
 
#include <vector>
#include <utility>
#include <cstddef>
#include <unordered_map>
#include <functional>
 
#include "CDPL/Base/APIPrefix.hpp"
#include "CDPL/Base/LookupKey.hpp"
#include "CDPL/Base/Any.hpp"
 
 
namespace CDPL
{
 
    namespace Base
    {
 
        class CDPL_BASE_API ControlParameterContainer
        {
 
            typedef std::unordered_map<LookupKey, Any, LookupKey::HashFunc> ParameterMap;
 
          public:
            typedef ParameterMap::value_type ParameterEntry;
 
            typedef ParameterMap::const_iterator ConstParameterIterator;
 
            typedef std::function<void(const LookupKey&, const Any&)> ParameterChangedCallbackFunction;
 
            typedef std::function<void(const LookupKey&)> ParameterRemovedCallbackFunction;
 
            typedef std::function<void()> ParentChangedCallbackFunction;
 
            std::size_t getNumParameters() const;
 
            template <typename T>
            void setParameter(const LookupKey& key, T&& val);
 
            const Any& getParameter(const LookupKey& key, bool throw_ = false, bool local = false) const;
 
            template <typename T>
            const T& getParameter(const LookupKey& key, bool local = false) const;
 
            template <typename T>
            const T& getParameterOrDefault(const LookupKey& key, const T& def_val, bool local = false) const;
 
            bool removeParameter(const LookupKey& key);
 
            void clearParameters();
 
            bool isParameterSet(const LookupKey& key, bool local = false) const;
 
            void addParameters(const ControlParameterContainer& cntnr);
 
            void copyParameters(const ControlParameterContainer& cntnr);
 
            ConstParameterIterator getParametersBegin() const;
 
            ConstParameterIterator getParametersEnd() const;
 
            ConstParameterIterator begin() const;
 
            ConstParameterIterator end() const;
 
            void setParent(const ControlParameterContainer* cntnr);
 
            const ControlParameterContainer* getParent() const;
 
            std::size_t registerParameterChangedCallback(const ParameterChangedCallbackFunction& func);
 
            void unregisterParameterChangedCallback(std::size_t id);
 
            std::size_t registerParameterRemovedCallback(const ParameterRemovedCallbackFunction& func);
 
            void unregisterParameterRemovedCallback(std::size_t id);
 
            std::size_t registerParentChangedCallback(const ParentChangedCallbackFunction& func);
 
            void unregisterParentChangedCallback(std::size_t id);
 
            inline const ControlParameterContainer& getParameters() const;
              
          protected:
            ControlParameterContainer():
                parent(0) {}
 
            ControlParameterContainer(const ControlParameterContainer& cntnr):
                parameters(cntnr.parameters), parent(0) {}
 
            virtual ~ControlParameterContainer();
 
            ControlParameterContainer& operator=(const ControlParameterContainer& cntnr);
 
          private:
            void parameterRemoved(const LookupKey&) const;
            void parameterChanged(const LookupKey&, const Any&) const;
 
            void parentParameterRemoved(const LookupKey&) const;
            void parentParameterChanged(const LookupKey&, const Any&) const;
 
            void parentChanged() const;
 
            inline bool isEmptyAny(const Any& val) const;
 
            template <typename T>
            bool isEmptyAny(const T& val) const;
 
            typedef std::vector<ControlParameterContainer*>                  ChildContainer;
            typedef std::pair<std::size_t, ParameterChangedCallbackFunction> ParamChangedCallbackContainerEntry;
            typedef std::vector<ParamChangedCallbackContainerEntry>          ParamChangedCallbackContainer;
            typedef std::pair<std::size_t, ParameterRemovedCallbackFunction> ParamRemovedCallbackContainerEntry;
            typedef std::vector<ParamRemovedCallbackContainerEntry>          ParamRemovedCallbackContainer;
            typedef std::pair<std::size_t, ParentChangedCallbackFunction>    ParentChangedCallbackContainerEntry;
            typedef std::vector<ParentChangedCallbackContainerEntry>         ParentChangedCallbackContainer;
 
            ParameterMap                     parameters;
            const ControlParameterContainer* parent;
            mutable ChildContainer           children;
            ParamChangedCallbackContainer    paramChangedCallbacks;
            ParamRemovedCallbackContainer    paramRemovedCallbacks;
            ParentChangedCallbackContainer   parentChangedCallbacks;
        };
    } // namespace Base
} // namespace CDPL
 
 
// Implementation of template members
 
template <typename T>
const T& CDPL::Base::ControlParameterContainer::getParameter(const LookupKey& key, bool local) const
{
    return getParameter(key, true, local).template getData<T>();
}
 
template <typename T>
const T& CDPL::Base::ControlParameterContainer::getParameterOrDefault(const LookupKey& key, const T& def_val, bool local) const
{
    const Any& val = getParameter(key, false, local);
 
    return (val.isEmpty() ? def_val : val.template getData<T>());
}
 
template <typename T>
void CDPL::Base::ControlParameterContainer::setParameter(const LookupKey& key, T&& val)
{
    if (isEmptyAny(val)) {
        removeParameter(key);
        return;
    }
 
    const Any& any_val = (parameters[key] = std::forward<T>(val));
 
    parameterChanged(key, any_val);
}
 
bool CDPL::Base::ControlParameterContainer::isEmptyAny(const Any& val) const
{
    return val.isEmpty();
}
 
template <typename T>
bool CDPL::Base::ControlParameterContainer::isEmptyAny(const T&) const
{
    return false;
}
 
const CDPL::Base::ControlParameterContainer& CDPL::Base::ControlParameterContainer::getParameters() const
{
    return *this;
}
 
#endif // CDPL_BASE_CONTROLPARAMETERCONTAINER_HPP