frag_vector.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * SHORE 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_CONTAINER_FRAG_VECTOR_HPP__
#define SHORE_CONTAINER_FRAG_VECTOR_HPP__

#include <algorithm>
#include <iterator>
#include <vector>

#include <boost/iterator/iterator_facade.hpp>

namespace shore {

template<typename Iterator>
class frag_vector
{
 public:

        typedef typename std::iterator_traits<Iterator>::value_type value_type;
        typedef typename std::iterator_traits<Iterator>::reference reference;
        typedef typename std::iterator_traits<Iterator>::pointer pointer;

 private:

        std::vector<Iterator> m_begins;
        std::vector<Iterator> m_ends;
        std::vector<size_t> m_begofs;
        std::vector<size_t> m_endofs;
        size_t m_size;

 public:
        
        frag_vector()
        :m_size(0)
        {}

        void add_fragment(Iterator beg,Iterator end)
        {
                m_begins.push_back(beg);
                m_ends.push_back(end);
                m_begofs.push_back(m_size);
                m_size+=(end-beg);
                m_endofs.push_back(m_size);
        }

        size_t size() const
        {
                return m_size;
        }

        bool empty() const
        {
                return m_size==0;
        }

        void clear()
        {
                m_begins.clear();
                m_ends.clear();
                m_begofs.clear();
                m_endofs.clear();
                m_size=0;
        }

        reference operator[](const size_t idx)
        {
                const std::vector<size_t>::const_iterator ub=
                        std::upper_bound(m_endofs.begin(),m_endofs.end(),idx);

                const size_t blocknum=ub-m_endofs.begin();
                return m_begins[blocknum][idx-m_begofs[blocknum]];
        }

        reference front()
        {
                return *m_begins.front();
        }

        reference back()
        {
                return (*(m_ends.back()-1));
        }
};

} // namespace

#endif // SHORE_CONTAINER_FRAG_VECTOR_HPP__