jaus++/2.0/src/jaus/core/service.cpp

Go to the documentation of this file.

#include "jaus/core/service.h"
#include "jaus/core/transport/transport.h"
#include "jaus/core/component.h"
#include "jaus/core/sensor.h"
#include <cstdio>

using namespace JAUS;

Mutex Service::mDebugMessagesMutex("JAUS");

Service::ID::ID(const std::string& name, const double version) : mName(name),
                                                                 mVersion(version)
{
}


Service::ID::ID(const ID& id)
{
    *this = id;
}


Service::ID::~ID()
{
}


int Service::ID::Write(Packet& packet) const
{
    Byte majorVersionNumber = (Byte)mVersion;
    Byte minorVersionNumber = (Byte)((mVersion - majorVersionNumber)*10);
    int result = 0;
    result += packet.Write( (Byte)(mName.size()) );
    result += packet.Write(mName);
    result += packet.Write(majorVersionNumber);
    result += packet.Write(minorVersionNumber);
    
    return result;
}


int Service::ID::Read(const Packet& packet)
{
    Byte strLen = 0;
    Byte majorVersionNumber = 0, minorVersionNumber = 0;
    int result = 0;
    
    result += packet.Read(strLen);
    if(result > 0 && strLen > 0)
    {
        result += packet.Read(mName, (unsigned int)strLen);
        result += packet.Read(majorVersionNumber);
        result += packet.Read(minorVersionNumber);
        mVersion = majorVersionNumber + minorVersionNumber/10.0;
    }
    return result;
}


void Service::ID::Clear()
{
    mName.clear();
    mVersion = 0.0;
}


std::string Service::ID::ToString(const bool nameOnly, const bool trim) const
{
    char buffer[512];
    size_t found;
    found = mName.find_last_of(":");
    std::string n = mName.substr(found + 1);
    if(trim &&  n.size() > 0)
    {
        if(nameOnly)
        {
            return n;
        }
        else
        {
            sprintf(buffer, "%s - version=%.2lf", n.c_str(), mVersion);
        }
    }
    else
    {
        if(nameOnly)
        {
            return mName;
        }
        else
        {
            sprintf(buffer, "%s - version=%.2lf", mName.c_str(), mVersion);
        }
    }
    return std::string(buffer);
}


Service::ID& Service::ID::operator =(const Service::ID& id)
{
    if(this != &id)
    {
        mName = id.mName;
        mVersion = id.mVersion;
    }
    return *this;
}


Service::Service(const ID& serviceIdentifier, const ID& parentServiceIdentifier) : mServiceID(serviceIdentifier),
                                                                                   mParentServiceID(parentServiceIdentifier)
{
    mServiceEnabledFlag = true;
    mpJausParentService = NULL;
    mDebugMessagesFlag = false;
    mpTransportService = dynamic_cast<Transport *>(this);
    mpComponent = NULL;
    mShutdownServiceFlag = false;
}


Service::~Service()
{
    Mutex::ScopedLock lock(&mJausServiceMutex);
    mServiceID.Clear();
    mParentServiceID.Clear();
    mJausChildServices.clear();
    mpJausParentService = NULL;
    mShutdownServiceFlag = true;
}


bool Service::Send(const Message* message, const int broadcastFlags) const
{
    if(mpTransportService)
    {
        return mpTransportService->Send(message, broadcastFlags);
    }
    return false;
}


bool Service::Send(const Message* message, 
                   Message* response, 
                   const unsigned int waitTimeMs) const
{
    if(mpTransportService)
    {
        return mpTransportService->Send(message, response, waitTimeMs);
    }
    return false;
}


bool Service::Send(const Message* message, 
                   Message::List& possibleResponses, 
                   const unsigned int waitTimeMs) const
{
    if(mpTransportService)
    {
        return mpTransportService->Send(message, possibleResponses, waitTimeMs);
    }
    return false;
}


void Service::Receive(const Message* message)
{
}


bool Service::SetComponentID(const Address& id)
{
    if(id.IsValid() && !id.IsBroadcast())
    {
        mComponentID = id;
        Service::Map::iterator child;
        Service::Map *children = &mJausChildServices;
        for(child = children->begin();
            child != children->end();
            child++)
        {
            child->second->SetComponentID(id);
        }
        return true;
    }
    return false;
}


bool Service::InheritsFrom(const Service::ID& id) const
{
    Mutex::ScopedLock lock(&mJausServiceMutex);
    if(mParentServiceID.mName == id.mName)
    {
        return true;
    }
    return false;
}


