Esempio n. 1
0
std::vector<std::basic_string<T_Char>> split(
                                        const std::basic_string<T_Char>& src,
const std::basic_string<T_Char>& delimit) {
    std::vector<std::basic_string<T_Char>> array;
    typedef typename std::basic_string<T_Char>::size_type size_type;
    typedef typename std::basic_string<T_Char>::const_iterator const_iterator;
    std::basic_string<T_Char> tmp;

    if (src.empty())
        return array;

    if (delimit.empty()) {
        array.reserve(array.size() + src.size());
        for (const_iterator it = src.begin(); it != src.end(); ++it)
            array.push_back(std::basic_string<T_Char>(1, *it));
        return array;
    }

    size_type src_pos = 0;
    while (src.begin() + src_pos != src.end()) {
        size_type fnd_pos = src.find(delimit, src_pos);
        if (fnd_pos == std::basic_string<T_Char>::npos) {
            array.push_back(std::basic_string<T_Char>(src, src_pos));
            break;
        }
        array.push_back(
            std::basic_string<T_Char>(src, src_pos, fnd_pos - src_pos));
        src_pos = fnd_pos + delimit.length();
    }
    return array;
}
    std::vector< std::basic_string< CharType > > str_split( std::basic_string< CharType > const & p_str, std::basic_string< CharType > const & p_delims, uint32_t p_maxSplits, bool p_bKeepVoid )
    {
        typedef std::basic_string< CharType > string_t;
        std::vector< string_t > l_arrayReturn;

        if ( ! p_str.empty() && ! p_delims.empty() && p_maxSplits > 0 )
        {
            l_arrayReturn.reserve( p_maxSplits + 1 );
            std::size_t l_numSplits = 0;
            std::size_t	l_pos = 0;
            std::size_t	l_start = 0;

            do
            {
                l_pos = p_str.find_first_of( p_delims, l_start );

                if ( l_pos == l_start )
                {
                    l_start = l_pos + 1;

                    if ( p_bKeepVoid )
                    {
                        l_arrayReturn.push_back( string_t() );
                    }
                }
                else if ( l_pos == string_t::npos || l_numSplits == p_maxSplits )
                {
                    string_t remnants = p_str.substr( l_start );

                    if ( !remnants.empty() || p_bKeepVoid )
                    {
                        l_arrayReturn.push_back( remnants );
                    }

                    return l_arrayReturn;
                }
                else
                {
                    l_arrayReturn.push_back( p_str.substr( l_start, l_pos - l_start ) );
                    l_start = l_pos + 1;
                }

                //l_start = p_str.find_first_not_of( p_delims, l_start );
                ++ l_numSplits;
            }
            while ( l_pos != string_t::npos );
        }

        return l_arrayReturn;
    }
Error ShellExecute(const std::basic_string<charT, traits, Allocator>& fileName   = std::basic_string<charT, traits, Allocator>(),
                   const std::basic_string<charT, traits, Allocator>& operation  = std::basic_string<charT, traits, Allocator>(),
                   const std::basic_string<charT, traits, Allocator>& parameters = std::basic_string<charT, traits, Allocator>(),
                   const std::basic_string<charT, traits, Allocator>& directory  = std::basic_string<charT, traits, Allocator>(),
                   HWND hwnd = HWND(NULL),
                   show_command showCmd = show_command_normal)
{
    const charT * const file = fileName.c_str();
    const charT * const op     = operation.empty()  ? NULL : operation.c_str();
    const charT * const params = parameters.empty() ? NULL : parameters.c_str();
    const charT * const dir    = directory.empty()  ? NULL : directory.c_str();

    return ShellExecute(hwnd, op, file, params, dir, showCmd);
}
    std::basic_string< char > str_convert< char, wchar_t >( std::basic_string< wchar_t > const & src )
    {
        std::basic_string< char > dst;

        if ( !src.empty() )
        {
            std::unique_lock< std::mutex > lock( g_conversionMutex );
            char * szloc = setlocale( LC_CTYPE, "" );
            size_t size = wcstombs( NULL, src.c_str(), 0 ) + 1;
            char * buffer = NULL;
            {
                auto guard = make_block_guard( [&buffer, &size]()
                {
                    buffer = new char[size + 1];
                }, [&buffer]()
                {
                    delete [] buffer;
                } );

                size = std::min( size, wcstombs( buffer, src.c_str(), size ) );
                setlocale( LC_CTYPE, szloc );
                dst.assign( buffer, buffer + size );
            }
        }

        return dst;
    }
