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); }