block_impl.h

Go to the documentation of this file.

/* Tide
 *
 * Header file for the common Block functionality object.
 *
 * Copyright 2011 Geoffrey Biggs geoffrey.biggs@aist.go.jp
 *     RT-Synthesis Research Group
 *     Intelligent Systems Research Institute,
 *     National Institute of Advanced Industrial Science and Technology (AIST),
 *     Japan
 *     All rights reserved.
 *
 * This file is part of Tide.
 *
 * Tide 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.
 *
 * Tide 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 Tide. If not, see <http://www.gnu.org/licenses/>.
 */

#if !defined(TIDE_BLOCK_IMPL_H_)
#define TIDE_BLOCK_IMPL_H_

#include <stdint.h>
#include <tide/block.h>
#include <tide/win_dll.h>
#include <utility>


namespace tide
{
    class TIDE_EXPORT BlockImpl : public Block,
        public boost::equality_comparable<BlockImpl>
    {
        public:
            BlockImpl(uint64_t track_number, int16_t timecode,
                    LacingType lacing=LACING_NONE);

            uint64_t track_number() const { return track_num_; }
            void track_number(uint64_t track_number)
                { track_num_ = track_number; }

            int16_t timecode() const { return timecode_; }
            void timecode(int16_t timecode) { timecode_ = timecode; }

            bool invisible() const { return invisible_; }
            void invisible(bool invisible) { invisible_ = invisible; }

            LacingType lacing() const { return lacing_; }
            void lacing(LacingType lacing) { lacing_ = lacing; }

            BlockImpl& operator=(BlockImpl const& other);

            value_type& at(size_type pos)
                { return frames_.at(pos); }
            value_type const& at(size_type pos) const
                { return frames_.at(pos); }

            value_type& operator[](size_type pos)
                { return frames_[pos]; }
            value_type const& operator[](size_type pos) const
                { return frames_[pos]; }

            iterator begin() { return frames_.begin(); }
            const_iterator begin() const { return frames_.begin(); }
            iterator end() { return frames_.end(); }
            const_iterator end() const { return frames_.end(); }
            reverse_iterator rbegin() { return frames_.rbegin(); }
            const_reverse_iterator rbegin() const { return frames_.rbegin(); }
            reverse_iterator rend() { return frames_.rend(); }
            const_reverse_iterator rend() const { return frames_.rend(); }

            bool empty() const { return frames_.empty(); }
            size_type count() const { return frames_.size(); }
            size_type max_count() const;

            void clear() { frames_.clear(); }

            void erase(iterator position)
                { frames_.erase(position); }
            void erase(iterator first, iterator last)
                { frames_.erase(first, last); }

            void push_back(value_type const& value);

            void resize(size_type count);

            void swap(BlockImpl& other);

            std::streamsize size() const;

            std::streamsize write(std::ostream& output, uint8_t extra_flags);

            typedef std::pair<std::streamsize, uint8_t> ReadResult;
            ReadResult read(std::istream& input, std::streamsize size);

            friend bool operator==(BlockImpl const& lhs, BlockImpl const& rhs);

            typedef boost::shared_ptr<std::vector<char> > value_type;

        protected:
            uint64_t track_num_;
            int16_t timecode_;
            bool invisible_;
            LacingType lacing_;
            std::vector<value_type> frames_;

            void validate() const;

            void reset();

            std::streamsize read_ebml_laced_frames(std::istream& input,
                    std::streamsize size);

            std::streamsize read_fixed_frames(std::istream& input,
                    std::streamsize size, unsigned int count);
    }; // class BlockImpl

    bool operator==(BlockImpl const& lhs, BlockImpl const& rhs);
}; // namespace tide

// group implementations

#endif // TIDE_BLOCK_IMPL_H_