bool Service::AddChildService(Service* childService)
{
    bool result = false;
    
    if(childService->InheritsFrom(mServiceID) == false)
        return result;
        
    Mutex::ScopedLock lock(&mJausServiceMutex);
    if(mpTransportService == NULL)
    {
        mpTransportService = dynamic_cast<Transport *>(this);
        Service* parent = mpJausParentService;
        while(mpTransportService == NULL || parent != NULL)
        {
            Transport* transport = dynamic_cast<Transport *>(parent);
            if(transport)
            {
                mpTransportService = transport;
                break;
            }
            parent = parent->mpJausParentService;
        }
    }
    Map::iterator child = mJausChildServices.find(childService->mServiceID.mName);
    if(child == mJausChildServices.end())
    {
        mJausChildServices[childService->mServiceID.mName] = childService;
        if(mpTransportService)
        {
            childService->mpTransportService = mpTransportService;
        }
        childService->mpJausParentService = this;
        childService->SetComponent(mpComponent);
        result = true;
    }
    return result;
}


bool Service::SetParentService(Service* parentService)
{

    Mutex::ScopedLock lock(&mJausServiceMutex);
    if(InheritsFrom(parentService->mServiceID) == false)
    {
        return false;
    }   
    
    mpJausParentService = parentService;
    return true;
}


Service* Service::GetParentService()
{
    return mpJausParentService;
}


const Service* Service::GetParentService() const
{
    return mpJausParentService;
}


Service* Service::GetChildService(const Service::ID& id)
{
    Mutex::ScopedLock lock(&mJausServiceMutex);
    Map::iterator child;
    child = mJausChildServices.find(id.mName);
    if(child != mJausChildServices.end())
    {
        return child->second;
    }
    return NULL;
}


const Service* Service::GetChildService(const Service::ID& id) const
{
    Mutex::ScopedLock lock(&mJausServiceMutex);
    Map::const_iterator child;
    child = mJausChildServices.find(id.mName);
    if(child != mJausChildServices.end())
    {
        return child->second;
    }
    return NULL;
}


Service::ID::Set Service::GetServices() const
{
    Mutex::ScopedLock lock(&mJausServiceMutex);
    Service::ID::Set services;
    Service::ID::Set::iterator s;

    services.insert(this->GetServiceID());

    Map::const_iterator child;
    for(child = mJausChildServices.begin();
        child != mJausChildServices.end();
        child++)
    {
        if(child->second->IsDiscoverable())
        {
            const Sensor* sensor = dynamic_cast<Sensor *>(child->second);
            if(sensor && sensor->IsSynchronizing())
            {
                continue;
            }
            Service::ID::Set childServices = child->second->GetServices();
            for(s = childServices.begin();
                s != childServices.end();
                s++)
            {
                services.insert(*s);
            }
        }
    }
    return services;
}


void Service::RecursiveShutdown()
{
    Map::iterator child;
    child = mJausChildServices.begin();
    while(child != mJausChildServices.end())
    {
        child->second->RecursiveShutdown();
        child++;
    }
    Shutdown();
}


void Service::SetComponent(Component* component)
{
    if(component == NULL) { return; }
    Mutex::ScopedLock lock(&mJausServiceMutex);
    mpComponent = component;
    if(component->TransportService())
    {
        mpTransportService = component->TransportService();
    }
    Map::iterator child;
    for(child = mJausChildServices.begin();
        child != mJausChildServices.end();
        child++)
    {
        child->second->SetComponent(component);
    }
}


void Service::PushMessageToChildren(const Message* message)
{
    Transport* transport = dynamic_cast<Transport *>(this);
    if(transport)
    {
        transport->TriggerMessageCallbacks(message);
        // Do command filtering here.  Access control service determiens if
        // the command should pass through or not.
        if(message->IsCommand() && 
           mpComponent->AccessControlService()->AcceptCommandMessage(message) == false)
        {
            return;
        }
        // Let all services receives message, even if they ignore it.
        Service::Map services = mpComponent->GetServices();
        Service::Map::iterator s;
        for(s = services.begin();
            s != services.end();
            s++)
        {
            if(s->second != transport && s->second->mServiceEnabledFlag)
            {
                s->second->Receive(message);
            }
        }
    }
}


Service::Map Service::GetChildServices()
{
    Mutex::ScopedLock lock(&mJausServiceMutex);
    Service::Map children = mJausChildServices;
    Service::Map::iterator child;
    for(child = children.begin();
        child != children.end();
        child++)
    {
        Service::Map children2 = child->second->GetChildServices();
        Service::Map::iterator child2;
        for(child2 = children2.begin();
            child2 != children2.end();
            child2++)
        {
            children[child2->first] = child2->second;
        }
    }
    return children;
}


const Service::Map Service::GetChildServices() const
{
    Mutex::ScopedLock lock(&mJausServiceMutex);
    Service::Map children = mJausChildServices;
    Service::Map::const_iterator child;
    for(child = children.begin();
        child != children.end();
        child++)
    {
        Service::Map children2 = child->second->GetChildServices();
        Service::Map::iterator child2;
        for(child2 = children2.begin();
            child2 != children2.end();
            child2++)
        {
            children[child2->first] = child2->second;
        }
    }
    return children;
}

/*  End of File */