TapeVisitor.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_TAPEVISITOR_H_
#define _MIRA_TAPEVISITOR_H_

#include <fw/Tape.h>

namespace mira {


class TapeVisitor
{
public:

    struct MessageInstance
    {
        MessageInstance() :
            tape(NULL), offset(0) {}

        Tape* tape;

        uint64 offset;

        std::string frameID;

        uint32 sequenceID;

        Buffer<uint8> data;

        bool compressed;
    };

    struct MessageInfo
    {
        MessageInfo() :
            tape(NULL),
            info(NULL),
            index(NULL) {}

        Tape* tape;

        Duration timeOffset;

        const Tape::ChannelInfo* info;

        const Tape::MessageIndex* index;

        bool operator<(const MessageInfo& other) const
        {
            return timeOffset < other.timeOffset;
        }
    };

    typedef std::vector<MessageInfo> MessageMap;
    typedef std::map<std::string, const Tape::ChannelInfo*> ChannelMap;

    class iterator;
    friend class iterator;

    class iterator
    {
    public:
        iterator() :
            mVisitor(NULL) {}

        iterator(TapeVisitor* visitor, MessageMap::iterator message) :
            mVisitor(visitor),
            mMessage(message) {}

        iterator& operator=(const iterator& other)
        {
            mVisitor = other.mVisitor;
            mMessage = other.mMessage;
            return *this;
        }

        iterator& operator++()
        {
            ++mMessage;
            return *this;
        }

        iterator& operator--()
        {
            --mMessage;
            return *this;
        }

        const MessageInstance& operator*() const
        {
            if (!mVisitor || mMessage == mVisitor->mMessages.end() )
                MIRA_THROW(XIO, "Cannot instantiate message from the end iterator");

            // If we are already instantiated return us
            if (mInstance.tape == mMessage->tape &&
                mInstance.offset == (mMessage->index->block+mMessage->index->offset))
                return mInstance;

            // copy informations about the message
            mInstance.tape = mMessage->tape;
            mInstance.offset = mMessage->index->block+mMessage->index->offset;

            // read the message from tape
            Duration oTime;
            mMessage->tape->readMessage(*mMessage->index, mInstance.frameID,
                                        mInstance.sequenceID, mInstance.data, oTime,
                                        mInstance.compressed);
            return mInstance;
        }

        const MessageInstance* operator->() const
        {
            return &this->operator *();
        }

        template <typename T>
        void read(Stamped<T>& oData)
        {
            validate();
            // perform type check
            if(mMessage->info->type!=typeName<T>()) {
                MIRA_THROW(XIO, "Cannot read a '"<<typeName<T>()<<
                    "' from Tape-Iterator message which has type '"<<mMessage->info->type<<"'");
            }

            // instantiate the data
            const MessageInstance& msgInst = this->operator*();
            Buffer<uint8> buf(msgInst.data);
            BinaryBufferDeserializer bs(&buf);
            // deserialize it ...
            bs.deserialize(oData.value(),false);
            // and fill in the header info
            oData.timestamp = mVisitor->getStartTime() + getTimeOffset();
            oData.frameID = msgInst.frameID;
            oData.sequenceID = msgInst.sequenceID;
        }

        void readJSON(Stamped<JSONValue>& oData);


        bool operator==(const iterator& other) const
        {
            return mVisitor == other.mVisitor && mMessage == other.mMessage;
        }

        bool operator!=(const iterator& other) const
        {
            return mVisitor != other.mVisitor || mMessage != other.mMessage;
        }

        Duration getTimeOffset() const
        {
            validate();
            return mMessage->timeOffset;
        }

        const Tape::ChannelInfo* getChannelInfo() const {
            validate();
            return mMessage->info;
        }

        Duration getTZOffset() const
        {
            validate();
            return mMessage->tape->getTZOffset();
        }


        friend class TapeVisitor;

    protected:

