C++ basic_string::append方法代码示例

void StringAppendVT(const CharType *format, va_list ap, std::basic_string<CharType> &output)
{
	CharType stack_buffer[1024];

	/* first, we try to finish the task using a fixed-size buffer in the stack */
	va_list ap_copy;
	GG_VA_COPY(ap_copy, ap);

	int result = vsnprintfT(stack_buffer, COUNT_OF(stack_buffer), format, ap_copy);
	va_end(ap_copy);
	if (result >= 0 && result < static_cast<int>(COUNT_OF(stack_buffer)))
	{
		/* It fits */
		output.append(stack_buffer, result);
		return;
	}

	/* then, we have to repeatedly increase buffer size until it fits. */
	int buffer_size = COUNT_OF(stack_buffer);
	std::basic_string<CharType> heap_buffer;
	for (;;)
	{
		if (result != -1)
		{
			assert(0);
			return; /* not expected, result should be -1 here */
		}
		buffer_size <<= 1; /* try doubling the buffer size */
		if (buffer_size > 32 * 1024 * 1024)
		{
			assert(0);
			return;	/* too long */
		}
		/* resize */
		heap_buffer.resize(buffer_size);
		/*
		 * NOTE: You can only use a va_list once.  Since we're in a while loop, we
		 * need to make a new copy each time so we don't use up the original.
		 */
		GG_VA_COPY(ap_copy, ap);
		result = vsnprintfT(&heap_buffer[0], buffer_size, format, ap_copy);
		va_end(ap_copy);

		if ((result >= 0) && (result < buffer_size)) {
			/* It fits */
			output.append(&heap_buffer[0], result);
			return;
		}
	}
}

		void AppendCharIfAbsent(
			std::basic_string<_Elem, _Traits, _Ax>& str,
			_Elem c)
		{
			typedef std::basic_string<_Elem, _Traits, _Ax> string_type;

			string_type::reverse_iterator r_iter = str.rbegin();
			if(*r_iter != c)
				str.append(1, c);
		}

void TokenizeBody (SBody *p_soBody, std::basic_string<unsigned char> &p_strBin, SDoc &p_soDoc)
{
	SBody *psoBody;
	STokenInd soTokenInd;
	std::map<STokenInd, std::map<u_int8, u_int8>>::iterator iterTokenizer;
	std::map<u_int8, u_int8>::iterator iterToken;

	psoBody = p_soBody;
	while (psoBody) {
		TokenizeElement (psoBody, p_strBin, p_soDoc);
		if (psoBody->m_psoAttrList) {
			TokinizeAttribute (psoBody->m_psoAttrList, p_strBin, p_soDoc);
			p_strBin.append ((unsigned char*)"\x01", 1);
		}
		if (psoBody->m_psoChildList) {
			TokenizeElement (psoBody->m_psoChildList, p_strBin, p_soDoc);
			p_strBin.append ((unsigned char*)"\x01", 1);
		}
		psoBody = psoBody->m_psoNext;
	}
}

template<typename T, typename O> typename Fsm<T, O>::State Fsm<T, O>::getNextLinearSequence(State startState, std::basic_string<Char>& input, BitSequence<Token>& output) const
{
	State state = startState;
	for (; state < getNumberOfStates() && transition_table[state].size() == 1; ++state)
	{
		input.append(1, transition_table[state].begin()->first);
		if (!transition_table[state].begin()->second.output.empty() || transition_table[state].begin()->second.nextState != state + 1)
		{
			output = transition_table[state].begin()->second.output;
			state = transition_table[state].begin()->second.nextState;
			break;
		}
	}
	return state;
}

