Edit: /usr/include/luabind/out_value_policy.hpp (12029B)
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef LUABIND_OUT_VALUE_POLICY_HPP_INCLUDED
#define LUABIND_OUT_VALUE_POLICY_HPP_INCLUDED
#include
#include // for LUABIND_DECORATE_TYPE
#include // for find_conversion_policy, etc
#include // for by_pointer, by_reference, etc
#include // for is_nonconst_pointer, is_nonconst_reference, etc
#include // for apply_wrap2
#include
#include // for if_
#include // for or_
#include // for is_same
#include // for operator new
namespace luabind { namespace detail
{
namespace mpl = boost::mpl;
template
struct char_array
{
char storage[N];
};
#if defined(__GNUC__) && ( __GNUC__ == 3 && __GNUC_MINOR__ == 1 )
template
char_array indirect_sizeof_test(by_reference);
template
char_array indirect_sizeof_test(by_const_reference);
template
char_array indirect_sizeof_test(by_pointer);
template
char_array indirect_sizeof_test(by_const_pointer);
template
char_array indirect_sizeof_test(by_value);
#else
template
char_array::type)>
indirect_sizeof_test(by_reference);
template
char_array::type)>
indirect_sizeof_test(by_const_reference);
template
char_array::type)>
indirect_sizeof_test(by_pointer);
template
char_array::type)>
indirect_sizeof_test(by_const_pointer);
template
char_array::type)>
indirect_sizeof_test(by_value);
#endif
template
struct indirect_sizeof
{
BOOST_STATIC_CONSTANT(int, value = sizeof(indirect_sizeof_test(LUABIND_DECORATE_TYPE(T))));
};
template
struct out_value_converter
{
int consumed_args() const
{
return 1;
}
template
T& apply(lua_State* L, by_reference, int index)
{
typedef typename find_conversion_policy<1, Policies>::type converter_policy;
typename mpl::apply_wrap2::type converter;
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
new (storage) T(converter.apply(L, LUABIND_DECORATE_TYPE(T), index));
return *storage;
#else
new (m_storage) T(converter.apply(L, LUABIND_DECORATE_TYPE(T), index));
return *reinterpret_cast(m_storage);
#endif
}
template
static int match(lua_State* L, by_reference, int index)
{
typedef typename find_conversion_policy<1, Policies>::type converter_policy;
typedef typename mpl::apply_wrap2::type converter;
return converter::match(L, LUABIND_DECORATE_TYPE(T), index);
}
template
void converter_postcall(lua_State* L, by_reference, int)
{
typedef typename find_conversion_policy<2, Policies>::type converter_policy;
typename mpl::apply_wrap2::type converter;
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
converter.apply(L, *storage);
storage->~T();
#else
converter.apply(L, *reinterpret_cast(m_storage));
reinterpret_cast(m_storage)->~T();
#endif
}
template
T* apply(lua_State* L, by_pointer, int index)
{
typedef typename find_conversion_policy<1, Policies>::type converter_policy;
typename mpl::apply_wrap2::type converter;
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
new (storage) T(converter.apply(L, LUABIND_DECORATE_TYPE(T), index));
return storage;
#else
new (m_storage) T(converter.apply(L, LUABIND_DECORATE_TYPE(T), index));
return reinterpret_cast(m_storage);
#endif
}
template
static int match(lua_State* L, by_pointer, int index)
{
typedef typename find_conversion_policy<1, Policies>::type converter_policy;
typedef typename mpl::apply_wrap2::type converter;
return converter::match(L, LUABIND_DECORATE_TYPE(T), index);
}
template
void converter_postcall(lua_State* L, by_pointer, int)
{
typedef typename find_conversion_policy<2, Policies>::type converter_policy;
typename mpl::apply_wrap2::type converter;
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
converter.apply(L, *storage);
storage->~T();
#else
converter.apply(L, *reinterpret_cast(m_storage));
reinterpret_cast(m_storage)->~T();
#endif
}
char m_storage[Size];
};
template
struct out_value_policy : conversion_policy
{
static void precall(lua_State*, const index_map&) {}
static void postcall(lua_State*, const index_map&) {}
struct only_accepts_nonconst_references_or_pointers {};
struct can_only_convert_from_lua_to_cpp {};
template
struct apply
{
typedef typename boost::mpl::if_
, typename boost::mpl::if_, is_nonconst_pointer >
, out_value_converter::value, Policies>
, only_accepts_nonconst_references_or_pointers
>::type
, can_only_convert_from_lua_to_cpp
>::type type;
};
};
template
struct pure_out_value_converter
{
int consumed_args() const
{
return 0;
}
template
T& apply(lua_State*, by_reference, int)
{
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
new (storage) T();
return *storage;
#else
new (m_storage) T();
return *reinterpret_cast(m_storage);
#endif
}
template
static int match(lua_State*, by_reference, int)
{
return 0;
}
template
void converter_postcall(lua_State* L, by_reference, int)
{
typedef typename find_conversion_policy<1, Policies>::type converter_policy;
typename mpl::apply_wrap2::type converter;
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
converter.apply(L, *storage);
storage->~T();
#else
converter.apply(L, *reinterpret_cast(m_storage));
reinterpret_cast(m_storage)->~T();
#endif
}
template
T* apply(lua_State*, by_pointer, int)
{
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
new (storage) T();
return storage;
#else
new (m_storage) T();
return reinterpret_cast(m_storage);
#endif
}
template
static int match(lua_State*, by_pointer, int)
{
return 0;
}
template
void converter_postcall(lua_State* L, by_pointer, int)
{
typedef typename find_conversion_policy<1, Policies>::type converter_policy;
typename mpl::apply_wrap2::type converter;
#if defined(__GNUC__) && __GNUC__ >= 4
T* storage = reinterpret_cast(m_storage);
converter.apply(L, *storage);
storage->~T();
#else
converter.apply(L, *reinterpret_cast(m_storage));
reinterpret_cast(m_storage)->~T();
#endif
}
char m_storage[Size];
};
template
struct pure_out_value_policy : conversion_policy
{
static void precall(lua_State*, const index_map&) {}
static void postcall(lua_State*, const index_map&) {}
struct only_accepts_nonconst_references_or_pointers {};
struct can_only_convert_from_lua_to_cpp {};
template
struct apply
{
typedef typename boost::mpl::if_
, typename boost::mpl::if_, is_nonconst_pointer >
, pure_out_value_converter::value, Policies>
, only_accepts_nonconst_references_or_pointers
>::type
, can_only_convert_from_lua_to_cpp
>::type type;
};
};
}}
namespace luabind
{
template
detail::policy_cons, detail::null_type>
out_value(LUABIND_PLACEHOLDER_ARG(N))
{
return detail::policy_cons, detail::null_type>();
}
template
detail::policy_cons, detail::null_type>
out_value(LUABIND_PLACEHOLDER_ARG(N), const Policies&)
{
return detail::policy_cons, detail::null_type>();
}
template
detail::policy_cons, detail::null_type>
pure_out_value(LUABIND_PLACEHOLDER_ARG(N))
{
return detail::policy_cons, detail::null_type>();
}
template
detail::policy_cons, detail::null_type>
pure_out_value(LUABIND_PLACEHOLDER_ARG(N), const Policies&)
{
return detail::policy_cons, detail::null_type>();
}
}
#endif // LUABIND_OUT_VALUE_POLICY_HPP_INCLUDED