AbstractVirtualDevice.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
 *
 * This software is dual-licensed to you under the MIT License (MIT) and
 * the Universal Permissive License (UPL). See the LICENSE file in the root
 * directory for license terms. You may choose either license, or both.
 */
 
#pragma once
 
#include <string>
#include <DeviceModel.hpp>
#include <NamedValue.hpp>
 
namespace iotdcl {
    class VirtualDevice;
 
    template <class V> class Event {
    public:
        virtual ~Event() {
        }
 
        virtual V* getVirtualDevice() = 0;
 
        virtual NamedValue* getNamedValue() const = 0;
    protected:
        VirtualDevice *vd;
        NamedValue *value;

        Event(VirtualDevice *vd, NamedValue *value) {
            this->vd = vd;
            this->value = value;
        }
    private:
        Event() {
        }
    };
 
    template <class V> class ChangeEvent: public Event<V> {
    public:
        virtual ~ChangeEvent() {
        }
    protected:
        ChangeEvent(VirtualDevice *vd, NamedValue *value) : Event<V>(vd,value) {}
    };
 
    template <class V> class ActionEvent: public Event<V> {
    public:
        virtual const std::string getName() const = 0;
        virtual ~ActionEvent() {
        }
    protected:
        ActionEvent(VirtualDevice *vd, NamedValue *value) : Event<V>(vd,value) {}
    };
 
    class ActionCallback {
    public:
        virtual void onAction(ActionEvent<VirtualDevice> &arguments) const = 0;
        virtual ~ActionCallback() {
        }
    };
 
    class ChangeCallback {
    public:
        virtual void onChange(const ChangeEvent<VirtualDevice>& event) const = 0;
    };
 
    template <class V> class ErrorEvent: public Event<V> {
    public:
        virtual const std::string getMessage() const = 0;
        virtual ~ErrorEvent() {
        }
    protected:
        ErrorEvent(VirtualDevice *vd, NamedValue *value) : Event<V>(vd,value) {}
    };
 
    class ErrorCallback {
    public:
        virtual void onError(const ErrorEvent<VirtualDevice>& event) const = 0;
    };
    template<class V> class AbstractVirtualDevice {
    public:
 
        virtual ~AbstractVirtualDevice() {
        }
 
        virtual const DeviceModel& getDeviceModel() = 0;
 
        virtual const std::string& getEndpointId() const = 0;
 
        template <typename T> V& set(const std::string &attributeName, T& value) {
            V *this_ptr(dynamic_cast<V*>(this));
            if (this_ptr != nullptr) {
                this_ptr->template set<T>(attributeName, value);
            }
            return *this_ptr;
        }
 
        template <typename T> T get(const std::string &attributeName) {
            V *this_ptr(dynamic_cast<V*>(this));
            if (this_ptr != nullptr) {
                return this_ptr->template get<T>(attributeName);
            }
            return 0;
        }
 
        virtual V& update(void) = 0;
 
        virtual void finish(void) = 0;
 
        virtual void setOnChange(const ChangeCallback *callback) = 0;
 
        virtual void setOnError(const ErrorCallback *callback) = 0;
        virtual void setOnChange(const std::string &attributeName, const ChangeCallback *callback) = 0;
 
        virtual void setOnError(const std::string &attributeName, const ErrorCallback *callback) = 0;
    };
};