memory_cluster.h

Go to the documentation of this file.

/* Tide
 *
 * Header for the in-memory Cluster.
 *
 * 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_MEMORY_CLUSTER_H_)
#define TIDE_MEMORY_CLUSTER_H_

#include <boost/iterator/iterator_facade.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
#include <tide/block_element.h>
#include <tide/cluster.h>
#include <tide/win_dll.h>


namespace tide
{
    class TIDE_EXPORT MemoryCluster : public Cluster
    {
        protected:
            typedef std::vector<BlockElement::Ptr> BlockStore;

        public:
            MemoryCluster(uint64_t timecode=0);

            // Iterator types

            template <typename BlockType, typename IterType>
            class TIDE_EXPORT IteratorBase
                : public boost::iterator_facade<
                    IteratorBase<BlockType, IterType>,
                    BlockType, boost::bidirectional_traversal_tag>
            {
                private:
                    struct enabler {};

                public:
                    IteratorBase()
                    {
                    }

                    IteratorBase(IterType iter)
                        : iter_(iter)
                    {
                    }

                    template <typename OtherType, typename OtherIterType>
                    IteratorBase(IteratorBase<OtherType, OtherIterType> const& other)
                        : iter_(other.iter_)
                    {
                    }

                protected:
                    // Necessary for Boost::iterator implementation.
                    friend class boost::iterator_core_access;

                    // Integrate with owning container
                    friend class MemoryCluster;

                    IterType iter_;

                    void increment()
                    {
                        ++iter_;
                    }

                    void decrement()
                    {
                        --iter_;
                    }

                    template <typename OtherType, typename OtherIterType>
                    bool equal(
                            IteratorBase<OtherType, OtherIterType> const& other) const
                    {
                        return iter_ == other.iter_;
                    }

                    BlockType& dereference() const
                    {
                        return *iter_;
                    }
            }; // class IteratorBase

            typedef IteratorBase<BlockElement::Ptr, BlockStore::iterator> Iterator;
            typedef IteratorBase<Block::ConstPtr, BlockStore::const_iterator>
                ConstIterator;

            // Iterator access

            Iterator begin();
            ConstIterator begin() const;
            Iterator end();
            ConstIterator end() const;

            // Cluster interface

            virtual bool empty() const { return blocks_.empty(); }
            virtual size_type count() const { return blocks_.size(); }
            virtual void clear() { blocks_.clear(); }

            virtual void erase(Iterator position)
                { blocks_.erase(position.iter_); }
            virtual void erase(Iterator first, Iterator last)
                { blocks_.erase(first.iter_, last.iter_); }

            virtual void push_back(value_type const& value)
                { blocks_.push_back(value); }

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

        protected:
            BlockStore blocks_;

            std::streamsize blocks_size() const;

            std::streamsize read_blocks(std::istream& input,
                    std::streamsize size);
    }; // class MemoryCluster
}; // namespace tide

// group elements

#endif // TIDE_MEMORY_CLUSTER_H_