FM / property

/usr/include/boost/property_map

Name	Size	Mode	Actions
parallel/	-	0755	rm
compose_property_map.hpp	2317	0644	edit dl rm
dynamic_property_map.hpp	10591	0644	edit dl rm
function_property_map.hpp	2003	0644	edit dl rm
property_map.hpp	20756	0644	edit dl rm
property_map_iterator.hpp	3843	0644	edit dl rm
shared_array_property_map.hpp	1468	0644	edit dl rm
transform_value_property_map.hpp	2208	0644	edit dl rm
vector_property_map.hpp	3356	0644	edit dl rm

Edit: /usr/include/boost/property_map/vector_property_map.hpp (3356B)

#ifndef BOOST_PROPERTY_MAP_VECTOR_PROPERTY_MAP_HPP
#define BOOST_PROPERTY_MAP_VECTOR_PROPERTY_MAP_HPP

#include <boost/property_map/property_map.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <iterator>
#include <vector>

namespace boost {
    template<typename T, typename IndexMap = identity_property_map>
    class vector_property_map
        : public boost::put_get_helper< 
              typename std::iterator_traits< 
                  typename std::vector<T>::iterator >::reference,
              vector_property_map<T, IndexMap> >
    {
    public:
        typedef typename property_traits<IndexMap>::key_type  key_type;
        typedef T value_type;
        typedef typename std::iterator_traits< 
            typename std::vector<T>::iterator >::reference reference;
        typedef boost::lvalue_property_map_tag category;

vector_property_map(const IndexMap& index = IndexMap())
        : store(new std::vector<T>()), index(index)
        {}

vector_property_map(unsigned initial_size, 
                            const IndexMap& index = IndexMap())
        : store(new std::vector<T>(initial_size)), index(index)
        {}

typename std::vector<T>::iterator storage_begin()
        {
            return store->begin();
        }

typename std::vector<T>::iterator storage_end()
        {
            return store->end();
        }

typename std::vector<T>::const_iterator storage_begin() const
        {
            return store->begin();
        }

typename std::vector<T>::const_iterator storage_end() const
        {
            return store->end();
        }

IndexMap&       get_index_map()       { return index; }
        const IndexMap& get_index_map() const { return index; }

public:
        // Copy ctor absent, default semantics is OK.
        // Assignment operator absent, default semantics is OK.
        // CONSIDER: not sure that assignment to 'index' is correct.

reference operator[](const key_type& v) const {
            typename property_traits<IndexMap>::value_type i = get(index, v);
            if (static_cast<unsigned>(i) >= store->size()) {
                store->resize(i + 1, T());
            }
            return (*store)[i];
        }
    private:
        // Conceptually, we have a vector of infinite size. For practical 
        // purposes, we start with an empty vector and grow it as needed.
        // Note that we cannot store pointer to vector here -- we cannot
        // store pointer to data, because if copy of property map resizes
        // the vector, the pointer to data will be invalidated. 
        // I wonder if class 'pmap_ref' is simply needed.
        shared_ptr< std::vector<T> > store;
        IndexMap index;
    };

template<typename T, typename IndexMap>
    vector_property_map<T, IndexMap>
    make_vector_property_map(IndexMap index)
    {
        return vector_property_map<T, IndexMap>(index);
    }
}

#ifdef BOOST_GRAPH_USE_MPI
#include <boost/property_map/parallel/vector_property_map.hpp>
#endif

#endif

// Copyright (C) Vladimir Prus 2003. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/graph/vector_property_map.html for // documentation. // #ifndef BOOST_PROPERTY_MAP_VECTOR_PROPERTY_MAP_HPP #define BOOST_PROPERTY_MAP_VECTOR_PROPERTY_MAP_HPP #include #include #include #include namespace boost { template class vector_property_map : public boost::put_get_helper< typename std::iterator_traits< typename std::vector::iterator >::reference, vector_property_map > { public: typedef typename property_traits::key_type key_type; typedef T value_type; typedef typename std::iterator_traits< typename std::vector::iterator >::reference reference; typedef boost::lvalue_property_map_tag category; vector_property_map(const IndexMap& index = IndexMap()) : store(new std::vector()), index(index) {} vector_property_map(unsigned initial_size, const IndexMap& index = IndexMap()) : store(new std::vector(initial_size)), index(index) {} typename std::vector::iterator storage_begin() { return store->begin(); } typename std::vector::iterator storage_end() { return store->end(); } typename std::vector::const_iterator storage_begin() const { return store->begin(); } typename std::vector::const_iterator storage_end() const { return store->end(); } IndexMap& get_index_map() { return index; } const IndexMap& get_index_map() const { return index; } public: // Copy ctor absent, default semantics is OK. // Assignment operator absent, default semantics is OK. // CONSIDER: not sure that assignment to 'index' is correct. reference operator[](const key_type& v) const { typename property_traits::value_type i = get(index, v); if (static_cast(i) >= store->size()) { store->resize(i + 1, T()); } return (*store)[i]; } private: // Conceptually, we have a vector of infinite size. For practical // purposes, we start with an empty vector and grow it as needed. // Note that we cannot store pointer to vector here -- we cannot // store pointer to data, because if copy of property map resizes // the vector, the pointer to data will be invalidated. // I wonder if class 'pmap_ref' is simply needed. shared_ptr< std::vector > store; IndexMap index; }; template vector_property_map make_vector_property_map(IndexMap index) { return vector_property_map(index); } } #ifdef BOOST_GRAPH_USE_MPI #include #endif #endif