ConditionCheck.h

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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 details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarX::Core
* @author     Kai Welke (welke _at_ kit _dot_ edu)
* @date       2011
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <ArmarXCore/core/system/ImportExport.h>
 
#include <ArmarXCore/interface/observers/VariantBase.h>
#include <ArmarXCore/interface/observers/ConditionCheckBase.h>
#include <ArmarXCore/interface/observers/ObserverInterface.h>
 
#include <ArmarXCore/observers/variant/Variant.h>
#include <ArmarXCore/observers/variant/DataFieldIdentifier.h>
 
#include <string>
#include <memory>
#include <map>
 
namespace armarx
{
    using VariantTypeIdList = std::vector<VariantTypeId>;
 
    class ConditionCheck;
    using ConditionCheckPtr = IceInternal::Handle<ConditionCheck>;
 
    class ARMARXCORE_IMPORT_EXPORT ConditionCheck :
        virtual public ConditionCheckBase
    {
    public:
        ConditionCheck();
 
        ~ConditionCheck() override {}
 
        //using ChannelRegistry = std::unordered_map<std::string, armarx::ChannelRegistryEntry>;
        using ChannelRegistry = armarx::ChannelRegistry;
        virtual ConditionCheckPtr createInstance(const CheckConfiguration& configuration, const ChannelRegistry& channelRegistry);
 
        virtual ConditionCheck* clone()
        {
            return new ConditionCheck();
        }
 
        void reset();
 
        void evaluateCondition(const DataFieldRegistry& dataFields);
 
        bool getFulFilled();
 
        friend std::ostream& operator<<(std::ostream& stream, const ConditionCheck& rhs)
        {
            // stream << ElementaryConditionPtr::dynamicCast(rhs.condition) << " = " << rhs.fulFilled;
            return stream;
        }
 
        friend std::ostream& operator<<(std::ostream& stream, const ConditionCheckPtr& rhs)
        {
            // stream << ElementaryConditionPtr::dynamicCast(rhs->condition) << " = " << rhs->fulFilled;
            return stream;
        }
 
    protected:
        void setNumberParameters(int numberParameters);
 
        void addSupportedType(VariantTypeId dataFieldType = 0, ParameterTypeList parameterTypes = ParameterTypeList());
 
        const Variant& getParameter(int index);
 
        virtual bool evaluate(const StringVariantMap& dataFields)
        {
            return true;
        }
 
        static ParameterTypeList createParameterTypeList(int numberTypes, ...);
 
    private:
        void assureTypeSupported(const CheckConfiguration& configuration, VariantTypeId dataFieldType);
 
        bool firstEval;
    };
}
namespace armarx::checks
{
    class CheckBase;
    using CheckBasePtr = std::shared_ptr<CheckBase>;
    using CheckBaseConstPtr = std::shared_ptr<const CheckBase>;
 
    class CheckBase
    {
    public:
        virtual ~CheckBase()
        {
        }
        virtual const std::string& getCheckStr() const
        {
            return _checkStr;
        }
 
        static CheckBasePtr create(const std::string& check)
        {
            return CheckBasePtr(new CheckBase(check));
        }
    private:
        const std::string _checkStr;
        CheckBase() {}
        CheckBase(std::string check) : _checkStr(check) {}
    };
 
}
 
#define ARMARX_CREATE_CHECK(OFFERER,NEWCHECK) namespace checks { namespace OFFERER { \
            const CheckBaseConstPtr NEWCHECK =  CheckBase::create(#NEWCHECK);\
        }}
 
extern template class ::IceInternal::Handle<::armarx::ConditionCheck>;