Win32 API 日本語リファレンス
ホームSystem.IO › GetQueuedCompletionStatus

GetQueuedCompletionStatus

関数
I/O完了ポートから完了したI/O結果を取り出す。
DLLKERNEL32.dll呼出規約winapiSetLastErrorあり対応OSWindows XP 以降

シグネチャ

// KERNEL32.dll
#include <windows.h>

BOOL GetQueuedCompletionStatus(
    HANDLE CompletionPort,
    DWORD* lpNumberOfBytesTransferred,
    UINT_PTR* lpCompletionKey,
    OVERLAPPED** lpOverlapped,
    DWORD dwMilliseconds
);

パラメーター

名前方向説明
CompletionPortHANDLEin完了ポートへのハンドルです。完了ポートを作成するには、 CreateIoCompletionPort 関数を使用してください。
lpNumberOfBytesTransferredDWORD*out完了した I/O 操作で転送されたバイト数を受け取る変数へのポインターです。
lpCompletionKeyUINT_PTR*outI/O 操作が完了したファイルハンドルに関連付けられた完了キー値を受け取る変数へのポインターです。完了キーは、 CreateIoCompletionPort の呼び出しで指定される、ファイルごとのキーです。
lpOverlappedOVERLAPPED**out

完了した I/O 操作が開始されたときに指定された OVERLAPPED 構造体のアドレスを受け取る変数へのポインターです。

完了ポートに関連付けられたファイルハンドルと有効な OVERLAPPED 構造体を関数に渡した場合でも、アプリケーションは完了ポート通知を抑制できます。これは、OVERLAPPED 構造体の hEvent メンバーに有効なイベントハンドルを指定し、その最下位ビットを設定することで行います。最下位ビットが設定された有効なイベントハンドルは、オーバーラップ I/O の完了時に完了パケットが完了ポートにエンキューされるのを抑制します。

dwMillisecondsDWORDin

完了パケットが完了ポートに現れるのを呼び出し側が待機する時間(ミリ秒単位)です。指定された時間内に完了パケットが現れなかった場合、関数はタイムアウトして FALSE を返し、*lpOverlappedNULL に設定します。

dwMillisecondsINFINITE の場合、関数はタイムアウトしません。dwMilliseconds がゼロで、デキューする I/O 操作が存在しない場合、関数はただちにタイムアウトします。

Windows XP、Windows Server 2003、Windows Vista、Windows 7、Windows Server 2008、および Windows Server 2008 R2: dwMilliseconds 値には、低電力状態で費やされた時間が含まれます。たとえば、コンピューターがスリープ状態の間もタイムアウトのカウントダウンは継続します。

Windows 8 以降、および Windows Server 2012 以降: dwMilliseconds 値には、低電力状態で費やされた時間は含まれません。たとえば、コンピューターがスリープ状態の間はタイムアウトのカウントダウンは継続しません。

戻り値の型: BOOL

公式ドキュメント

指定された I/O 完了ポートから I/O 完了パケットのデキューを試みます。

戻り値

成功した場合は非ゼロ(TRUE)を、それ以外の場合はゼロ(FALSE)を返します。

拡張エラー情報を取得するには、 GetLastError を呼び出してください。

詳細については、「解説」セクションを参照してください。

解説(Remarks)

この関数は、指定された完了ポートにスレッドを関連付けます。1 つのスレッドは、最大で 1 つの完了ポートにのみ関連付けることができます。

GetQueuedCompletionStatus の呼び出しが、それに関連付けられた完了ポートハンドルが呼び出しの待機中に閉じられたために失敗した場合、関数は FALSE を返し、*lpOverlappedNULL となり、GetLastErrorERROR_ABANDONED_WAIT_0 を返します。

Windows Server 2003 および Windows XP: 呼び出しの待機中に完了ポートハンドルを閉じても、前述の動作にはなりません。関数は、ポートからエントリが削除されるまで、または INFINITE 以外の値が指定されている場合はタイムアウトが発生するまで、待機を継続します。

