ChannelProperty.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_CHANNELPROPERTY_H_
#define _MIRA_CHANNELPROPERTY_H_

#include <QLineEdit>

#include <serialization/ReflectorInterface.h>
#include <serialization/IsObjectTrackable.h>
#include <serialization/SplitReflect.h>
#include <serialization/GetterSetter.h>
#include <serialization/PropertySerializer.h>

#include <fw/Framework.h>
#include <fw/AuthorityProvider.h>

#include <widgets/PropertyEditorDelegateUtils.h>

namespace mira {


class ChannelPropertyBase
{
public:

    ChannelPropertyBase() : mAuthorityProvider(NULL), mOptional(false) {}
    virtual ~ChannelPropertyBase() {}

public:

    const std::string& getID() const {
        return mChannelID;
    }

    void setName(const std::string& name) {
        mName = name;
    }

    const std::string& getName() const {
        return mName;
    }

public:

    virtual bool isValid() const = 0;
    
    virtual uint32 getDataUpdateCount() const = 0;

    virtual std::list<std::pair<std::string, Typename>> getAvailableChannels() = 0;

public:

    void setOptional() {
        mOptional = true;
    }

    bool isOptional() const {
        return mOptional;
    }

public:
    virtual void update() = 0;

    virtual void set(const std::string& id, IAuthorityProvider* authorityProvider)
    {
        mChannelID = id;
        mAuthorityProvider = authorityProvider;
    }

protected:
    std::string mName;
    std::string mChannelID;
    IAuthorityProvider* mAuthorityProvider;
    bool mOptional;
};


class ChannelPropertyProxy
{

public:

    ChannelPropertyProxy() : property(NULL) {}
    ChannelPropertyProxy(const std::string& id, ChannelPropertyBase* p) :
        channelID(id), property(p) {}

public:

    template <typename Reflector>
    void reflect(Reflector& r) {
        r.member("Channel",channelID, "The ID of the channel");
    }

public:

    bool isValid() const {
        assert(property);
        return property->isValid();
    }

    std::list<std::pair<std::string, Typename>> getAvailableChannels()
    {
        assert(property);
        return property->getAvailableChannels();
    }

public:

    std::string channelID;
    ChannelPropertyBase* property;

};

template<>
class IsObjectTrackable<ChannelPropertyProxy> : public std::false_type {};


template <typename T>
class ChannelProperty : public ChannelPropertyBase
{

public:
    ChannelProperty() :
        mDataUpdates(0),
        mProcessedUpdates(0),
        mDataChangedFn(NULL),
        mDataIntervalChangedFn(NULL),
        mChannelChangedFn(NULL)
    {}

public: // implementation of ChannelPropertyBase

    virtual bool isValid() const {
        return mChannel.isValid();
    }

    virtual uint32 getDataUpdateCount() const {
        return mDataUpdates;
    }

    virtual std::list<std::pair<std::string, Typename>> getAvailableChannels() {
        return MIRA_FW.getChannelManager().getChannelsOfType<T>();
    }

public:

    // overwritten from ChannelPropertyBase
    // will unsubscribe a set channel
    virtual void set(const std::string& id, IAuthorityProvider* authorityProvider)
    {
        ChannelPropertyBase::set(id,authorityProvider);
        mDataUpdates = 0;

        // unsubscribe and reset our channel
        if(mChannel.isValid()) {
            assert(mAuthorityProvider!=NULL);
            Authority& authority = mAuthorityProvider->getAuthority();
            authority.unsubscribe<T>(mChannel.getID());
            mChannel.reset();
        }

        if (mChannelChangedFn)
            mChannelChangedFn();

        mProcessedUpdates = -1; // setting different from mDataUpdates ensures
                                // update() will immediately try to read from channel,
                                // before next channel update (channel may already hold data)
    }

public:
    void setDataChangedCallback(boost::function<void (ChannelRead<T>)> dataChangedFn)
    {
        mDataChangedFn = dataChangedFn;
        mDataIntervalChangedFn = NULL;
    }

    template<typename Class>
    void setDataChangedCallback(void (Class::*f)(ChannelRead<T>), Class* obj)
    {
        mDataChangedFn = boost::bind(f, obj, _1);
        mDataIntervalChangedFn = NULL;
    }

    void setDataIntervalChangedCallback(boost::function<void (ChannelReadInterval<T>)> dataChangedFn)
    {
        mDataChangedFn = NULL;
        mDataIntervalChangedFn = dataChangedFn;
    }

    template<typename Class>
    void setDataIntervalChangedCallback(void (Class::*f)(ChannelReadInterval<T>), Class* obj)
    {
        mDataChangedFn = NULL;
        mDataIntervalChangedFn = boost::bind(f, obj, _1);
    }

    void setChannelChangedCallback(boost::function<void ()> channelChangedFn)
    {
        mChannelChangedFn = channelChangedFn;
    }

