abstractroutingengine.h

/*
    Copyright (C) 2012  Intel Corporation

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/


#ifndef ABSTRACTROUTINGENGINE_H
#define ABSTRACTROUTINGENGINE_H

#include <sys/types.h>
#include <stdlib.h>
#include <boost/any.hpp>
#include <functional>
#include <string>
#include <time.h>

#include "vehicleproperty.h"
#include "abstractpropertytype.h"
#include "propertyinfo.hpp"

class AbstractSink;
class AbstractSource;
class AsyncPropertyReply;
class AsyncRangePropertyReply;
class AsyncSetPropertyRequest;


typedef std::function<void (AsyncPropertyReply*)> GetPropertyCompletedSignal;
typedef std::function<void (AsyncRangePropertyReply*)> GetRangedPropertyCompletedSignal;
typedef std::function<void (AsyncPropertyReply*)> TimedOutCallback;

class AsyncPropertyRequest
{
public:
    AsyncPropertyRequest()
        :property(VehicleProperty::NoValue),zoneFilter(Zone::None), timeout(10000)
    {

    }

    AsyncPropertyRequest(const AsyncPropertyRequest &request)
    {
        this->property = request.property;
        this->completed = request.completed;
        this->sourceUuidFilter = request.sourceUuidFilter;
        this->zoneFilter = request.zoneFilter;
        this->timeout = request.timeout;
    }

    AsyncPropertyRequest & operator = (const AsyncPropertyRequest & other)
    {
        this->property = other.property;
        this->completed = other.completed;
        this->sourceUuidFilter = other.sourceUuidFilter;
        this->zoneFilter = other.zoneFilter;
        this->timeout = other.timeout;

        return *this;
    }

    virtual ~AsyncPropertyRequest() { }

    VehicleProperty::Property property;

    std::string sourceUuidFilter;

    Zone::Type zoneFilter;

    GetPropertyCompletedSignal completed;

    uint timeout;

    std::string pid;
};

class AsyncPropertyReply: public AsyncPropertyRequest
{
public:
    AsyncPropertyReply();

    AsyncPropertyReply(const AsyncPropertyRequest &request);

    AsyncPropertyReply(const AsyncSetPropertyRequest &request);

    virtual ~AsyncPropertyReply();

    enum Error {
        NoError = 0,
        Timeout,
        InvalidOperation,
        PermissionDenied,
        ZoneNotSupported
    };

    static std::string errorToStr(Error err)
    {
        if(err == NoError)
            return "NoError";
        else if(err == Timeout)
            return "Timeout";
        else if(err == InvalidOperation)
            return "InvalidOperation";
        else if(err == PermissionDenied)
            return "PermissionDenied";
        else if(err == ZoneNotSupported)
            return "ZoneNotSupported";

        DebugOut(DebugOut::Warning) << "Could not translate error: " << err << endl;
        return "";
    }

    static Error strToError(std::string err)
    {
        if(err == "NoError")
            return NoError;
        else if(err == "Timeout")
            return Timeout;
        else if(err == "InvalidOperation")
            return InvalidOperation;
        else if(err == "PermissionDenied")
            return PermissionDenied;
        else if(err == "ZoneNotSupported")
            return ZoneNotSupported;

        DebugOut(DebugOut::Warning) << "Could not translate error string: " << err << endl;
        return NoError;
    }

    AbstractPropertyType* value;

    bool success;

    TimedOutCallback timedout;

    Error error;

private:
    void setTimeout();
    GSource* timeoutSource;
};

class AsyncSetPropertyRequest: public AsyncPropertyRequest
{
public:
    AsyncSetPropertyRequest()
        :value(NULL)
    {

    }

    AsyncSetPropertyRequest(const AsyncPropertyRequest &request)
        :AsyncPropertyRequest(request), value(NULL)
    {

    }

    virtual ~AsyncSetPropertyRequest()
    {

    }

    AbstractPropertyType* value;
};

class AsyncRangePropertyRequest
{
public:
    AsyncRangePropertyRequest()
        :zone(Zone::None), timeBegin(0), timeEnd(0), sequenceBegin(-1), sequenceEnd(-1)
    {

    }

    AsyncRangePropertyRequest(const AsyncRangePropertyRequest &request)
    {
        this->properties = request.properties;
        this->completed = request.completed;
        this->timeBegin = request.timeBegin;
        this->timeEnd = request.timeEnd;
        this->sequenceBegin = request.sequenceBegin;
        this->sequenceEnd = request.sequenceEnd;
        this->sourceUuid = request.sourceUuid;
        this->zone = request.zone;
    }

    virtual ~AsyncRangePropertyRequest() {}

    PropertyList properties;

    std::string sourceUuid;

    Zone::Type zone;

    GetRangedPropertyCompletedSignal completed;

    double timeBegin;

    double timeEnd;

    int32_t sequenceBegin;

    int32_t sequenceEnd;

    std::string pid;
};

class AsyncRangePropertyReply: public AsyncRangePropertyRequest
{
public:
    AsyncRangePropertyReply(AsyncRangePropertyRequest request)
        :AsyncRangePropertyRequest(request), success(false)
    {

    }

    ~AsyncRangePropertyReply()
    {
        for(auto itr = values.begin(); itr != values.end(); itr++)
        {
            delete (*itr);
        }

        values.clear();
    }

    AsyncPropertyReply::Error error;

    std::list<AbstractPropertyType*> values;

    bool success;
};

class AbstractRoutingEngine
{
public:
    typedef std::function<void (AbstractPropertyType* value)> PropertyChangedType;

    AbstractRoutingEngine(std::map<std::string, std::string> configuration):mConfig(configuration) {}
    virtual ~AbstractRoutingEngine();

    virtual void registerSource(AbstractSource* src) = 0;
    virtual void updateSupported(PropertyList added, PropertyList removed, AbstractSource* source) = 0;


    void updateProperty(VehicleProperty::Property property, AbstractPropertyType* value, std::string uuid)
    {
        DebugOut(DebugOut::Warning)<<"updateProperty(VehicleProperty::Property,AbstractPropertyType*,std::string) is deprecated.  use new updateProperty(AbstractPropertyType*, const std::string &)"<<endl;
        updateProperty(value,uuid);
    }

    virtual void updateProperty(AbstractPropertyType* value, const std::string &uuid) = 0;
    virtual PropertyList supported() = 0;

    virtual void registerSink(AbstractSink* self) = 0;
    virtual void  unregisterSink(AbstractSink* self) = 0;

    virtual std::vector<std::string> sourcesForProperty(const VehicleProperty::Property & property) = 0;

    virtual AsyncPropertyReply * getPropertyAsync(AsyncPropertyRequest request) = 0;

    virtual void getRangePropertyAsync(AsyncRangePropertyRequest request) = 0;

    virtual AsyncPropertyReply * setProperty(AsyncSetPropertyRequest request) = 0;

    virtual uint subscribeToProperty(const VehicleProperty::Property & propertyName, PropertyChangedType callback, std::string pid="") = 0;

    virtual void unsubscribeToProperty(uint handle) = 0;

    virtual bool subscribeToProperty(const VehicleProperty::Property & propertyName, AbstractSink* self) = 0;

    virtual bool subscribeToProperty(const VehicleProperty::Property & propertyName, const std::string & sourceUuidFilter, AbstractSink *self) = 0;

    virtual bool subscribeToProperty(const VehicleProperty::Property & propertyName, const std::string & sourceUuidFilter, Zone::Type zoneFilter, AbstractSink *self) = 0;

    virtual bool unsubscribeToProperty(const VehicleProperty::Property &, AbstractSink* self) = 0;

    virtual PropertyInfo getPropertyInfo(const VehicleProperty::Property &, const std::string & sourceUuid) = 0;

protected:
    std::map<std::string, std::string> mConfig;
};

#endif // ABSTRACTROUTINGENGINE_H