Example #1
0
bool changenth(std::string &str, int n, const char *with, bool insert = false, bool nonzero = false)
{
    std::string::size_type s, e;
    if (!findnth(str, n, s, e))
        return false;

    if (nonzero && str.substr(s, e-s) == "0")
        return true;                                        // not an error
    if (!insert)
        str.replace(s, e-s, with);
    else
        str.insert(s, with);

    return true;
}
// This is used by several of the FileIO and /dev/fs functions
std::string HLE_IPC_BuildFilename(std::string path_wii)
{
	std::string path_full = File::GetUserPath(D_SESSION_WIIROOT_IDX);

	// Replaces chars that FAT32 can't support with strings defined in /sys/replace
	for (auto& replacement : replacements)
	{
		for (size_t j = 0; (j = path_wii.find(replacement.first, j)) != path_wii.npos; ++j)
			path_wii.replace(j, 1, replacement.second);
	}

	path_full += path_wii;

	return path_full;
}
Example #3
0
File: tools.cpp Project: Berze/sour
bool replaceString(std::string& text, const std::string& key, const std::string& value)
{
	if(text.find(key) == std::string::npos)
		return false;

	std::string::size_type start = 0, pos = 0;
	while((start = text.find(key, pos)) != std::string::npos)
	{
		text.replace(start, key.size(), value);
		//text = text.substr(0, start) + value + text.substr(start + key.size());
		pos = start + value.size();
	}

	return true;
}
Example #4
0
void findandreplace( std::string& tInput, std::string tFind, std::string tReplace ) { 
	size_t uPos = 0; 
	size_t uFindLen = tFind.length(); 
	size_t uReplaceLen = tReplace.length();
		
	if( uFindLen == 0 ){
		return;
	}

	for( ;(uPos = tInput.find( tFind, uPos )) != std::string::npos; ){
		tInput.replace( uPos, uFindLen, tReplace );
		uPos += uReplaceLen;
	}	
	
}
Example #5
0
bool replaceString(std::string& text, const std::string key, const std::string value)
{
	std::string::size_type start = text.find(key);
	if(start == std::string::npos) //skip if there's no key in text
		return false;

	std::string::size_type pos = 0;
	for(; start != std::string::npos; start = text.find(key, pos))
	{
		text.replace(start, key.size(), value);
		pos = start + key.size();
	}

	return true;
}
Example #6
0
BOOL URLParser::Replace(std::string& strSource, std::string& strToFind, std::string& ptrToReplace)
{
    BOOL bRetVal = FALSE;
    while(TRUE)
    {
        int iPos = strSource.find(strToFind, 0);
        if(std::string::npos == iPos)
        {
            break;
        }
        strSource.replace(iPos, strToFind.length(), ptrToReplace);
        bRetVal = TRUE;
    }
    return bRetVal;
}
Example #7
0
// This is used by several of the FileIO and /dev/fs functions
std::string HLE_IPC_BuildFilename(std::string path_wii, int _size)
{
	std::string path_full = File::GetUserPath(D_WIIROOT_IDX);

	// Replaces chars that FAT32 can't support with strings defined in /sys/replace
	for (auto i = replacements.begin(); i != replacements.end(); ++i)
	{
		for (size_t j = 0; (j = path_wii.find(i->first, j)) != path_wii.npos; ++j)
			path_wii.replace(j, 1, i->second);
	}

	path_full += path_wii;

	return path_full;
}
Example #8
0
std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest)
{
  size_t pos = 0;

  if (src == dest)
    return result;

  while ((pos = result.find(src, pos)) != std::string::npos)
  {
    result.replace(pos, src.size(), dest);
    pos += dest.length();
  }

  return result;
}
static void replaceDefines(const std::string& compileTimeDefines, std::string& out)
{
    // Replace semicolons with '#define ... \n'
    if (compileTimeDefines.size() > 0)
    {
        size_t pos;
        out = compileTimeDefines;
        out.insert(0, "#define ");
        while ((pos = out.find(';')) != std::string::npos)
        {
            out.replace(pos, 1, "\n#define ");
        }
        out += "\n";
    }
}
Example #10
0
// static
void CMIRIAMResourceObject::unescapeId(std::string & id)
{
  // We have to convert all %[0-9a-fA-F][0-9a-fA-F] character sequences to utf8 characters.
  std::string::size_type pos;

  for (pos = 0; pos < id.length(); pos++)
    if (id[pos] == '%' &&
        id.find_first_not_of("0123456789abcdefABCDEF", pos + 1) > pos + 2)
      {
        char ascii[2];
        ascii[0] = (unsigned char) strtol(id.substr(pos + 1 , 2).c_str(), NULL, 16);
        ascii[1] = 0x0;
        id.replace(pos, 3, CCopasiXMLInterface::utf8(ascii));
      }
}
Example #11
0
std::size_t StringExtend::ReplaceAll (std::string& source, const std::string& prototype, const std::string& copy)
{
	if(prototype.empty()) {
        return 0;
    }

    std::size_t startpos = 0, counter = 0;
    while((startpos = source.find(prototype, startpos)) != std::string::npos) {
        source.replace(startpos, prototype.length(), copy);
        startpos += copy.length();
        counter ++;
    }

    return counter;
}
Example #12
0
File: main.cpp Project: CCJY/coliru
//actual filtering
void FilterBadWords(std::string& s)
{
    //preconstruct our array, we love speed gain by paying startup time
    static auto const& Mapping_CP852 = [] {
        std::cout << "PRECONSTRUCT: " << __PRETTY_FUNCTION__ << "\n";

        static uint8_t mappings[0x100];
        for(unsigned i = 0; i < sizeof(mappings); ++i)
            mappings[i] = static_cast<uint8_t>(i); 

        mappings[0x88 /* ł */] = 'l';
        mappings[0xa5 /* ą */] = 'a';
        mappings[0xa9 /* ę */] = 'e';
        mappings[0x86 /* ć */] = 'c';
        mappings[0xbe /* ż */] = 'z';
        mappings[0xab /* ź */] = 'z';
        mappings[0xa2 /* ó */] = 'o';
        mappings[0x98 /* ś */] = 's';
        mappings[0xe4 /* ń */] = 'n';
        mappings[0x9d /* Ł */] = 'L';
        mappings[0xa4 /* Ą */] = 'A';
        mappings[0xa8 /* Ę */] = 'E';
        mappings[0x8f /* Ć */] = 'C';
        mappings[0xbd /* Ż */] = 'Z';
        mappings[0x8d /* Ź */] = 'Z';
        mappings[0xe0 /* Ó */] = 'O';
        mappings[0x97 /* Ś */] = 'S';
        mappings[0xe3 /* Ń */] = 'N';

        return mappings;
    }();

    std::string sc(s); // bit redundant work here
    for (auto& character : sc) character = Mapping_CP852[(uint8_t)character];

    for (auto &badword : badwords) {
        size_t pos = sc.find(badword);
        size_t size = badword.size();

        while (pos != std::string::npos)
        {
            s.replace ( s.begin() + pos,  s.begin() + pos + size, "*");
            sc.replace(sc.begin() + pos, sc.begin() + pos + size, "*");

            pos = sc.find(badword);
        }
    }
}
bool FixPathCase(std::string& basePath, std::string &path, FixPathCaseBehavior behavior)
{
	size_t len = path.size();

	if (len == 0)
		return true;

	if (path[len - 1] == '/')
	{
		len--;

		if (len == 0)
			return true;
	}

	std::string fullPath;
	fullPath.reserve(basePath.size() + len + 1);
	fullPath.append(basePath); 

	size_t start = 0;
	while (start < len)
	{
		size_t i = path.find('/', start);
		if (i == std::string::npos)
			i = len;

		if (i > start)
		{
			std::string component = path.substr(start, i - start);

			// Fix case and stop on nonexistant path component
			if (FixFilenameCase(fullPath, component) == false) {
				// Still counts as success if partial matches allowed or if this
				// is the last component and only the ones before it are required
				return (behavior == FPC_PARTIAL_ALLOWED || (behavior == FPC_PATH_MUST_EXIST && i >= len));
			}

			path.replace(start, i - start, component);

			fullPath.append(component);
			fullPath.append(1, '/');
		}

		start = i + 1;
	}

	return true;
}
Example #14
0
std::string AptCacheFile::debParser(std::string descr)
{
    // Policy page on package descriptions
    // http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Description
    unsigned int i;
    string::size_type nlpos=0;

    nlpos = descr.find('\n');
    // delete first line
    if (nlpos != string::npos) {
        descr.erase(0, nlpos + 2);        // del "\n " too
    }

    // avoid replacing '\n' for a ' ' after a '.\n' is found
    bool removedFullStop = false;
    while (nlpos < descr.length()) {
        // find the new line position
        nlpos = descr.find('\n', nlpos);
        if (nlpos == string::npos) {
            // if it could not find the new line
            // get out of the loop
            break;
        }

        i = nlpos;
        // erase the char after '\n' which is always " "
        descr.erase(++i, 1);

        // remove lines likes this: " .", making it a \n
        if (descr[i] == '.') {
            descr.erase(i, 1);
            nlpos = i;
            // don't permit the next round to replace a '\n' to a ' '
            removedFullStop = true;
            continue;
        } else if (descr[i] != ' ' && removedFullStop == false) {
            // it's not a line to be verbatim displayed
            // So it's a paragraph let's replace '\n' with a ' '
            // replace new line with " "
            descr.replace(nlpos, 1, " ");
        }

        removedFullStop = false;
        nlpos++;
    }

    return descr;
}
Example #15
0
void escapeXMLChars(std::string &s)
{
  std::string bad = "<>&";
  const char *replace[] =
  {
    "&lt;", "&gt;", "&amp;"
  };
  for (unsigned i = 0; i < s.size(); i++)
    {
      unsigned n = bad.find(s[i]);
      if (n != std::string::npos)
        {
          s.replace(i, 1, replace[n]);
        }
    }
}
Example #16
0
 static void replaceAll(std::string& str,
                        const std::string& from,
                        const std::string& to)
 {
   size_t start_pos = 0;
   while((start_pos = str.find(from, start_pos)) != std::string::npos)
   {
     //size_t end_pos = start_pos + from.length();
     while((start_pos = str.find(from, start_pos)) != std::string::npos)
     {
       str.replace(start_pos, from.length(), to);
       start_pos += to.length();
     }
     start_pos += to.length();
   }
 }
