ConditionHandler.cpp

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
*/
 
#include "ConditionHandler.h"
 
#include <sstream>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <ArmarXCore/observers/ConditionCheck.h>
#include <ArmarXCore/observers/ObserverObjectFactories.h>
#include <ArmarXCore/observers/condition/ConditionRoot.h>
 
namespace armarx
{
    ConditionHandlerPropertyDefinitions::ConditionHandlerPropertyDefinitions(std::string prefix) :
        ComponentPropertyDefinitions(prefix)
    {
        defineOptionalProperty<std::string>("Observers", "", "Comma seperated observer list");
        defineOptionalProperty<int>(
            "HistoryLength", 1000, "Length of condition history kept by the conditionhandler");
    }
 
    // *******************************************************
    // implementation of ObserverInterface
    // *******************************************************
    ConditionIdentifier
    ConditionHandler::installCondition(const EventListenerInterfacePrx& listener,
                                       const TermImplBasePtr& expression,
                                       const EventBasePtr& e,
                                       bool onlyFireOnce,
                                       bool reportDatafields,
                                       const DatafieldRefList& refs,
                                       const Ice::Current& c)
    {
        return installConditionWithDescription(
            listener, expression, e, "", onlyFireOnce, reportDatafields, refs, c);
    }
 
    ConditionIdentifier
    ConditionHandler::installConditionWithDescription(const EventListenerInterfacePrx& listener,
                                                      const TermImplBasePtr& expression,
                                                      const EventBasePtr& e,
                                                      const std::string& desc,
                                                      bool onlyFireOnce,
                                                      bool reportDatafields,
                                                      const DatafieldRefList& refs,
                                                      const Ice::Current& c)
    {
        // generate root expression
        ConditionRootPtr root = new ConditionRoot(listener, e, desc, onlyFireOnce, refs);
        ARMARX_DEBUG << "Installing condition: " << root << std::endl;
        root->addChild(expression);
 
        // extract checks
        std::vector<LiteralImplPtr> literals = ConditionRoot::ExtractLiterals(root);
 
        // forward the onlyfireonce flag to all literals
        for (LiteralImplPtr& literal : literals)
        {
            literal->checkConfig.reportAlways = !onlyFireOnce;
            literal->checkConfig.reportDatafieldValues = reportDatafields;
        }
 
        std::unique_lock lock(conditionRegistryMutex);
 
        // go through literals and install checks
        installChecks(literals, c);
 
        // store in registry
        std::pair<int, ConditionRootBasePtr> entry;
        entry.first = generateId();
        entry.second = root;
 
        conditionRegistry.insert(entry);
 
        ConditionIdentifier id;
        id.uniqueId = entry.first;
 
        ARMARX_DEBUG << "Installed condition: " << root << std::endl;
        setMetaInfo("conditionCount", new Variant((int)conditionRegistry.size()));
        return id;
    }
 
    void
    ConditionHandler::removeCondition(const ConditionIdentifier& id, const Ice::Current& c)
    {
        ARMARX_DEBUG << "Removing condition " << id.uniqueId << std::endl;
 
        std::unique_lock lock(conditionRegistryMutex);
        ConditionRegistry::iterator iter = conditionRegistry.find(id.uniqueId);
 
        if (iter == conditionRegistry.end())
        {
            return;
        }
 
        ConditionRootPtr root = ConditionRootPtr::dynamicCast(iter->second);
 
        // extract checks
        std::vector<LiteralImplPtr> literals = ConditionRoot::ExtractLiterals(root);
 
        // go through literals and remove checks
        removeChecks(literals, c);
 
        // remove from registry
        std::pair<int, ConditionRootBasePtr> tmp = *iter;
        conditionRegistry.erase(iter);
 
        // insert into history
        std::unique_lock lockHistory(conditionHistoryMutex);
        conditionHistory.insert(tmp);
 
        if (int(conditionHistory.size()) > historyLength)
        {
            conditionHistory.erase(conditionHistory.begin());
        }
        setMetaInfo("conditionHistory", new Variant((int)conditionHistory.size()));
        setMetaInfo("conditionCount", new Variant((int)conditionRegistry.size()));
    }
 
    void
    ConditionHandler::removeAllConditions(const Ice::Current& c)
    {
        ConditionRegistry::iterator iter;
        std::vector<int> conditionIds;
 
        {
            std::unique_lock lock(conditionRegistryMutex);
 
            if (!conditionRegistry.empty())
            {
                for (iter = conditionRegistry.begin(); iter != conditionRegistry.end(); iter++)
                {
                    conditionIds.push_back(iter->first);
                }
            }
        }
 
        if (!conditionIds.empty())
        {
            for (int id : conditionIds)
            {
                removeCondition(ConditionIdentifier{id}, c);
            }
        }
 
        std::unique_lock lockHistory(conditionHistoryMutex);
        conditionHistory.clear();
        setMetaInfo("conditionHistory", new Variant((int)conditionHistory.size()));
        setMetaInfo("conditionCount", new Variant((int)conditionRegistry.size()));
    }
 
