boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-22 17:32:55 +00:00
Code Issues Projects Releases Wiki Activity

Seperate most code into visitor.hpp, use algo_selector instead of container_traits

Browse Source 
[SVN r1538]
This commit is contained in:
Raoul Gough
2003-09-11 22:39:54 +00:00
parent ec103b76cd
commit 0cf6fdc7f0
1 changed files with 7 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
include/boost/python/suite/indexing/container_suite.hpp
View File

@@ -25,163 +25,28 @@
#ifndef container_suite_rmg_20030823_included
#define container_suite_rmg_20030823_included
#include "container_traits.hpp"
#include "slice_handler.hpp"
#include "algo_selector.hpp"
#include "visitor.hpp"
#include <boost/python/return_by_value.hpp>
#include <boost/python/return_value_policy.hpp>
#include <boost/python/def_visitor.hpp>
#include <boost/python/iterator.hpp>
// #include <boost/python/return_internal_reference.hpp>
namespace indexing {
template<IndexStyle>
struct maybe_add_getitem {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &, Algorithms const &, Policy const &) { }
};
template<>
struct maybe_add_getitem<index_style_nonlinear> {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &pyClass
, Algorithms const &
, Policy const &policy)
{
pyClass.def ("__getitem__", &Algorithms::get, policy);
}
};
template<>
struct maybe_add_getitem<index_style_linear> {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &pyClass
, Algorithms const &
, Policy const &policy)
{
pyClass.def ("__getitem__", &Algorithms::get, policy);
pyClass.def ("__getitem__"
, slice_handler<Algorithms, Policy>::make_getitem (policy));
}
};
template<IndexStyle>
struct maybe_add_setitem {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &, Algorithms const &, Policy const &) { }
};
template<>
struct maybe_add_setitem<index_style_nonlinear> {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &pyClass
, Algorithms const &
, Policy const &policy)
{
pyClass.def ("__setitem__", &Algorithms::assign, policy);
}
};
template<>
struct maybe_add_setitem<index_style_linear> {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &pyClass
, Algorithms const &
, Policy const &policy)
{
pyClass.def ("__setitem__", &Algorithms::assign, policy);
pyClass.def ("__setitem__"
, slice_handler<Algorithms, Policy>::make_setitem (policy));
}
};
template<bool doit>
struct maybe_add_iter {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &, Algorithms const &, Policy const &) { }
};
template<>
struct maybe_add_iter<true> {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &pyClass
, Algorithms const &
, Policy const &policy)
{
pyClass.def ("__iter__"
, boost::python::range<Policy> (Algorithms::begin
, Algorithms::end));
}
};
template<bool doit>
struct maybe_add_append {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &, Algorithms const &, Policy const &) { }
};
template<>
struct maybe_add_append<true> {
template<class PythonClass, class Algorithms, class Policy>
static void apply (PythonClass &pyClass
, Algorithms const &
, Policy const &policy)
{
pyClass.def ("append", &Algorithms::push_back, policy);
}
};
template<class Container, class Policy, class Traits>
class container_suite_impl
: public boost::python::def_visitor <container_suite_impl<Container, Policy, Traits> >
{
Policy mPolicy;
public:
typedef typename Traits::algorithms algorithms;
typedef typename Traits::reference reference_return;
typedef Policy return_policy;
container_suite_impl (Policy const &policy) : mPolicy (policy) { }
template <class PythonClass>
void visit (PythonClass &pyClass) const
{
maybe_add_getitem<Traits::index_style>
::apply (pyClass, algorithms(), mPolicy);
maybe_add_setitem<Traits::index_style>
::apply (pyClass, algorithms(), mPolicy);
maybe_add_iter<((Traits::index_style != index_style_linear)
&& Traits::has_copyable_iter)>
::apply (pyClass, algorithms(), mPolicy);
maybe_add_append<Traits::has_push_back>
::apply (pyClass, algorithms(), mPolicy);
}
};
template<class Container, class Traits = container_traits<Container> >
template<class Container, class Algorithms = algo_selector<Container> >
struct container_suite
{
typedef boost::python::return_value_policy<boost::python::return_by_value>
default_policies;
static
container_suite_impl <Container, default_policies, Traits>
generate ()
static visitor<Algorithms, default_policies> generate ()
{
return container_suite_impl <Container, default_policies, Traits> (default_policies());
return visitor <Algorithms, default_policies> (default_policies());
}
template<typename Policy>
static
container_suite_impl <Container, Policy, Traits>
generate (Policy const &policy)
static visitor<Algorithms, Policy> generate (Policy const &policy)
{
return container_suite_impl <Container, Policy, Traits> (policy);
return visitor <Algorithms, Policy> (policy);
}
};
}