Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
19 kB · 655 lines
C++
at master
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656// Copyright David Abrahams 2002.// 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 CLASS_DWA200216_HPP# define CLASS_DWA200216_HPP
# include <boost/python/detail/prefix.hpp>
# include <boost/noncopyable.hpp>
# include <boost/python/class_fwd.hpp># include <boost/python/object/class.hpp>
# include <boost/python/object.hpp># include <boost/python/type_id.hpp># include <boost/python/data_members.hpp># include <boost/python/make_function.hpp># include <boost/python/signature.hpp># include <boost/python/init.hpp># include <boost/python/args_fwd.hpp>
# include <boost/python/object/class_metadata.hpp># include <boost/python/object/pickle_support.hpp># include <boost/python/object/add_to_namespace.hpp>
# include <boost/python/detail/overloads_fwd.hpp># include <boost/python/detail/operator_id.hpp># include <boost/python/detail/def_helper.hpp># include <boost/python/detail/force_instantiate.hpp># include <boost/python/detail/unwrap_type_id.hpp># include <boost/python/detail/unwrap_wrapper.hpp>
# include <boost/type_traits/is_same.hpp># include <boost/type_traits/is_member_function_pointer.hpp># include <boost/type_traits/is_polymorphic.hpp>
# include <boost/mpl/size.hpp># include <boost/mpl/for_each.hpp># include <boost/mpl/bool.hpp># include <boost/mpl/not.hpp>
# include <boost/detail/workaround.hpp>
# if BOOST_WORKAROUND(__MWERKS__, <= 0x3004) \ /* pro9 reintroduced the bug */ \ || (BOOST_WORKAROUND(__MWERKS__, > 0x3100) \ && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201))) \ || BOOST_WORKAROUND(__GNUC__, < 3)
# define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1
# endif
# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING# include <boost/mpl/and.hpp># include <boost/type_traits/is_member_pointer.hpp># endif
namespace boost { namespace python {
template <class DerivedVisitor> class def_visitor;
enum no_init_t { no_init };
namespace detail{ // This function object is used with mpl::for_each to write the id // of the type a pointer to which is passed as its 2nd compile-time // argument. into the iterator pointed to by its runtime argument struct write_type_id { write_type_id(type_info**p) : p(p) {}
// Here's the runtime behavior template <class T> void operator()(T*) const { *(*p)++ = type_id<T>(); }
type_info** p; };
template <class T> struct is_data_member_pointer : mpl::and_< is_member_pointer<T> , mpl::not_<is_member_function_pointer<T> > > {}; # ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING# define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , detail::is_data_member_pointer<D>()# define BOOST_PYTHON_YES_DATA_MEMBER , mpl::true_# define BOOST_PYTHON_NO_DATA_MEMBER , mpl::false_# elif defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)# define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , 0# define BOOST_PYTHON_YES_DATA_MEMBER , int# define BOOST_PYTHON_NO_DATA_MEMBER , ...# else # define BOOST_PYTHON_DATA_MEMBER_HELPER(D)# define BOOST_PYTHON_YES_DATA_MEMBER# define BOOST_PYTHON_NO_DATA_MEMBER# endif namespace error { // // A meta-assertion mechanism which prints nice error messages and // backtraces on lots of compilers. Usage: // // assertion<C>::failed // // where C is an MPL metafunction class // template <class C> struct assertion_failed { }; template <class C> struct assertion_ok { typedef C failed; };
template <class C> struct assertion : mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type {};
// // Checks for validity of arguments used to define virtual // functions with default implementations. // template <class Default> void not_a_derived_class_member(Default) {} template <class T, class Fn> struct virtual_function_default { template <class Default> static void must_be_derived_class_member(Default const&) { // https://svn.boost.org/trac/boost/ticket/5803 //typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) typedef typename assertion<is_polymorphic<T> >::failed test1;# endif typedef typename assertion<is_member_function_pointer<Fn> >::failed test2; not_a_derived_class_member<Default>(Fn()); } }; }}
// This is the primary mechanism through which users will expose// C++ classes to Python.template < class W // class being wrapped , class X1 // = detail::not_specified , class X2 // = detail::not_specified , class X3 // = detail::not_specified >class class_ : public objects::class_base{ public: // types typedef objects::class_base base; typedef class_<W,X1,X2,X3> self; typedef typename objects::class_metadata<W,X1,X2,X3> metadata; typedef W wrapped_type; private: // types
// A helper class which will contain an array of id objects to be // passed to the base class constructor struct id_vector { typedef typename metadata::bases bases; id_vector() { // Stick the derived class id into the first element of the array ids[0] = detail::unwrap_type_id((W*)0, (W*)0);
// Write the rest of the elements into succeeding positions. type_info* p = ids + 1; mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0); }
BOOST_STATIC_CONSTANT( std::size_t, size = mpl::size<bases>::value + 1); type_info ids[size]; }; friend struct id_vector;
public: // constructors // Construct with the class name, with or without docstring, and default __init__() function class_(char const* name, char const* doc = 0);
// Construct with class name, no docstring, and an uncallable __init__ function class_(char const* name, no_init_t);
// Construct with class name, docstring, and an uncallable __init__ function class_(char const* name, char const* doc, no_init_t);
// Construct with class name and init<> function template <class DerivedT> inline class_(char const* name, init_base<DerivedT> const& i) : base(name, id_vector::size, id_vector().ids) { this->initialize(i); }
// Construct with class name, docstring and init<> function template <class DerivedT> inline class_(char const* name, char const* doc, init_base<DerivedT> const& i) : base(name, id_vector::size, id_vector().ids, doc) { this->initialize(i); }
public: // member functions // Generic visitation template <class Derived> self& def(def_visitor<Derived> const& visitor) { visitor.visit(*this); return *this; }
// Wrap a member function or a non-member function which can take // a T, T cv&, or T cv* as its first parameter, a callable // python object, or a generic visitor. template <class F> self& def(char const* name, F f) { this->def_impl( detail::unwrap_wrapper((W*)0) , name, f, detail::def_helper<char const*>(0), &f); return *this; }
template <class A1, class A2> self& def(char const* name, A1 a1, A2 const& a2) { this->def_maybe_overloads(name, a1, a2, &a2); return *this; }
template <class Fn, class A1, class A2> self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2) { // The arguments are definitely: // def(name, function, policy, doc_string) // def(name, function, doc_string, policy)
this->def_impl( detail::unwrap_wrapper((W*)0) , name, fn , detail::def_helper<A1,A2>(a1,a2) , &fn);
return *this; }
template <class Fn, class A1, class A2, class A3> self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3) { this->def_impl( detail::unwrap_wrapper((W*)0) , name, fn , detail::def_helper<A1,A2,A3>(a1,a2,a3) , &fn);
return *this; }
// // Data member access // template <class D> self& def_readonly(char const* name, D const& d, char const* doc=0) { return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); }
template <class D> self& def_readwrite(char const* name, D const& d, char const* doc=0) { return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); } template <class D> self& def_readonly(char const* name, D& d, char const* doc=0) { return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); }
template <class D> self& def_readwrite(char const* name, D& d, char const* doc=0) { return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); }
// Property creation# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) template <class Get> self& add_property(char const* name, Get fget, char const* docstr = 0) { base::add_property(name, this->make_getter(fget), docstr); return *this; }
template <class Get, class Set> self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0) { base::add_property( name, this->make_getter(fget), this->make_setter(fset), docstr); return *this; }# else private: template <class Get> self& add_property_impl(char const* name, Get fget, char const* docstr, int) { base::add_property(name, this->make_getter(fget), docstr); return *this; }
template <class Get, class Set> self& add_property_impl(char const* name, Get fget, Set fset, ...) { base::add_property( name, this->make_getter(fget), this->make_setter(fset), 0); return *this; }
public: template <class Get> self& add_property(char const* name, Get fget) { base::add_property(name, this->make_getter(fget), 0); return *this; }
template <class Get, class DocStrOrSet> self& add_property(char const* name, Get fget, DocStrOrSet docstr_or_set) { this->add_property_impl(name, this->make_getter(fget), docstr_or_set, 0); return *this; }
template <class Get, class Set> self& add_property(char const* name, Get fget, Set fset, char const* docstr) { base::add_property( name, this->make_getter(fget), this->make_setter(fset), docstr); return *this; }# endif template <class Get> self& add_static_property(char const* name, Get fget) { base::add_static_property(name, object(fget)); return *this; }
template <class Get, class Set> self& add_static_property(char const* name, Get fget, Set fset) { base::add_static_property(name, object(fget), object(fset)); return *this; } template <class U> self& setattr(char const* name, U const& x) { this->base::setattr(name, object(x)); return *this; }
// Pickle support template <typename PickleSuiteType> self& def_pickle(PickleSuiteType const& x) { error_messages::must_be_derived_from_pickle_suite(x); detail::pickle_suite_finalize<PickleSuiteType>::register_( *this, &PickleSuiteType::getinitargs, &PickleSuiteType::getstate, &PickleSuiteType::setstate, PickleSuiteType::getstate_manages_dict()); return *this; }
self& enable_pickling() { this->base::enable_pickling_(false); return *this; }
self& staticmethod(char const* name) { this->make_method_static(name); return *this; } private: // helper functions
// Builds a method for this class around the given [member] // function pointer or object, appropriately adjusting the type of // the first signature argument so that if f is a member of a // (possibly not wrapped) base class of T, an lvalue argument of // type T will be required. // // @group PropertyHelpers { template <class F> object make_getter(F f) { typedef typename api::is_object_operators<F>::type is_obj_or_proxy; return this->make_fn_impl( detail::unwrap_wrapper((W*)0) , f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>() ); } template <class F> object make_setter(F f) { typedef typename api::is_object_operators<F>::type is_obj_or_proxy; return this->make_fn_impl( detail::unwrap_wrapper((W*)0) , f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>() ); } template <class T, class F> object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_) { return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0)); }
template <class T, class D, class B> object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_) { D T::*pm = pm_; return python::make_getter(pm); }
template <class T, class D, class B> object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_) { D T::*pm = pm_; return python::make_setter(pm); }
template <class T, class F> object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_) { return x; } // } template <class D, class B> self& def_readonly_impl( char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER) { return this->add_property(name, pm_, doc); }
template <class D, class B> self& def_readwrite_impl( char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER) { return this->add_property(name, pm_, pm_, doc); }
template <class D> self& def_readonly_impl( char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER) { return this->add_static_property(name, python::make_getter(d)); }
template <class D> self& def_readwrite_impl( char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER) { return this->add_static_property(name, python::make_getter(d), python::make_setter(d)); }
template <class DefVisitor> inline void initialize(DefVisitor const& i) { metadata::register_(); // set up runtime metadata/conversions typedef typename metadata::holder holder; this->set_instance_size( objects::additional_instance_size<holder>::value ); this->def(i); } inline void initialize(no_init_t) { metadata::register_(); // set up runtime metadata/conversions this->def_no_init(); } // // These two overloads discriminate between def() as applied to a // generic visitor and everything else. // // @group def_impl { template <class T, class Helper, class LeafVisitor, class Visitor> inline void def_impl( T* , char const* name , LeafVisitor , Helper const& helper , def_visitor<Visitor> const* v ) { v->visit(*this, name, helper); }
template <class T, class Fn, class Helper> inline void def_impl( T* , char const* name , Fn fn , Helper const& helper , ... ) { objects::add_to_namespace( *this , name , make_function( fn , helper.policies() , helper.keywords() , detail::get_signature(fn, (T*)0) ) , helper.doc() );
this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>()); } // }
// // These two overloads handle the definition of default // implementation overloads for virtual functions. The second one // handles the case where no default implementation was specified. // // @group def_default { template <class Fn, class Helper> inline void def_default( char const* name , Fn , Helper const& helper , mpl::bool_<true>) { detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member( helper.default_implementation()); objects::add_to_namespace( *this, name, make_function( helper.default_implementation(), helper.policies(), helper.keywords()) ); } template <class Fn, class Helper> inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>) { } // } // // These two overloads discriminate between def() as applied to // regular functions and def() as applied to the result of // BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to // discriminate. // // @group def_maybe_overloads { template <class OverloadsT, class SigT> void def_maybe_overloads( char const* name , SigT sig , OverloadsT const& overloads , detail::overloads_base const*)
{ // convert sig to a type_list (see detail::get_signature in signature.hpp) // before calling detail::define_with_defaults. detail::define_with_defaults( name, overloads, *this, detail::get_signature(sig)); }
template <class Fn, class A1> void def_maybe_overloads( char const* name , Fn fn , A1 const& a1 , ...) { this->def_impl( detail::unwrap_wrapper((W*)0) , name , fn , detail::def_helper<A1>(a1) , &fn );
} // }};
//// implementations//
template <class W, class X1, class X2, class X3>inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc) : base(name, id_vector::size, id_vector().ids, doc){ this->initialize(init<>());// select_holder::assert_default_constructible();}
template <class W, class X1, class X2, class X3>inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t) : base(name, id_vector::size, id_vector().ids){ this->initialize(no_init);}
template <class W, class X1, class X2, class X3>inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t) : base(name, id_vector::size, id_vector().ids, doc){ this->initialize(no_init);}
}} // namespace boost::python
# undef BOOST_PYTHON_DATA_MEMBER_HELPER# undef BOOST_PYTHON_YES_DATA_MEMBER# undef BOOST_PYTHON_NO_DATA_MEMBER# undef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
#endif // CLASS_DWA200216_HPP