Example #17
0
NS_LEMON_FILESYSTEM_BEGIN

static void replace(std::string& str, const char* from, const char* to)
{
    unsigned size = strlen(from);
    if( size == 0 )
        return;

    unsigned size_to = strlen(to);
    size_t start_pos = 0;
    while( (start_pos = str.find(from, start_pos)) != std::string::npos )
    {
        str.replace(start_pos, size, to);
        start_pos += size_to;
    }
}
Example #18
0
std::string
StringUtils::replace(std::string str, const char* what,
                     const char* by) {
    const std::string what_tmp(what);
    const std::string by_tmp(by);
    size_t idx = str.find(what);
    const size_t what_len = what_tmp.length();
    if (what_len > 0) {
        const size_t by_len = by_tmp.length();
        while (idx != std::string::npos) {
            str = str.replace(idx, what_len, by);
            idx = str.find(what, idx + by_len);
        }
    }
    return str;
}
  /*!
   * @if jp
   * @brief 文字列を置き換える
   * @else
   * @brief Replace string
   * @endif
   */
  unsigned int replaceString(std::string& str, const std::string from,
                     const std::string to)
  {
    std::string::size_type pos(0);
    unsigned int cnt(0);

    while (pos != std::string::npos)
      {
        pos = str.find(from, pos);
        if (pos == std::string::npos) break;
        str.replace(pos, from.size(), to);
        pos += to.size();
        ++cnt;
      }
    return cnt;
  }