/*******************************************************************************
**
** Function:        nativeNfcTag_doTransceiveStatus
**
** Description:     Receive the completion status of transceive operation.
**                  status: operation status.
**                  buf: Contains tag's response.
**                  bufLen: Length of buffer.
**
** Returns:         None
**
*******************************************************************************/
void nativeNfcTag_doTransceiveStatus (tNFA_STATUS status, uint8_t* buf, uint32_t bufLen)
{
    SyncEventGuard g (sTransceiveEvent);
    ALOGD ("%s: data len=%d", __FUNCTION__, bufLen);
    if (!sWaitingForTransceive)
    {
        ALOGE ("%s: drop data", __FUNCTION__);
        return;
    }
    sRxDataStatus = status;
    if (sRxDataStatus == NFA_STATUS_OK || sRxDataStatus == NFA_STATUS_CONTINUE)
        sRxDataBuffer.append (buf, bufLen);

    if (sRxDataStatus == NFA_STATUS_OK)
        sTransceiveEvent.notifyOne ();
}

    inline void serializeString(SF::Archive & ar, std::basic_string<C,T,A> & s)
    {
        if (ar.isRead())
        {
            boost::uint32_t count = 0;
            ar & count;

            SF::IStream &is = *ar.getIstream();

            s.resize(0);

            std::size_t minSerializedLength = sizeof(C);
            if (ar.verifyAgainstArchiveSize(count*minSerializedLength))
            {
                if (count > s.capacity())
                {
                    s.reserve(count);
                }
            }

            boost::uint32_t charsRemaining = count;
            const boost::uint32_t BufferSize = 512;
            C buffer[BufferSize];
            while (charsRemaining)
            {
                boost::uint32_t charsToRead = RCF_MIN(BufferSize, charsRemaining);
                boost::uint32_t bytesToRead = charsToRead*sizeof(C);

                RCF_VERIFY(
                    is.read( (char *) buffer, bytesToRead) == bytesToRead,
                    RCF::Exception(RCF::_SfError_ReadFailure()))
                    (bytesToRead)(BufferSize)(count);

                s.append(buffer, charsToRead);
                charsRemaining -= charsToRead;
            }
        }
        else if (ar.isWrite())
        {
            boost::uint32_t count = static_cast<boost::uint32_t >(s.length());
            ar & count;
            ar.getOstream()->writeRaw(
                (char *) s.c_str(),
                count*sizeof(C));
        }

    }

 void FormatMessageGLE(std::basic_string<wchar_t, Traits, Alloc>& out, int code)
 {
   wchar_t* lpMsgBuf(0);
   FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS,
     0, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&lpMsgBuf, 0, NULL);
   if(lpMsgBuf)
   {
     out = lpMsgBuf;
     LocalFree(lpMsgBuf);
   }
   else
   {
     out = L"Unknown error: ";
     wchar_t temp[50];
     _itow(code, temp, 50);
     out.append(temp);
   }
 }

inline void code_convert(const CharT* str1, std::size_t len, std::basic_string< CharT, TargetTraitsT, TargetAllocatorT >& str2, std::locale const& = std::locale())
{
    str2.append(str1, len);
}

void TokinizeAttribute (SBody *p_psoBody, std::basic_string<unsigned char> &p_strBin, SDoc &p_soDoc)
{
	static u_int8 ui8CodePage = 0;
	SBody *psoBody;
	STokenInd soTokenInd;
	std::map<STokenInd, std::map<u_int8, u_int8>>::iterator iterTokenizer;
	std::map<u_int8, u_int8>::iterator iterToken;
	SWBXMLToken soToken = { 0 };

	psoBody = p_psoBody;
	while (psoBody) {
		/* инициализируем структуру для поиска токена */
		soTokenInd.m_strType = psoBody->m_strType;
		soTokenInd.m_strName = psoBody->m_strName;
		soTokenInd.m_strValue = psoBody->m_strValue;
		/* запрашиваем нобходимый токен */
		iterTokenizer = g_mapTokenizer.find (soTokenInd);
		/* если токен не найден */
		if (iterTokenizer == g_mapTokenizer.end () && soTokenInd.m_strValue.length ()) {
			soTokenInd.m_strValue = "";
			/* ищем токен повторно для пустого значения */
			iterTokenizer = g_mapTokenizer.find (soTokenInd);
		}
		/* если токен так и не найден */
		if (iterTokenizer == g_mapTokenizer.end ()) {
			/* LITERAL */
			soToken.m_uiToken = 0x04;
			p_strBin.append (&soToken.m_ui8Value, sizeof (soToken));
			/* определяем индекс литерала */
			std::basic_string<mb_u_int32> strInd;
			CreateLiteral (p_psoBody, p_soDoc, strInd);
			for (unsigned int i = 0; i < strInd.length (); i++)
				p_strBin.append (&(strInd[i].m_uiValue), 1);
		} else {
			/* формируем токен */
			iterToken = iterTokenizer->second.find (ui8CodePage);
			/* если значение, соответствующее текущей кодовой странице, найдено */
			if (iterToken == iterTokenizer->second.end ()) {
				iterToken = iterTokenizer->second.begin ();
				ui8CodePage = iterToken->first;
				p_strBin.append ((unsigned char*)"\x00", 1);
				p_strBin.append ((unsigned char*)&(iterToken->first), 1);
			}
			soToken.m_ui8Value = iterToken->second;
			/* формируем токен */
			p_strBin.append (&soToken.m_ui8Value, sizeof (soToken));
		}
		/* если значение не токенизировано */
		if (psoBody->m_strValue.length () && 0 == soTokenInd.m_strValue.length ()) {
			/* ищем токенизированное значение */
			soTokenInd.m_strType = "value";
			soTokenInd.m_strName = psoBody->m_strValue;
			soTokenInd.m_strValue = "";
			iterTokenizer = g_mapTokenizer.find (soTokenInd);
			/* если подходящий токен не найден */
			if (iterTokenizer == g_mapTokenizer.end ()) {
				p_strBin.append ((unsigned char*)"\x03", 1);
				p_strBin.append ((unsigned char*)psoBody->m_strValue.c_str (), psoBody->m_strValue.length () + 1);
			} else {
				iterToken = iterTokenizer->second.find (ui8CodePage);
				if (iterToken == iterTokenizer->second.end ()) {
					iterToken = iterTokenizer->second.begin ();
					ui8CodePage = iterToken->first;
					p_strBin.append ((unsigned char*)"\x00", 1);
					p_strBin.append ((unsigned char*)&(iterToken->first), 1);
				}
				soToken.m_ui8Value = iterToken->second;
				p_strBin.append (&soToken.m_ui8Value, 1);
			}
		}
		psoBody = psoBody->m_psoNext;
	}
}