GetQueuedCompletionStatus 関数が成功した場合、成功した I/O 操作の完了パケットを完了ポートからデキューし、次のパラメーターが指す変数に情報を格納しています: lpNumberOfByteslpCompletionKey、および lpOverlapped。失敗した場合(戻り値が FALSE)、これらの同じパラメーターには、次のような特定の値の組み合わせが含まれることがあります。

I/O 完了ポートの理論、使用法、および関連する関数の詳細については、「I/O Completion Ports」を参照してください。

Windows 8 および Windows Server 2012 では、この関数は次のテクノロジでサポートされています。

テクノロジ サポート
Server Message Block (SMB) 3.0 プロトコル はい
SMB 3.0 トランスペアレントフェールオーバー (TFO) はい
SMB 3.0 とスケールアウトファイル共有 (SO) はい
クラスター共有ボリュームファイルシステム (CsvFS) はい
回復性ファイルシステム (ReFS) はい
出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での呼び出し定義

// KERNEL32.dll
#include <windows.h>

BOOL GetQueuedCompletionStatus(
    HANDLE CompletionPort,
    DWORD* lpNumberOfBytesTransferred,
    UINT_PTR* lpCompletionKey,
    OVERLAPPED** lpOverlapped,
    DWORD dwMilliseconds
);
[return: MarshalAs(UnmanagedType.Bool)]
[DllImport("KERNEL32.dll", SetLastError = true, ExactSpelling = true)]
static extern bool GetQueuedCompletionStatus(
    IntPtr CompletionPort,   // HANDLE
    out uint lpNumberOfBytesTransferred,   // DWORD* out
    out UIntPtr lpCompletionKey,   // UINT_PTR* out
    IntPtr lpOverlapped,   // OVERLAPPED** out
    uint dwMilliseconds   // DWORD
);
<DllImport("KERNEL32.dll", SetLastError:=True, ExactSpelling:=True)>
Public Shared Function GetQueuedCompletionStatus(
    CompletionPort As IntPtr,   ' HANDLE
    <Out> ByRef lpNumberOfBytesTransferred As UInteger,   ' DWORD* out
    <Out> ByRef lpCompletionKey As UIntPtr,   ' UINT_PTR* out
    lpOverlapped As IntPtr,   ' OVERLAPPED** out
    dwMilliseconds As UInteger   ' DWORD
) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
' CompletionPort : HANDLE
' lpNumberOfBytesTransferred : DWORD* out
' lpCompletionKey : UINT_PTR* out
' lpOverlapped : OVERLAPPED** out
' dwMilliseconds : DWORD
Declare PtrSafe Function GetQueuedCompletionStatus Lib "kernel32" ( _
    ByVal CompletionPort As LongPtr, _
    ByRef lpNumberOfBytesTransferred As Long, _
    ByRef lpCompletionKey As LongPtr, _
    ByVal lpOverlapped As LongPtr, _
    ByVal dwMilliseconds As Long) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。
import ctypes
from ctypes import wintypes

GetQueuedCompletionStatus = ctypes.windll.kernel32.GetQueuedCompletionStatus
GetQueuedCompletionStatus.restype = wintypes.BOOL
GetQueuedCompletionStatus.argtypes = [
    wintypes.HANDLE,  # CompletionPort : HANDLE
    ctypes.POINTER(wintypes.DWORD),  # lpNumberOfBytesTransferred : DWORD* out
    ctypes.POINTER(ctypes.c_size_t),  # lpCompletionKey : UINT_PTR* out
    ctypes.c_void_p,  # lpOverlapped : OVERLAPPED** out
    wintypes.DWORD,  # dwMilliseconds : DWORD
]
# GetLastError: use ctypes.GetLastError() (or ctypes.WinDLL(use_last_error=True))
require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('KERNEL32.dll')
GetQueuedCompletionStatus = Fiddle::Function.new(
  lib['GetQueuedCompletionStatus'],
  [
    Fiddle::TYPE_VOIDP,  # CompletionPort : HANDLE
    Fiddle::TYPE_VOIDP,  # lpNumberOfBytesTransferred : DWORD* out
    Fiddle::TYPE_VOIDP,  # lpCompletionKey : UINT_PTR* out
    Fiddle::TYPE_VOIDP,  # lpOverlapped : OVERLAPPED** out
    -Fiddle::TYPE_INT,  # dwMilliseconds : DWORD
  ],
  Fiddle::TYPE_INT)
