folly::Future<bool> MyServiceAsyncClient::future_hasDataById(apache::thrift::RpcOptions& rpcOptions, int64_t id) {
folly::Promise<bool> promise1;
auto future2 = promise1.getFuture();
std::unique_ptr<apache::thrift::RequestCallback> callback3(new apache::thrift::FutureCallback<bool>(std::move(promise1), recv_wrapped_hasDataById, channel_, (rpcOptions.getUseForReadHeaders() ? &rpcOptions : nullptr)));
hasDataById(rpcOptions, std::move(callback3), id);
return std::move(future2);
}
folly::Future<folly::Unit> MyRootAsyncClient::future_do_root(apache::thrift::RpcOptions& rpcOptions) {
folly::Promise<folly::Unit> promise1;
auto future2 = promise1.getFuture();
std::unique_ptr<apache::thrift::RequestCallback> callback3(new apache::thrift::FutureCallback<folly::Unit>(std::move(promise1), recv_wrapped_do_root, channel_, (rpcOptions.getUseForReadHeaders() ? &rpcOptions : nullptr)));
do_root(rpcOptions, std::move(callback3));
return std::move(future2);
}
void
CLogSvcServer::RegisterServerSocketEventHandlers( void )
{
TEventCallback callback( this, &CLogSvcServer::OnServerSocketClientConnected );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ClientConnectedEvent ,
callback );
TEventCallback callback2( this, &CLogSvcServer::OnServerSocketClientDisconnected );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ClientDisconnectedEvent ,
callback2 );
TEventCallback callback3( this, &CLogSvcServer::OnServerSocketClientError );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ClientErrorEvent ,
callback3 );
TEventCallback callback4( this, &CLogSvcServer::OnServerSocketServerSocketClosed );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ServerSocketClosedEvent ,
callback4 );
TEventCallback callback5( this, &CLogSvcServer::OnServerSocketServerSocketError );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ServerSocketErrorEvent ,
callback5 );
TEventCallback callback6( this, &CLogSvcServer::OnServerSocketServerSocketClientError );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ServerSocketClientErrorEvent ,
callback6 );
}
void do_call() {
int i = callback();
printf("callback returned %d to c\n", i);
int j = callback2(123, 8.76);
printf("callback2 returned %d to c\n", j);
double d = callback3();
printf("callback3 returned %f to c\n", d);
}
struct string_list *
verify_tal_file (char *typerep, int typereplen,
char *tofile, int tofilelen,
char *codefile, int codefilelen)
{
CAMLparam0();
CAMLlocal4(Caml_typerep,Caml_tofile,Caml_codefile,answer);
static value *verify_tal_file_closure = NULL;
struct string_list *retval = NULL;
Caml_typerep = alloc_string(typereplen);
Caml_tofile = alloc_string(tofilelen);
Caml_codefile = alloc_string(codefilelen);
memcpy(String_val(Caml_typerep),typerep,typereplen);
memcpy(String_val(Caml_tofile),tofile,tofilelen);
memcpy(String_val(Caml_codefile),codefile,codefilelen);
if (verify_tal_file_closure == NULL)
verify_tal_file_closure = caml_named_value ("verify_tal_file");
answer = callback3(*verify_tal_file_closure,
Caml_typerep, Caml_tofile, Caml_codefile);
/* process the results -- should be a string list option */
/* convert it to a C struct */
if (Is_block(answer)) {
value list = Field(answer, 0);
struct string_list tmp;
struct string_list *ptmp = &tmp;
while (Is_block(list)) {
ptmp->next = GC_malloc(sizeof(struct string_list));
ptmp = ptmp->next;
if (retval == NULL) {
retval = ptmp;
}
ptmp->str = CONVERT_SYM((char *)(Field(list, 0)));
list = Field(list,1);
}
}
/* else None */
CAMLreturn(retval);
}
value_t c_win32_iterate_connections (
value_t iterator )
{
RASCONN * lpRasConn;
DWORD lpcb, lpcConnections;
unsigned int nRet, i;
CAMLparam1 ( iterator );
CAMLlocal1 ( name );
#ifdef WRAS_EMULATION
lpRasConn = calloc ( 1, sizeof(RASCONN));
#else
lpRasConn = (LPRASCONN) GlobalAlloc(GPTR, sizeof(RASCONN));
#endif
lpRasConn->dwSize = sizeof(RASCONN);
lpcb = sizeof(RASCONN);
nRet = RasEnumConnections(lpRasConn, &lpcb, &lpcConnections);
for ( i = 0; i < lpcConnections; i ++ )
{
if ( debug_print )
printf ( "Processing connection %s 0x%08x\n",
lpRasConn[i].szEntryName,
(unsigned) lpRasConn[i].hrasconn );
name = copy_string ( lpRasConn[i].szEntryName );
callback3 ( iterator, name,
Val_int (LOWORD(lpRasConn[i].hrasconn)),
Val_int (HIWORD(lpRasConn[i].hrasconn)));
}
#ifdef WRAS_EMULATION
free ( lpRasConn );
#else
GlobalFree ( lpRasConn );
#endif
CAMLreturn (Val_int ( lpcConnections ));
return 0; /* dummy, to shut down warning */
}
int gsl_multiroot_callback_fdf(const gsl_vector *x, void *params,
gsl_vector *F, gsl_matrix *J)
{
int barr_flags = BIGARRAY_FLOAT64 | BIGARRAY_C_LAYOUT;
struct callback_params *p=params;
value x_barr, f_barr, j_barr;
int len = x->size;
gsl_vector_view x_v, f_v;
gsl_matrix_view j_v;
x_barr = alloc_bigarray_dims(barr_flags, 1, NULL, len);
f_barr = alloc_bigarray_dims(barr_flags, 1, NULL, len);
j_barr = alloc_bigarray_dims(barr_flags, 2, NULL, len, len);
x_v = gsl_vector_view_array(Data_bigarray_val(x_barr), len);
f_v = gsl_vector_view_array(Data_bigarray_val(f_barr), len);
j_v = gsl_matrix_view_array(Data_bigarray_val(j_barr), len, len);
gsl_vector_memcpy(&x_v.vector, x);
callback3(Field(p->closure, 2), x_barr, f_barr, j_barr);
gsl_vector_memcpy(F, &f_v.vector);
gsl_matrix_memcpy(J, &j_v.matrix);
return GSL_SUCCESS;
}
bool ClientHandler::OnConsoleMessage(CefRefPtr<CefBrowser> browser, const CefString& message, const CefString& source, int line)
{
ASSERT(CefCurrentlyOn(TID_UI));
PostCallback(callback3(WhenConsoleMessage, source.ToString(), line, message.ToString()));
return true;
}
value mycallback3(value fun, value arg1, value arg2, value arg3)
{
value res;
res = callback3(fun, arg1, arg2, arg3);
return res;
}
int
ml_recvf(int bufid, int tid, int tag)
{
return Int_val(callback3(mlf, Val_int(bufid), Val_int(tid), Val_int(tag)));
}
void ClientHandler::OnLoadingStateChange(CefRefPtr<CefBrowser> browser, bool isLoading, bool canGoBack, bool canGoForward)
{
PostCallback(callback3(WhenStateChange, isLoading, canGoBack, canGoForward));
}