Esempio n. 5
0
void IO::TrimRight(std::basic_string<charType> & str, const char* chars2remove)
{
	if (!str.empty()) {  	//trim the characters in chars2remove from the right
		std::string::size_type pos = 0;
		if (chars2remove != NULL) {
			pos = str.find_last_not_of(chars2remove);

			if (pos != std::string::npos)
				str.erase(pos+1);
			else
				str.erase( str.begin() , str.end() ); // make empty
		}
		else {       		//trim space
			pos = std::string::npos;
			for (int i = str.size()-1; i >= 0; --i) {
				if (!isspace(str[i])) {
					pos = i;
					break;
				}
			}
			if (pos != std::string::npos) {
				if (pos+1 != str.size())
					str.resize(pos+1);
			}
			else {
				str.clear();
			}
		}
	}
}
Esempio n. 6
0
    std::basic_string<Ch> encode_char_entities(const std::basic_string<Ch> &s)
    {
        // Don't do anything for empty strings.
        if(s.empty()) return s;

        typedef typename std::basic_string<Ch> Str;
        Str r;
        // To properly round-trip spaces and not uglify the XML beyond
        // recognition, we have to encode them IF the text contains only spaces.
        Str sp(1, Ch(' '));
        if(s.find_first_not_of(sp) == Str::npos) {
            // The first will suffice.
            r = detail::widen<Ch>("&#32;");
            r += Str(s.size() - 1, Ch(' '));
        } else {
            typename Str::const_iterator end = s.end();
            for (typename Str::const_iterator it = s.begin(); it != end; ++it)
            {
                switch (*it)
                {
                    case Ch('<'): r += detail::widen<Ch>("&lt;"); break;
                    case Ch('>'): r += detail::widen<Ch>("&gt;"); break;
                    case Ch('&'): r += detail::widen<Ch>("&amp;"); break;
                    case Ch('"'): r += detail::widen<Ch>("&quot;"); break;
                    case Ch('\''): r += detail::widen<Ch>("&apos;"); break;
                    default: r += *it; break;
                }
            }
        }
        return r;
    }
Esempio n. 7
0
  std::basic_string<C>
  perl_s (std::basic_string<C> const& src, std::basic_string<C> const& e)
  {
    typedef std::basic_string<C> string;
    typedef typename string::size_type size;

    if (e.empty ())
      return src;

    C delimiter (e[0]);

    size first = e.find (delimiter);
    size middle = e.find (delimiter, first + 1);
    size last = e.find (delimiter, middle + 1);

    string pattern (e, first + 1, middle - first - 1);
    string format (e, middle + 1, last - middle - 1);

    //std::cout << pattern << "  " << format << std::endl;

    boost::basic_regex<C> expr (pattern);

    return regex_merge (
      src,
      expr,
      format,
      boost::match_default | boost::format_all );
  }
const std::basic_string<charT>& nan_text() {
    static std::basic_string<charT> r;
    if (r.empty()) {
        std::basic_ostringstream<charT> out;
        out << "#NaN#";
        r = out.str();
    }
    return r;
}
Esempio n. 9
0
 cstr(const std::basic_string<char_type, CharTraits, Allocator>& s)
 {
     if (s.empty()) {
         clear();
     } else {
         buf_ = s.c_str();
         size_ = s.size();
     }
 }
inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
{ 
   if(0 == *p)
   {
      if(s.empty() || ((s.size() == 1) && (s[0] == 0)))
         return 0;
   }
   return s.compare(p); 
}
Esempio n. 11
0
bool EndsWith(const std::basic_string<CharT> &lhs, const std::basic_string<CharT> &rhs)
{
    if (rhs.empty())
        return true;

    if (lhs.length() < rhs.length())
        return false;

    return lhs.compare(lhs.length() - rhs.length(), rhs.length(), rhs) == 0;
}
Esempio n. 12
0
		std::basic_string<CharType> escape_argument_if_needed(const std::basic_string<CharType>& arg)
		{
			if (!arg.empty() && !has_escapable_characters(arg))
			{
				return arg;
			}
			else
			{
				return escape_argument(arg);
			}
		}
