int main(int argc, char* argv[]) { std::string user, pwd, url, path; int port; if (!checkParams(argc, argv, user, pwd, url, port, path)) { std::cerr << "Program run with incorrect arguments!" << std::endl; return 1; } Client client; if (!client.init(url, port, user, pwd)) { std::cerr << "Failed to initialize the client." << std::endl; return 1; } std::string list; if (!client.list(path, list)) { std::cerr << "Failed to receive list of files." << std::endl; return 1; } std::cout << list << std::endl; return 0; }
void SearchController::resultsAction() { checkParams({"id"}); const int id = params()["id"].toInt(); int limit = params()["limit"].toInt(); int offset = params()["offset"].toInt(); const auto searchHandlers = sessionManager()->session()->getData<SearchHandlerDict>(SEARCH_HANDLERS); if (!searchHandlers.contains(id)) throw APIError(APIErrorType::NotFound); const SearchHandlerPtr searchHandler = searchHandlers[id]; const QList<SearchResult> searchResults = searchHandler->results(); const int size = searchResults.size(); if (offset > size) throw APIError(APIErrorType::Conflict, tr("Offset is out of range")); // normalize values if (offset < 0) offset = size + offset; if (offset < 0) // check again throw APIError(APIErrorType::Conflict, tr("Offset is out of range")); if (limit <= 0) limit = -1; if ((limit > 0) || (offset > 0)) setResult(getResults(searchResults.mid(offset, limit), searchHandler->isActive(), size)); else setResult(getResults(searchResults, searchHandler->isActive(), size)); }
bool check(const php::Func& f) { assert(checkParams(f)); assert(checkName(f.name)); for (DEBUG_ONLY auto& block : f.blocks) assert(checkBlock(*block)); /* * Some of these relationships may change as async/await * implementation progresses. Asserting them now so they are * revisited here if they aren't true anymore. */ if (f.isClosureBody) assert(!f.top); if (f.isPairGenerator) assert(f.isGenerator); if (f.isClosureBody) { assert(f.cls && f.cls->parentName && f.cls->parentName->isame(s_Closure.get())); } boost::dynamic_bitset<> seenId(f.nextBlockId); for (auto& block : f.blocks) { assert(checkBlock(*block)); // All blocks have unique ids in a given function; not necessarily // consecutive. assert(block->id < f.nextBlockId); assert(!seenId.test(block->id)); seenId.set(block->id); } assert(checkExnTree(f)); return true; }
Picdok::Picdok(QWidget *parent) : QMainWindow(parent), ui(new Ui::Picdok) // Set up form. { WaitPtr(true); ui->setupUi(this); showPic = 0; inParams = new QStringList(QApplication::arguments()); curDir = ""; curDirHdg = new QLabel; curDirLabel = new QLabel; curDirNum = new QLabel; img = new QImage; imgDisp = new QImage; pixmDisp = new QPixmap; matx = new QTransform; settings = new QSettings(QDir::homePath() + QDir::separator() + SETTINGS_FILE, QSettings::IniFormat, this); // Check command line parameter and use supplied directory if valid, else use saved settings,or current directory if none. readSettings(checkParams(inParams)); noAutomove = false; setupStatusBar(); // Connect the context menu signals from lblPic to the required slots here. connect(ui->lblPic, SIGNAL(pdlSigDesel()), this, SLOT(doDeselect())); connect(ui->lblPic, SIGNAL(pdlSigDel()), this, SLOT(doDelete())); connect(ui->lblPic, SIGNAL(pdlSigRen()), this, SLOT(doPicRename())); connect(ui->lblPic, SIGNAL(pdlSigMov()), this, SLOT(doPicMove())); desk = QApplication::desktop(); setFocusOnCommentIfEmpty(); WaitPtr(false); }
void SearchController::installPluginAction() { checkParams({"sources"}); const QStringList sources = params()["sources"].split('|'); for (const QString &source : sources) SearchPluginManager::instance()->installPlugin(source); }
void SearchController::uninstallPluginAction() { checkParams({"names"}); const QStringList names = params()["names"].split('|'); for (const QString &name : names) SearchPluginManager::instance()->uninstallPlugin(name.trimmed()); }
double ExpectedValueFitness::evaluateFitness(map<string, vector3> _pos, map<string, double> _dblAcc, map<string, long> _intAcc){ if(!checkParams(_pos, _dblAcc, _intAcc)) return 0; if(_dblAcc["LowerBound"] > _dblAcc["Value"]) return (_dblAcc["LowerBound"] - _dblAcc["Value"]) * _dblAcc["EVWeight"]; else if(_dblAcc["Value"] > _dblAcc["UpperBound"]) return (_dblAcc["Value"] - _dblAcc["UpperBound"]) * _dblAcc["EVWeight"]; else return 0; }
int GEI_Unit_InactiveTime (GEI_Unit unit){ int ret = isInitialized("GEI_Unit_InactiveTime"); if (ret == 0){ LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_InactiveTime", &u); if (ret == 0) ret = u->second.inactiveTime; } return ret; }
float GEI_Unit_GetHealth (GEI_Unit unit){ int ret = isInitialized("GEI_Unit_GetHealth"); if (ret == 0){ LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_GetHealth", &u); if (ret == 0) return u->second.health; } return ret; }
void SearchController::enablePluginAction() { checkParams({"names", "enable"}); const QStringList names = params()["names"].split('|'); const bool enable = Utils::String::parseBool(params()["enable"].trimmed(), false); for (const QString &name : names) SearchPluginManager::instance()->enablePlugin(name.trimmed(), enable); }
int GEI_Unit_GetGroup (GEI_Unit unit){ int ret = isInitialized("GEI_Unit_GetGroup"); if (ret == 0){ LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_GetGroup", &u); if (ret == 0) ret = u->second.group; } return ret; }
int GEI_Unit_GetType (GEI_Unit unit){ int ret = isInitialized("GEI_Unit_GetType"); if (ret == 0){ // récupération de l'unité LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_GetType", &u); if (ret == 0) ret = u->second.type; } return ret; }
GEI_Coalition GEI_Unit_GetCoalition (GEI_Unit unit){ int ret = isInitialized("GEI_Unit_GetCoalition"); if (ret == 0){ // récupération de l'unité LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_GetCoalition", &u); if (ret == 0) ret = u->second.coalition; } return (GEI_Coalition)ret; }
bool Monitor::sendParamsToWorker(RoboCompCommonBehavior::ParameterList params) { if(checkParams(params)) { //Set params to worker if(worker->setParams(params) == true) return true; } rError("Incorrect parameters"); return false; }
int GEI_Unit_Stop (GEI_Unit unit){ int ret = isInitialized("GEI_Unit_Stop"); if (ret == 0){ LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_Stop", &u, true); if (ret == 0){ std::vector<float> bidon; // seulement pour passer un paramètre addCommand(unit, CMD_STOP, bidon); } } return ret; }
GEI_Pos GEI_StartPosition (){ GEI_Pos tmp; // vérification de l'initialisation int ret = checkParams("GEI_StartPosition"); if (ret == 0) return ld.startPosition; else{ tmp.x = ret; tmp.y = ret; } return tmp; }
GEI_Pos GEI_MapSize (){ GEI_Pos tmp; // vérification de l'initialisation int ret = checkParams("GEI_MapSize"); if (ret == 0) return ld.mapSize; else{ tmp.x = ret; tmp.y = ret; } return tmp; }
double expoTreeSIRSurvival(int parVecLen, double* K, double* beta, double* mu, double* psi, double rho, vector<double>& times, vector<int>& ttypes, int extant, int est_norm, int vflag, int rescale, int nroot) { double fx = -INFINITY; if (! checkParams(parVecLen,K,beta,mu,psi,rho,nroot)) { if (vflag > 0) { fprintf(stderr,"Ilegal parameters. Returning inf.\n"); fprintf(stderr,"N = %g, beta = %g, mu = %g, psi = %g, rho = %g\n", K[0],beta[0],mu[0],psi[0],rho); } return -INFINITY; } double* maxK = max_element(K,K+parVecLen); int maxN = ceil(*maxK); int dim = sir_index_N(0,maxN,maxN)+1; vector<double> p0(dim,0.0); double t0 = 0.0; double scale = 0.0; int ki = 0; int nt = times.size(); int Ncur = (int) ceil(K[0]); p0[0] = 1.0; /* probability that the tree went extinct before the present */ for (int R(0); R <= Ncur; ++R) { for (int I(0); I <= Ncur-R; ++I) { int i = sir_index_N(I,R,maxN); p0[i] = (rho > 0.0) ? pow(1.-rho,I) : 1.0; } } int info = 0; sir_expotree(K,&ki,beta,mu,psi,&nt,&parVecLen, times.data(),ttypes.data(),p0.data(), &t0,&info,&est_norm,&vflag,&rescale); if (info > 0) { int m = sir_index_N(1,0,maxN); fx = 1.0 - exp(p0[m] + scale); if (vflag > 0) fprintf(stderr,"ln(p(1,t)) = %20.12e\n",fx); } else { if (vflag > 0) fprintf(stderr,"rExpoTree returned %d!\n",info); return -INFINITY; } return (fx > 0) ? log(fx) : -INFINITY; }
//---------------------------------------------------------------------------- Guido2ImageErrorCodes Guido2Image::gmnFileToImage ( const char * gmnFileName, const char * imageFileName , Guido2ImageImageFormat imageFormat, int pageIndex, const QSize& outputSizeConstraint, float zoom, char * errorMsgBuffer, int bufferSize ) { Guido2ImageErrorCodes errorCode = checkParams( true, gmnFileName, imageFileName, imageFormat, pageIndex, outputSizeConstraint, zoom, errorMsgBuffer, bufferSize ); if ( errorCode != GUIDO_2_IMAGE_SUCCESS ) return errorCode; QGuidoPainter * painter = buildPainterFromGMNFile(gmnFileName); if ( !painter ) return GUIDO_2_IMAGE_GUIDO_ENGINE_NOT_STARTED; return guidoPainterToImage(painter,imageFileName,imageFormat,pageIndex,outputSizeConstraint,zoom,errorMsgBuffer, bufferSize); }
void LazyGraph::loadIndexed(bool loadSubgraphs) { assert(fileReader != 0); int nodeCount; int curveCount; int areaCount; int subgraphCount; long int offset; nParamsNodes = fileReader->read<int>(); nParamsCurves = fileReader->read<int>(); nParamsAreas = fileReader->read<int>(); nParamsCurveExtremities = fileReader->read<int>(); nParamsCurvePoints = fileReader->read<int>(); nParamsAreaCurves = fileReader->read<int>(); nParamsSubgraphs = fileReader->read<int>(); checkParams(nParamsNodes, nParamsCurves, nParamsAreas, nParamsCurveExtremities, nParamsCurvePoints, nParamsAreaCurves, nParamsSubgraphs); offset = fileReader->read<long int>(); fileReader->seekg(offset, ios::beg); nodeCount = fileReader->read<int>(); curveCount = fileReader->read<int>(); areaCount = fileReader->read<int>(); subgraphCount = fileReader->read<int>(); for (int i = 0; i < nodeCount; i++) { NodeId nid = nextNodeId; nextNodeId.id++; offset = fileReader->read<long int>(); nodeOffsets.insert(make_pair(nid, offset)); } for (int i = 0; i < curveCount; i++) { CurveId cid = nextCurveId; nextCurveId.id++; offset = fileReader->read<long int>(); curveOffsets.insert(make_pair(cid, offset)); } for (int i = 0; i < areaCount; i++) { AreaId aid = nextAreaId; nextAreaId.id++; offset = fileReader->read<long int>(); areaOffsets.insert(make_pair(aid, offset)); } for (int i = 0; i < subgraphCount; i++) { AreaId aid; aid.id = fileReader->read<int>(); offset = fileReader->read<long int>(); subgraphOffsets.insert(make_pair(aid, offset)); } }
void dspCheckRegister::sPrint() { if(!checkParams()) return; ParameterList params; params.append("bankaccnt_id", _bankaccnt->id()); _dates->appendValue(params); params.append("print"); rptCheckRegister newdlg(this, "", TRUE); newdlg.set(params); }
void dspARApplications::sPrint() { if (!checkParams()) return; ParameterList params; setParams(params); orReport report("ARApplications", params); if (report.isValid()) report.print(); else report.reportError(this); }
GEI_Unit GEI_GetUnitAt (int index, GEI_Coalition c){ int ret = checkParams("GEI_GetUnitAt", NULL, false, (int*)&c); if (ret == 0){ try{ // retourne directement la donnée. Si l'index n'est pas bon, une // exeption sera levée ret = ld.coalitions[c]->at(index); } catch (std::out_of_range e) { std::cerr << "GEI_GetUnitAt : index out of range" << std::endl; ret = -7; } } return ret; }
int GEI_Unit_ActionOnUnit (int unit, int action, int target){ int ret = isInitialized("GEI_Unit_ActionOnUnit"); if (ret == 0){ LocalMapUnits::iterator u = ld.units->find(unit); LocalMapUnits::iterator t = ld.units->find(target); ret = checkParams("GEI_Unit_ActionOnUnit", &u, true, NULL, &t); if (ret == 0){ // enregistrer la commande std::vector<float> params (1, 0); params[0] = target; addCommand(unit, action, params); } } return ret; }
bool procMainArg(MainParam* params, int argc, char* argv[]) { int argp = 1, ret = 1; while(ret != 0 && argp < argc){ ret = getMainParam(params, argc, argv, argp); argp += ret; } if(argp < argc || !checkParams(params)){ //zostali nespracovatelne argumenty alebo parametre boli nekorektne fprintf(stderr, "%s", ECODEMSG[ECLWRONG]); return false; } else return true; }
GEI_Pos GEI_Unit_GetPosition (GEI_Unit unit){ GEI_Pos tmp; int ret = isInitialized("GEI_Unit_GetPosition"); if (ret == 0){ // vérification de l'initialisation LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_GetPosition", &u); if (ret == 0) tmp = u->second.pos; else{ tmp.x = ret; tmp.y = ret; } } return tmp; }
void IPXMenic::filterIPXPackets() { vector<unsigned char> actualPacket; int i; for (i = 0; i < packets.size(); i++) { actualPacket = packets[i]; if ((actualPacket[14] == 0xFF) && (actualPacket[15] == 0xFF) && checkParams(actualPacket)) { changeIPXPacket(&actualPacket); filtered->push_back(actualPacket); } } }
int GEI_Unit_ActionOnPosition (int unit, int action, float x, float y){ int ret = isInitialized("GEI_Unit_ActionOnPosition"); if (ret == 0){ LocalMapUnits::iterator u = ld.units->find(unit); ret = checkParams("GEI_Unit_ActionOnPosition", &u, true); if (ret == 0){ // enregistrer la commande std::vector<float> params (3, 0); params[0] = x; params[1] = -1; // ce champs est rempli lors de l'éxécution de la // commande (càd coté moteur du jeu) params[2] = y; addCommand(unit, action, params); } } return ret; }
void SearchController::startAction() { checkParams({"pattern", "category", "plugins"}); if (!Utils::ForeignApps::pythonInfo().isValid()) throw APIError(APIErrorType::Conflict, "Python must be installed to use the Search Engine."); const QString pattern = params()["pattern"].trimmed(); const QString category = params()["category"].trimmed(); const QStringList plugins = params()["plugins"].split('|'); QStringList pluginsToUse; if (plugins.size() == 1) { const QString pluginsLower = plugins[0].toLower(); if (pluginsLower == "all") pluginsToUse = SearchPluginManager::instance()->allPlugins(); else if ((pluginsLower == "enabled") || (pluginsLower == "multi")) pluginsToUse = SearchPluginManager::instance()->enabledPlugins(); else pluginsToUse << plugins; } else { pluginsToUse << plugins; } ISession *const session = sessionManager()->session(); auto activeSearches = session->getData<QSet<int>>(ACTIVE_SEARCHES); if (activeSearches.size() >= MAX_CONCURRENT_SEARCHES) throw APIError(APIErrorType::Conflict, QString("Unable to create more than %1 concurrent searches.").arg(MAX_CONCURRENT_SEARCHES)); const auto id = generateSearchId(); const SearchHandlerPtr searchHandler {SearchPluginManager::instance()->startSearch(pattern, category, pluginsToUse)}; QObject::connect(searchHandler.data(), &SearchHandler::searchFinished, this, [session, id, this]() { searchFinished(session, id); }); QObject::connect(searchHandler.data(), &SearchHandler::searchFailed, this, [session, id, this]() { searchFailed(session, id); }); auto searchHandlers = session->getData<SearchHandlerDict>(SEARCH_HANDLERS); searchHandlers.insert(id, searchHandler); session->setData(SEARCH_HANDLERS, QVariant::fromValue(searchHandlers)); activeSearches.insert(id); session->setData(ACTIVE_SEARCHES, QVariant::fromValue(activeSearches)); const QJsonObject result = {{"id", id}}; setResult(result); }
void TCP_UDPMenic::filterUDPPackets() { vector<unsigned char> actualPacket; int i; for (i = 0; i < packets.size(); i++) { actualPacket = packets[i]; if ((actualPacket[23] == 0x11) && checkParams(actualPacket)) { changeUDPPacket(&actualPacket); calculateChecksumTCP_UDP(&actualPacket, "UDP"); calculateChecksumIPv4(&actualPacket); filtered->push_back(actualPacket); } } }