PortCoreUnit.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * Copyright (C) 2006-2010 RobotCub Consortium
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_OS_IMPL_PORTCOREUNIT_H
#define YARP_OS_IMPL_PORTCOREUNIT_H
 
#include <yarp/os/Name.h>
#include <yarp/os/impl/PortCore.h>
#include <yarp/os/impl/ThreadImpl.h>
 
#include <string>
 
namespace yarp {
namespace os {
namespace impl {
 
class PortCoreUnit :
        public ThreadImpl
{
public:
    PortCoreUnit(PortCore& owner, int index) :
            owner(owner),
            doomed(false),
            hasMode(false),
            pupped(false),
            index(index)
    {
    }
 
    virtual ~PortCoreUnit()
    {
    }
 
    virtual bool isInput()
    {
        return false;
    }
 
    virtual bool isOutput()
    {
        return false;
    }
 
    virtual bool isFinished()
    {
        return false;
    }
 
    virtual Route getRoute()
    {
        return Route("null", "null", "null");
    }
 
    bool isDoomed()
    {
        return doomed;
    }
 
    void setDoomed()
    {
        doomed = true;
    }
 
    virtual void* send(const yarp::os::PortWriter& writer,
                       yarp::os::PortReader* reader,
                       const yarp::os::PortWriter* callback,
                       void* tracker,
                       const std::string& envelope,
                       bool waitAfter = true,
                       bool waitBefore = true,
                       bool* gotReply = nullptr)
    {
        // do nothing
        YARP_UNUSED(writer);
        YARP_UNUSED(reader);
        YARP_UNUSED(callback);
        YARP_UNUSED(envelope);
        YARP_UNUSED(waitAfter);
        YARP_UNUSED(waitBefore);
        YARP_UNUSED(gotReply);
        return tracker;
    }
 
    virtual void* takeTracker()
    {
        return nullptr;
    }
 
    virtual bool isBusy()
    {
        return false;
    }
 
    virtual bool interrupt()
    {
        return false;
    }
 
    void setMode()
    {
        Name name(getRoute().getCarrierName() + std::string("://test"));
        mode = name.getCarrierModifier("log", &hasMode);
    }
 
    int getIndex()
    {
        return index;
    }
 
    std::string getMode(bool* hasMode = nullptr)
    {
        if (hasMode != nullptr) {
            *hasMode = this->hasMode;
        }
        return (this->hasMode) ? mode : "";
    }
 
    bool isPupped() const
    {
        return pupped;
    }
 
    std::string getPupString() const
    {
        return pupString;
    }
 
    void setPupped(const std::string& pupString)
    {
        pupped = true;
        this->pupString = pupString;
    }
 
    virtual void setCarrierParams(const yarp::os::Property& params)
    {
        YARP_UNUSED(params);
    }
 
    virtual void getCarrierParams(yarp::os::Property& params)
    {
        YARP_UNUSED(params);
    }
 
 
protected:
    PortCore& getOwner()
    {
        return owner;
    }
 
private:
    PortCore& owner;       
    bool doomed;           
    std::string mode;      
    bool hasMode;          
    bool pupped;           
    int index;             
    std::string pupString; 
};
 
} // namespace impl
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_IMPL_PORTCOREUNIT_H