Esempio n. 13
0
File: Symbol.hpp Progetto: EQ4/lad
	/** Return true iff `str` is a valid Symbol. */
	static inline bool is_valid(const std::basic_string<char>& str) {
		if (str.empty() || (str[0] >= '0' && str[0] <= '9')) {
			return false;  // Must start with a letter or underscore
		}

		for (size_t i = 0; i < str.length(); ++i) {
			if (!is_valid_char(str[i])) {
				return false;  // All characters must be _, a-z, A-Z, 0-9
			}
		}

		return true;
	}
Esempio n. 14
0
ResultList split(const std::basic_string<CharT> &s,
    const std::basic_string<CharT> &delimiter, bool keepEmptyParts = true)
{
    ResultList slist;

    // If delimiter.empty():
    //   pos = s.find(delimiter, start);
    // pos will be 0.
    if (delimiter.empty()) {
        slist.push_back(s);
        return slist;
    }


    typename std::basic_string<CharT>::size_type start = 0;
    typename std::basic_string<CharT>::size_type pos;

    std::basic_string<CharT> part;

    if (delimiter.length() == 1) {
        CharT ch = delimiter[0];

        // Hope that:
        //   find(std::basic_string<CharT>, CharT ch)
        // will be faster than:
        //   find(std::basic_string<CharT>, std::basic_string<CharT>)
        while ((pos = s.find(ch, start)) != s.npos) { // Use strchr/wcschr instead?
            part = s.substr(start, pos - start);

            if (!part.empty() || keepEmptyParts)
                slist.push_back(part);

            start = pos + delimiter.length();
        }
    } else {
        while ((pos = s.find(delimiter, start)) != s.npos) { // Use strstr/wcsstr instead?
            part = s.substr(start, pos - start);

            if (!part.empty() || keepEmptyParts)
                slist.push_back(part);

            start = pos + delimiter.length();
        }
    }

    if (start != s.length() || keepEmptyParts)
        slist.push_back(s.substr(start));

    return slist;
}
Esempio n. 15
0
 std::basic_string<Char> PathJoin(const std::basic_string<Char>& dir, const std::basic_string<Char>& file)
 {
   if(dir.empty()) return file;
   Char c = *(dir.rbegin());
   switch(c)
   {
   case '\\':
   case '/':
     return dir + file;
   }
   std::basic_string<Char> ret(dir);
   ret.push_back('\\');
   ret.append(file);
   return ret;
 }
Esempio n. 16
0
	template<typename char_t> std::basic_string<char_t> trim(const std::basic_string<char_t>& what)
	{
		if ( what.empty() ) return what;

		const char_t whitespace[3] = { char_t(' '), char_t('\t'), 0 };
		size_t left = what.find_first_not_of(whitespace);
		size_t right = what.find_last_not_of(whitespace);

		if ( left == std::basic_string<char_t>::npos )
		{
			return std::basic_string<char_t>();
		}
		else
		{
			return what.substr(left, right-left+1);
		}
	}
