void ModificationDefinitionsSet::setModifications(const StringList & fixed_modifications, const StringList & variable_modifications) { fixed_mods_.clear(); variable_mods_.clear(); if (!fixed_modifications.empty()) { for (StringList::const_iterator it = fixed_modifications.begin(); it != fixed_modifications.end(); ++it) { ModificationDefinition def; def.setModification(*it); def.setFixedModification(true); fixed_mods_.insert(def); } } if (!variable_modifications.empty()) { for (StringList::const_iterator it = variable_modifications.begin(); it != variable_modifications.end(); ++it) { ModificationDefinition def; def.setModification(*it); def.setFixedModification(false); variable_mods_.insert(def); } } }
// Attempts to instance a decorator into a given list. bool ElementDefinition::InstanceDecorator(const String& name, const String& type, const PropertyDictionary& properties, const StringList& pseudo_classes) { Decorator* decorator = Factory::InstanceDecorator(type, properties); if (decorator == NULL) { Log::Message(Log::LT_WARNING, "Failed to instance decorator '%s' of type '%s'.", name.CString(), type.CString()); return false; } if (pseudo_classes.empty()) { if (decorator != NULL) decorators[name] = decorator; } else { PseudoClassDecoratorMap::iterator i = pseudo_class_decorators.find(pseudo_classes); if (i == pseudo_class_decorators.end()) { DecoratorMap decorators; decorators[name] = decorator; pseudo_class_decorators[pseudo_classes] = decorators; } else (*i).second[name] = decorator; } return true; }
/// set the file path to the primary MS run (usually the mzML file obtained after data conversion from raw files) void FeatureMap::setPrimaryMSRunPath(const StringList& s) { if (!s.empty()) { this->setMetaValue("spectra_data", DataValue(s)); } }
api_return ShareApi::handleFindDupePaths(ApiRequest& aRequest) { const auto& reqJson = aRequest.getRequestBody(); json ret; StringList paths; auto path = JsonUtil::getOptionalField<string>("path", reqJson, false, false); if (path) { paths = ShareManager::getInstance()->getDirPaths(Util::toNmdcFile(*path)); } else { auto tth = Deserializer::deserializeTTH(reqJson); paths = ShareManager::getInstance()->getRealPaths(tth); } if (!paths.empty()) { for (const auto& p : paths) { ret.push_back(p); } } else { ret = json::array(); } aRequest.setResponseBody(ret); return websocketpp::http::status_code::ok; }
bool AdcCommand::getParam(const char* name, size_t start, StringList& ret) const { for(string::size_type i = start; i < getParameters().size(); ++i) { if(toCode(name) == toCode(getParameters()[i].c_str())) { ret.push_back(getParameters()[i].substr(2)); } } return !ret.empty(); }
void WenboxPlugin::switchCurrentAudioDeviceToWenbox() { Config & config = ConfigManager::getInstance().getCurrentConfig(); //Looks for the Wenbox audio device from the list of devices from the OS StringList wenboxAudioDeviceId = getWenboxOutputAudioDeviceId(); if (!wenboxAudioDeviceId.empty()) { //Changes audio settings config.set(Config::WENBOX_AUDIO_OUTPUT_DEVICEID_KEY, wenboxAudioDeviceId); config.set(Config::WENBOX_AUDIO_RINGER_DEVICEID_KEY, wenboxAudioDeviceId); } wenboxAudioDeviceId = getWenboxInputAudioDeviceId(); if (!wenboxAudioDeviceId.empty()) { //Changes audio settings config.set(Config::WENBOX_AUDIO_INPUT_DEVICEID_KEY, wenboxAudioDeviceId); } }
QString WulforUtil::getHubNames(const dcpp::CID &cid){ StringList hubs = ClientManager::getInstance()->getHubNames(cid, ""); if (hubs.empty()) return tr("Offline"); else return _q(Util::toString(hubs)); }
void EntitiesEntity::getChildsStatement(const shared_ptr<IPortalDatabase> &database, const ObjectsTypes &types, const RangeUint32 &range, bool count, bool includeSystem, bool includeInvisible, shared_ptr<DbSqlSelect> &statement) const { OS_LOCK(m_cs); // Nota: qui bisogna specificare sempre la tabella perch dall'esterno la select pu essere messa in join con altre tabelle shared_ptr<DbSqlSelect> select(OS_NEW DbSqlSelect(DBTABLES::SNAPSHOT_OBJECTS_TABLE)); if(count) select->count = true; else select->fields.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::ENTITY, DBTABLES::SNAPSHOT_OBJECTS_TABLE)); database->getPortal()->getSnapshotManager()->ensureChilds(database, getEntityID()); select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::PARENT, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(getEntityID())); // Genera il filtro sui tipi di figli StringList childsTypes; for(ObjectsTypes::const_iterator i = types.begin(); i != types.end(); ++i) { if((*i) != portalObjectTypeUnknown) childsTypes.push_back(Convert::toSQL(static_cast<uint32>(*i))); } // Se stato specificato un filtro sul tipo di figli lo applica if(childsTypes.empty() == false) { select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::TYPE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), childsTypes); } // Includi le sezioni di sistema (virtuali)? // Sono figlie della root, per cui la condizione ha senso solo in quel caso if(getEntityID() == ObjectsSystem::instance()->getRootID()) { if(includeSystem == true) { // Salta la root stessa select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::ENTITY, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(ObjectsSystem::instance()->getRootID()), DbSqlCondition::cfDifferent | DbSqlCondition::cfAnd); } else { // VERYURGENT: Le classi statement non hanno una "not in"... poco male, ma userebbe meglio l'indice. select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::INSERT_DATE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(DateTime::EMPTY), DbSqlCondition::cfDifferent | DbSqlCondition::cfAnd); } } if(includeInvisible == false) select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::VISIBLE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(true)); uint32 size = range.size(); if(size != 0) select->limit.setCount(size); uint32 start = range.start(); if(start != 0) select->limit.setOffset(start); statement = select; }
// Get user channels. void meth::GetUserChannels(LogicalConnections::iterator conn, String &response) { StringList channels = ::GetUserChannels(GetConnectionUserName(conn)); if (!channels.empty()) { response = "[" + implode(channels) + "]"; } else { response = "null"; } }
String AbstractFileManager::joinComponents(const StringList& pathComponents) { if (pathComponents.empty()) return ""; StringStream result; for (unsigned int i = 0; i < pathComponents.size() - 1; i++) result << pathComponents[i] << pathSeparator(); result << pathComponents.back(); return result.str(); }
Program::Pointer ProgramFactory::loadProgram(const std::string& file, ObjectsCache& cache, const StringList& defines) { auto cachedPrograms = cache.findObjects(file); for (Program::Pointer cached : cachedPrograms) { if (cached.valid()) { if (cached->defines().size() == defines.size()) { bool same = true; for (auto& inDefine : defines) { for (auto& cDefine : cached->defines()) { if (inDefine != cDefine) { same = false; break; } if (!same) break; } } if (same) return cached; } } } std::string vertex_shader; std::string geom_shader; std::string frag_shader; StringList sourceFiles = loadProgramSources(file, vertex_shader, geom_shader, frag_shader); if (sourceFiles.empty()) return Program::Pointer::create(renderContext()); std::string workFolder = getFilePath(file); parseSourceCode(ShaderType_Vertex, vertex_shader, defines, workFolder); parseSourceCode(ShaderType_Geometry, geom_shader, defines, workFolder); parseSourceCode(ShaderType_Fragment, frag_shader, defines, workFolder); Program::Pointer program = Program::Pointer::create(renderContext(), vertex_shader, geom_shader, frag_shader, getFileName(file), file, defines); for (auto& s : sourceFiles) program->addOrigin(s); cache.manage(program, _private->loader); return program; }
void Transfer::getParams(const UserConnection& aSource, StringMap& params) { params["userCID"] = aSource.getUser()->getCID().toBase32(); params["userNI"] = Util::toString(ClientManager::getInstance()->getNicks(aSource.getUser()->getCID(), aSource.getHubUrl())); params["userI4"] = aSource.getRemoteIp(); StringList hubNames = ClientManager::getInstance()->getHubNames(aSource.getUser()->getCID(), aSource.getHubUrl()); if(hubNames.empty()) hubNames.push_back(_("Offline")); params["hub"] = Util::toString(hubNames); StringList hubs = ClientManager::getInstance()->getHubs(aSource.getUser()->getCID(), aSource.getHubUrl()); if(hubs.empty()) hubs.push_back(_("Offline")); params["hubURL"] = Util::toString(hubs); params["fileSI"] = Util::toString(getSize()); params["fileSIshort"] = Util::formatBytes(getSize()); params["fileSIactual"] = Util::toString(getActual()); params["fileSIactualshort"] = Util::formatBytes(getActual()); params["speed"] = str(F_("%1%/s") % Util::formatBytes(getAverageSpeed())); params["time"] = Util::formatSeconds((GET_TICK() - getStart()) / 1000); params["fileTR"] = getTTH().toBase32(); }
void herschel::xml::displayStringList(Port<Octet>& port, zstring outerTagName, zstring tagName, const StringList& strlist) { if (!strlist.empty()) displayOpenTag(port, outerTagName); for (StringList::const_iterator it = strlist.begin(); it != strlist.end(); it++) { String str = (*it); displayOpenTag(port, tagName, !K(newline)); herschel::display(port, str); displayCloseTag(port, tagName); } if (!strlist.empty()) displayCloseTag(port, outerTagName); }
ExitCodes main_(int, const char**) override { StringList in = getStringList_("in"); StringList out = getStringList_("out"); bool inplace = getFlag_("i"); // consistency checks if (out.empty() && !inplace) { writeLog_("Cannot write output files, as neither -out nor -i are given. Use either of them, but not both!"); printUsage_(); return ILLEGAL_PARAMETERS; } if (out.size() > 0 && inplace) { writeLog_("Two incompatible arguments given (-out and -i). Use either of them, but not both!"); printUsage_(); return ILLEGAL_PARAMETERS; } if (!inplace && out.size() != in.size()) { writeLog_("Output and input file list length must be equal!"); printUsage_(); return ILLEGAL_PARAMETERS; } // do the conversion! FileHandler fh; for (Size i = 0; i < in.size(); ++i) { FileTypes::Type f_type = fh.getType(in[i]); if (f_type == FileTypes::INI) updateINI(in[i], inplace ? "" : out[i]); else if (f_type == FileTypes::TOPPAS) updateTOPPAS(in[i], inplace ? "" : out[i]); } for (Size i = 0; i < tmp_files_.size(); ++i) { // clean up File::remove(tmp_files_[i]); } if (failed_.size() > 0) { writeLog_("The following INI/TOPPAS files could not be updated:\n " + ListUtils::concatenate(failed_, "\n ")); return INPUT_FILE_CORRUPT; } return EXECUTION_OK; }
StringList AbstractFileManager::resolvePath(const StringList& pathComponents) { StringList cleanComponents; for (unsigned int i = 0; i < pathComponents.size(); i++) { const String& component = pathComponents[i]; if (component != ".") { if (component == ".." && !cleanComponents.empty()) cleanComponents.pop_back(); else cleanComponents.push_back(component); } } return cleanComponents; }
void SearchManager::onRES(const AdcCommand& cmd, const UserPtr& from, const string& remoteIp) { int freeSlots = -1; int64_t size = -1; string file; string tth; string token; for(StringIterC i = cmd.getParameters().begin(); i != cmd.getParameters().end(); ++i) { const string& str = *i; if(str.compare(0, 2, "FN") == 0) { file = Util::toNmdcFile(str.substr(2)); } else if(str.compare(0, 2, "SL") == 0) { freeSlots = Util::toInt(str.substr(2)); } else if(str.compare(0, 2, "SI") == 0) { size = Util::toInt64(str.substr(2)); } else if(str.compare(0, 2, "TR") == 0) { tth = str.substr(2); } else if(str.compare(0, 2, "TO") == 0) { token = str.substr(2); } } if(!file.empty() && freeSlots != -1 && size != -1) { /// @todo get the hub this was sent from, to be passed as a hint? (eg by using the token?) StringList names = ClientManager::getInstance()->getHubNames(from->getCID(), Util::emptyString); string hubName = names.empty() ? _("Offline") : Util::toString(names); StringList hubs = ClientManager::getInstance()->getHubs(from->getCID(), Util::emptyString); string hub = hubs.empty() ? _("Offline") : Util::toString(hubs); SearchResult::Types type = (file[file.length() - 1] == '\\' ? SearchResult::TYPE_DIRECTORY : SearchResult::TYPE_FILE); if(type == SearchResult::TYPE_FILE && tth.empty()) return; /// @todo Something about the slots SearchResultPtr sr(new SearchResult(from, type, 0, freeSlots, size, file, hubName, hub, remoteIp, TTHValue(tth), token)); fire(SearchManagerListener::SR(), sr); } }
void Transfer::getParams(const UserConnection& aSource, StringMap& params) const { params["userCID"] = aSource.getUser()->getCID().toBase32(); params["userNI"] = Util::toString(ClientManager::getInstance()->getNicks(aSource.getUser()->getCID(), aSource.getHubUrl())); params["userI4"] = aSource.getRemoteIp(); StringList hubNames = ClientManager::getInstance()->getHubNames(aSource.getUser()->getCID(), aSource.getHubUrl()); if(hubNames.empty()) hubNames.push_back(STRING(OFFLINE)); params["hub"] = Util::toString(hubNames); StringList hubs = ClientManager::getInstance()->getHubs(aSource.getUser()->getCID(), aSource.getHubUrl()); if(hubs.empty()) hubs.push_back(STRING(OFFLINE)); params["hubURL"] = Util::toString(hubs); params["fileSI"] = Util::toString(getSize()); params["fileSIshort"] = Util::formatBytes(getSize()); params["fileSIchunk"] = Util::toString(getPos()); params["fileSIchunkshort"] = Util::formatBytes(getPos()); params["fileSIactual"] = Util::toString(getActual()); params["fileSIactualshort"] = Util::formatBytes(getActual()); params["speed"] = Util::formatBytes(static_cast<int64_t>(getAverageSpeed())) + "/s"; params["time"] = Text::fromT(Util::formatSeconds((GET_TICK() - getStart()) / 1000)); params["fileTR"] = getTTH().toBase32(); }
int main(int argc, char *argv[]) { StringList excludeGlobalFunctions; StringList luaFiles; std::string globalExcludeFunctionFileName; std::string tocFileName; std::string addonDir; stObfuscatorSetting settings; srand(static_cast<unsigned int>(time(NULL))); parseArguments(argc, argv, tocFileName, addonDir, globalExcludeFunctionFileName, luaFiles, settings); print("Addon dir: %s\n", addonDir.c_str()); print("Work dir: %s\n", getWorkDir()); LuaObfuscator::readAddonGlobalExcludeFunctions(globalExcludeFunctionFileName.c_str(), excludeGlobalFunctions); LuaObfuscator::readAddonTocFile(tocFileName.c_str(), luaFiles); // add absolute path name, if need //validateFileNames(luaFiles, addonDir.c_str()); if (luaFiles.empty()) { printHelp(); printf("\nNo a files for an obfuscating\n"); return -1; } try { LuaObfuscator obfuscator(luaFiles, excludeGlobalFunctions, addonDir); print("create bak file: %d\n", settings.bCreateBakFile); print("create one file: %d\n", settings.bCreateOneFile); print("obfuscate const int: %d\n", settings.ObfuscateConstInt); print("obfuscate const float: %d\n", settings.ObfuscateConstFloat); print("obfuscate const string: %d\n", settings.ObfuscateConstString); print("obfuscate local vars: %d\n", settings.ObfuscateLocalVasAndParam); print("obfuscate global fucntions: %d\n", settings.ObfuscateGlobalFunctionName); obfuscator.obfuscate(settings); } catch (std::exception) { print("ERROR: obfuscator creating fail\n"); } #ifdef _DEBUG getchar(); #endif return 0; }
/** * Note: intended to be used with fsck only */ bool StorageTkEx::getNextContDirID(unsigned hashDirNum, int64_t lastOffset, std::string* outID, int64_t* outNewOffset) { *outID = ""; StringList outIDs; FhgfsOpsErr retVal = getContDirIDsIncremental(hashDirNum, lastOffset, 1, &outIDs, outNewOffset); if ( ( outIDs.empty() ) || ( retVal != FhgfsOpsErr_SUCCESS ) ) return false; else { *outID = outIDs.front(); return true; } }
void SearchManager::onRES(const AdcCommand& cmd, const UserPtr& from, const string& remoteIp) { int freeSlots = -1; int64_t size = -1; string file; string tth; string token; for(auto& str: cmd.getParameters()) { if(str.compare(0, 2, "FN") == 0) { file = Util::toNmdcFile(str.substr(2)); } else if(str.compare(0, 2, "SL") == 0) { freeSlots = Util::toInt(str.substr(2)); } else if(str.compare(0, 2, "SI") == 0) { size = Util::toInt64(str.substr(2)); } else if(str.compare(0, 2, "TR") == 0) { tth = str.substr(2); } else if(str.compare(0, 2, "TO") == 0) { token = str.substr(2); } } if(file.empty() || freeSlots == -1 || size == -1) { return; } auto type = (*(file.end() - 1) == '\\' ? SearchResult::TYPE_DIRECTORY : SearchResult::TYPE_FILE); if(type == SearchResult::TYPE_FILE && tth.empty()) { return; } string hubUrl; // token format: [per-hub unique id] "/" [per-search actual token] (see AdcHub::search) auto slash = token.find('/'); if(slash == string::npos) { return; } { auto uniqueId = Util::toUInt32(token.substr(0, slash)); auto lock = ClientManager::getInstance()->lock(); auto& clients = ClientManager::getInstance()->getClients(); auto i = boost::find_if(clients, [uniqueId](const Client* client) { return client->getUniqueId() == uniqueId; }); if(i == clients.end()) { return; } hubUrl = (*i)->getHubUrl(); } token.erase(0, slash + 1); StringList names = ClientManager::getInstance()->getHubNames(from->getCID()); string hubName = names.empty() ? _("Offline") : Util::toString(names); /// @todo Something about the slots fire(SearchManagerListener::SR(), SearchResultPtr(new SearchResult(HintedUser(from, hubUrl), type, 0, freeSlots, size, file, hubName, remoteIp, TTHValue(tth), token))); }
void MsgHelperRepair::createDefDirInodes(Node* node, StringList* inodeIDs, FsckDirInodeList* createdInodes) { const char* logContext = "MsgHelperRepair (createDefDirInodes)"; StringList failedInodeIDs; bool commRes; char *respBuf = NULL; NetMessage *respMsg = NULL; CreateDefDirInodesMsg createDefDirInodesMsgEx(inodeIDs); commRes = MessagingTk::requestResponse(node, &createDefDirInodesMsgEx, NETMSGTYPE_CreateDefDirInodesResp, &respBuf, &respMsg); if ( commRes ) { CreateDefDirInodesRespMsg* createDefDirInodesRespMsg = (CreateDefDirInodesRespMsg*) respMsg; // parse failed creates createDefDirInodesRespMsg->parseFailedInodeIDs(&failedInodeIDs); // parse created inodes createDefDirInodesRespMsg->parseCreatedInodes(createdInodes); SAFE_FREE(respBuf); SAFE_DELETE(respMsg); } else { SAFE_FREE(respBuf); SAFE_DELETE(respMsg); failedInodeIDs = *inodeIDs; LogContext(logContext).logErr("Communication error occured with node: " + node->getID()); } if (! failedInodeIDs.empty()) { for (StringListIter iter = failedInodeIDs.begin(); iter != failedInodeIDs.end(); iter++) { LogContext(logContext).log(Log_CRITICAL, "Failed to create default directory inode on " "metadata node: " + node->getID() + " entryID: " + *iter); } } }
void ProgramFactory::reloadObject(LoadableObject::Pointer obj, ObjectsCache&) { std::string vertex_shader; std::string geom_shader; std::string frag_shader; StringList sourceFiles = loadProgramSources(obj->origin(), vertex_shader, geom_shader, frag_shader); if (sourceFiles.empty()) return; // TODO: handle defines std::string workFolder = getFilePath(obj->origin()); parseSourceCode(ShaderType_Vertex, vertex_shader, StringList(), workFolder); parseSourceCode(ShaderType_Geometry, geom_shader, StringList(), workFolder); parseSourceCode(ShaderType_Fragment, frag_shader, StringList(), workFolder); Program::Pointer(obj)->buildProgram(vertex_shader, geom_shader, frag_shader); }
String DefParser::typeNames(unsigned int types) { StringList names; if ((types & Integer) != 0) names.push_back("integer number"); if ((types & Decimal) != 0) names.push_back("decimal number"); if ((types & QuotedString) != 0) names.push_back("string"); if ((types & OParenthesis) != 0) names.push_back("opening parenthesis"); if ((types & CParenthesis) != 0) names.push_back("closing parenthesis"); if ((types & OBrace) != 0) names.push_back("opening brace"); if ((types & CBrace) != 0) names.push_back("closing brace"); if ((types & Word) != 0) names.push_back("word"); if ((types & Question) != 0) names.push_back("question mark"); if ((types & ODefinition) != 0) names.push_back("definition start ('/*')"); if ((types & CDefinition) != 0) names.push_back("definition end ('*/')"); if ((types & Semicolon) != 0) names.push_back("semicolon"); if ((types & Newline) != 0) names.push_back("newline"); if ((types & Comma) != 0) names.push_back("comma"); if ((types & Equality) != 0) names.push_back("equality sign"); if (names.empty()) return "unknown token type"; if (names.size() == 1) return names[0]; StringStream str; str << names[0]; for (unsigned int i = 1; i < names.size() - 1; i++) str << ", " << names[i]; str << ", or " << names[names.size() - 1]; return str.str(); }
String sanitizePath(const String &path) { // Standardize slashes to POSIX style String fixedPath = posixPath(path); // Check if path is absolute bool isAbsolute = isAbsolutePath(fixedPath); // Tokenize path StringList pathComponents; std::size_t start = 0; do { std::size_t separator = (std::min)(fixedPath.find('/', start), fixedPath.length()); String token = fixedPath.substr(start, separator - start); if (token.empty() || token == ".") { // a/./b -> a/b and a//b -> a/b } else if (token == "..") { if (pathComponents.empty()) { // ../a -> ../a // /../a -> /a if (!isAbsolute) pathComponents.push_back(token); } else { // ../../a -> ../../a // a/../c -> c if (pathComponents.back() == "..") pathComponents.push_back(token); else pathComponents.pop_back(); } } else { pathComponents.push_back(token); } start = separator + 1; } while (start < path.length()); // Figure out if we need to add a leading slash String prefix; if (strBeginsWith(fixedPath, "/")) prefix = "/"; // Return reassembled path return prefix + joinStrings(pathComponents, "/"); }
// Registers a shorthand property definition. bool PropertySpecification::RegisterShorthand(const String& shorthand_name, const String& property_names, ShorthandType type) { StringList properties; StringUtilities::ExpandString(properties, property_names.ToLower()); if (properties.empty()) return false; String lower_case_name = shorthand_name.ToLower(); // Construct the new shorthand definition and resolve its properties. PropertyShorthandDefinition* property_shorthand = new PropertyShorthandDefinition(); for (size_t i = 0; i < properties.size(); i++) { const PropertyDefinition* property = GetProperty(properties[i]); if (property == NULL) { Log::Message(Log::LT_ERROR, "Shorthand property '%s' was registered with invalid property '%s'.", shorthand_name.CString(), properties[i].CString()); delete property_shorthand; return false; } property_shorthand->properties.push_back(PropertyShorthandDefinition::PropertyDefinitionList::value_type(properties[i], property)); } if (type == AUTO) { if (properties.size() == 4 && properties[0].Find("-top") != String::npos && properties[1].Find("-right") != String::npos && properties[2].Find("-bottom") != String::npos && properties[3].Find("-left") != String::npos) property_shorthand->type = BOX; else property_shorthand->type = FALL_THROUGH; } else property_shorthand->type = type; shorthands[lower_case_name] = property_shorthand; return true; }
String SimpleAutomatonParser::tokenName(const SimpleAutomatonToken::Type typeMask) const { StringList names; if (typeMask | SimpleAutomatonToken::Comma) names.push_back("','"); if (typeMask | SimpleAutomatonToken::Semicolon) names.push_back("';'"); if (typeMask | SimpleAutomatonToken::Identifier) names.push_back("identifier"); for (size_t i = 0; i < 11; ++i) if (typeMask | SimpleAutomatonTokenMappings[i].type) names.push_back("'" + String(SimpleAutomatonTokenMappings[i].str, SimpleAutomatonTokenMappings[i].len) + "'"); if (names.empty()) return "unknown token type"; if (names.size() == 1) return names[0]; return StringUtils::join(names, ", "); }
void DefaultHttpHeader::set(const std::string& name, const StringList& values) { if (values.empty()) { return; } validateHeaderName(name); int h = hash(name); int i = index(h); removeHeader(h, i, name); for (size_t i = 0; i < values.size(); ++i) { if (values[i].empty()) { break; } HttpCodecUtil::validateHeaderValue(values[i]); addHeader(h, i, name, values[i]); } }
Path& Path::normalize() { StringTokenizer tokenizer(_path); tokenizer.onCharset("/"); std::string elem; StringList parts; while(tokenizer.next(elem)) { if(elem == ".." && ! parts.empty()) parts.pop(); else if(elem != ".") parts << elem; } _path = parts.join('/'); return *this; }
ParseV2::ParseV2(const char* file_name) : file_(file_name) { // For each line in the file, read it in and try to make sense of it // based on the indent level and the leading verb. //cout << "TRACE: parsing SSQLS v2 file " << file_name << '.' << endl; string line; bool subdirective; while (file_.read_line(line, subdirective)) { // Skip empty lines if (line.empty()) continue; // Break line up into whitespace-separated tokens StringList tokens; tokenize(tokens, line); if (tokens.empty()) continue; // shouldn't happen // Try to interpret token list Line* line = Line::parse(tokens, subdirective, file_); assert(line != 0); // errors should be signalled with exceptions Include* iline = dynamic_cast<Include*>(line); if (iline) { // Include lines are a special case: we hoist the parsed // lines from the included file up into our line list. lines_.reserve(lines_.size() + (iline->end() - iline->begin())); for (LineListIt it = iline->begin(); it != iline->end(); ++it) { lines_.push_back(*it); } delete iline; } else { // Normal case: add line to our line list lines_.push_back(line); } } }
static void generate(const UnitPtr& un, bool all, bool checksum, bool ns, const vector<string>& includePaths, Output& out) { if(!all) { vector<string> paths = includePaths; for(vector<string>::iterator p = paths.begin(); p != paths.end(); ++p) { *p = fullPath(*p); } StringList includes = un->includeFiles(); if(!includes.empty()) { if(ns) { out << sp; out << nl << "namespace"; out << sb; } for(StringList::const_iterator q = includes.begin(); q != includes.end(); ++q) { string file = changeInclude(*q, paths); out << nl << "require_once '" << file << ".php';"; } if(ns) { out << eb; } } } CodeVisitor codeVisitor(out, ns); un->visit(&codeVisitor, false); if(checksum) { ChecksumMap checksums = createChecksums(un); if(!checksums.empty()) { out << sp; if(ns) { out << "namespace"; // Global namespace. out << sb; } for(ChecksumMap::const_iterator p = checksums.begin(); p != checksums.end(); ++p) { out << nl << "$Ice_sliceChecksums[\"" << p->first << "\"] = \""; ostringstream str; str.flags(ios_base::hex); str.fill('0'); for(vector<unsigned char>::const_iterator q = p->second.begin(); q != p->second.end(); ++q) { str << (int)(*q); } out << str.str() << "\";"; } if(ns) { out << eb; } } } out << nl; // Trailing newline. }