BOOST_PYTHON_DECL void delslice(object const& target, handle<> const& begin, handle<> const& end) { if (assign_slice( target.ptr(), begin.get(), end.get(), 0) == -1 ) { throw_error_already_set(); } }
inline handle::handle(handle const& other) : m_interpreter(other.m_interpreter) , m_index(LUA_NOREF) { if (m_interpreter == 0) return; other.push(m_interpreter); m_index = luaL_ref(m_interpreter, LUA_REGISTRYINDEX); }
static attribute create(handle const& loc, const char* name, datatype const& type, dataspace const& space) { hid_t id = H5Acreate(loc.getId(), name, type, space, H5P_DEFAULT, H5P_DEFAULT); assert(id >= 0); return attribute(std::move(id)); }
attribute get_attribute(handle const& loc, const char* obj_name, const char* attr_name) { hid_t id = H5Aopen_by_name(loc.getId(), obj_name, attr_name, H5P_DEFAULT, H5P_DEFAULT); if (id < 0) throw std::runtime_error("H5Aopen_by_name failed"); return attribute(std::move(id)); }
wlan_if_list wlan_enum_interfaces(handle const& h) { WLAN_INTERFACE_INFO_LIST* iflist = nullptr; DWORD res; res = ::WlanEnumInterfaces(h.get(), nullptr, &iflist); if (res == ERROR_SUCCESS) return wlan_if_list(iflist, ::WlanFreeMemory); boost::throw_exception(boost::system::system_error(res, boost::system::system_category(), "win::wlan_enum_interfaces")); return wlan_if_list(); }
string python_get_error(handle<> exType, handle<> val, handle<> trace) { string msg("Python: "); try { if (val) { if (const char* str = to_string(val.get())) { msg += str; } } else if (exType) { msg += to_string(exType.get()); } PycString_IMPORT; if (trace && PycStringIO) { object traceOut(handle<>(PycStringIO->NewOutput(128))); PyTraceBack_Print(trace.get(), traceOut.ptr()); msg += "\n"; msg += PyString_AsString(object( handle<>(PycStringIO->cgetvalue(traceOut.ptr()))).ptr()); } } catch (const exception& e) { msg += e.what() + string(__func__); } catch (...) { msg += "Unknown error in " + string(__func__); } return msg; }
void function::argument_error(PyObject* args, PyObject* /*keywords*/) const { static handle<> exception( PyErr_NewException(const_cast<char*>("Boost.Python.ArgumentError"), PyExc_TypeError, 0)); object message = "Python argument types in\n %s.%s(" % make_tuple(this->m_namespace, this->m_name); list actual_args; for (ssize_t i = 0; i < PyTuple_Size(args); ++i) { char const* name = PyTuple_GetItem(args, i)->ob_type->tp_name; actual_args.append(str(name)); } message += str(", ").join(actual_args); message += ")\ndid not match C++ signature:\n "; message += str("\n ").join(signatures()); #if BOOST_PYTHON_DEBUG_ERROR_MESSAGES std::printf("\n--------\n%s\n--------\n", extract<const char*>(message)()); #endif PyErr_SetObject(exception.get(), message.ptr()); throw_error_already_set(); }
void wlan_register_notification(handle const& h, wlan_register_notification_handler const& handler) { wlan_register_notification_handler* cb = new wlan_register_notification_handler(handler); DWORD res; res = ::WlanRegisterNotification(h.get(), WLAN_NOTIFICATION_SOURCE_ALL, TRUE, detail::wlan_notify_handler, cb, nullptr, nullptr); if (res == ERROR_SUCCESS) return; delete cb; boost::throw_exception(boost::system::system_error(res, boost::system::system_category(), "win::wlan_register_notification")); }
static void unwrap(lua_State* L, handle const& value) { value.push(L); }
static void unwrap(lua_State* interpreter, handle const& value) { value.push(interpreter); }
// 1枚の絵 - 通常の画像であるかチェック inline bool is_simple(handle const& i) { return i.count() == 1; }
BOOST_PYTHON_DECL object getslice(object const& target, handle<> const& begin, handle<> const& end) { return object( detail::new_reference( apply_slice(target.ptr(), begin.get(), end.get()))); }
handle<> apply_to_own_type(handle<> x) { // Tests that we can return handle<> from a callback and that we // can pass arbitrary handle<T>. return call<handle<> >(x.get(), type_handle(borrowed(x->ob_type))); }
/** * Constructs a new process object. * * Creates a new process object that represents a running process * within the system. * * This operation is only available on Windows systems. The handle is * closed when the process instance (and all of its copies) is destroyed. */ process(handle h) : id_(GetProcessId(h.native())), handle_(h) { }
handle(handle<Y> const& r) : m_p(python::xincref(python::upcast<T>(r.get()))) { }
inline void swap(handle &a, handle &b) noexcept { a.swap(b); }