自学教程：C++ CHECK_HANDLE函数代码示例

static void alloc_cb(uv_handle_t* handle,                     size_t suggested_size,                     uv_buf_t* buf) {  static char slab[65536];  CHECK_HANDLE(handle);  ASSERT(suggested_size <= sizeof(slab));  buf->base = slab;  buf->len = sizeof(slab);}

static int set_offset(int handle, off_t newoffset ){    CHECK_HANDLE(handle);    off_t oldoffset = s_handle_slots[handle].offset;    ZRT_LOG_PARAM(L_INFO, P_INT, handle);    ZRT_LOG_PARAM(L_INFO, P_LONGINT, oldoffset);    ZRT_LOG_PARAM(L_INFO, P_LONGINT, newoffset);    s_handle_slots[handle].offset = newoffset;    return 0;}

static void sv_send_cb(uv_udp_send_t* req, int status) {  ASSERT(req != NULL);  ASSERT(status == 0);  CHECK_HANDLE(req->handle);  sv_send_cb_called++;  uv_close((uv_handle_t*) req->handle, close_cb);}

int scytale_reader_open(RedCryptoReaderHandle * handle, char const * path, char const * derivator) {    SCOPED_TRACE;    CHECK_HANDLE(handle);    handle->error_ctx.set_error(Error(NO_ERROR));    CHECK_NOTHROW(        handle->in_crypto_transport.open(path, {derivator, strlen(derivator)}),        ERR_TRANSPORT_OPEN_FAILED);    return 0;}

int pcmcia_access_configuration_register(client_handle_t handle,					 conf_reg_t *reg){	struct pcmcia_socket *s;	if (CHECK_HANDLE(handle))		return CS_BAD_HANDLE;	s = SOCKET(handle);	return pccard_access_configuration_register(s, handle->Function, reg);}

static void send_cb(uv_udp_send_t* req, int status) {  CHECK_REQ(req);  CHECK_HANDLE(req->handle);  ASSERT(status == UV_EMSGSIZE);  uv_close((uv_handle_t*)req->handle, close_cb);  send_cb_called++;}

void DDSChatModule::startupPublisher(void){    // Create publisher and set user data as "<name>,<id>"    pPub = pDomainParticipant->create_publisher(DDS_PUBLISHER_QOS_DEFAULT,NULL,            DDS_STATUS_MASK_NONE);    CHECK_HANDLE(pPub,"Cannot create publisher/n");    printf("Created publisher/n");    // Create data writers for respective topics    for(int iTopic=0; iTopic<(MAX_TOPICS-1); iTopic++)    {        pWriter[iTopic] = pPub->create_datawriter(pTopic[iTopic],DDS_DATAWRITER_QOS_DEFAULT,                    NULL,DDS_STATUS_MASK_NONE);        CHECK_HANDLE(pWriter[iTopic],"Cannot create data writer/n");    }}

int scytale_writer_close(RedCryptoWriterHandle * handle) {    SCOPED_TRACE;    CHECK_HANDLE(handle);    HashArray qhash;    HashArray fhash;    CHECK_NOTHROW(handle->out_crypto_transport.close(qhash, fhash), ERR_TRANSPORT_CLOSED);    hash_to_hashhex(qhash, handle->qhashhex);    hash_to_hashhex(fhash, handle->fhashhex);    return 0;}

IVS_DRAW_API LONG Draw_GetCursorType(DRAW_HANDLE handle, POINT Point){	CHECK_HANDLE(handle);	CIADrawer *pIADrawer = (CIADrawer *)handle;	if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&Point))	{		return CURSOR_TYPE_ARROW;	}	return pIADrawer->GetCursorType(Point);}

// 根据鼠标点坐标选中智能分析单个图形（选择特定组中与鼠标坐标最近的单个图形）IVS_DRAW_API LONG Draw_SelectGraphicByGraphicPoint(DRAW_HANDLE handle, POINT point, ULONG *ulGraphicGroup, BOOL *bAllowDel){	CHECK_HANDLE(handle);	if ((NULL == ulGraphicGroup) || (NULL == bAllowDel))	{		return IVS_PARA_INVALID;	}	CIADrawer *pIADrawer = (CIADrawer *)handle;	return pIADrawer->SelectGraphicByPoint(point, *ulGraphicGroup, *bAllowDel);}