#[link(name = "kernel32")]
extern "system" {
    fn GetQueuedCompletionStatus(
        CompletionPort: *mut core::ffi::c_void,  // HANDLE
        lpNumberOfBytesTransferred: *mut u32,  // DWORD* out
        lpCompletionKey: *mut usize,  // UINT_PTR* out
        lpOverlapped: *mut *mut OVERLAPPED,  // OVERLAPPED** out
        dwMilliseconds: u32  // DWORD
    ) -> i32;
}
// crates: windows-sys provides ready-made bindings for this API.
$sig = @"
[return: MarshalAs(UnmanagedType.Bool)]
[DllImport("KERNEL32.dll", SetLastError = true)]
public static extern bool GetQueuedCompletionStatus(IntPtr CompletionPort, out uint lpNumberOfBytesTransferred, out UIntPtr lpCompletionKey, IntPtr lpOverlapped, uint dwMilliseconds);
"@
$api = Add-Type -MemberDefinition $sig -Name 'KERNEL32_GetQueuedCompletionStatus' -Namespace Win32 -PassThru
# $api::GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
#uselib "KERNEL32.dll"
#func global GetQueuedCompletionStatus "GetQueuedCompletionStatus" sptr, sptr, sptr, sptr, sptr
; GetQueuedCompletionStatus CompletionPort, varptr(lpNumberOfBytesTransferred), varptr(lpCompletionKey), varptr(lpOverlapped), dwMilliseconds   ; 戻り値は stat
; CompletionPort : HANDLE -> "sptr"
; lpNumberOfBytesTransferred : DWORD* out -> "sptr"
; lpCompletionKey : UINT_PTR* out -> "sptr"
; lpOverlapped : OVERLAPPED** out -> "sptr"
; dwMilliseconds : DWORD -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。
出力引数:
#uselib "KERNEL32.dll"
#cfunc global GetQueuedCompletionStatus "GetQueuedCompletionStatus" sptr, var, var, var, int
; res = GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
; CompletionPort : HANDLE -> "sptr"
; lpNumberOfBytesTransferred : DWORD* out -> "var"
; lpCompletionKey : UINT_PTR* out -> "var"
; lpOverlapped : OVERLAPPED** out -> "var"
; dwMilliseconds : DWORD -> "int"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
出力引数:
; BOOL GetQueuedCompletionStatus(HANDLE CompletionPort, DWORD* lpNumberOfBytesTransferred, UINT_PTR* lpCompletionKey, OVERLAPPED** lpOverlapped, DWORD dwMilliseconds)
#uselib "KERNEL32.dll"
#cfunc global GetQueuedCompletionStatus "GetQueuedCompletionStatus" intptr, var, var, var, int
; res = GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
; CompletionPort : HANDLE -> "intptr"
; lpNumberOfBytesTransferred : DWORD* out -> "var"
; lpCompletionKey : UINT_PTR* out -> "var"
; lpOverlapped : OVERLAPPED** out -> "var"
; dwMilliseconds : DWORD -> "int"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
import (
	"golang.org/x/sys/windows"
	"unsafe"
)

var (
	kernel32 = windows.NewLazySystemDLL("KERNEL32.dll")
	procGetQueuedCompletionStatus = kernel32.NewProc("GetQueuedCompletionStatus")
)