Example #20
0
//============================================================================
// FUNCTION : SPELLutils::replace
//============================================================================
void SPELLutils::replace( std::string& str, std::string original, std::string newstr )
{
    std::string::size_type pos;
    while(true)
    {
        pos = str.find(original);
        if (pos != std::string::npos)
        {
            str.replace(pos, original.size(), newstr.c_str());
        }
        else
        {
            break;
        }
    }
}
Example #21
0
	// 字符串替换
	int kbe_replace(std::string& str,  const std::string& pattern,  const std::string& newpat) 
	{ 
		int count = 0; 
		const size_t nsize = newpat.size(); 
		const size_t psize = pattern.size(); 

		for(size_t pos = str.find(pattern, 0);  
			pos != std::string::npos; 
			pos = str.find(pattern,pos + nsize)) 
		{ 
			str.replace(pos, psize, newpat); 
			count++; 
		} 

		return count; 
	}
Example #22
0
// adjusts a POSIX path to system-specific conventions
// -> changes '/' to DIR_DELIM
// -> absolute paths start with "C:\\" on windows
std::string p(std::string path)
{
	for (size_t i = 0; i < path.size(); ++i) {
		if (path[i] == '/') {
			path.replace(i, 1, DIR_DELIM);
			i += std::string(DIR_DELIM).size() - 1; // generally a no-op
		}
	}

	#ifdef _WIN32
	if (path[0] == '\\')
		path = "C:" + path;
	#endif

	return path;
}
bool ChangeTokNth(std::string& str, uint32 n, char const* with, bool insert = false, bool allowZero = false)
{
    std::string::size_type s = 0, e = 0;
    if (!FindTokNth(str, n, s, e))
        return false;

    if (allowZero && str.substr(s, e - s) == "0")
        return true;                                        // not an error

    if (!insert)
        str.replace(s, e-s, with);
    else
        str.insert(s, with);

    return true;
}
Example #24
0
std::string string_replace_first_instance( std::string src, std::string const& target, std::string const& repl){
	// handle error situations/trivial cases

	if (target.length() == 0 || src.length() == 0) {
		return src;
	}

	size_t idx = 0;

		idx = src.find( target, idx);

		src.replace( idx, target.length(), repl);
		idx += repl.length();

	return src;
}
Example #25
0
std::string ReplaceString(std::string subject, const std::string& search, const std::string& replace, int & counter) {
  // http://stackoverflow.com/questions/4643512/replace-substring-with-another-substring-c

  if( subject.find_first_not_of(" \t") != -1 && subject.at( subject.find_first_not_of(" \t") ) == '#' ){
      return subject;
    }
  else{
      size_t pos = 0;
      while((pos = subject.find(search, pos)) != std::string::npos) {
          subject.replace(pos, search.length(), replace);
          counter++;
          pos += replace.length();
        }
      return subject;
    }
}
static void ReplaceInString(std::string& str, const std::string& what,
                            const std::string& replacement)
{
    size_t lst = 0;
    size_t l1 = what.size();
    size_t l2 = replacement.size();
    if (l1 == 0 && l2 == 0)
        return;                 // Nothing to do
    do {
        size_t t = str.find(what, lst);
        if(t == std::string::npos)
            return;
        str.replace(t, l1, replacement);
        t += l2;
    } while(true);
}
Example #27
0
// ------------------------------------------------------------------------------------------------
void XFileParser::ParseDataObjectTextureFilename( std::string& pName)
{
    readHeadOfDataObject();
    GetNextTokenAsString( pName);
    CheckForClosingBrace();

    // FIX: some files (e.g. AnimationTest.x) have "" as texture file name
    if (!pName.length())
    {
        DefaultLogger::get()->warn("Length of texture file name is zero. Skipping this texture.");
    }

    // some exporters write double backslash paths out. We simply replace them if we find them
    while ( pName.find( "\\\\") != std::string::npos)
        pName.replace( pName.find( "\\\\"), 2, "\\");
}
Example #28
0
void
escape(std::string &str)
{
  std::map<char, std::string> escapes;
  escapes['\a'] = "\\a";
  escapes['\b'] = "\\b";
  escapes['\f'] = "\\f";
  escapes['\n'] = "\\n";
  escapes['\t'] = "\\t";
  escapes['\v'] = "\\v";
  escapes['\r'] = "\\r";

  for (std::map<char, std::string>::iterator it = escapes.begin(); it != escapes.end(); ++it)
    for (size_t pos=0; (pos=str.find(it->first, pos)) != std::string::npos; pos+=it->second.size())
      str.replace(pos, 1, it->second);
}
Example #29
0
/** Remplace the newline characters by a space
  *
  * It is used to strip newline characters in strings comming from the
  * admin site.
  *
  * \param s The string to modify
  *
  * \return The modified string
  *
  */
std::string RainbruRPG::Core::StringConv::
xmlStripNewLine(std::string s){
  int i=0;
  char c=13;
  std::string search(1, c);
  do {
    i=s.find(search, i);

    if (i!=-1){
      s.replace(i, 1, " ");
    }	
	
  } while (i!=-1);

  return s;
}
  std::string simplify_white_space( std::string str ) 
  { 
      char const* separator = " \t\r\n";

      std::string::size_type pos = str.find_first_not_of(separator);
      str.erase(0,pos);

      pos = str.find_last_not_of(separator); 
      str.erase(pos+1);

      pos = 0;
      while( ( pos = str.find( "  ", pos ) ) != std::string::npos ) 
          str.replace( pos, 2, " " );

      return str;
  }