cluster.h

Go to the documentation of this file.

/* Tide
 *
 * Header for the Cluster element's base class.
 *
 * 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_CLUSTER_H_)
#define TIDE_CLUSTER_H_

#include <tide/block_element.h>
#include <tide/master_element.h>
#include <tide/uint_element.h>
#include <tide/win_dll.h>


namespace tide
{
    class SilentTrackNumber : public UIntElement
    {
        public:
            SilentTrackNumber(uint64_t track_number)
                : UIntElement(ids::SilentTrackNumber, track_number)
            {
            }
    };

    //template <typename Impl>
    class TIDE_EXPORT Cluster : public MasterElement
    {
        public:
            typedef boost::shared_ptr<Cluster> Ptr;
            typedef BlockElement::Ptr value_type;
            typedef size_t size_type;
            typedef value_type& reference;
            typedef value_type const& const_reference;

            Cluster(uint64_t timecode=0);

            virtual ~Cluster() {};

            // Cluster interface

            virtual bool empty() const = 0;
            virtual size_type count() const = 0;
            virtual void clear() = 0;

            //virtual void erase(typename Impl::Iterator position) = 0;
            //virtual void erase(typename Impl::Iterator first, typename Impl::Iterator last) = 0;

            virtual void push_back(value_type const& value) = 0;

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

            std::vector<SilentTrackNumber>& silent_tracks()
                { return silent_tracks_; }

            uint64_t position() const;

            uint64_t previous_size() const { return prev_size_; }
            void previous_size(uint64_t size) { prev_size_ = size; }

            std::streamsize size() const;

            std::streamsize read(std::istream& input)
                { return Element::read(input); }

            virtual std::streamsize finalise(std::ostream& output) = 0;

        protected:
            UIntElement timecode_;
            std::vector<SilentTrackNumber> silent_tracks_;
            UIntElement position_;
            UIntElement prev_size_;
            std::streamsize size_;
            bool writing_;

            //this element.
            std::streamsize meta_size() const;

            std::streamsize body_size() const
                { return size_; }

            std::streamsize write_size(std::ostream& output);

            std::streamsize write_body(std::ostream& output);

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

            virtual std::streamsize blocks_size() const = 0;

            virtual std::streamsize read_blocks(std::istream& input,
                    std::streamsize size) = 0;

            std::streamsize read_silent_tracks(std::istream& input);

            virtual void reset();
    }; // class Cluster
}; // namespace tide

// group interfaces

#endif // TIDE_CLUSTER_H_