mapnik/include/mapnik/vertex_vector.hpp

/*****************************************************************************
 * 
 * This file is part of Mapnik (c++ mapping toolkit)
 *
 * Copyright (C) 2006 Artem Pavlenko
 *
 * This library 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.
 *
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *****************************************************************************/
//  Credits:
//  I gratefully acknowledge the inspiring work of Maxim Shemanarev (McSeem), 
//  author of Anti-Grain Geometry (http://www.antigrain.com). I have used 
//  the datastructure from AGG as a template for my own. 


//$Id: vertex_vector.hpp 39 2005-04-10 20:39:53Z pavlenko $

#ifndef VERTEX_VECTOR_HPP
#define VERTEX_VECTOR_HPP
// mapnik
#include <mapnik/vertex.hpp>
#include <mapnik/ctrans.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/tuple/tuple.hpp>
// stl
#include <vector>
#include <cstring>

namespace mapnik
{
template <typename T>
class vertex_vector : private boost::noncopyable
{
    typedef typename T::type value_type;
    typedef vertex<value_type,2> vertex_type;
    enum block_e {
        block_shift = 8,
        block_size  = 1<<block_shift,
        block_mask  = block_size - 1,
        grow_by     = 256
    };

private:
    unsigned num_blocks_;
    unsigned max_blocks_;
    value_type** vertexs_;
    unsigned char** commands_;
    unsigned pos_;
public:
        
    vertex_vector() 
        : num_blocks_(0),
          max_blocks_(0),
          vertexs_(0),
          commands_(0),
          pos_(0) {}

    ~vertex_vector()
    {
        if ( num_blocks_ )
        {
            value_type** vertexs=vertexs_ + num_blocks_ - 1;
            while ( num_blocks_-- )
            {
                delete [] *vertexs;
                --vertexs;
            }
            delete [] vertexs_;
        }
    }
    unsigned size() const 
    {
        return pos_;
    }
        
    void push_back (value_type x,value_type y,unsigned command)
    {
        unsigned block = pos_ >> block_shift;
        if (block >= num_blocks_)
        {
            allocate_block(block);
        }
        value_type* vertex = vertexs_[block] + ((pos_ & block_mask) << 1);
        unsigned char* cmd= commands_[block] + (pos_ & block_mask);
            
        *cmd = static_cast<unsigned char>(command);
        *vertex++ = x;
        *vertex   = y;
        ++pos_;
    }
    unsigned get_vertex(unsigned pos,value_type* x,value_type* y) const
    {
        if (pos >= pos_) return SEG_END;
        unsigned block = pos >> block_shift;
        const value_type* vertex = vertexs_[block] + (( pos & block_mask) << 1);
        *x = (*vertex++);
        *y = (*vertex);
        return commands_[block] [pos & block_mask];
    }
                
    void set_capacity(size_t)
    {
        //do nothing
    }
        
private:
    void allocate_block(unsigned block)
    {
        if (block >= max_blocks_)
        {
            value_type** new_vertexs = new value_type* [(max_blocks_ + grow_by) * 2];
            unsigned char** new_commands = (unsigned char**)(new_vertexs + max_blocks_ + grow_by);
            if (vertexs_)
            {
                std::memcpy(new_vertexs,vertexs_,max_blocks_ * sizeof(value_type*));
                std::memcpy(new_commands,commands_,max_blocks_ * sizeof(unsigned char*));
                delete [] vertexs_;
            }
            vertexs_ = new_vertexs;
            commands_ = new_commands;
            max_blocks_ += grow_by;
        }
        vertexs_[block] = new value_type [block_size * 2 + block_size / (sizeof(value_type))];
        commands_[block] = (unsigned char*)(vertexs_[block] + block_size*2);
        ++num_blocks_;
    }
};

template <typename T>
struct vertex_vector2 : boost::noncopyable
{
    typedef typename T::type value_type;
    typedef boost::tuple<value_type,value_type,char> vertex_type;
    typedef typename std::vector<vertex_type>::const_iterator const_iterator;
    vertex_vector2() {}
    unsigned size() const 
    {
        return cont_.size();
    }

    void push_back (value_type x,value_type y,unsigned command)
    {
        cont_.push_back(vertex_type(x,y,command));
    }
    unsigned get_vertex(unsigned pos,value_type* x,value_type* y) const
    {
        if (pos >= cont_.size()) return SEG_END;
        vertex_type const& c = cont_[pos];
        *x = boost::get<0>(c);
        *y = boost::get<1>(c);
        return boost::get<2>(c);
    }
        
    const_iterator begin() const
    {
        return cont_.begin();
    }
        
    const_iterator end() const
    {
        return cont_.end();
    }

    void set_capacity(size_t size)
    {
        cont_.reserve(size);
    }
private:
    std::vector<vertex_type> cont_;
};
}

#endif //VERTEX_VECTOR_HPP