// CompletionPort (HANDLE), lpNumberOfBytesTransferred (DWORD* out), lpCompletionKey (UINT_PTR* out), lpOverlapped (OVERLAPPED** out), dwMilliseconds (DWORD)
r1, _, err := procGetQueuedCompletionStatus.Call(
	uintptr(CompletionPort),
	uintptr(lpNumberOfBytesTransferred),
	uintptr(lpCompletionKey),
	uintptr(lpOverlapped),
	uintptr(dwMilliseconds),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // BOOL
function GetQueuedCompletionStatus(
  CompletionPort: THandle;   // HANDLE
  lpNumberOfBytesTransferred: Pointer;   // DWORD* out
  lpCompletionKey: Pointer;   // UINT_PTR* out
  lpOverlapped: Pointer;   // OVERLAPPED** out
  dwMilliseconds: DWORD   // DWORD
): BOOL; stdcall;
  external 'KERNEL32.dll' name 'GetQueuedCompletionStatus';
result := DllCall("KERNEL32\GetQueuedCompletionStatus"
    , "Ptr", CompletionPort   ; HANDLE
    , "Ptr", lpNumberOfBytesTransferred   ; DWORD* out
    , "Ptr", lpCompletionKey   ; UINT_PTR* out
    , "Ptr", lpOverlapped   ; OVERLAPPED** out
    , "UInt", dwMilliseconds   ; DWORD
    , "Int")   ; return: BOOL
●GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds) = DLL("KERNEL32.dll", "bool GetQueuedCompletionStatus(void*, void*, void*, void*, dword)")
# 呼び出し: GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
# CompletionPort : HANDLE -> "void*"
# lpNumberOfBytesTransferred : DWORD* out -> "void*"
# lpCompletionKey : UINT_PTR* out -> "void*"
# lpOverlapped : OVERLAPPED** out -> "void*"
# dwMilliseconds : DWORD -> "dword"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。
const std = @import("std");