Esempio n. 17
0
File: Symbol.hpp Progetto: EQ4/lad
	/** Convert a string to a valid symbol.
	 *
	 * This will make a best effort at turning `str` into a complete, valid
	 * Symbol, and will always return one.
	 */
	static inline Symbol symbolify(const std::basic_string<char>& in) {
		if (in.empty()) {
			return Symbol("_");
		}

		std::basic_string<char> out(in);
		for (size_t i = 0; i < in.length(); ++i) {
			if (!is_valid_char(out[i])) {
				out[i] = '_';
			}
		}

		if (is_valid_start_char(out[0])) {
			return Symbol(out);
		} else {
			return Symbol(std::string("_") + out);
		}
	}
    std::basic_string< wchar_t > str_convert< wchar_t, char >( std::basic_string< char > const & src )
    {
        std::basic_string< wchar_t > dst;

        if ( !src.empty() )
        {
            try
            {
                std::unique_lock< std::mutex > lock( g_conversionMutex );
                char * szloc = setlocale( LC_CTYPE, "" );
                mbtowc( NULL, NULL, 0 );
                size_t max = src.size();
                int length = 1;
                const char * in = src.c_str();
                dst.reserve( src.size() );

                while ( max > 0 && length >= 1 )
                {
                    wchar_t wc;
                    length = mbtowc( &wc, in, max );

                    if ( length >= 1 )
                    {
                        dst += wc;
                        max -= length;
                        in += length;
                    }
                }

                setlocale( LC_CTYPE, szloc );
            }
            catch ( std::exception & exc )
            {
                CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << exc.what() );
            }
            catch ( ... )
            {
                CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << INFO_UNKNOWN );
            }
        }

        return std::move( dst );
    }
Esempio n. 19
0
    void IO::TrimLeft(std::basic_string<charType> & str, const char* chars2remove)
    {
        if (!str.empty())   //trim the characters in chars2remove from the left
        {
            std::string::size_type pos = 0;
            if (chars2remove != NULL)
            {
                pos = str.find_first_not_of(chars2remove);

                if (pos != std::string::npos)
                    str.erase(0,pos);
                else
                    str.erase( str.begin() , str.end() ); // make empty
            }
            else        //trim space
            {
                pos = std::string::npos;        //pos = -1
                for (size_t i = 0; i < str.size(); ++i)
                {
                    if (!isspace(str[i]))
                    {
                        pos = i;
                        break;
                    }
                }
                if (pos != std::string::npos)
                {
                    if (pos > 0)
                    {
                        size_t length = str.size() - pos;
                        for (size_t i = 0; i < length; ++i) str[i] = str[i+pos];
                        str.resize(length);
                    }
                }
                else
                {
                    str.clear();
                }
            }
        }
    }
    std::basic_string< char > str_convert< char, wchar_t >( std::basic_string< wchar_t > const & src )
    {
        std::basic_string< char > dst;

        if ( !src.empty() )
        {
            try
            {
                std::unique_lock< std::mutex > lock( g_conversionMutex );
                std::string szloc = setlocale( LC_CTYPE, "" );
                size_t max = src.size();
                int length = 1;
                const wchar_t * in = src.c_str();
                char buffer[32] = { 0 };
                dst.reserve( 1 + src.size() * 2 );

                while ( *in && length >= 1 )
                {
                    length = wctomb( buffer, *in );

                    if ( length >= 1 )
                    {
                        dst += buffer;
                        in++;
                    }
                }

                setlocale( LC_CTYPE, szloc.c_str() );
            }
            catch ( std::exception & exc )
            {
                CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << exc.what() );
            }
            catch ( ... )
            {
                CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << INFO_UNKNOWN );
            }
        }

        return std::move( dst );
    }