int scytale_meta_reader_read_hash(RedCryptoMetaReaderHandle * handle, int version, int has_checksum){    SCOPED_TRACE;    CHECK_HANDLE(handle);    handle->mwrm_reader.set_header({static_cast<WrmVersion>(version), bool(has_checksum)});    CHECK_NOTHROW(        handle->mwrm_reader.read_meta_hash_line(handle->meta_line),        ERR_TRANSPORT_READ_FAILED);    return 0;}

int scytale_meta_reader_read_line(RedCryptoMetaReaderHandle * handle){    SCOPED_TRACE;    CHECK_HANDLE(handle);    CHECK_NOTHROW(        handle->eof            = Transport::Read::Eof == handle->mwrm_reader.read_meta_line(handle->meta_line),        ERR_TRANSPORT_READ_FAILED);    return handle->eof ? ERR_TRANSPORT_NO_MORE_DATA : 0;}

int scytale_reader_qhash(RedCryptoReaderHandle * handle, const char * file){    SCOPED_TRACE;    CHECK_HANDLE(handle);    CHECK_NOTHROW(        InCryptoTransport::HASH qhash = handle->in_crypto_transport.qhash(file);        hash_to_hashhex(qhash.hash, handle->qhashhex),        ERR_TRANSPORT_READ_FAILED    );    return 0;}

// 智能分析点击确定U型框中间节点位置坐标IVS_DRAW_API LONG Draw_ULineSetPoint(DRAW_HANDLE handle, POINT point, ULONG /*ulGraphicGroup*/){	CHECK_HANDLE(handle);	CIADrawer *pIADrawer = (CIADrawer *)handle;	if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&point))	{// 		pIADrawer->StopDrawGraphics(ulGraphicGroup);		return IVS_FAIL;	}	return pIADrawer->DrawIAULine(point, TRUE, FALSE, TRUE);}

// 选中指定图形组的所有图形IVS_DRAW_API LONG Draw_SelectGraphicByGroup(DRAW_HANDLE handle, ULONG ulGraphicGroup, BOOL *bAllowDel){	CHECK_HANDLE(handle);	if (NULL == bAllowDel)	{		return IVS_PARA_INVALID;	}	CIADrawer *pIADrawer = (CIADrawer *)handle;	return pIADrawer->SelectGraphicByGroup(ulGraphicGroup, *bAllowDel);}

static void ipv6_recv_ok(uv_udp_t* handle,                         ssize_t nread,                         const uv_buf_t* buf,                         const struct sockaddr* addr,                         unsigned flags) {  CHECK_HANDLE(handle);  ASSERT(nread >= 0);  if (nread)    recv_cb_called++;}

// 智能分析结束修改图形IVS_DRAW_API LONG Draw_ModifyFinish(DRAW_HANDLE handle, ULONG ulGraphicGroup, POINT point){	CHECK_HANDLE(handle);	CIADrawer *pIADrawer = (CIADrawer *)handle;	if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&point))	{		pIADrawer->InsertCurrentToGraphicList();		return IVS_SUCCEED;	}	return pIADrawer->ModifyIAShapeUpDate(point, TRUE, ulGraphicGroup);}

void fcrystal_ituple_transfer(const sint *handle,                              sint A[], const sint *m, sint *n,                              const sint *nmax, const sint *proc_key){  struct array ar, *const ar_ptr = &ar;  const unsigned size=(*m)*sizeof(sint);  CHECK_HANDLE("crystal_ituple_transfer");  ar.ptr=A, ar.n=*n, ar.max=*nmax;  *n = sarray_transfer_many(&ar_ptr,&size,1, 1,0,1,(*proc_key-1)*sizeof(sint),         (uint*)&A[*proc_key-1],size, handle_array[*handle]);}

