Initial Commit

.svn/pristine/49/49e883f48da4cf353af7e2d670663fff0dc90c02.svn-base

@@ -0,0 +1,242 @@
+//  (C) Copyright Joel de Guzman 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)
+
+#ifndef VECTOR_INDEXING_SUITE_JDG20036_HPP
+# define VECTOR_INDEXING_SUITE_JDG20036_HPP
+
+# include <boost/python/suite/indexing/indexing_suite.hpp>
+# include <boost/python/suite/indexing/container_utils.hpp>
+# include <boost/python/iterator.hpp>
+
+namespace boost { namespace python {
+            
+    // Forward declaration
+    template <class Container, bool NoProxy, class DerivedPolicies>
+    class vector_indexing_suite;
+    
+    namespace detail
+    {
+        template <class Container, bool NoProxy>
+        class final_vector_derived_policies 
+            : public vector_indexing_suite<Container, 
+                NoProxy, final_vector_derived_policies<Container, NoProxy> > {};
+    }
+
+    // The vector_indexing_suite class is a predefined indexing_suite derived 
+    // class for wrapping std::vector (and std::vector like) classes. It provides
+    // all the policies required by the indexing_suite (see indexing_suite).
+    // Example usage:
+    //
+    //  class X {...};
+    //
+    //  ...
+    //
+    //      class_<std::vector<X> >("XVec")
+    //          .def(vector_indexing_suite<std::vector<X> >())
+    //      ;
+    //
+    // By default indexed elements are returned by proxy. This can be
+    // disabled by supplying *true* in the NoProxy template parameter.
+    //
+    template <
+        class Container, 
+        bool NoProxy = false,
+        class DerivedPolicies 
+            = detail::final_vector_derived_policies<Container, NoProxy> >
+    class vector_indexing_suite 
+        : public indexing_suite<Container, DerivedPolicies, NoProxy>
+    {
+    public:
+    
+        typedef typename Container::value_type data_type;
+        typedef typename Container::value_type key_type;
+        typedef typename Container::size_type index_type;
+        typedef typename Container::size_type size_type;
+        typedef typename Container::difference_type difference_type;
+        
+        template <class Class>
+        static void 
+        extension_def(Class& cl)
+        {
+            cl
+                .def("append", &base_append)
+                .def("extend", &base_extend)
+            ;
+        }
+        
+        static 
+        typename mpl::if_<
+            is_class<data_type>
+          , data_type&
+          , data_type
+        >::type
+        get_item(Container& container, index_type i)
+        { 
+            return container[i];
+        }
+
+        static object 
+        get_slice(Container& container, index_type from, index_type to)
+        { 
+            if (from > to)
+                return object(Container());
+            return object(Container(container.begin()+from, container.begin()+to));
+        }
+
+        static void 
+        set_item(Container& container, index_type i, data_type const& v)
+        { 
+            container[i] = v;
+        }
+
+        static void 
+        set_slice(Container& container, index_type from, 
+            index_type to, data_type const& v)
+        { 
+            if (from > to) {
+                return;
+            }
+            else {
+                container.erase(container.begin()+from, container.begin()+to);
+                container.insert(container.begin()+from, v);
+            }
+        }
+
+        template <class Iter>
+        static void 
+        set_slice(Container& container, index_type from, 
+            index_type to, Iter first, Iter last)
+        { 
+            if (from > to) {
+                container.insert(container.begin()+from, first, last);
+            }
+            else {
+                container.erase(container.begin()+from, container.begin()+to);
+                container.insert(container.begin()+from, first, last);
+            }
+        }
+
+        static void 
+        delete_item(Container& container, index_type i)
+        { 
+            container.erase(container.begin()+i);
+        }
+        
+        static void 
+        delete_slice(Container& container, index_type from, index_type to)
+        { 
+            if (from > to) {
+                // A null-op.
+                return;
+            }
+            container.erase(container.begin()+from, container.begin()+to);
+        }
+        
+        static size_t
+        size(Container& container)
+        {
+            return container.size();
+        }
+        
+        static bool
+        contains(Container& container, key_type const& key)
+        {
+            return std::find(container.begin(), container.end(), key)
+                != container.end();
+        }
+        
+        static index_type
+        get_min_index(Container& /*container*/)
+        { 
+            return 0;
+        }
+
+        static index_type
+        get_max_index(Container& container)
+        { 
+            return container.size();
+        }
+      
+        static bool 
+        compare_index(Container& /*container*/, index_type a, index_type b)
+        {
+            return a < b;
+        }
+        
+        static index_type
+        convert_index(Container& container, PyObject* i_)
+        { 
+            extract<long> i(i_);
+            if (i.check())
+            {
+                long index = i();
+                if (index < 0)
+                    index += DerivedPolicies::size(container);
+                if (index >= long(container.size()) || index < 0)
+                {
+                    PyErr_SetString(PyExc_IndexError, "Index out of range");
+                    throw_error_already_set();
+                }
+                return index;
+            }
+            
+            PyErr_SetString(PyExc_TypeError, "Invalid index type");
+            throw_error_already_set();
+            return index_type();
+        }
+      
+        static void 
+        append(Container& container, data_type const& v)
+        { 
+            container.push_back(v);
+        }
+        
+        template <class Iter>
+        static void 
+        extend(Container& container, Iter first, Iter last)
+        { 
+            container.insert(container.end(), first, last);
+        }
+        
+    private:
+    
+        static void
+        base_append(Container& container, object v)
+        {
+            extract<data_type&> elem(v);
+            // try if elem is an exact Data
+            if (elem.check())
+            {
+                DerivedPolicies::append(container, elem());
+            }
+            else
+            {
+                //  try to convert elem to data_type
+                extract<data_type> elem(v);
+                if (elem.check())
+                {
+                    DerivedPolicies::append(container, elem());
+                }
+                else
+                {
+                    PyErr_SetString(PyExc_TypeError, 
+                        "Attempting to append an invalid type");
+                    throw_error_already_set();
+                }
+            }
+        }
+        
+        static void
+        base_extend(Container& container, object v)
+        {
+            std::vector<data_type> temp;
+            container_utils::extend_container(temp, v);
+            DerivedPolicies::extend(container, temp.begin(), temp.end());
+        }
+    };
+       
+}} // namespace boost::python 
+
+#endif // VECTOR_INDEXING_SUITE_JDG20036_HPP