avtIVPSolver::Result avtIVPAdamsBashforth::RK4Step(const avtIVPField* field, avtVector &yNew ) { avtVector f[4]; avtIVPField::Result result; if ((result = (*field)(t, yCur, f[0])) != avtIVPField::OK) return ConvertResult(result); f[0] *= h; if ((result = (*field)(t+0.5*h, yCur + f[0] * 0.5, f[1])) != avtIVPField::OK) return ConvertResult(result); f[1] *= h; if ((result = (*field)(t+0.5*h, yCur + f[1] * 0.5, f[2])) != avtIVPField::OK) return ConvertResult(result); f[2] *= h; if ((result = (*field)(t+h, yCur + f[2], f[3])) != avtIVPField::OK) return ConvertResult(result); f[3] *= h; yNew = yCur + (f[0] + 2.0 * f[1] + 2.0 * f[2] + f[3]) * (1.0 / 6.0); return avtIVPSolver::OK; }
// native sampleMethod void sampleMethod(JXValue *results, int argc) { for (int i = 0; i < argc; i++) { std::string str; ConvertResult(&results[i], str); if (compare_base[i] != str.c_str()[0]) { flush_console("FAIL! Item(%d) : %s \n", i, str.c_str()); exit(-1); } } JXValue out; // fnc represents the JS side function fnc = &results[9]; param1 = results + 3; param2 = results + 4; // call JS side fnc with 2 parameters and get // the result to 'out' JX_CallFunction(fnc, (results + 3), 2, &out); // make fnc persistent so we can call it later again // see 'int main' for second call JX_MakePersistent(fnc); JX_MakePersistent(param1); JX_MakePersistent(param2); assert(JX_GetDataLength(&out) == 11 && "Expected return value was 'test{\"a\":3}"); JX_Free(&out); assert(out.data_ == NULL && out.size_ == 0 && "JX_FreeResultData leaks?"); }
int ObserverPlugin::ExtractItem( HANDLE hArchive, int nIndex, const TCHAR* lpDestPath, ExtractProcessCallbacks* pCallbacks ) { ExtractOperationParams params; memset(¶ms, 0, sizeof(params)); memcpy(¶ms.callbacks, pCallbacks, sizeof(ExtractProcessCallbacks)); #ifdef UNICODE const wchar_t* lpDestPathCopy = lpDestPath; #else wchar_t* lpDestPathCopy = AnsiToUnicode(lpDestPath); #endif params.destFilePath = lpDestPathCopy; params.flags = 0; params.item = nIndex; int nResult = E_BROKEN; //TO DO REAL RESULT if ( m_pfnExtract ) nResult = m_pfnExtract(hArchive, params); #ifdef UNICODE #else free(lpDestPathCopy); #endif return ConvertResult(nResult); }
JNIEXPORT jstring JNICALL Java_org_capriza_jxcore_jxcore_convertToString(JNIEnv *env, jobject thiz, jlong id) { JXValue *val; if (id < 0) val = cb_values + (id + 3); else val = JX_RemoveStoredValue(0, id); std::string str_result; ConvertResult(val, str_result); if (id >= 0) JX_Free(val); return env->NewStringUTF(str_result.c_str()); }
void Log::CloseLog( BOOL result, char* message ) { char buffer[40]; char* result_s = ConvertResult( result ); if(message) { hal_snprintf( buffer, sizeof(buffer), "%12s, %4s", message, result_s ); } else { hal_snprintf( buffer, sizeof(buffer), "%12s, %4s", m_logBuffer, result_s ); } m_handler( buffer, NULL ); }
void sampleMethod(JXValue *results, int argc) { for (int i = 0; i < argc; i++) { std::string str; ConvertResult(&results[i], str); if (compare_base[i] != str.c_str()[0]) { flush_console("FAIL! Item(%d) : %s \n", i, str.c_str()); exit(-1); } } JXValue out; JX_CallFunction(&results[9], (results + 3), 2, &out); assert(JX_GetDataLength(&out) == 11 && "Expected return value was 'test{\"a\":3}"); JX_Free(&out); assert(out.data_ == NULL && out.size_ == 0 && "JX_FreeResultData leaks?"); }
int MaPlugin::GetArchiveItem(ArchiveItem* pItem, ArcItemInfo* pInfo) { oldfar::PluginPanelItem item; memset(&item, 0, sizeof(oldfar::PluginPanelItem)); //модули глючат и считают, что тут нули ArcItemInfo MaItemInfo; memset(&MaItemInfo, 0, sizeof(ArcItemInfo)); int nResult = m_pfnGetArcItem(&item, &MaItemInfo); if ( nResult == GETARC_SUCCESS ) { #ifdef UNICODE pItem->lpFileName = AnsiToUnicode(item.FindData.cFileName); pItem->lpAlternateFileName = AnsiToUnicode(item.FindData.cAlternateFileName); #else pItem->lpFileName = StrDuplicate(item.FindData.cFileName); pItem->lpAlternateFileName = StrDuplicate(item.FindData.cFileName); #endif pItem->nFileSize = ((unsigned __int64)item.FindData.nFileSizeHigh << 32)+(unsigned __int64)item.FindData.nFileSizeLow; pItem->dwFileAttributes = item.FindData.dwFileAttributes; pItem->nPackSize = ((unsigned __int64)item.PackSizeHigh << 32)+(unsigned __int64)item.PackSize; pItem->dwCRC32 = item.CRC32; if ( MaItemInfo.Encrypted ) pItem->dwFlags |= AIF_CRYPTED; if ( MaItemInfo.Solid ) pItem->dwFlags |= AIF_SOLID; if ( pInfo ) memcpy(pInfo, &MaItemInfo, sizeof(ArcItemInfo)); return E_SUCCESS; } return ConvertResult (nResult); }
int main(int argc, char **args) { JX_InitializeOnce("/test/bin/cpp/"); JX_InitializeNewEngine(); JX_DefineMainFile(contents); JX_StartEngine(); JXValue ret_val; JX_Evaluate("process.callMe()", "eval", &ret_val); while (JX_LoopOnce() != 0) usleep(1); assert(JX_IsError(&ret_val) && "error was expected"); std::string str; ConvertResult(&ret_val, str); assert(!strcmp("TypeError: this is type exception", str.c_str()) && "Exception output doesn't match"); JX_Free(&ret_val); JX_StopEngine(); }
avtIVPSolver::Result avtIVPEuler::Step(avtIVPField* field, double t_max, avtIVPStep* ivpstep) { const double direction = sign( 1.0, t_max - t ); h = sign( h, direction ); bool last = false; // do not run past integration end if( (t + 1.01*h - t_max) * direction > 0.0 ) { last = true; h = t_max - t; } // stepsize underflow? if( 0.1*std::abs(h) <= std::abs(t)*epsilon ) return avtIVPSolver::STEPSIZE_UNDERFLOW; avtIVPField::Result fieldResult; avtVector yNew, vNew; if( field->GetOrder() == 2 ) { avtVector aCur; if ((fieldResult = (*field)(t, yCur, vCur, aCur)) != avtIVPField::OK) return ConvertResult(fieldResult); vNew = vCur + aCur * h; // New velocity yNew = yCur + vNew * h; // New position } else //if( field->GetOrder() == 1 ) { if ((fieldResult = (*field)(t, yCur, vCur)) != avtIVPSolver::OK) return ConvertResult(fieldResult); yNew = yCur + vCur * h; // New position } ivpstep->resize(2); if( convertToCartesian ) { (*ivpstep)[0] = field->ConvertToCartesian( yCur ); (*ivpstep)[1] = field->ConvertToCartesian( yNew ); } else { (*ivpstep)[0] = yCur; (*ivpstep)[1] = yNew; } ivpstep->t0 = t; ivpstep->t1 = t + h; numStep++; yCur = yNew; vCur = vNew; t = t+h; // Reset the step size on sucessful step. h = h_max; return (last ? avtIVPSolver::TERMINATE : avtIVPSolver::OK); }
avtIVPSolver::Result avtIVPDopri5::Step(avtIVPField* field, double t_max, avtIVPStep* ivpstep) { const double direction = sign( 1.0, t_max - t ); avtIVPField::Result fieldResult; // compute maximum stepsize double local_h_max = h_max; if( local_h_max == 0.0 ) local_h_max = std::abs( t_max - t ); // compute k1 to ensure first-same-as-last principle, // maybe also needed for hinit()) if( n_steps == 0 ) { if ((fieldResult = (*field)( t, y, k1 )) != avtIVPSolver::OK) return ConvertResult(fieldResult); n_eval++; } // determine stepsize (user-specified or educated guess) if( h == 0.0 ) { if( h_init == 0.0 ) { h = GuessInitialStep( field, local_h_max, t_max ); } else { h = h_init; } } else { h = sign( h, direction ); } bool reject = false; // integration step loop, will exit after successful step while( true ) { bool last = false; avtVector y_new, y_stiff; // stepsize underflow? if( 0.1*std::abs(h) <= std::abs(t)*epsilon ) { if (DebugStream::Level5()) debug5 << "\tavtIVPDopri5::Step(): exiting at t = " << t << ", step size too small (h = " << h << ")\n"; return avtIVPSolver::STEPSIZE_UNDERFLOW; } // Check to make sure we don't exceed the max step. if( h_max != 0.0 && std::abs(h) > std::abs(h_max) ) h = sign( h_max, h ); // do not run past integration end if( (t + 1.01*h - t_max) * direction > 0.0 ) { last = true; h = t_max - t; } n_steps++; if (DebugStream::Level5()) debug5 << "\tavtIVPDopri5::Step(): t = " << t << ", y = " << y << ", h = " << h << ", t+h = " << t+h << '\n'; avtVector k2, k3, k4, k5, k6, k7; // perform stages y_new = y + h*a21*k1; if ((fieldResult = (*field)( t+c2*h, y_new, k2 )) != avtIVPField::OK) return ConvertResult(fieldResult); y_new = y + h * ( a31*k1 + a32*k2 ); if ((fieldResult = (*field)( t+c3*h, y_new, k3 )) != avtIVPField::OK) return ConvertResult(fieldResult); y_new = y + h * ( a41*k1 + a42*k2 + a43*k3 ); if ((fieldResult = (*field)( t+c4*h, y_new, k4 )) != avtIVPField::OK) return ConvertResult(fieldResult); y_new = y + h * ( a51*k1 + a52*k2 + a53*k3 + a54*k4 ); if ((fieldResult = (*field)( t+c5*h, y_new, k5 )) != avtIVPField::OK) return ConvertResult(fieldResult); y_stiff = y_new = y + h * (a61*k1 + a62*k2 + a63*k3 + a64*k4 + a65*k5); if ((fieldResult = (*field)( t+h, y_new, k6 )) != avtIVPField::OK) return ConvertResult(fieldResult); y_new = y + h * (a71*k1 + a73*k3 + a74*k4 + a75*k5 + a76*k6 ); if ((fieldResult = (*field)( t+h, y_new, k7 )) != avtIVPField::OK) return ConvertResult(fieldResult); n_eval += 6; double err = 0.0, h_new, fac11; // error estimation avtVector ee = h * ( e1*k1 + e3*k3 + e4*k4 + e5*k5 + e6*k6 + e7*k7 ); double sk, sqr; for( size_t i=0; i<3; i++ ) { sk = abstol + reltol * std::max(std::abs(y[i]), std::abs(y_new[i])); sqr = ee[i]/sk; err += sqr*sqr; } err = sqrt(err / 3.0); // compute next potential stepsize fac11 = pow( err, 0.2 - beta*0.75 ); // Lund-stabilization double fac = fac11 / pow( facold, beta ); // we require facl <= h_new/h <= facr fac = std::max( 1.0/facr, std::min( 1.0/facl, fac/safe ) ); h_new = h / fac; if( h_new > std::numeric_limits<double>::max() ) h_new = std::numeric_limits<double>::max(); if( h_new < -std::numeric_limits<double>::max() ) h_new = std::numeric_limits<double>::max(); if( err <= 1.0 ) { // step accepted facold = std::max( err, 1.0e-4 ); n_accepted++; // stiffness detection if( !(n_accepted % nstiff) || (iasti > 0) ) { double stnum = 0.0, stden = 0.0, sqr; for( size_t i=0; i < 3; i++ ) { sqr = k7[i] - k6[i]; stnum += sqr * sqr; sqr = y_new[i] - y_stiff[i]; stden += sqr * sqr; } if( stden > 0.0 ) hlamb = h * sqrt( stnum/stden ); if( fabs(hlamb) > 3.25 ) { nonsti = 0; iasti++; if( iasti == 15 ) { if (DebugStream::Level5()) debug5 << "\tavtIVPDopri5::Step(): exiting at t = " << t << ", problem seems stiff (y = " << y << ")\n"; return avtIVPSolver::STIFFNESS_DETECTED; } } else { nonsti++; if( nonsti == 6 ) iasti = 0; } } // --- step looks ok - prepare for return if( reject ) h_new = direction * std::min( std::abs(h_new), std::abs(h) ); // fill in step // make interpolation polynomial if( ivpstep ) { ivpstep->resize(5); if( convertToCartesian ) { (*ivpstep)[0] = field->ConvertToCartesian( y ); (*ivpstep)[1] = field->ConvertToCartesian( y + (h*k1/4.) ); (*ivpstep)[2] = field->ConvertToCartesian( (y + y_new)/2 + h*( (d1+1)*k1 + d3*k3 + d4*k4 + d5*k5 + d6*k6 + (d7-1)*k7 )/6. ); (*ivpstep)[3] = field->ConvertToCartesian( y_new - h*k7/4 ); (*ivpstep)[4] = field->ConvertToCartesian( y_new ); } else { (*ivpstep)[0] = y; (*ivpstep)[1] = y + (h*k1/4.); (*ivpstep)[2] = (y + y_new)/2 + h*( (d1+1)*k1 + d3*k3 + d4*k4 + d5*k5 + d6*k6 + (d7-1)*k7 )/6.; (*ivpstep)[3] = y_new - h*k7/4; (*ivpstep)[4] = y_new; } ivpstep->t0 = t; ivpstep->t1 = t + h; } // update internal state // first-same-as-last for k1 k1 = k7; y = y_new; t = t+h; h = h_new; numStep++; return last ? avtIVPSolver::TERMINATE : avtIVPSolver::OK; } else { // step rejected h_new = h / std::min( 1.0/facl, fac11/safe ); reject = true; if( n_accepted >= 1 ) n_rejected++; h = h_new; if (DebugStream::Level5()) debug5 << "\tavtIVPDopri5::Step(): step rejected, retry with h = " << h << '\n'; } } }
static void callJXcoreNative(JXValue *results, int argc) { JNIEnv *env = jxcore::JniHelper::getEnv(); jclass arrClass = env->FindClass("java/util/ArrayList"); jmethodID arrInit = env->GetMethodID(arrClass, "<init>", "()V"); jobject objArray = env->NewObject(arrClass, arrInit); jmethodID addObject = env->GetMethodID(arrClass, "add", "(Ljava/lang/Object;)Z"); jclass boolClass = NULL; jmethodID boolMethod; jclass intClass = NULL; jmethodID intMethod; jclass doubleClass = NULL; jmethodID doubleMethod; jclass strClass = env->FindClass("java/lang/String"); for (int i = 0; i < argc; i++) { JXValue *result = results + i; jobject objValue = NULL; switch (result->type_) { case RT_Boolean: { if (boolClass == NULL) { boolClass = env->FindClass("java/lang/Boolean"); boolMethod = env->GetMethodID(boolClass, "<init>", "(Z)V"); } jboolean bl = JX_GetBoolean(result) ? JNI_TRUE : JNI_FALSE; objValue = env->NewObject(boolClass, boolMethod, bl); } break; case RT_Int32: { if (intClass == NULL) { intClass = env->FindClass("java/lang/Integer"); intMethod = env->GetMethodID(intClass, "<init>", "(I)V"); } jint nt = JX_GetInt32(result); objValue = env->NewObject(intClass, intMethod, nt); } break; case RT_Double: { if (doubleClass == NULL) { doubleClass = env->FindClass("java/lang/Double"); doubleMethod = env->GetMethodID(doubleClass, "<init>", "(D)V"); } jdouble db = JX_GetDouble(result); objValue = env->NewObject(doubleClass, doubleMethod, db); } break; case RT_Buffer: { char *arr = JX_GetString(result); int length = JX_GetDataLength(result); jbyteArray ret = env->NewByteArray(length); env->SetByteArrayRegion(ret, 0, length, (jbyte *)arr); objValue = (jobject)ret; free(arr); } break; case RT_Object: { std::string str_result; ConvertResult(result, str_result); const char *data = str_result.c_str(); int ln = JX_GetDataLength(result); if (ln > 0 && *data != '{' && *data != '[') { objValue = (jobject)env->NewStringUTF(str_result.c_str()); } else { jobjectArray ret = (jobjectArray)env->NewObjectArray( 1, strClass, env->NewStringUTF("")); jstring jstr = env->NewStringUTF(str_result.c_str()); env->SetObjectArrayElement(ret, 0, jstr); objValue = (jobject)ret; env->DeleteLocalRef(jstr); } } break; case RT_Error: case RT_String: { std::string str_result; ConvertResult(result, str_result); objValue = env->NewStringUTF(str_result.c_str()); } break; default: break; } env->CallBooleanMethod(objArray, addObject, objValue); env->DeleteLocalRef(objValue); } jxcore::CallJava(objArray); env->DeleteLocalRef(objArray); env->DeleteLocalRef(arrClass); env->DeleteLocalRef(strClass); if (doubleClass != NULL) env->DeleteLocalRef(doubleClass); if (intClass != NULL) env->DeleteLocalRef(intClass); if (boolClass != NULL) env->DeleteLocalRef(boolClass); }
/** * @brief ルーム作成 * @param [IN] smcal SMCAL * @param [IN] parm APIパラメータ * @param [IN] ChatRoomInf ルーム作成情報 * @param [OUT] roomNo ルームNo * @param [IN] recv センタ受信データ * @param [OUT] apiStatus APIステータス * @return 処理結果(E_SC_RESULT) */ E_SC_RESULT CC_RoomReg_SendRecv(SMCAL *smcal, const T_CC_CMN_SMS_API_PRM *parm, const SMCREATEROOMINF *ChatRoomInf, Char *roomNo, Char *recv, INT32 recvBufSize, Char *apiStatus) { E_SC_RESULT ret = e_SC_RESULT_SUCCESS; E_SC_CAL_RESULT calRet = e_SC_CAL_RESULT_SUCCESS; static Char uri[CC_CMN_URI_STR_MAX_LEN] = {}; Char *body = NULL; UINT32 bodySize = 0; E_CONTEXT_TYPE contextType = E_TEXT_XML; SMCALOPT opt = {}; UINT32 recvSize = 0; Char *data = NULL; INT32 status = 0; SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_START); do { // パラメータチェック if (CC_ISNULL(smcal)) { SCC_LOG_ErrorPrint(SC_TAG_CC, "param error[smcal], " HERE); ret = e_SC_RESULT_BADPARAM; break; } if (CC_ISNULL(parm)) { SCC_LOG_ErrorPrint(SC_TAG_CC, "param error[parm], " HERE); ret = e_SC_RESULT_BADPARAM; break; } if (CC_ISNULL(ChatRoomInf)) { SCC_LOG_ErrorPrint(SC_TAG_CC, "param error[ChatRoomInf], " HERE); ret = e_SC_RESULT_BADPARAM; break; } if(CC_ISINVALIDSTR(ChatRoomInf->userList)) { SCC_LOG_ErrorPrint(SC_TAG_CC, "param error[userList], " HERE); ret = e_SC_RESULT_BADPARAM; break; } if (CC_ISNULL(roomNo)) { SCC_LOG_ErrorPrint(SC_TAG_CC, "param error[roomNo], " HERE); ret = e_SC_RESULT_BADPARAM; break; } if (CC_ISNULL(recv)) { SCC_LOG_ErrorPrint(SC_TAG_CC, "param error[recv], " HERE); ret = e_SC_RESULT_BADPARAM; break; } if (CC_ISNULL(apiStatus)) { SCC_LOG_ErrorPrint(SC_TAG_CC, "param error[apiStatus], " HERE); ret = e_SC_RESULT_BADPARAM; break; } // 初期化 *apiStatus = EOS; opt.cancel = SCC_IsCancel; #ifdef SC_CMN_BASIC_AUTH_SMS // BASIC認証 opt.isBasicAuth = true; strcpy(opt.basic.basicAuthId, SC_CMN_BASIC_AUTH_ID); strcpy(opt.basic.basicAuthPwd, SC_CMN_BASIC_AUTH_PWD); #endif // メモリ確保 data = (Char*)SCC_MALLOC(CC_ROOM_REG_SEND_BODY_SIZE); if (NULL == data) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC() error " HERE); ret = e_SC_RESULT_MALLOC_ERR; break; } ///URI生成 ret = CC_RoomReg_CreateUri(parm, uri, CC_CMN_URI_STR_MAX_LEN); if(CC_CMN_RESULT_OK != ret){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"CC_RoomReg_CreateUri() error " HERE); break; } ///body生成 ret = CC_RoomReg_CreateBody(parm, ChatRoomInf, data, CC_ROOM_REG_SEND_BODY_SIZE); if(CC_CMN_RESULT_OK != ret){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"CC_RoomReg_CreateBody() error " HERE); break; } // HTTPデータ送受信 calRet = SC_CAL_PostRequest(smcal, uri, data, strlen(data), recv, recvBufSize, &recvSize, &opt); if(e_SC_CAL_RESULT_SUCCESS != calRet){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_PostRequest error, " HERE); ret = ConvertResult(calRet); break; } // HTTPデータ解析 calRet = SC_CAL_AnalyzeResponseStatus(smcal, recv, recvSize, (const Char**)&body, &bodySize, &contextType, &status); if(e_SC_CAL_RESULT_SUCCESS != calRet){ if (CC_CMN_SERVER_STOP == status) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"server stop..., " HERE); ret = e_SC_RESULT_SERVER_STOP; } else { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_AnalyzeResponseStatus error, " HERE); ret = ConvertResult(calRet); } break; } // レスポンス解析 ret = CC_RoomReg_AnalyzeHttpResp(body, contextType, roomNo, &opt, apiStatus); if(e_SC_RESULT_SUCCESS != ret){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"CC_RoomReg_AnalyzeHttpResp error, " HERE); break; } } while (0); if (NULL != data) { SCC_FREE(data); } SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_END); return (ret); }
avtIVPSolver::Result avtIVPRK4::Step(avtIVPField* field, double t_max, avtIVPStep* ivpstep) { double t_local = GetLocalTime(); const double direction = sign( 1.0, t_max - t_local ); h = sign( h, direction ); bool last = false; // do not run past integration end if( (t_local + 1.01*h - t_max) * direction > 0.0 ) { last = true; h = t_max - t_local; } // stepsize underflow?? if( 0.1*std::abs(h) <= std::abs(t_local)*epsilon ) { if (DebugStream::Level5()) { debug5 << "\tavtIVPRK4::Step(): exiting at t = " << t << ", step size too small (h = " << h << ")\n"; } return avtIVPSolver::STEPSIZE_UNDERFLOW; } avtIVPField::Result fieldResult; avtVector yNew, vNew, k1, k2, k3, k4; // Compute the RK4 values. k1 = vCur; // Set for usage with directionless fields // so that the current direction is known. if ((fieldResult = (*field)(t_local, yCur, k1)) != avtIVPField::OK ) return ConvertResult(fieldResult); k2 = k1 * 0.5; yNew = yCur + h * k2; if ((fieldResult = (*field)(t_local+0.5*h, yNew, k2)) != avtIVPField::OK) return ConvertResult(fieldResult); k3 = k2 * 0.5; yNew = yCur + h * k3; if ((fieldResult = (*field)(t_local+0.5*h, yNew, k3)) != avtIVPField::OK) return ConvertResult(fieldResult); k4 = k3; yNew = yCur + h * k4; if ((fieldResult = (*field)(t_local+h, yNew, k4)) != avtIVPField::OK) return ConvertResult(fieldResult); // Calculate the new position. vNew = (k1 + 2.0*k2 + 2.0*k3 + k4) / 6.0; yNew = yCur + h * vNew; // Convert and save the position. ivpstep->resize(2); if( convertToCartesian ) { (*ivpstep)[0] = field->ConvertToCartesian( yCur ); (*ivpstep)[1] = field->ConvertToCartesian( yNew ); } else { (*ivpstep)[0] = yCur; (*ivpstep)[1] = yNew; } ivpstep->t0 = t; ivpstep->t1 = t + h; yCur = yNew; vCur = vNew; t = t + h; if( period && last ) t += FLT_EPSILON; // Reset the step size on sucessful step. h = h_max; return (last ? avtIVPSolver::TERMINATE : avtIVPSolver::OK); }
/** * @brief ユーザー属性照会 * @param [IN] smcal SMCAL * @param [IN/OUT] parm APIパラメータ * @param [IN] srchGuid 取得対象ユーザーID * @param [OUT] userInfo ユーザ属性 * @param [IN] recv センタ受信データ * @param [IN] recvBufSize センタ受信データバッファサイズ * @param [OUT] apiStatus APIステータス * @return 処理結果(E_SC_RESULT) */ E_SC_RESULT CC_UserattrInfo_SendRecv(SMCAL *smcal, const T_CC_CMN_SMS_API_PRM *parm, const Char *srchGuid, SMUSERPROFILE *userInfo, Char *recv, UINT32 recvBufSize, Char *apiStatus, Bool isPolling) { E_SC_RESULT ret = e_SC_RESULT_SUCCESS; E_SC_CAL_RESULT calRet = e_SC_CAL_RESULT_SUCCESS; Char *uri = NULL; Char *data = NULL; Char *body = NULL; UINT32 bodySize = 0; E_CONTEXT_TYPE contextType = E_TEXT_XML; SMCALOPT opt = {}; UINT32 recvSize = 0; const Char *guid = NULL; INT32 status = 0; SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_START); do { // 初期化 if (isPolling) { opt.cancel = SCC_IsCancel_Polling; } else { opt.cancel = SCC_IsCancel; } #ifdef SC_CMN_BASIC_AUTH_SMS // BASIC認証 opt.isBasicAuth = true; strcpy(opt.basic.basicAuthId, SC_CMN_BASIC_AUTH_ID); strcpy(opt.basic.basicAuthPwd, SC_CMN_BASIC_AUTH_PWD); #endif // メモリ確保 uri = (Char*)SCC_MALLOC(CC_CMN_URI_STR_MAX_LEN); if (NULL == uri) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC() error, " HERE); ret = e_SC_RESULT_MALLOC_ERR; break; } data = (Char*)SCC_MALLOC(CC_USERATTR_INFO_SEND_BODY_SIZE); if (NULL == data) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC error, " HERE); ret = CC_CMN_RESULT_MALLOC_ERR; break; } // URI生成 if ((NULL != srchGuid) && (EOS != *srchGuid)) { guid = srchGuid; } else { guid = parm->ApiPrmMups.guid; } CC_UserattrInfo_CreateUri(parm, guid, uri); // body生成 CC_UserattrInfo_CreateBody(parm, guid, data); // HTTPデータ送受信 // calRet = SC_CAL_GetRequest(smcal, uri, recv, recvBufSize, &recvSize, &opt); calRet = SC_CAL_PostRequest(smcal, uri, data, strlen(data), recv, recvBufSize, &recvSize, &opt); if(e_SC_CAL_RESULT_SUCCESS != calRet){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_PostRequest error, " HERE); ret = ConvertResult(calRet); break; } // HTTPデータ解析 calRet = SC_CAL_AnalyzeResponseStatus(smcal, recv, recvSize, (const Char**)&body, &bodySize, &contextType, &status); if(e_SC_CAL_RESULT_SUCCESS != calRet){ if (CC_CMN_SERVER_STOP == status) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"server stop..., " HERE); ret = e_SC_RESULT_SERVER_STOP; } else { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_AnalyzeResponseStatus error, " HERE); ret = ConvertResult(calRet); } break; } // レスポンス解析 ret = CC_UserattrInfo_AnalyzeHttpResp(body, contextType, userInfo, &opt, apiStatus); if(e_SC_RESULT_SUCCESS != ret){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"CC_UserattrInfo_AnalyzeHttpResp error, " HERE); break; } } while (0); SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_END); return (ret); }
/** * @brief パーソナルお知らせ情報取得 * @param [IN] smcal SMCAL * @param [IN] parm APIパラメータ * @param [IN] offset 取得データの開始位置 * @param [IN] limit 最大取得件数 * @param [IN] msgStatus ステータス * @param [IN] personalInfo パーソナルお知らせ情報 * @param [IN] personalInfoNum パーソナルお知らせ情報数 * @param [IN] recv センタ受信データ * @param [OUT] apiStatus APIステータス * @return 処理結果(E_SC_RESULT) */ E_SC_RESULT CC_MessageInbox_SendRecv(SMCAL *smcal, const T_CC_CMN_SMS_API_PRM *parm, INT32 offset, INT32 limit, INT32 msgStatus, SMPERSONALINFO *personalInfo, INT32 *personalInfoNum, Char *personalNum, Char *recv, INT32 recvBufSize, Char *apiStatus) { E_SC_RESULT ret = e_SC_RESULT_SUCCESS; E_SC_CAL_RESULT calRet = e_SC_CAL_RESULT_SUCCESS; Char *uri = NULL; Char *body = NULL; UINT32 bodySize = 0; E_CONTEXT_TYPE contextType = E_TEXT_XML; SMCALOPT opt = {}; UINT32 recvSize = 0; Char *data = NULL; INT32 status = 0; SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_START); do { // 初期化 opt.isResOutputFile = true; opt.cancel = SCC_IsCancel; CC_GetTempDirPath(opt.resFilePath); strcat(opt.resFilePath, CC_PERSONALINFO_RES_FILE); #ifdef SC_CMN_BASIC_AUTH_SMS // BASIC認証 opt.isBasicAuth = true; strcpy(opt.basic.basicAuthId, SC_CMN_BASIC_AUTH_ID); strcpy(opt.basic.basicAuthPwd, SC_CMN_BASIC_AUTH_PWD); #endif *apiStatus = EOS; // メモリ確保 uri = (Char*)SCC_MALLOC(CC_CMN_URI_STR_MAX_LEN); if (NULL == uri) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC error " HERE); ret = e_SC_RESULT_MALLOC_ERR; break; } data = (Char*)SCC_MALLOC(CC_PERSONALINFO_SEND_BODY_SIZE); if (NULL == data) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC error " HERE); ret = e_SC_RESULT_MALLOC_ERR; break; } // URI生成 CC_MessageInbox_CreateUri(parm, uri); // body生成 CC_MessageInbox_CreateBody(parm, offset, limit, msgStatus, data); // HTTPデータ送受信 calRet = SC_CAL_PostRequest(smcal, uri, data, strlen(data), recv, recvBufSize, &recvSize, &opt); if(e_SC_CAL_RESULT_SUCCESS != calRet){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_PostRequest error, " HERE); ret = ConvertResult(calRet); break; } // HTTPデータ解析 calRet = SC_CAL_AnalyzeResponseStatus(smcal, recv, recvSize, (const Char**)&body, &bodySize, &contextType, &status); if(e_SC_CAL_RESULT_SUCCESS != calRet){ if (CC_CMN_SERVER_STOP == status) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"server stop..., " HERE); ret = e_SC_RESULT_SERVER_STOP; } else { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_AnalyzeResponseStatus error, " HERE); ret = ConvertResult(calRet); } break; } // レスポンス解析 ret = CC_MessageInbox_AnalyzeHttpResp(body, contextType, limit, personalInfo, personalInfoNum, personalNum, &opt, apiStatus); if(e_SC_RESULT_SUCCESS != ret){ SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"CC_MessageInbox_AnalyzeHttpResp error, " HERE); break; } } while (0); // メモリ解放 if (NULL != uri) { SCC_FREE(uri); } if (NULL != data) { SCC_FREE(data); } // XMLファイル削除 remove(opt.resFilePath); SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_END); return (ret); }
/** * Will be called by the parser to load an instrument. */ String LSCPServer::LoadInstrument(String Filename, uint Instrument, uint SamplerChannel) { dmsg(2,("LSCPServer: LoadInstrument(Filename=%s,Instrument=%d,SamplerChannel=%d)\n", Filename.c_str(), Instrument, SamplerChannel)); result_t res = pEngine->LoadInstrument(Filename.c_str(), Instrument); return ConvertResult(res); }
/** * @brief マッピングに評価をつける * @param [IN] smcal SMCAL * @param [IN] parm APIパラメータ * @param [OUT] mappingId マッピングID * @param [IN] ratingOwn 本人評価値 * @param [OUT] rating 評価値 * @param [IN] recv センタ受信データ * @param [OUT] apiStatus APIステータス * @return 処理結果(E_SC_RESULT) */ E_SC_RESULT CC_MappingRateReg_SendRecv(SMCAL *smcal, const T_CC_CMN_SMS_API_PRM *parm, const Char *mappingId, INT32 ratingOwn, Char *rating, Char *recv, INT32 recvBufSize, Char *apiStatus) { E_SC_RESULT ret = e_SC_RESULT_SUCCESS; E_SC_CAL_RESULT calRet = e_SC_CAL_RESULT_SUCCESS; Char *uri = NULL; Char *body = NULL; UINT32 bodySize = 0; E_CONTEXT_TYPE contextType = E_TEXT_XML; SMCALOPT opt = {}; UINT32 recvSize = 0; Char *data = NULL; INT32 status = 0; SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_START); do { // 初期化 *apiStatus = EOS; opt.cancel = SCC_IsCancel; #ifdef SC_CMN_BASIC_AUTH_SMS // BASIC認証 opt.isBasicAuth = true; strcpy(opt.basic.basicAuthId, SC_CMN_BASIC_AUTH_ID); strcpy(opt.basic.basicAuthPwd, SC_CMN_BASIC_AUTH_PWD); #endif // メモリ確保 uri = (Char*)SCC_MALLOC(CC_CMN_URI_STR_MAX_LEN); if (NULL == uri) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC error, " HERE); ret = e_SC_RESULT_MALLOC_ERR; break; } data = (Char*)SCC_MALLOC(CC_MAPPINGRATE_REG_SEND_BODY_SIZE); if (NULL == data) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC error, " HERE); ret = e_SC_RESULT_MALLOC_ERR; break; } // URI生成 CC_MappingRateReg_CreateUri(parm, uri); // body生成 CC_MappingRateReg_CreateBody(parm, mappingId, ratingOwn, data); // HTTPデータ送受信 calRet = SC_CAL_PostRequest(smcal, uri, data, strlen(data), recv, recvBufSize, &recvSize, &opt); if (e_SC_CAL_RESULT_SUCCESS != calRet) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_PostRequest error, " HERE); ret = ConvertResult(calRet); break; } // HTTPデータ解析 calRet = SC_CAL_AnalyzeResponseStatus(smcal, recv, recvSize, (const Char**)&body, &bodySize, &contextType, &status); if (e_SC_CAL_RESULT_SUCCESS != calRet) { if (CC_CMN_SERVER_STOP == status) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"server stop..., " HERE); ret = e_SC_RESULT_SERVER_STOP; } else { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SC_CAL_AnalyzeResponse error, " HERE); ret = ConvertResult(calRet); } break; } // レスポンス解析 ret = CC_MappingRateReg_AnalyzeHttpResp(body, contextType, rating, &opt, apiStatus); if (e_SC_RESULT_SUCCESS != ret) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"CC_MappingRateReg_AnalyzeHttpResp error, " HERE); break; } } while (0); // メモリ解放 if (NULL != uri) { SCC_FREE(uri); } if (NULL != data) { SCC_FREE(data); } SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_END); return (ret); }
bool FWebJSScripting::HandleExecuteUObjectMethodMessage(CefRefPtr<CefListValue> MessageArguments) { FGuid ObjectKey; // Message arguments are Name, Value, bGlobal if (MessageArguments->GetSize() != 4 || MessageArguments->GetType(0) != VTYPE_STRING || MessageArguments->GetType(1) != VTYPE_STRING || MessageArguments->GetType(2) != VTYPE_STRING || MessageArguments->GetType(3) != VTYPE_LIST ) { // Wrong message argument types or count return false; } if (!FGuid::Parse(FString(MessageArguments->GetString(0).ToWString().c_str()), ObjectKey)) { // Invalid GUID return false; } // Get the promise callback and use that to report any results from executing this function. FGuid ResultCallbackId; if (!FGuid::Parse(FString(MessageArguments->GetString(2).ToWString().c_str()), ResultCallbackId)) { // Invalid GUID return false; } UObject* Object = GuidToPtr(ObjectKey); if (Object == nullptr) { // Unknown uobject id InvokeJSErrorResult(ResultCallbackId, TEXT("Unknown UObject ID")); return true; } FName MethodName = MessageArguments->GetString(1).ToWString().c_str(); UFunction* Function = Object->FindFunction(MethodName); if (!Function) { InvokeJSErrorResult(ResultCallbackId, TEXT("Unknown UObject Function")); return true; } // Coerce arguments to function arguments. uint16 ParamsSize = Function->ParmsSize; TArray<uint8> Params; UProperty* ReturnParam = nullptr; // Convert cef argument list to a dictionary, so we can use FStructDeserializer to convert it for us CefRefPtr<CefDictionaryValue> NamedArgs = CefDictionaryValue::Create(); { int32 CurrentArg = 0; CefRefPtr<CefListValue> CefArgs = MessageArguments->GetList(3); for ( TFieldIterator<UProperty> It(Function); It; ++It ) { UProperty* Param = *It; if (Param->PropertyFlags & CPF_Parm) { if (Param->PropertyFlags & CPF_ReturnParm) { ReturnParam = Param; } else { CopyContainerValue(NamedArgs, CefArgs, CefString(*Param->GetName()), CurrentArg); CurrentArg++; } } } if (ParamsSize > 0) { // UFunction is a subclass of UStruct, so we can treat the arguments as a struct for deserialization UStruct* TypeInfo = Cast<UStruct>(Function); Params.AddUninitialized(ParamsSize); TypeInfo->InitializeStruct(Params.GetData()); FWebJSStructDeserializerBackend Backend = FWebJSStructDeserializerBackend(SharedThis(this), NamedArgs); FStructDeserializer::Deserialize(Params.GetData(), *TypeInfo, Backend); } } Object->ProcessEvent(Function, Params.GetData()); if ( ReturnParam ) { FWebJSParam Results[1] = {ConvertResult(ReturnParam, Params.GetData())}; InvokeJSFunction(ResultCallbackId, 1, Results, false); } else { InvokeJSFunction(ResultCallbackId, 0, nullptr, false); } return true; }
avtIVPSolver::Result avtIVPAdamsBashforth::Step(avtIVPField* field, double t_max, avtIVPStep* ivpstep) { const double direction = sign( 1.0, t_max - t ); h = sign( h, direction ); bool last = false; // do not run past integration end if( (t + 1.01*h - t_max) * direction > 0.0 ) { last = true; h = t_max - t; } // stepsize underflow? if( 0.1*std::abs(h) <= std::abs(t)*epsilon ) return avtIVPSolver::STEPSIZE_UNDERFLOW; avtIVPSolver::Result res; avtIVPField::Result fieldResult; avtVector yNew = yCur; // Use a fourth-order Runga Kutta integration to seed the Adams-Bashforth. if( numStep < ADAMS_BASHFORTH_NSTEPS ) { // Save the first vector values in the history. if( numStep == 0 ) { if ((fieldResult = (*field)(t, yCur, history[0])) != avtIVPField::OK) return ConvertResult(fieldResult); } res = RK4Step( field, yNew ); } else res = ABStep( field, yNew ); if (res == OK) { ivpstep->resize(2); if( convertToCartesian ) { (*ivpstep)[0] = field->ConvertToCartesian( yCur ); (*ivpstep)[1] = field->ConvertToCartesian( yNew ); } else { (*ivpstep)[0] = yCur; (*ivpstep)[1] = yNew; } ivpstep->t0 = t; ivpstep->t1 = t + h; numStep++; // Update the history to save the last 5 vector values. history[4] = history[3]; history[3] = history[2]; history[2] = history[1]; history[1] = history[0]; if ((fieldResult = (*field)(t, yNew, history[0])) != avtIVPField::OK) return ConvertResult(fieldResult); yCur = yNew; t = t+h; if( last ) res = avtIVPSolver::TERMINATE; // Reset the step size on sucessful step. h = h_max; } return res; }
avtIVPSolver::Result avtIVPRK4::Step(avtIVPField* field, double t_max, avtIVPStep* ivpstep) { const double direction = sign( 1.0, t_max - t ); h = sign( h, direction ); bool last = false; // do not run past integration end if( (t + 1.01*h - t_max) * direction > 0.0 ) { last = true; h = t_max - t; } // stepsize underflow? if( 0.1*std::abs(h) <= std::abs(t)*epsilon ) return avtIVPSolver::STEPSIZE_UNDERFLOW; //avtIVPSolver::Result res = avtIVPSolverResult::OK; avtIVPField::Result fieldResult; avtVector k1; if ((fieldResult = (*field)(t, y, k1)) != avtIVPField::OK ) return ConvertResult(fieldResult); avtVector k2; if ((fieldResult = (*field)(t+0.5*h, y+0.5*h*k1, k2)) != avtIVPField::OK) return ConvertResult(fieldResult); avtVector k3; if ((fieldResult = (*field)(t+0.5*h, y+0.5*h*k2, k3)) != avtIVPField::OK) return ConvertResult(fieldResult); avtVector k4; if ((fieldResult = (*field)(t+h, y+h*k3, k4)) != avtIVPField::OK) return ConvertResult(fieldResult); avtVector ynew = y + h*(k1 + 2.0*k2 + 2.0*k3 + k4)/6.0; ivpstep->resize(2); if( convertToCartesian ) { (*ivpstep)[0] = field->ConvertToCartesian( y ); (*ivpstep)[1] = field->ConvertToCartesian( ynew ); } else { (*ivpstep)[0] = y; (*ivpstep)[1] = ynew; } ivpstep->t0 = t; ivpstep->t1 = t + h; numStep++; y = ynew; t = t+h; // Reset the step size on sucessful step. h = h_max; return (last ? avtIVPSolver::TERMINATE : avtIVPSolver::OK); }