Esempio n. 21
0
void test_ok(std::string file,std::locale const &l,std::basic_string<Char> cmp=std::basic_string<Char>())
{
    if(cmp.empty())
        cmp=to<Char>(file);
    std::ofstream test("testi.txt");
    test << file;
    test.close();
    typedef std::basic_fstream<Char> stream_type;

    stream_type f1("testi.txt",stream_type::in);
    f1.imbue(l);
    TEST(read_file<Char>(f1) == cmp); 
    f1.close();

    stream_type f2("testo.txt",stream_type::out);
    f2.imbue(l);
    f2 << cmp;
    f2.close();

    std::ifstream testo("testo.txt");
    TEST(read_file<char>(testo) == file);
}
Esempio n. 22
0
bool utfConvert(
    const std::basic_string<From>& from, std::basic_string<To>& to,
    ConversionResult(*cvtfunc)(const typename FromTrait::ArgType**, const typename FromTrait::ArgType*,
        typename ToTrait::ArgType**, typename ToTrait::ArgType*,
        ConversionFlags)
    )
{
    static_assert(sizeof(From) == sizeof(typename FromTrait::ArgType), "Error size mismatched");
    static_assert(sizeof(To) == sizeof(typename ToTrait::ArgType), "Error size mismatched");

    if (from.empty())
    {
        to.clear();
        return true;
    }

    // See: http://unicode.org/faq/utf_bom.html#gen6
    static const int most_bytes_per_character = 4;

    const size_t maxNumberOfChars = from.length(); // all UTFs at most one element represents one character.
    const size_t numberOfOut = maxNumberOfChars * most_bytes_per_character / sizeof(To);

    std::basic_string<To> working(numberOfOut, 0);

    auto inbeg = reinterpret_cast<const typename FromTrait::ArgType*>(&from[0]);
    auto inend = inbeg + from.length();


    auto outbeg = reinterpret_cast<typename ToTrait::ArgType*>(&working[0]);
    auto outend = outbeg + working.length();
    auto r = cvtfunc(&inbeg, inend, &outbeg, outend, strictConversion);
    if (r != conversionOK)
        return false;

    working.resize(reinterpret_cast<To*>(outbeg) - &working[0]);
    to = std::move(working);

    return true;
};
void StringTrimT(std::basic_string<CharType> &output)
{
	if (output.empty())
		return;
	size_t bound1 = 0;
	size_t bound2 = output.length();
	const CharType *src = output.data();

	for (; bound2 > 0; bound2--)
		if (NOT_SPACE(src[bound2-1]))
			break;

	for (; bound1 < bound2; bound1++)
		if (NOT_SPACE(src[bound1]))
			break;

	if (bound1 < bound2) {
		memmove((void *)src,
				src + bound1,
				sizeof(CharType) * (bound2 - bound1));
	}

	output.resize(bound2 - bound1);
}
Esempio n. 24
0
 bool is_simple_key(const std::basic_string<Ch> &key)
 {
     const static std::basic_string<Ch> chars = convert_chtype<Ch, char>(" \t{};\n\"");
     return !key.empty() && key.find_first_of(chars) == key.npos;
 }
Esempio n. 25
0
std::basic_string<Out>
codecvt(
	std::basic_string<In> const &_string,
	std::locale const &_locale,
	Function const &_function
)
{
	typedef std::basic_string<
		Out
	> return_type;

	typedef fcppt::container::raw_vector<
		Out
	> buffer_type;

	if(
		_string.empty()
	)
		return return_type();

	fcppt::codecvt_type const &conv(
		std::use_facet<
			fcppt::codecvt_type
		>(
			_locale
		)
	);

	buffer_type buf(
		_string.size()
	);

	typedef fcppt::codecvt_type::state_type state_type;

	state_type state;

	std::memset(
		&state,
		0,
		sizeof(state_type)
	);

	Out *to = buf.data();

	for(
		In const *from = _string.data(),
		*from_next = nullptr;
		; // loop forever
		from = from_next
	)
	{
		Out *to_next;

		std::codecvt_base::result const result(
			(
				conv.*_function
			)(
				state,
				from,
				fcppt::container::data_end(
					_string
				),
				from_next,
				to,
				buf.data_end(),
				to_next
			)
		);

		switch(
			result
		)
		{
		case std::codecvt_base::noconv:
			return
				return_type(
					_string.begin(),
					_string.end()
				);
		case std::codecvt_base::error:
			throw fcppt::exception(
				FCPPT_TEXT("codecvt: error!")
			);
		case std::codecvt_base::partial:
			{
				typename buffer_type::difference_type const diff(
					std::distance(
						buf.data(),
						to_next
					)
				);

				buf.resize(
					buf.size() * 2
				);

				to = buf.data() + diff;
			}
			continue;
		case std::codecvt_base::ok:
			return
				return_type(
					buf.data(),
					to_next
				);
		}

		FCPPT_ASSERT_UNREACHABLE;
	}
}
Esempio n. 26
0
	template<typename char_t> bool ends_with(const std::basic_string<char_t>& what, const std::basic_string<char_t>& with)
	{
		return !what.empty() && (what.find(with) == what.length()-with.length());
	}
