Node.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of CCA project
 *
 * Copyright (C) 2011 by Arne Nordmann <anordman at cor-lab dot uni-bielefeld dot de>
 *
 * This file may be licensed under the terms of the
 * GNU Lesser General Public License Version 3 (the ``LGPL''),
 * or (at your option) any later version.
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the LGPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the LGPL along with this
 * program. If not, go to http://www.gnu.org/licenses/lgpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The development of this software was supported by:
 *   CoR-Lab, Research Institute for Cognition and Robotics
 *     Bielefeld University
 *
 * ============================================================ */

#pragma once

#include <string>
#include <vector>
#include <map>

#include <boost/format.hpp>

#include <rsb/Factory.h>
#include <rsb/Informer.h>
#include <rsb/Listener.h>
#include <rsb/Event.h>

#include <rsc/runtime/Properties.h>

#include "cca/buffer/Buffer.h"
#include "cca/buffer/SingleItemBuffer.h"
#include "cca/port/InputPort.h"
#include "cca/port/OutputPort.h"
#include "cca/port/PortConfiguration.h"
#include "cca/ProcessingStrategy.h"
#include "cca/component/Info.h"
#include "cca/Exception.h"

namespace cca {

using namespace boost;

class Node;
typedef ::boost::shared_ptr<Node> NodePtr;

class Node {

public:

    Node(const std::string &name);
    virtual ~Node();

    template<typename T>
    void registerProperty(const std::string &name, const T& defaultvalue) {
        RSCTRACE(logger,
                this->getName() + " registerProperty() property " + name);
        RSCTRACE(logger,
                str( format("%1% registerProperty() property"
                "'%2%' with default value '%3%'") % this->getName() % name % defaultvalue));
        this->properties[name] = defaultvalue;
        this->defaultProperties[name] = defaultvalue;
    }

    template<typename T>
    T getProperty(const std::string& name) const {
        RSCTRACE(logger,
                str( format("%1% getProperty() property "
                "'%2%' is '%3%'") % this->getName() % name % this->properties.get < T > (name)));
        return this->properties.get<T>(name);
    }

    template<typename T>
    void setProperty(const std::string& name, const T& value) throw () {
        RSCTRACE(logger, str(format("%1% setProperty() property "
        "'%2%' to '%3%'") % this->getName() % name % value));

        this->properties[name] = value;
    }

    virtual std::string getName() const;

    virtual void configureInputPort(const std::string &name,
            PortConfigurationPtr portcfg);

    virtual void configureInputPort(const std::string &name,
            const std::string &scope);

    virtual void configureOutputPort(const std::string &name,
            PortConfigurationPtr portcfg);
    virtual void configureOutputPort(const std::string &name,
            const std::string &scope);

    virtual void setProcessingStrategy(StrategyPtr strategy);

    virtual bool isReady() const;

    virtual void onCreate();

    virtual void onStop();

    virtual void onResume();

    virtual void onReset();

    virtual void onLoad();

    virtual void onPersist();

    virtual void onTick();

    virtual void onInitialize();

    virtual bool initialize();

    virtual bool reset();

    void tick();

    virtual std::string print() const;

    virtual void onProcess() = 0;

    virtual bool isConfigured();

protected:

    void registerPort(const std::string &name, InputPortPtr port,
            bool optional = false);

    void registerPort(const std::string &name, OutputPortPtr port,
            bool optional = false);

    bool newValueAt(const std::string &name) const;

    virtual void process();

    virtual void create();

    virtual bool stop();

    virtual bool resume();

    virtual bool load();

    virtual bool persist();

    virtual void inputCallback(rsb::EventPtr event, const std::string& name);

    typedef std::pair<std::string, InputPortPtr> NamedInputPort;
    typedef std::pair<std::string, OutputPortPtr> NamedOutputPort;
    typedef std::map<std::string, InputPortPtr> NamedInputPorts;
    typedef std::map<std::string, OutputPortPtr> NamedOutputPorts;

    NamedInputPorts inputPorts;

    NamedOutputPorts outputPorts;

    std::map<std::string, std::string> config;

    std::map<std::string, std::string> userconfig;

    virtual StrategyPtr getProcessingStrategy() const;

    rsc::runtime::Properties properties;

    rsc::runtime::Properties defaultProperties;

private:
    Node(Node &node);

    void operator=(const Node&);

    std::string name;

    bool ready, loaded, created, configured, processing;

    StrategyPtr strategy;

    rsc::logging::LoggerPtr logger;
};

}

std::ostream & operator<<(std::ostream& os, const cca::Node& node);