void create_simple(pointless_create_t* c){    // error string    const char* error = 0;    // vector    uint32_t vector_handle = pointless_create_vector_value(c);    CHECK_HANDLE(vector_handle);    // bitvector    uint32_t value = 123;    uint32_t bitvector_handle = pointless_create_bitvector(c, &value, 27);    CHECK_HANDLE(bitvector_handle);    // string    uint32_t string_handle = pointless_create_string_ascii(c, (uint8_t*)"Arni Mar Jonsson");    if (string_handle == POINTLESS_CREATE_VALUE_FAIL) {        fprintf(stderr, "pointless_create_string_ascii() failure/n");        exit(EXIT_FAILURE);    }    uint32_t unicode_handle = pointless_create_unicode_ascii(c, "Arni Mar Jonsson", &error);    if (string_handle == POINTLESS_CREATE_VALUE_FAIL) {        fprintf(stderr, "pointless_create_unicode_ascii() failure: %s/n", error);        exit(EXIT_FAILURE);    }    // add to vector    uint32_t i, handles[] = { bitvector_handle, vector_handle, string_handle, unicode_handle };    for (i = 0; i < 4; i++) {        if (pointless_create_vector_value_append(c, vector_handle, handles[i]) == POINTLESS_CREATE_VALUE_FAIL) {            fprintf(stderr, "pointless_create_vector_append() failure/n");            exit(EXIT_FAILURE);        }    }    pointless_create_set_root(c, vector_handle);}

static	geBoolean	GENESISCC FSDos_SetHints(void *Handle, const geVFile_Hints *Hints){	DosFile *	File;	File = Handle;	CHECK_HANDLE(File);	assert(File->FileHandle != INVALID_HANDLE_VALUE);	return GE_FALSE;}

static void cl_send_cb(uv_udp_send_t* req, int status) {  int r;  ASSERT(req != NULL);  ASSERT(status == 0);  CHECK_HANDLE(req->handle);  r = uv_udp_recv_start(req->handle, alloc_cb, cl_recv_cb);  ASSERT(r == 0);  cl_send_cb_called++;}

int pcmcia_reset_card(client_handle_t handle, client_req_t *req){	struct pcmcia_socket *skt;    	if (CHECK_HANDLE(handle))		return CS_BAD_HANDLE;	skt = SOCKET(handle);	if (!skt)		return CS_BAD_HANDLE;	return pccard_reset_card(skt);}

// 智能分析点击确定U型线最后一边并且结束画U型线// （若已确定三条边，直接结束画图；若第三条边未确定，则以当前点为U型线第三边终点）IVS_DRAW_API LONG Draw_ULineFinish(DRAW_HANDLE handle, POINT point, ULONG /*ulGraphicGroup*/){	CHECK_HANDLE(handle);	CIADrawer *pIADrawer = (CIADrawer *)handle;	if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&point))	{		pIADrawer->InsertCurrentToGraphicList();// 		pIADrawer->StopDrawGraphics(ulGraphicGroup);		return IVS_SUCCEED;	}	return pIADrawer->DrawIAULine(point, TRUE, TRUE, TRUE);}

int pcmcia_get_configuration_info(client_handle_t handle,				  config_info_t *config){	struct pcmcia_socket *s;	if ((CHECK_HANDLE(handle)) || !config)		return CS_BAD_HANDLE;	s = SOCKET(handle);	if (!s)		return CS_BAD_HANDLE;	return pccard_get_configuration_info(s, handle->Function, config);}

IVS_DRAW_API LONG Draw_WindowPointToGraphicPoint(DRAW_HANDLE handle, POINT* pPoint){	CHECK_HANDLE(handle);	CIADrawer *pIADrawer = (CIADrawer *)handle;	if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(pPoint))	{		pIADrawer->InsertCurrentToGraphicList();		// 		pIADrawer->StopDrawGraphics(ulGraphicGroup);		return IVS_SUCCEED;	}		return IVS_SUCCEED;}

/*++Routine Name:    CUICtrlFeatNUpCombo::EnableDependentCtrlsRoutine Description:    This method is used to enable or disable other controls in the UI based on the    current combo box selection.Arguments:    hDlg - handle to the parent window    lSel - current combo box selectionReturn Value:    HRESULT    S_OK - On success    E_*  - On error--*/HRESULTCUICtrlFeatNUpCombo::EnableDependentCtrls(    __in CONST HWND hDlg,    __in CONST LONG lSel    ){    HRESULT hr = S_OK;    HWND hWnd = NULL;    //    // Here we are enabling/disabling the NUp and Binding controls depending on the current    // NUp selection.    //    // When NUp is more than 1 page per sheet we enable the NUp order controls and disable    // binding option controls.    //    if (SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_COMBO_NUP_ORDER), E_HANDLE)))    {       EnableWindow(hWnd, lSel > NUP_1PPS_SEL);    }    if (SUCCEEDED(hr) &&        SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_TXT_NUP_ORDER), E_HANDLE)))    {       EnableWindow(hWnd, lSel > NUP_1PPS_SEL);    }    if (SUCCEEDED(hr) &&        SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_COMBO_JOBBIND), E_HANDLE)))    {       EnableWindow(hWnd, lSel == NUP_1PPS_SEL);    }    if (SUCCEEDED(hr) &&        SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_TXT_JOBBIND), E_HANDLE)))    {       EnableWindow(hWnd, lSel == NUP_1PPS_SEL);    }    if (SUCCEEDED(hr) &&        SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_COMBO_DOCBIND), E_HANDLE)))    {       EnableWindow(hWnd, lSel == NUP_1PPS_SEL);    }    if (SUCCEEDED(hr) &&        SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_TXT_DOCBIND), E_HANDLE)))    {       EnableWindow(hWnd, lSel == NUP_1PPS_SEL);    }    if (FAILED(hr))    {        hr = HRESULT_FROM_WIN32(GetLastError());    }    ERR_ON_HR(hr);    return hr;}

kadm5_ret_t kadm5_chpass_principal_util(void *server_handle,					krb5_principal princ,					char *new_pw, 					char **ret_pw,					char *msg_ret,					unsigned int msg_len){  kadm5_server_handle_t handle = server_handle;  CHECK_HANDLE(server_handle);  return _kadm5_chpass_principal_util(handle, handle->lhandle, princ,				      new_pw, ret_pw, msg_ret, msg_len);}

static int mtd_set_vpp(client_handle_t handle, mtd_vpp_req_t *req){    socket_info_t *s;    if (CHECK_HANDLE(handle))	return CS_BAD_HANDLE;    if (req->Vpp1 != req->Vpp2)	return CS_BAD_VPP;    s = SOCKET(handle);    s->socket.Vpp = req->Vpp1;    if (s->ss_entry(s->sock, SS_SetSocket, &s->socket))	return CS_BAD_VPP;    return CS_SUCCESS;}

static int mtd_rdy_mask(client_handle_t handle, mtd_rdy_req_t *req){    socket_info_t *s;    if (CHECK_HANDLE(handle))	return CS_BAD_HANDLE;    s = SOCKET(handle);    if (req->Mask & CS_EVENT_READY_CHANGE)	s->socket.csc_mask |= SS_READY;    else	s->socket.csc_mask &= ~SS_READY;    if (s->ss_entry(s->sock, SS_SetSocket, &s->socket))	return CS_GENERAL_FAILURE;    return CS_SUCCESS;}

voidPOMP2_Parallel_fork( POMP2_Region_handle* pomp2_handle,                     int                  if_clause,                     int                  num_threads,                     POMP2_Task_handle*   pomp2_old_task,                     const char           ctc_string[] ){    EPIK_Region_descriptor* rdescr = (EPIK_Region_descriptor*) (*pomp2_handle);    CHECK_HANDLE();    *pomp2_old_task = pomp2_current_task;    if( pomp2_tracing )    {      esd_omp_fork( rdescr->rid );    }}