        void validate() const
        {
            if (!mVisitor || mMessage == mVisitor->mMessages.end())
                MIRA_THROW(XIO, "Cannot access message at the end iterator");
        }

        mutable MessageInstance mInstance;
        TapeVisitor* mVisitor;
        MessageMap::iterator mMessage;
    };

    void visit(Tape* iTape,
               Duration first = Duration::negativeInfinity(),
               Duration last = Duration::infinity(),
               bool ignoreStartTime = false);

    void visit(Tape* iTape, const std::vector<std::string>& channels,
               Duration first = Duration::negativeInfinity(),
               Duration last = Duration::infinity(),
               bool ignoreStartTime = false);

    Time getStartTime() const
    {
        if ( mStart )
            return *mStart;
        return Time::invalid();
    }

    void setStartTime(const Time& start)
    {
        mStart.reset(start);
        for (uint32 i=0; i<mMessages.size(); ++i)
            mMessages[i].timeOffset = (mMessages[i].tape->getStartTime() +
                                       mMessages[i].index->timeOffset) - *mStart;
    }

    Duration getFirstMessageTimeOffset() const
    {
        if (mMessages.size() > 0)
            return mMessages.begin()->timeOffset;
        return Duration::nanoseconds(0);
    }

    Duration getLastMessageTimeOffset() const
    {
        if (mMessages.size() > 0)
            return mMessages.rbegin()->timeOffset;
        return Duration::nanoseconds(0);
    }

    Duration getLastMessageTZOffset() const
    {
        if (mMessages.size() > 0)
            return mMessages.rbegin()->tape->getTZOffset();
        return Duration::nanoseconds(0);
    }

    uint32 getMessageCount() const
    {
        return mMessages.size();
    }

    iterator begin()
    {
        return iterator(this, mMessages.begin());
    }

    iterator at(Duration timeOffset)
    {
        if ( mMessages.size() == 0 )
            return iterator(this, mMessages.end());
        if ( mMessages.size() == 1 )
            return iterator(this, mMessages.begin());
        MessageMap::iterator it = mMessages.begin();
        Duration diffNext = abs(mMessages[0].timeOffset-timeOffset);
        for(uint32 i=0; i<mMessages.size()-1;++i, ++it)
        {
            Duration diffNow = diffNext;
            diffNext = abs(mMessages[i+1].timeOffset-timeOffset);
            if ( diffNow < diffNext )
                return iterator(this, it);
        }
        return iterator(this, mMessages.end());
    }

    iterator end()
    {
        return iterator(this, mMessages.end());
    }

    iterator findNextOf(Duration startOffset, const std::string& channel)
    {
        return findNextOf(at(startOffset), channel);
    }

    iterator findNextOf(const iterator& start, const std::string& channel)
    {
        MessageMap::iterator i = start.mMessage;
        for(; i!=mMessages.end(); ++i)
            if (i->info->name == channel)
                return iterator(this, i);
        return iterator(this, mMessages.end());
    }

    iterator findNextOfAnyOf(Duration startOffset, const std::vector<std::string>& channels)
    {
        return findNextOfAnyOf(at(startOffset), channels);
    }

    iterator findNextOfAnyOf(const iterator& start, const std::vector<std::string>& channels)
    {
        MessageMap::iterator i = start.mMessage;
        for(; i!=mMessages.end(); ++i)
            if (std::find(channels.begin(), channels.end(), i->info->name) != channels.end())
                return iterator(this, i);

        return iterator(this, mMessages.end());
    }

    const ChannelMap& getChannels() const
    {
        return mChannels;
    }

protected:

    void addChannel(Tape* tape, const Tape::ChannelInfo* channel,
                    Duration first = Duration::nanoseconds(0),
                    Duration last = Duration::infinity());

    void reIndex(Tape* tape, bool ignoreStartTime = false);

    boost::optional<Time> mStart;
    MessageMap mMessages;
    ChannelMap mChannels;
};


}

#endif