Esempio n. 27
0
inline std::basic_string<CharT> unescape_impl(std::basic_string<CharT> src, EscapeFlags flags)
{
    if (src.empty()) return {};
    typedef CharT char_type;
    typedef std::basic_string<char_type> string_type;
    typedef typename string_type::iterator iterator_type;
    typedef detail::named_character_references_traits<char_type> named_character_references_traits_type;
    typedef detail::unescape_traits<char_type> unescape_traits_type;

    boost::match_results<iterator_type> what;
    boost::match_flag_type rgx_flags = boost::match_default;
    iterator_type start = src.begin(), end = src.end();

    // this function must not fail.
    auto const perform_replace = [&](string_type const& replace_to) -> void {
        std::size_t const last_pos_i = std::distance(src.begin(), what[0].first);

//        std::cout << "replacing " << what.str(0) << " to " << replace_to << std::endl;

        src.replace(what[0].first, what[0].second, replace_to);
        start = src.begin() + last_pos_i + replace_to.size();
        end = src.end();
    };

    auto const process = [&]() -> bool {
        string_type const found_str(what.str(0));

        string_type found_code;
        bool is_numeric = false;
        bool is_hexadecimal = false;

        BOOST_ASSERT(what.size() == 5);

        // determine whether it's named, decimal or hexadecimal
        if (what.str(1).empty() && what.str(3).empty()) {
            // named
            is_numeric = false;

        } else {
            is_numeric = true;

            if (!what.str(1).empty()) {
                // hexadecimal
                BOOST_ASSERT(!what.str(2).empty());

                is_hexadecimal = true;
                found_code = what.str(2);

            } else {
                // decimal
                BOOST_ASSERT(!what.str(3).empty());
                BOOST_ASSERT(!what.str(4).empty());

                is_hexadecimal = false;
                found_code = what.str(4);
            }
        }

        try {
            // check for each types
            auto const& table = named_character_references_traits_type::table();

            if (is_numeric) {
                if ((flags & UNESCAPE_DECIMAL) && is_hexadecimal) {
                    UChar32 const cp = std::stoull(unescape_traits_type::hexadecimal_prefix() + found_code, nullptr, 16);
                    perform_replace(saya::to<string_type>(saya::ustring(cp)));
                    return true;

                } else if ((flags & UNESCAPE_DECIMAL) && !is_hexadecimal) {
                    UChar32 const cp = boost::lexical_cast<UChar32>(found_code);
                    perform_replace(saya::to<string_type>(saya::ustring(cp)));
                    return true;
                }
            } else {
                if ((flags & UNESCAPE_NAMED) && table.count(found_str)) {
                    perform_replace(table.at(found_str));
                    return true;
                }
            }

        } catch (std::out_of_range const&) {
            return false;

        } catch (std::invalid_argument const&) {
            return false;

        } catch (boost::bad_lexical_cast const&) {
            return false;
        }
        return false;
    };

    while (boost::regex_search(start, end, what, detail::unescape_traits<char_type>::character_reference_rgx(), rgx_flags)) {
        if (!process()) {
            // skip and continue
            start = what[0].second;
        }
        rgx_flags |= boost::match_prev_avail;
    }

    return src;
}
Esempio n. 28
0
bool enum_file_lines::GetTString(std::vector<T>& From, std::basic_string<T>& To, eol::type& Eol, bool bBigEndian) const
{
	To.clear();

	// Обработка ситуации, когда у нас пришёл двойной \r\r, а потом не было \n.
	// В этом случаем считаем \r\r двумя MAC окончаниями строк.
	if (m_CrCr)
	{
		m_CrCr = false;
		Eol = eol::type::mac;
		return true;
	}

	auto CurrentEol = eol::type::none;
	for (const auto* ReadBufPtr = ReadPos < ReadSize? From.data() + ReadPos / sizeof(T) : nullptr; ; ++ReadBufPtr, ReadPos += sizeof(T))
	{
		if (ReadPos >= ReadSize)
		{
			if (!(SrcFile.Read(From.data(), ReadBufCount * sizeof(T), ReadSize) && ReadSize))
			{
				Eol = CurrentEol;
				return !To.empty() || CurrentEol != eol::type::none;
			}

			if (bBigEndian && sizeof(T) != 1)
			{
				swap_bytes(From.data(), From.data(), ReadSize);
			}

			ReadPos = 0;
			ReadBufPtr = From.data();
		}

		if (CurrentEol == eol::type::none)
		{
			// UNIX
			if (*ReadBufPtr == m_Eol.lf<T>())
			{
				CurrentEol = eol::type::unix;
				continue;
			}
			// MAC / Windows? / Notepad?
			else if (*ReadBufPtr == m_Eol.cr<T>())
			{
				CurrentEol = eol::type::mac;
				continue;
			}
		}
		else if (CurrentEol == eol::type::mac)
		{
			if (m_CrSeen)
			{
				m_CrSeen = false;

				// Notepad
				if (*ReadBufPtr == m_Eol.lf<T>())
				{
					CurrentEol = eol::type::bad_win;
					continue;
				}
				else
				{
					// Пришёл \r\r, а \n не пришёл, поэтому считаем \r\r двумя MAC окончаниями строк
					m_CrCr = true;
					break;
				}
			}
			else
			{
				// Windows
				if (*ReadBufPtr == m_Eol.lf<T>())
				{
					CurrentEol = eol::type::win;
					continue;
				}
				// Notepad or two MACs?
				else if (*ReadBufPtr == m_Eol.cr<T>())
				{
					m_CrSeen = true;
					continue;
				}
				else
				{
					break;
				}
			}
		}
		else
		{
			break;
		}

		To.push_back(*ReadBufPtr);
		CurrentEol = eol::type::none;
	}

	Eol = CurrentEol;
	return true;
}
Esempio n. 29
0
 bool is_simple_data(const std::basic_string<Ch> &data)
 {
     const static std::basic_string<Ch> chars = convert_chtype<Ch, char>(" \t{};\n\"");
     return !data.empty() && data.find_first_of(chars) == data.npos;
 }
