/usr/include/luabind/detail/instance_holder.hpp is in libluabind-dev 0.9.1+dfsg-11.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | // Copyright Daniel Wallin 2008. Use, modification and distribution is
// subject to 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 LUABIND_INSTANCE_HOLDER_081024_HPP
# define LUABIND_INSTANCE_HOLDER_081024_HPP
# include <luabind/detail/inheritance.hpp>
# include <luabind/detail/class_rep.hpp> // TODO
# include <luabind/get_pointer.hpp>
# include <luabind/typeid.hpp>
# include <boost/type_traits/is_polymorphic.hpp>
# include <stdexcept>
namespace luabind { namespace detail {
class instance_holder
{
public:
instance_holder(class_rep* cls, bool pointee_const)
: m_cls(cls)
, m_pointee_const(pointee_const)
{}
virtual ~instance_holder()
{}
virtual std::pair<void*, int> get(class_id target) const = 0;
virtual void release() = 0;
class_rep* get_class() const
{
return m_cls;
}
bool pointee_const() const
{
return m_pointee_const;
}
private:
class_rep* m_cls;
bool m_pointee_const;
};
namespace mpl = boost::mpl;
inline mpl::false_ check_const_pointer(void*)
{
return mpl::false_();
}
inline mpl::true_ check_const_pointer(void const*)
{
return mpl::true_();
}
template <class T>
void release_ownership(std::auto_ptr<T>& p)
{
p.release();
}
template <class P>
void release_ownership(P const&)
{
throw std::runtime_error(
"luabind: smart pointer does not allow ownership transfer");
}
template <class T>
class_id static_class_id(T*)
{
return registered_class<T>::id;
}
template <class P, class Pointee = void const>
class pointer_holder : public instance_holder
{
public:
pointer_holder(
P p, class_id dynamic_id, void* dynamic_ptr, class_rep* cls
)
: instance_holder(cls, check_const_pointer(false ? get_pointer(p) : 0))
, p(p)
, weak(0)
, dynamic_id(dynamic_id)
, dynamic_ptr(dynamic_ptr)
{}
std::pair<void*, int> get(class_id target) const
{
if (target == registered_class<P>::id)
return std::pair<void*, int>(&this->p, 0);
void* naked_ptr = const_cast<void*>(static_cast<void const*>(
weak ? weak : get_pointer(p)));
if (!naked_ptr)
return std::pair<void*, int>((void*)0, 0);
return get_class()->casts().cast(
naked_ptr
, static_class_id(false ? get_pointer(p) : 0)
, target
, dynamic_id
, dynamic_ptr
);
}
void release()
{
weak = const_cast<void*>(static_cast<void const*>(
get_pointer(p)));
release_ownership(p);
}
private:
mutable P p;
// weak will hold a possibly stale pointer to the object owned
// by p once p has released it's owership. This is a workaround
// to make adopt() work with virtual function wrapper classes.
void* weak;
class_id dynamic_id;
void* dynamic_ptr;
};
}} // namespace luabind::detail
#endif // LUABIND_INSTANCE_HOLDER_081024_HPP
|