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