size_t StringReplaceAllT(const std::basic_string<CharType> &find,
						 const std::basic_string<CharType> &replace,
						 std::basic_string<CharType> &output)
{
	size_t find_length = find.size();
	size_t replace_length = replace.size();
	size_t offset = 0, endpos;
	size_t target = 0, found_pos;
	size_t replaced = 0;
	CharType *data_ptr;

	if (find.empty() || output.empty())
		return 0;

	/*
	 * to avoid extra memory reallocating,
	 * we use two passes to finish the task in the case that replace.size() is greater find.size()
	 */

	if (find_length < replace_length)
	{
		/* the first pass, count all available 'find' to be replaced  */
		for (;;)
		{
			offset = output.find(find, offset);
			if (offset == std::basic_string<CharType>::npos)
				break;
			replaced++;
			offset += find_length;
		}

		if (replaced == 0)
			return 0;

		size_t newsize = output.size() + replaced * (replace_length - find_length);

		/* we apply for more memory to hold the content to be replaced */
		endpos = newsize;
		offset = newsize - output.size();
		output.resize(newsize);
		data_ptr = &output[0];

		memmove((void*)(data_ptr + offset),
				(void*)data_ptr,
				(output.size() - offset) * sizeof(CharType));
	}
	else
	{
		endpos = output.size();
		offset = 0;
		data_ptr = const_cast<CharType *>(&output[0]);
	}

	/* the second pass,  the replacement */
	while (offset < endpos)
	{
		found_pos = output.find(find, offset);
		if (found_pos != std::basic_string<CharType>::npos)
		{
			/* move the content between two targets */
			if (target != found_pos)
				memmove((void*)(data_ptr + target),
						(void*)(data_ptr + offset),
						(found_pos - offset) * sizeof(CharType));

			target += found_pos - offset;

			/* replace */
			memcpy(data_ptr + target,
				   replace.data(),
				   replace_length * sizeof(CharType));

			target += replace_length;
			offset = find_length + found_pos;
			replaced++;
		}
		else
		{
			/* ending work  */
			if (target != offset)
				memcpy((void*)(data_ptr + target),
					   (void*)(data_ptr + offset),
					   (endpos - offset) * sizeof(CharType));
			break;
		}
	}

	if (replace_length < find_length)
		output.resize(output.size() - replaced * (find_length - replace_length));

	return replaced;
}