    template<typename Class>
    void setChannelChangedCallback(void (Class::*f)(), Class* obj)
    {
        mChannelChangedFn = boost::bind(f, obj);
    }

    Channel<T> getChannel()
    {
        if(mChannelID.empty())
            MIRA_THROW(XRuntime, "No channel specified.");

        if(!mChannel.isValid() && mAuthorityProvider!=NULL) {
            Authority& authority = mAuthorityProvider->getAuthority();

            // here we will set the channel by subscribing the channel with
            // the specified id, however, we will subscribe only if the channel
            // exists to prevent creating a new channel
            if(MIRA_FW.getChannelManager().hasChannel(mChannelID))
            {
                mChannel = authority.subscribe<T>(mChannelID, &ChannelProperty::callback, this);
                mDataUpdates = MIRA_FW.getChannelManager().getNrOfDataChanges(mChannelID);
            }
            else
                MIRA_THROW(XRuntime, "The channel '" << mChannelID << "' does not exist.");
            mProcessedUpdates = -1; // see set()
        }
        return mChannel;
    }

    virtual void update()
    {
        getChannel();
        int64 updates = mDataUpdates;

        // - after update, before processing it: mDataUpdates > mProcessedUpdates
        // - when mDataUpdates has overflown (uint32): mDataUpdates < mProcessedUpdates
        // - after (re)initialization: mDataUpdates > mProcessedUpdates
        if ((updates != mProcessedUpdates) && (mDataChangedFn || mDataIntervalChangedFn) )
        {
            mProcessedUpdates = updates;
            if ( mDataChangedFn )
                try {
                    mDataChangedFn(mChannel.read());
                }
                catch(XInvalidRead&) {}
            else {
                ChannelReadInterval<T> tInterval;
                if ( !mLastUpdate.isValid() ) {
                    bool increase = mChannel.isAutoIncreasingStorageDuration();

                    // get all slots that are there, without affecting the storage duration
                    MIRA_FW.getChannelManager().setAutoIncreaseStorageDuration(mChannelID, false);
                    try {
                        tInterval = mChannel.readInterval(Time::unixEpoch());
                    }
                    catch(XInvalidRead&) {}
                    MIRA_FW.getChannelManager().setAutoIncreaseStorageDuration(mChannelID, increase);
                }
                else {
                    try {
                        tInterval = mChannel.readInterval(mLastUpdate);
                    }
                    catch(XInvalidRead&) {}
                }

                // we have to check if there actually is new data, even though mDataUpdates changed:
                // it happens we already read the newest data (triggered by a previous callback),
                // then callback for the new data is executed _afterwards_ and increments mDataUpdates
                if (tInterval.empty())
                    return;

                mDataIntervalChangedFn( tInterval );
                typename ChannelReadInterval<T>::const_iterator it = tInterval.end();
                it--;
                mLastUpdate = ((ChannelRead<T>)it)->timestamp;
            }
        }

    }

    void callback(ChannelRead<T> channel)
    {
        ++mDataUpdates;
    }

public:


    template<typename Reflector>
    static void channelProperty(Reflector& r, const std::string& name,
            ChannelProperty& channel,
        const std::string& comment, IAuthorityProvider* authorityProvider)
    {
        r.property(name.c_str(),
            getter<ChannelPropertyProxy>(
                    boost::bind(proxyGetter, &channel, authorityProvider)),
            setter<ChannelPropertyProxy>(
                    boost::bind(proxySetter, &channel, _1, authorityProvider)),
            comment.c_str());
    }

private:

    static void proxySetter(ChannelProperty* This, const ChannelPropertyProxy& proxy,
                            IAuthorityProvider* authorityProvider) {
        This->set(proxy.channelID, authorityProvider);
    }

    static ChannelPropertyProxy proxyGetter(ChannelProperty* This,
            IAuthorityProvider* authorityProvider) {
        This->mAuthorityProvider = authorityProvider;
        return ChannelPropertyProxy(This->mChannelID, This);
    }

private:

    Channel<T>  mChannel;
    uint32 mDataUpdates;
    int64 mProcessedUpdates;
    boost::function<void (ChannelRead<T>)> mDataChangedFn;
    boost::function<void (ChannelReadInterval<T>)> mDataIntervalChangedFn;
    boost::function<void ()> mChannelChangedFn;
    Time mLastUpdate;
};



class ChannelPropertyDelegateLineEdit : public QLineEdit, public IPropertyDelegate_Edit
{
    Q_OBJECT
public:
    ChannelPropertyDelegateLineEdit(PropertyNode* p, QWidget* parent);

    void initFromProperty() override;
public slots:
    void slotSetValue();
signals:
    void propertyEdited() override;
public:
    TypedPropertyNode<ChannelPropertyProxy>* property;
};


}

#endif