TapePlayer.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_TAPEPLAYER_H_
#define _MIRA_TAPEPLAYER_H_

#include <serialization/Serialization.h>
#include <fw/Framework.h>
#include <fw/TapeVisitor.h>

namespace mira {


class TapePlayer
{
public:

    TapePlayer();

    virtual ~TapePlayer()
    {
        stop();
        mAuthority.checkout();
    }

    template <typename Reflector>
    void reflect(Reflector& r)
    {}

    void pause()
    {
        mStepTo.reset();
        mStepToChannel.reset();
        mJumpTo.reset();
        mPlayImmediately = false;
        mPause = true;
    }

    bool isPaused() const
    {
        return mPause;
    }

    bool inStepTo() const
    {
        return mStepTo.is_initialized() || mStepToChannel.is_initialized();
    }

    void step()
    {
        stepTo(Duration::microseconds(-1));
    }

    void stepTo(Duration time);

    bool stepTo(const std::string& channelID);

    bool stepToAnyOf(const std::vector<std::string>& channelIDs);

    void stop()
    {
        mThread.interrupt();
        mThread.join();
        mIsPlaying = false;
        mErrorMessage.reset();
    }

    void setLoop(bool loop, int32 count = -1)
    {
        mLoopCount = count;
        mLoop = loop;
    }

    void setTimeScaler(float scaler)
    {
        assert(scaler >= 0.0f);
        mTimeScaler = 1.0f/scaler;
    }

    float getTimeScaler() const
    {
        return 1.0f/mTimeScaler;
    }

    void load(TapeVisitor* iVisitor, Time startTime=Time::now(), const std::string& prefix = "");

    void play();

    bool isPlaying() const
    {
        return mIsPlaying;
    }

    bool hasError() const
    {
        return mErrorMessage.is_initialized();
    }

    std::string getErrorMessage() const
    {
        if (mErrorMessage)
            return *mErrorMessage;
        return "";
    }

    Duration getCurrentMessageTimeOffset() const
    {
        if (mVisitor == NULL)
            return Duration::nanoseconds(0);
        if (mMessage == mVisitor->end())
            return mVisitor->getLastMessageTimeOffset();
        return mMessage.getTimeOffset();
    }

    Duration getCurrentMessageTZOffset() const
    {
        if (mVisitor == NULL)
            return Duration::nanoseconds(0);
        if (mMessage == mVisitor->end())
            return mVisitor->getLastMessageTZOffset();
        return mMessage.getTZOffset();
    }

    Time getRelativeStartTime() const
    {
        return mStartTime;
    }

    void jumpTo(Duration time);

    Authority* getAuthority()
    {
        return &mAuthority;
    }

protected:

    void stepTo(const TapeVisitor::iterator& i);
    void doPlay();

protected:

    Authority mAuthority;
    boost::thread mThread;
    int32 mLoopCount;
    bool mLoop;
    bool mPause;
    bool mPlayImmediately;
    bool mIsPlaying;
    float mTimeScaler;
    Time mStartTime;
    boost::optional<Duration> mJumpTo;
    boost::optional<Duration> mStepTo;
    boost::optional<TapeVisitor::iterator> mStepToChannel;
    boost::optional<std::string> mErrorMessage;
    TapeVisitor* mVisitor;
    TapeVisitor::iterator mMessage;
    boost::mutex mConditionMutex;
    boost::condition_variable mCondition;
    std::string mNamespacePrefix;
};


}

#endif