opcClient.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2014 WYSIWYD Consortium, European Commission FP7 Project ICT-612139
 * Authors: Stéphane Lallée
 * email:   stephane.lallee@gmail.com
 * website: https://github.com/robotology/icub-client/
 * Permission is granted to copy, distribute, and/or modify this program
 * under the terms of the GNU General Public License, version 2 or any
 * later version published by the Free Software Foundation.
 *
 * A copy of the license can be found at
 * icub-client/license/gpl.txt
 *
 * This program 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
 */

#ifndef __ICUBCLIENT_OPCC_H__
#define __ICUBCLIENT_OPCC_H__

#include <memory>
#include "icubclient/knowledge/representations.h"
#include "icubclient/tags.h"

namespace icubclient{

class OPCClient
{
    friend class ICubClient;

protected:
    yarp::os::Port opc; 
    bool write(yarp::os::Bottle &cmd, yarp::os::Bottle &reply, bool Verbose=false);

    std::map<int, Entity*>       entitiesByID;

    void addEntity(Entity* e);

    int getRelationID(
            Entity* subject,
            Entity* verb,
            Entity* object = nullptr,
            Entity* complement_place = nullptr,
            Entity* complement_time = nullptr,
            Entity* complement_manner = nullptr);

    bool changeName(Entity *e, const std::string &newName);

    std::string opcName;

public: 
    OPCClient(const std::string &moduleName);

    bool isVerbose;

    template <class T>
    T* addEntity(const std::string &name) {
        std::string name_appended = name;
        int appendix = 0;
        Entity *e = getEntity(name, true);
        // loop until we find the first appendix which is not used yet
        while(e!=nullptr) {
            ++appendix;
            name_appended = name + "_" + std::to_string(appendix);
            e = getEntity(name_appended,true);
        }

        //Else we create it in the OPC.
        T *o = new T();
        o->m_name = name_appended;
        addEntity(o);
        return o;
    }

    template <class T>
    T* addOrRetrieveEntity(const std::string &name)
    {
        Entity *e = getEntity(name,true);
        if ( e != nullptr)
        {
            if (isVerbose)
                yError() <<"Trying to add an already existing entity (" << name << ")";
            return dynamic_cast<T*>(e);
        }

        //Else we create it in the OPC.
        T* o = new T();
        o->m_name = name;
        addEntity(o);
        return o;
    }

    bool isConnected() {
        if(opcName=="") {
            return false;
        } else {
            if(yarp::os::Network::isConnected(opc.getName().c_str(), ("/" + opcName + "/rpc").c_str())) {
                return true;
            } else {
                return connect(opcName);
            }
        }
    }

    bool connect(const std::string &opcName)
    {
        this->opcName = opcName;
        return yarp::os::Network::connect(opc.getName().c_str(), ("/" + opcName + "/rpc").c_str());
    }

    void interrupt();

    void close();

    void clear();

    bool setEntityProperty(std::string sourceEntityName, std::string propertyName, std::string targetEntityName);

    bool addRelation(const Relation &r, double lifeTime = -1);

    bool addRelation(
            Entity* subject,
            Entity* verb,
            Entity* object = nullptr,
            double lifeTime = -1,
            Entity* complement_place = nullptr,
            Entity* complement_time = nullptr,
            Entity* complement_manner = nullptr
            );

    bool removeRelation(const Relation &r);
    
    bool removeRelation(
            Entity* subject,
            Entity* verb,
            Entity* object = nullptr,
            Entity* complement_place = nullptr,
            Entity* complement_time = nullptr,
            Entity* complement_manner = nullptr
            );
    
    bool containsRelation(
            Entity* subject,
            Entity* verb,
            Entity* object = nullptr,
            Entity* complement_place = nullptr,
            Entity* complement_time = nullptr,
            Entity* complement_manner = nullptr
            );

    bool containsRelation(const Relation &r);

    std::list<Relation>  getRelations();
    
    std::list<Relation>  getRelations(std::string entity);

    std::list<Relation>  getRelations(Entity* entity);

    std::list<Relation>  getRelationsMatching(std::string subject = "any",std::string verb = "any", std::string object = "any", std::string c_place = "any", std::string c_time = "any", std::string c_manner = "any" );

    std::list<Relation>  getRelationsMatchingLoosly(std::string subject = "any", std::string verb = "any", std::string object = "any", std::string c_place = "any", std::string c_time = "any", std::string c_manner = "any");

    bool setLifeTime(int id, double lifeTime);

    Entity *getEntity(const std::string &name, bool forceUpdate = false);

    Entity *getEntity(int id, bool forceUpdate = false);

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

    bool removeEntity(int id);

    void checkout(bool updateCache=true);

    void update();

    void update(Entity *e);

    void commit();

    void commit(Entity *e);

    std::list<Entity*> Entities(const yarp::os::Bottle &condition);

    std::list<Entity*> Entities(const std::string &prop, const std::string &op, const std::string &value);

    std::list<Entity*> EntitiesCache() const;

    std::list<std::shared_ptr<Entity>> EntitiesCacheCopy() const;

    std::string toString();
};

}//Namespace
#endif