ambplugin.h

Go to the documentation of this file.

/*
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 _AMBPLUGIN_H_
#define _AMBPLUGIN_H_

#include <abstractsource.h>
#include "ambpluginimpl.h"
#include <string>

template<class T>
class AmbPlugin : public AbstractSource {

    static_assert(std::is_base_of<AmbPluginImpl, T>::value, "AmbPluginImpl has to be a base of T");

public:
    AmbPlugin(AbstractRoutingEngine* re, const std::map<std::string, std::string>& config);
    virtual ~AmbPlugin() {}

    // from AbstractSource:
public:

    virtual void getPropertyAsync(AsyncPropertyReply *reply);

    virtual void getRangePropertyAsync(AsyncRangePropertyReply *reply);

    virtual AsyncPropertyReply * setProperty(AsyncSetPropertyRequest request);

    virtual void subscribeToPropertyChanges(VehicleProperty::Property property);

    virtual void unsubscribeToPropertyChanges(VehicleProperty::Property property);

    virtual PropertyList supported();

    virtual int supportedOperations();

    virtual PropertyInfo getPropertyInfo(const VehicleProperty::Property & property);

    // from AbstractSink
public:

    virtual const string uuid();

    virtual void propertyChanged(AbstractPropertyType* value);

    virtual void supportedChanged(const PropertyList & supportedProperties);


    // AmbPlugin's own methods
public:

    void init();

private:

    std::unique_ptr<T> d;
};

//----------------------------------------------------------------------------
// Function implementations
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// AmbPlugin
//----------------------------------------------------------------------------

template<typename T>
AmbPlugin<T>::AmbPlugin(AbstractRoutingEngine* re, const std::map<std::string, std::string>& config) :
    AbstractSource(re, config),
    d(new T(re, config, *this))
{

}

template<typename T>
void AmbPlugin<T>::getPropertyAsync(AsyncPropertyReply *reply)
{
    if(d)
        d->getPropertyAsync(reply);
}

template<typename T>
void AmbPlugin<T>::getRangePropertyAsync(AsyncRangePropertyReply *reply)
{
    if(d)
        d->getRangePropertyAsync(reply);
}

template<typename T>
AsyncPropertyReply* AmbPlugin<T>::setProperty(AsyncSetPropertyRequest request)
{
    if(d)
        return d->setProperty(request);
    return nullptr;
}

template<typename T>
void AmbPlugin<T>::subscribeToPropertyChanges(VehicleProperty::Property property)
{
    if(d)
        d->subscribeToPropertyChanges(property);
}

template<typename T>
void AmbPlugin<T>::unsubscribeToPropertyChanges(VehicleProperty::Property property)
{
    if(d)
        return d->unsubscribeToPropertyChanges(property);
}

template<typename T>
PropertyList AmbPlugin<T>::supported()
{
    return d ? d->supported() : PropertyList();
}

template<typename T>
int AmbPlugin<T>::supportedOperations()
{
    return d ? d->supportedOperations() : 0;
}

template<typename T>
PropertyInfo AmbPlugin<T>::getPropertyInfo(const VehicleProperty::Property &property)
{
    return d ? d->getPropertyInfo(property) : PropertyInfo::invalid();
}

template<typename T>
const string AmbPlugin<T>::uuid()
{
    return d ? d->uuid() : "";
}

template<typename T>
void AmbPlugin<T>::propertyChanged(AbstractPropertyType* value)
{
    if(d)
        d->propertyChanged(value);
}

template<typename T>
void AmbPlugin<T>::supportedChanged(const PropertyList &supportedProperties)
{
    if(d)
        d->supportedChanged(supportedProperties);
}

template<typename T>
void AmbPlugin<T>::init()
{
    if(d)
        d->init();
}

#endif // _AMBPLUGIN_H_