bool join_sub_string
    (
        const basic_cstring_view<CharT, Traits>&                in,
        typename basic_cstring_view<CharT, Traits>::size_type&  pos,
        std::basic_string<CharT, Traits, Allocator>&            out,
        InputIterator                                           valuesBegin,
        InputIterator                                           valuesEnd,
        bool                                                    optional
    )
{
    using string_type   = std::basic_string<CharT, Traits, Allocator>;
    using size_type     = typename string_type::size_type;

    bool escapeChar         = false;
    bool replacedAllValues  = true;

    const auto numValues = static_cast<size_type>(std::distance(valuesBegin, valuesEnd));

    if (numValues < 0)
        throw std::invalid_argument("reversed range iterators in join_string");

    for (auto num = in.size(); pos < num;)
    {
        /* Get next character */
        auto c = in[pos++];

        if (escapeChar)
        {
            /* Add character without transformation to output string */
            out.push_back(c);
            escapeChar = false;
        }
        else
        {
            if (c == CharT('\\'))
            {
                /* Next character will be added without transformation */
                escapeChar = true;
            }
            else if (c == CharT('{'))
            {
                /* Parse index N in '{N}' */
                string_type idxStr;
                while (pos < num)
                {
                    /* Get next character */
                    c = in[pos++];
                    if (c == CharT('}'))
                        break;
                    else
                        idxStr.push_back(c);
                }

                /* Get value by index from array */
                const auto idx = static_cast<size_type>(std::stoul(idxStr));
                if (idx < numValues)
                {
                    /* Append value to output string */
                    const auto& val = *(valuesBegin + idx);
                    if (string_empty(val))
                        replacedAllValues = false;
                    else
                        string_append(out, val);
                }
                else if (optional)
                {
                    /* This sub string will not be added to the final output string */
                    replacedAllValues = false;
                }
                else
                {
                    /* If this value replacement was not optional -> error */
                    throw std::out_of_range(
                        "index (" + std::to_string(idx) + ") out of range [0, " +
                        std::to_string(numValues) + ") in join_string"
                    );
                }
            }
            else if (c == CharT('['))
            {
                /* Parse optional part with recursive call */
                string_type outOpt;
                if (join_sub_string(in, pos, outOpt, valuesBegin, valuesEnd, true))
                    out.append(outOpt);
            }
            else if (c == CharT(']'))
            {
                /* Close optional part and return from recursive call */
                break;
            }
            else
            {
                /* Add current character to output string */
                out.push_back(c);
            }
        }
    }

    if (escapeChar)
        throw std::invalid_argument("incomplete escape character in report string");
//.........这里部分代码省略.........