    ConditionRegistry
    ConditionHandler::getActiveConditions(const Ice::Current& c)
    {
        std::unique_lock lock(conditionRegistryMutex);
 
        return conditionRegistry;
    }
 
    ConditionRegistry
    ConditionHandler::getPastConditions(const Ice::Current& c)
    {
        std::unique_lock lock(conditionHistoryMutex);
 
        return conditionHistory;
    }
 
    ConditionRootBasePtr
    ConditionHandler::getCondition(Ice::Int id, const Ice::Current& c)
    {
        {
            std::unique_lock lock(conditionRegistryMutex);
            auto it = conditionRegistry.find(id);
 
            if (it != conditionRegistry.end())
            {
                return it->second;
            }
        }
        {
            std::unique_lock lock(conditionHistoryMutex);
            auto it = conditionHistory.find(id);
 
            if (it != conditionHistory.end())
            {
                return it->second;
            }
        }
        return nullptr;
    }
 
    std::string
    ConditionHandler::getDefaultName() const
    {
        return "ConditionHandler";
    }
 
    Ice::StringSeq
    ConditionHandler::getObserverNames(const Ice::Current& c)
    {
        return observerNames;
    }
 
    // *******************************************************
    // Component hooks
    // *******************************************************
    void
    ConditionHandler::onInitComponent()
    {
        currentId = 0;
 
        // read observer dependencies. These observers will be precaches
        std::string observers = getProperty<std::string>("Observers");
        simox::alg::trim(observers);
 
        if (!observers.empty())
        {
            observerNames = simox::alg::split(observers, ",");
        }
 
        useObservers(observerNames);
 
        // read max length of history
        historyLength = getProperty<int>("HistoryLength").getValue();
 
        onInitConditionHandler();
    }
 
    void
    ConditionHandler::onConnectComponent()
    {
 
        // precach
        preCacheObservers(observerNames);
 
        // subclass init
        onStartConditionHandler();
    }
 
    // *******************************************************
    // private methods
    // *******************************************************
    int
    ConditionHandler::generateId()
    {
        std::unique_lock lock(idMutex);
        return currentId++;
    }
 
    void
    ConditionHandler::useObservers(std::vector<std::string>& names)
    {
        std::unique_lock lock(iceManagerMutex);
 
        std::vector<std::string>::iterator iter = names.begin();
 
        while (iter != names.end())
        {
            usingProxy(*iter);
            iter++;
        }
    }
 
    void
    ConditionHandler::preCacheObservers(std::vector<std::string>& names)
    {
        std::unique_lock lock(iceManagerMutex);
 
        std::vector<std::string>::iterator iter = names.begin();
 
        while (iter != names.end())
        {
            getProxy<ObserverInterfacePrx>(*iter);
            iter++;
        }
    }
 
    ObserverInterfacePrx
    ConditionHandler::getObserver(std::string observerName)
    {
        std::unique_lock lock(iceManagerMutex);
        ObserverInterfacePrx proxy;
 
        try
        {
            proxy = getProxy<ObserverInterfacePrx>(observerName);
            ObserverInterfacePrx::checkedCast(proxy);
        }
        catch (...)
        {
            throw InvalidConditionException("Observer \"" + observerName + "\" does not exist.");
        }
 
        return proxy;
    }
 
    void
    ConditionHandler::installChecks(std::vector<LiteralImplPtr>& literals, const Ice::Current& c)
    {
        std::vector<LiteralImplPtr>::iterator iter = literals.begin();
 
        while (iter != literals.end())
        {
            ObserverInterfacePrx proxy =
                getObserver((*iter)->checkConfig.dataFieldIdentifier->observerName);
            (*iter)->installCheck(c.adapter, proxy);
 
            iter++;
        }
    }
 
    void
    ConditionHandler::removeChecks(std::vector<LiteralImplPtr>& literals, const Ice::Current& c)
    {
        std::vector<LiteralImplPtr>::iterator iter = literals.begin();
 
        while (iter != literals.end())
        {
            ObserverInterfacePrx proxy =
                getObserver((*iter)->checkConfig.dataFieldIdentifier->observerName);
            (*iter)->removeCheck(c.adapter, proxy);
 
            iter++;
        }
    }
 
    PropertyDefinitionsPtr
    ConditionHandler::createPropertyDefinitions()
    {
        return PropertyDefinitionsPtr(
            new ConditionHandlerPropertyDefinitions(getConfigIdentifier()));
    }
} // namespace armarx