HTTPServerRequestImpl::HTTPServerRequestImpl(HTTPServerResponse& response, HTTPServerSession& session, HTTPServerParams* pParams): _response(response), _pStream(0), _pParams(pParams) { poco_check_ptr (_pParams); _pParams->duplicate(); HTTPHeaderInputStream hs(session); read(hs); // Now that we know socket is still connected, obtain addresses _clientAddress = session.clientAddress(); _serverAddress = session.serverAddress(); if (getChunkedTransferEncoding()) _pStream = new HTTPChunkedInputStream(session); else if (getContentLength() != HTTPMessage::UNKNOWN_CONTENT_LENGTH) _pStream = new HTTPFixedLengthInputStream(session, getContentLength()); else if (getMethod() == HTTPRequest::HTTP_GET || getMethod() == HTTPRequest::HTTP_HEAD) _pStream = new HTTPFixedLengthInputStream(session, 0); else _pStream = new HTTPInputStream(session); }
bool onekeyShare(int platformId, CCDictionary *content, C2DXShareResultEvent callback) { JniMethodInfo mi; if (platformId > 0) { bool isHave = getMethod(mi, "onekeyShare", "(ILjava/lang/String;)V"); if (!isHave) { return false; } } else { bool isHave = getMethod(mi, "onekeyShare", "(Ljava/lang/String;)V"); if (!isHave) { return false; } } CCJSONConverter* json = CCJSONConverter::sharedConverter(); const char* ccContent = json->strFrom(content); jstring jContent = mi.env->NewStringUTF(ccContent); // free(ccContent); if (platformId > 0) { mi.env->CallStaticVoidMethod(mi.classID, mi.methodID, platformId, jContent); } else { mi.env->CallStaticVoidMethod(mi.classID, mi.methodID, jContent); } releaseMethod(mi); shareCb = callback; return true; }
/** * @brief Parse socket data. * @param [in] s The socket from which to retrieve data. */ void HttpParser::parse(Socket s) { std::string line; line = s.readToDelim(lineTerminator); parseRequestLine(line); line = s.readToDelim(lineTerminator); while(!line.empty()) { m_headers.insert(parseHeader(line)); line = s.readToDelim(lineTerminator); } // Only PUT and POST requests have a body if (getMethod() != "POST" && getMethod() != "PUT") { return; } // We have now parsed up to and including the separator ... we are now at the point where we // want to read the body. There are two stories here. The first is that we know the exact length // of the body or we read until we can't read anymore. if (hasHeader(HttpRequest::HTTP_HEADER_CONTENT_LENGTH)) { std::string val = getHeader(HttpRequest::HTTP_HEADER_CONTENT_LENGTH); int length = std::atoi(val.c_str()); uint8_t data[length]; s.receive_cpp(data, length, true); m_body = std::string((char *)data, length); } else { uint8_t data[512]; int rc = s.receive_cpp(data, sizeof(data)); m_body = std::string((char *)data, rc); } ESP_LOGD(LOG_TAG, "Size of body: %d", m_body.length()); } // parse
void dynpm(GtkWidget *widget, gpointer data){ char **cards = getCards((char*) DEFAULT_DRM_DIR); if (cards == NULL) { g_printerr("Card list is empty.\n"); return; } int idx = 0; while (cards[idx] != NULL) { g_print("Found card: %s\n", cards[idx]); if (canModifyPM()) { g_print("Setting dynpm\n"); setMethod(cards[idx], DYNPM); g_print("method = %d\n", getMethod(cards[idx])); if (getMethod(cards[idx]) != METHOD_UNKNOWN) { g_print("profile = %d\n", getProfile(cards[idx])); } } else { g_print("Insufficient permission to modify PM method\n"); } idx++; } freeCards(cards); }
RunnerStatus DynamicResult::deduceStatus(oRunner &runner) const { if (getMethod(MDeduceRStatus)) return toStatus(getMethod(MDeduceRStatus)->evaluate(parser)); else if (getMethodSource(MDeduceRStatus).empty()) return GeneralResult::deduceStatus(runner); else throw meosException("Syntax error"); }
int DynamicResult::deduceTime(oRunner &runner, int startTime) const { if (getMethod(MDeduceRTime)) return getMethod(MDeduceRTime)->evaluate(parser); else if (getMethodSource(MDeduceRTime).empty()) return GeneralResult::deduceTime(runner, startTime); else throw meosException("Syntax error"); }
int DynamicResult::deducePoints(oTeam &team) const { if (getMethod(MDeduceTPoints)) return getMethod(MDeduceTPoints)->evaluate(parser); else if (getMethodSource(MDeduceTPoints).empty()) return GeneralResult::deducePoints(team); else throw meosException("Syntax error"); }
void Reporter::processEnd() { mFirst = true; if(getMethod(mType) == COUT) { std::cout << std::endl; } else if(getMethod(mType) == LOG) { // Not implemented yet } }
bool TdeinterlaceSettings::getTip(unsigned int pageId, char_t *tipS, size_t len) { if (getMethod(cfgId).id != DSCALER) { tsnprintf_s(tipS, len, _TRUNCATE, _l("Method: %s"), getMethod(cfgId).name); return true; } else { return false; } }
int DynamicResult::score(oRunner &runner, RunnerStatus st, int time, int points) const { if (getMethod(MRScore)) { parser.addSymbol("ComputedTime", time); parser.addSymbol("ComputedStatus", st); parser.addSymbol("ComputedPoints", points); return getMethod(MRScore)->evaluate(parser); } else if (getMethodSource(MRScore).empty()) return GeneralResult::score(runner, st, time, points); else throw meosException("Syntax error"); }
void Actions::loadJTextField(){ ui->comboBox->clear(); ui->comboBox->addItem("onEnter"); ui->comboBox->addItem("onEditText"); // добавить другие варианты здесь emit getMethod(0); }
bool WPaintedWidget::createPainter() { if (painter_) return false; if (preferredMethod_ == PngImage) { painter_ = new WWidgetRasterPainter(this); return true; } const WEnvironment& env = WApplication::instance()->environment(); /* * For IE < 9: no choice. Use VML */ if (env.agentIsIElt(9)) { painter_ = new WWidgetVectorPainter(this, WWidgetPainter::InlineVml); return true; } /* Otherwise, combined preferred method with actual capabilities */ Method method = getMethod(); if (method == InlineSvgVml) painter_ = new WWidgetVectorPainter(this, WWidgetPainter::InlineSvg); else if (method == PngImage) painter_ = new WWidgetRasterPainter(this); else painter_ = new WWidgetCanvasPainter(this); return true; }
void ListFilter::columnChanged(bool doFilter) { if(column.IsWindow() && method.IsWindow()) { auto n = method.GetCount(); size_t col = getColumn(); for (int i = StringMatch::METHOD_LAST; i < n; ++i) { method.DeleteString(StringMatch::METHOD_LAST); } if (getMethod() == -1) { method.SetCurSel(StringMatch::PARTIAL); } if (col >= colCount || columns[col]->isNumericType()) { method.AddString(_T("=")); method.AddString(_T(">=")); method.AddString(_T("<=")); method.AddString(_T(">")); method.AddString(_T("<")); method.AddString(_T("!=")); } if (doFilter) textUpdated(true); usingTypedMethod = false; } }
int solveLinearSystemByIterativeMethods(double** A, double* b, double* x, int n, string methodStr, double abs_eps = 1.0E-12, double rel_eps = 1.0E-15, long max_iter_num = 10000000) { int method = getMethod(methodStr); int iterCount = 0; switch(method) { case Jacobi: iterCount = solveByJacobi(A, b, x, n); break; case GaussSeidel: iterCount = solveByGaussSeidel(A, b, x, n); break; case ConjugateGradient: iterCount = solveByConjugateGradient(A, b, x, n); break; case PCG: iterCount = solveByPreconditionedConjugateGradient(A, b, x, n); break; case FFT: break; case MultiGrid: break; } return iterCount; }
void Actions::loadJTextArea(){ ui->comboBox->clear(); ui->comboBox->addItem("onKeyPress"); // добавить другие варианты здесь emit getMethod(0); }
void FeiyuSdkHelper::doQuitRole(const char* serverId, const char* serverName, const char* roleId, const char* roleLv, const char* roleName, const char* uid, const char* nickName, const char* extStr) { JniMethodInfo mi; const char* signature = "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"; bool isHave = getMethod(mi, "doQuitRole", signature); if (isHave) { jstring serverId_content = mi.env->NewStringUTF(serverId); jstring serverName_content = mi.env->NewStringUTF(serverName); jstring roleId_content = mi.env->NewStringUTF(roleId); jstring roleLv_content = mi.env->NewStringUTF(roleLv); jstring roleName_content = mi.env->NewStringUTF(roleName); jstring uid_content = mi.env->NewStringUTF(uid); jstring nickName_content = mi.env->NewStringUTF(nickName); jstring extStr_content = mi.env->NewStringUTF(extStr); mi.env->CallStaticVoidMethod(mi.classID, mi.methodID, serverId_content, serverName_content, roleId_content, roleLv_content, roleName_content, uid_content, nickName_content, extStr_content); mi.env->DeleteLocalRef(extStr_content); mi.env->DeleteLocalRef(roleId_content); mi.env->DeleteLocalRef(roleLv_content); mi.env->DeleteLocalRef(roleName_content); mi.env->DeleteLocalRef(serverId_content); mi.env->DeleteLocalRef(serverName_content); mi.env->DeleteLocalRef(nickName_content); mi.env->DeleteLocalRef(uid_content); releaseMethod(mi); } }
bool ShareRec::getLocalVideoPath(jlong videoId, char** path){ jobject javaRecorder = getRecorder(); if (javaRecorder != NULL) { JniMethodInfo mi; bool res = getMethod(mi, "getLocalVideoPath", "(J)Ljava/lang/String;"); if (res) { jstring jpath = (jstring) mi.env->CallObjectMethod(javaRecorder, mi.methodID, videoId); releaseMethod(mi); if (jpath != NULL) { const char* cpath = mi.env->GetStringUTFChars(jpath, JNI_FALSE); int len = mi.env->GetStringUTFLength(jpath); char* tmp = (char*) malloc(sizeof(char) * len); for (int i = 0; i < len; i++) { tmp[i] = cpath[i]; } path[0] = tmp; mi.env->ReleaseStringUTFChars(jpath, cpath); return true; } } } return false; }
void Actions::loadJComboBox(){ ui->comboBox->clear(); ui->comboBox->addItem("onSelectItem"); // добавить другие варианты здесь emit getMethod(0); }
void HttpMessageHandler::handle(struct ns_connection *nc, struct http_message *hm) { std::string requestMethod = getMethod(hm); if (requestMethod.compare("GET") == 0) { handleGet(nc, hm); }else if (requestMethod.compare("OPTIONS") == 0) { sendOptions(nc); } }
ReturnType ProvidedServicePort::callService(std::string &name, std::string &invalue, std::string &outvalue) { Method *p = getMethod(name); if (p == NULL) return OPROS_UNSUPPORTED_METHOD; return p->call(invalue, outvalue); }
Method* rvmGetMethod(Env* env, Class* clazz, const char* name, const char* desc) { Method* method = getMethod(env, clazz, name, desc); if (rvmExceptionCheck(env)) return NULL; if (!method) { rvmThrowNoSuchMethodError(env, name); return NULL; } return method; }
JavaMethod *JNIKit::getMethod(string declaredIn, string methodName, string desc) { // Resolve class and resolve method in succession JavaClass *declaringClass = getClass(declaredIn); if (!declaringClass) throw JNIError("could not resolve class from string"); return getMethod(declaringClass, methodName, desc); }
void TdeinterlaceSettings::createFilters(size_t filtersorder, Tfilters *filters, TfilterQueue &queue) const { idffOnChange(idffs, filters, queue.temporary); if (is && show) { if (!queue.temporary) { setOnChange(IDFF_deinterlaceMethod, filters, &Tfilters::onQueueChange); } queueFilter<TimgFilterDeinterlace>(filtersorder, filters, queue); switch (getMethod(cfgId).id) { case BYPASS: break; case TOMSMOCOMP_DEINT_FILTER: queueFilter<TimgFilterTomsMoComp>(filtersorder, filters, queue); return; case DGBOB_DEINT_FILTER: queueFilter<TimgFilterDGbob>(filtersorder, filters, queue); return; case FRAMERATEDOUBLER: queueFilter<TimgFilterFramerateDoubler>(filtersorder, filters, queue); return; case DSCALER: queueFilter<TimgFilterDScalerDI>(filtersorder, filters, queue); return; case KERNELDEINT: queueFilter<TimgFilterKernelDeint2>(filtersorder, filters, queue); return; case KERNELBOB: queueFilter<TimgFilterKernelBob>(filtersorder, filters, queue); return; case YADIF: queueFilter<TimgFilterYadif>(filtersorder, filters, queue); return; default: queueFilter<TimgFilterAvcodecDeinterlace>(filtersorder, filters, queue); return; //mplayer deinterlacers } } if (getMethod(cfgId).id != YADIF || !is || !show) { // Inform yadif filter that it is no longer in the filter queue. // FIXME create more generic function that call Tfilter::onRemoveFromFilterQueue. TimgFilterYadif *imgFilterYadif = filters->getFilter<TimgFilterYadif>(); imgFilterYadif->done(); } }
/** * Return paramter value for the given name. If returned string is empty, it means that the parameter was not present. * If the returned string is SSOAgentRequest::EMPTY_PARAM, it means that the parameter is present, without a value. */ string SSOAgentRequest::getParameter(string pName) { if (params.empty()) { string qryStr = this->getQueryString(); if (!qryStr.empty()) { // Read and parse query string into parameters. parseQueryString(qryStr); } else if (!strcmp(getMethod().c_str(), "POST")) { // Read and parse request body into parametsers. DWORD bodySz = this->getBodySize(); if (bodySz > 0) { LPBYTE body = this->getBody(); jk_log(logger, JK_LOG_DEBUG, "POST Request has a body, type=[%s] size=%d", getContentType().c_str(), bodySz); parsePostData(body, bodySz, this->getContentType()); } else { jk_log(logger, JK_LOG_DEBUG, "POST Request has no body"); } } else { jk_log(logger, JK_LOG_TRACE, "GET Request has no parameters, method [%s]", getMethod().c_str()); } // Just for debugging purposes map<string, string>::iterator i; for (i = params.begin() ; i != params.end() ; i++) { pair <string, string> p = *i; jk_log(logger, JK_LOG_DEBUG, "Populating request with param %s=[%s]", p.first.c_str(), p.second.c_str()); } } map<string, string>::const_iterator params_it; params_it = params.find(pName); // Did we find the parameter ?! if (params_it == params.end()) { return SSOAgentRequest::EMPTY_STR; } else { return params_it->second; } }
unsigned int dtor(int) { C *c = (C *) this; C &cRef = *c; auto vt = VirtualTable<C, baseclasses...>::getVTable(cRef); unsigned int index = VTUtils::getDestructorOffset<C>(); void *dtorPtr = vt.getMethod(index); void(*method)(C *) = union_cast<void (*)(C *)>(dtorPtr); method(c); return 0; }
void FeiyuSdkHelper::doLogin() { JniMethodInfo mi; bool isHave = getMethod(mi, "doLogin", "()V"); if (isHave) { mi.env->CallStaticVoidMethod(mi.classID, mi.methodID); releaseMethod(mi); } }
void FeiyuSdkHelper::showExitGameDialog() { JniMethodInfo mi; bool isHave = getMethod(mi, "showExitGameDialog", "()V"); if (isHave) { mi.env->CallStaticVoidMethod(mi.classID, mi.methodID); releaseMethod(mi); } }
void Transport::debuggerInfo(InfoVec &info) { Add(info, "Thread Type", getThreadTypeName()); Add(info, "URL", getCommand()); Add(info, "HTTP", getHTTPVersion()); Add(info, "Method", getMethodName()); if (getMethod() == Method::POST) { int size; getPostData(size); Add(info, "Post Data", FormatSize(size)); } }
void FeiyuSdkHelper::doSetting(bool bOpen) { JniMethodInfo mi; bool isHave = getMethod(mi, "doSetting", "(Z)V"); if (isHave) { mi.env->CallStaticVoidMethod(mi.classID, mi.methodID, bOpen); releaseMethod(mi); } }
void ShareRec::stopRecorder() { jobject javaRecorder = getRecorder(); if (javaRecorder != NULL) { JniMethodInfo mi; bool res = getMethod(mi, "stop", "()V"); if (res) { mi.env->CallVoidMethod(javaRecorder, mi.methodID); releaseMethod(mi); } } }