extern "kernel32" fn GetQueuedCompletionStatus(
    CompletionPort: ?*anyopaque, // HANDLE
    lpNumberOfBytesTransferred: [*c]u32, // DWORD* out
    lpCompletionKey: [*c]usize, // UINT_PTR* out
    lpOverlapped: [*c][*c]OVERLAPPED, // OVERLAPPED** out
    dwMilliseconds: u32 // DWORD
) callconv(std.os.windows.WINAPI) i32;
proc GetQueuedCompletionStatus(
    CompletionPort: pointer,  # HANDLE
    lpNumberOfBytesTransferred: ptr uint32,  # DWORD* out
    lpCompletionKey: ptr uint,  # UINT_PTR* out
    lpOverlapped: ptr OVERLAPPED,  # OVERLAPPED** out
    dwMilliseconds: uint32  # DWORD
): int32 {.importc: "GetQueuedCompletionStatus", stdcall, dynlib: "KERNEL32.dll".}
pragma(lib, "kernel32");
extern(Windows)
int GetQueuedCompletionStatus(
    void* CompletionPort,   // HANDLE
    uint* lpNumberOfBytesTransferred,   // DWORD* out
    size_t* lpCompletionKey,   // UINT_PTR* out
    OVERLAPPED** lpOverlapped,   // OVERLAPPED** out
    uint dwMilliseconds   // DWORD
);
ccall((:GetQueuedCompletionStatus, "KERNEL32.dll"), stdcall, Int32,
      (Ptr{Cvoid}, Ptr{UInt32}, Ptr{Csize_t}, Ptr{OVERLAPPED}, UInt32),
      CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
# CompletionPort : HANDLE -> Ptr{Cvoid}
# lpNumberOfBytesTransferred : DWORD* out -> Ptr{UInt32}
# lpCompletionKey : UINT_PTR* out -> Ptr{Csize_t}
# lpOverlapped : OVERLAPPED** out -> Ptr{OVERLAPPED}
# dwMilliseconds : DWORD -> UInt32
# stdcall は 32bit のみ意味を持つ(x64 では無視)。
local ffi = require("ffi")
ffi.cdef[[
int32_t GetQueuedCompletionStatus(
    void* CompletionPort,
    uint32_t* lpNumberOfBytesTransferred,
    uintptr_t* lpCompletionKey,
    void* lpOverlapped,
    uint32_t dwMilliseconds);
]]
local kernel32 = ffi.load("kernel32")
-- kernel32.GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
-- CompletionPort : HANDLE
-- lpNumberOfBytesTransferred : DWORD* out
-- lpCompletionKey : UINT_PTR* out
-- lpOverlapped : OVERLAPPED** out
-- dwMilliseconds : DWORD
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
const koffi = require('koffi');
const lib = koffi.load('KERNEL32.dll');
const GetQueuedCompletionStatus = lib.func('__stdcall', 'GetQueuedCompletionStatus', 'int32_t', ['void *', 'uint32_t *', 'uintptr_t *', 'void *', 'uint32_t']);
// GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
// CompletionPort : HANDLE -> 'void *'
// lpNumberOfBytesTransferred : DWORD* out -> 'uint32_t *'
// lpCompletionKey : UINT_PTR* out -> 'uintptr_t *'
// lpOverlapped : OVERLAPPED** out -> 'void *'
// dwMilliseconds : DWORD -> 'uint32_t'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
const lib = Deno.dlopen("KERNEL32.dll", {
  GetQueuedCompletionStatus: { parameters: ["pointer", "pointer", "pointer", "pointer", "u32"], result: "i32" },
});
// lib.symbols.GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds)
// CompletionPort : HANDLE -> "pointer"
// lpNumberOfBytesTransferred : DWORD* out -> "pointer"
// lpCompletionKey : UINT_PTR* out -> "pointer"
// lpOverlapped : OVERLAPPED** out -> "pointer"
// dwMilliseconds : DWORD -> "u32"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。
<?php
$ffi = FFI::cdef(<<<C
int32_t GetQueuedCompletionStatus(
    void* CompletionPort,
    uint32_t* lpNumberOfBytesTransferred,
    size_t* lpCompletionKey,
    void* lpOverlapped,
    uint32_t dwMilliseconds);
C, "KERNEL32.dll");
// $ffi->GetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds);
// CompletionPort : HANDLE
// lpNumberOfBytesTransferred : DWORD* out
// lpCompletionKey : UINT_PTR* out
// lpOverlapped : OVERLAPPED** out
// dwMilliseconds : DWORD
// 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
// WINAPI(stdcall): x64 では呼出規約が統一されるため問題なし。x86 では __stdcall 対応のラッパが必要な場合あり。
import com.sun.jna.*;
import com.sun.jna.ptr.*;
import com.sun.jna.win32.StdCallLibrary;
import com.sun.jna.win32.W32APIOptions;

public interface Kernel32 extends StdCallLibrary {
    Kernel32 INSTANCE = Native.load("kernel32", Kernel32.class);
    boolean GetQueuedCompletionStatus(
        Pointer CompletionPort,   // HANDLE
        IntByReference lpNumberOfBytesTransferred,   // DWORD* out
        LongByReference lpCompletionKey,   // UINT_PTR* out
        Pointer lpOverlapped,   // OVERLAPPED** out
        int dwMilliseconds   // DWORD
    );
}
@[Link("kernel32")]
lib LibKERNEL32
  fun GetQueuedCompletionStatus = GetQueuedCompletionStatus(
    CompletionPort : Void*,   # HANDLE
    lpNumberOfBytesTransferred : UInt32*,   # DWORD* out
    lpCompletionKey : LibC::SizeT*,   # UINT_PTR* out
    lpOverlapped : OVERLAPPED**,   # OVERLAPPED** out
    dwMilliseconds : UInt32   # DWORD
  ) : Int32
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。
import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef GetQueuedCompletionStatusNative = Int32 Function(Pointer<Void>, Pointer<Uint32>, Pointer<UintPtr>, Pointer<Void>, Uint32);
typedef GetQueuedCompletionStatusDart = int Function(Pointer<Void>, Pointer<Uint32>, Pointer<UintPtr>, Pointer<Void>, int);
final GetQueuedCompletionStatus = DynamicLibrary.open('KERNEL32.dll')
    .lookupFunction<GetQueuedCompletionStatusNative, GetQueuedCompletionStatusDart>('GetQueuedCompletionStatus');
// CompletionPort : HANDLE -> Pointer<Void>
// lpNumberOfBytesTransferred : DWORD* out -> Pointer<Uint32>
// lpCompletionKey : UINT_PTR* out -> Pointer<UintPtr>
// lpOverlapped : OVERLAPPED** out -> Pointer<Void>
// dwMilliseconds : DWORD -> Uint32
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。
{$mode objfpc}{$H+}
function GetQueuedCompletionStatus(
  CompletionPort: THandle;   // HANDLE
  lpNumberOfBytesTransferred: Pointer;   // DWORD* out
  lpCompletionKey: Pointer;   // UINT_PTR* out
  lpOverlapped: Pointer;   // OVERLAPPED** out
  dwMilliseconds: DWORD   // DWORD
): BOOL; stdcall;
  external 'KERNEL32.dll' name 'GetQueuedCompletionStatus';
import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "GetQueuedCompletionStatus"
  c_GetQueuedCompletionStatus :: Ptr () -> Ptr Word32 -> Ptr CUIntPtr -> Ptr () -> Word32 -> IO CInt
-- CompletionPort : HANDLE -> Ptr ()
-- lpNumberOfBytesTransferred : DWORD* out -> Ptr Word32
-- lpCompletionKey : UINT_PTR* out -> Ptr CUIntPtr
-- lpOverlapped : OVERLAPPED** out -> Ptr ()
-- dwMilliseconds : DWORD -> Word32
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。
open Ctypes
open Foreign

let getqueuedcompletionstatus =
  foreign "GetQueuedCompletionStatus"
    ((ptr void) @-> (ptr uint32_t) @-> (ptr size_t) @-> (ptr void) @-> uint32_t @-> returning int32_t)
(* CompletionPort : HANDLE -> (ptr void) *)
(* lpNumberOfBytesTransferred : DWORD* out -> (ptr uint32_t) *)
(* lpCompletionKey : UINT_PTR* out -> (ptr size_t) *)
(* lpOverlapped : OVERLAPPED** out -> (ptr void) *)
(* dwMilliseconds : DWORD -> uint32_t *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)
(cffi:define-foreign-library kernel32 (t "KERNEL32.dll"))
(cffi:use-foreign-library kernel32)

(cffi:defcfun ("GetQueuedCompletionStatus" get-queued-completion-status :convention :stdcall) :int32
  (completion-port :pointer)   ; HANDLE
  (lp-number-of-bytes-transferred :pointer)   ; DWORD* out
  (lp-completion-key :pointer)   ; UINT_PTR* out
  (lp-overlapped :pointer)   ; OVERLAPPED** out
  (dw-milliseconds :uint32))   ; DWORD
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。
use Win32::API;
my $GetQueuedCompletionStatus = Win32::API::More->new('KERNEL32',
    'BOOL GetQueuedCompletionStatus(HANDLE CompletionPort, LPVOID lpNumberOfBytesTransferred, LPVOID lpCompletionKey, LPVOID lpOverlapped, DWORD dwMilliseconds)');
# my $ret = $GetQueuedCompletionStatus->Call($CompletionPort, $lpNumberOfBytesTransferred, $lpCompletionKey, $lpOverlapped, $dwMilliseconds);
# CompletionPort : HANDLE -> HANDLE
# lpNumberOfBytesTransferred : DWORD* out -> LPVOID
# lpCompletionKey : UINT_PTR* out -> LPVOID
# lpOverlapped : OVERLAPPED** out -> LPVOID
# dwMilliseconds : DWORD -> DWORD
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。

関連項目

類似 API
公式の関連項目
使用する型