C++ stringstream::good方法代码示例

    bool NodeFactory::readCombinaison(stringstream &sPath, U32 maxPosition, U32 &position, U8* &pCombinaisons) noexcept{
        bool bResult = true;
        if (position == 0)//if there was no previous search
            position = sPath.str().find_first_of('[');
        else
            position = sPath.str().find_first_of('[', position + 1);
        if (static_cast<size_t> (position) != string::npos) {
            char separator = '[';
            cerr << "fillNodeInit: found [" << endl;
            sPath.seekg(static_cast<size_t> (position + 1), ios::beg);
            for (U32 combiItem = 0; combiItem < maxPosition; combiItem++) {
                if (sPath.good()) {
                    if (separator != ']') {//retrieve another item of the combinaison
                        U32 temp;
                        sPath >> temp;
                        *pCombinaisons = static_cast<U8> (temp);
                        pCombinaisons++;

                        cerr << "position:" << position << endl;
                        cerr << "[" << temp << "]";
                        cerr << "�" << combiItem << "," << maxPosition << "�" << endl;
                    }
                    else //separator == ']'
                    {//combinaison completed too soon, all items of the combinaison are not retrieved
                        bResult = false;
                        break;
                    }
                } else {//incomplete combinaison

void NetworkRenderer::parse_network_result_output(stringstream &recv_ss) {
    int packet_number;
    recv_ss>>packet_number;
    recv_ss.get();
    std::vector<Color> result;
    while(recv_ss.good()) {

        int ir,ig,ib;
        ir=recv_ss.get();
        ig=recv_ss.get();
        ib=recv_ss.get();

        float r,g,b;
        r=(float)ir/(float)255;
        g=(float)ig/(float)255;
        b=(float)ib/(float)255;
        if(recv_ss.good()) {
            Color c(r,g,b);
            result.push_back(c);
        }

    }
    int height;
    int act_height=CLIENT_TASK_LINES*packet_number;
    if(act_height+CLIENT_TASK_LINES>rendering_height) {
        height=rendering_height-act_height;
    } else {
        height=CLIENT_TASK_LINES;
    }
//    display.add_surface(0,act_height,rendering_width,height,result);
    std::vector<Color> realresult;
    for(int i=0;i<Settings::getAsInt("window_width")*5;i++) {
        realresult.push_back(Color(1,0,0));

    }
    display.add_line_group(0,act_height,realresult);

    Logger::log()<<"Received "<<packet_number<<" of "<<result.size()<<" (height="<<act_height<<")"<<std::endl;
//    display.refresh_part_display_timecheck();
}

/************************************************************************
 * solveTheProblem							*
 *	Assumes the equations and variables have already been entered	*
 *	solves the problem, writing the solution in TEMP_FILE, 		*
 *	including the tags and problem statements if the problem was	*
 *	not completely solved.						*
 *   Then it opens the file for reading, and returns the first line	*
 *	[does not close file]						*
 ************************************************************************/
const char* solveTheProblem() {
  int k;

  if (isFirst) throw string("solveTheProblem called before initialization");
  try {
    // reset the buffer to be empty
    resultBuffer.str(string());
    if(resultBuffer.good()) {
      numsols->assign(canonvars->size(),HUGE_VAL);
      if (solveeqs(resultBuffer)) {
	// should we do checking of solution here?
	bool discrep = false;
	for (k = 0; k < canoneqf->size(); k++) {
	  if (checksol((*canoneqf)[k],numsols,RELERR) > 1) {
	    if (!discrep) {
	      resultBuffer << "<DISCREPANCIES>" << endl;
	      discrep = true;
	    }
	    resultBuffer << (*canoneqf)[k]->getInfix() << endl;
	  }
	} // loop over equations to check
	dimchkeqf(resultBuffer);
	// end of "should we do checking of solution here?"
      }
    } 
    else throw string("unable to create solution buffer");
  } 
  catch (string message) { throw message; } 
  catch (...) { throw string("solveTheProblem went boom!!"); }

  // this would be a good place to insert checksol ? or after returning
  // solution, in solveMoreOfTheProblem ?
  try {
    resultBuffer.clear();
    resultBuffer.seekg(0);
    int tk;
    try { tk = resultBuffer.eof(); } 
    catch (...) { throw string("eof?!?"); }
    if (! tk) {
      string t;
      try { t = getaline(resultBuffer); }
      catch (...) { throw string("getaline fails???"); }
      try { sprintf(lzbfr, "%s", t.c_str()); } 
      catch(...) { throw string("copy is wrong??"); }
      return lzbfr;
    } 
    else return error[4];
  } 
  catch (string message) { throw message; } 
  catch (...) { throw string("Read went bad!!"); }
  return error[3];
}

void readElement(string& readed, stringstream &str) {

    int c;
    do {
        c = str.get();
        if (c != ';') {
            if ((readed.length() != 0) || ((c != 13) && (c != 10))) {
                if (str.good()) {
                    char str[2];
                    str[0] = c;
                    str[1] = '\0';
                    readed += str;
                } else {
                    break;
                }
            }
        }
    } while (c != ';');
}

int ResourceParser::ReadLine(stringstream& p_stream, vector<string>& p_tokens, int& p_line)
{
	p_tokens.clear();
	size_t i = 0;
	int result = READ_CHUNK;
	char buf[LINE_BUFFER_SIZE];

	for (; i < LINE_BUFFER_SIZE; ++i)
	{
		p_stream.get(buf[i]);

		if (!p_stream.good() || ('\n' == buf[i]))
		{
			buf[i] = '\0';
			++p_line;
			break;
		}

		if (BLOCK_OPENING_BRACES.c_str()[0] == buf[i])
		{
			result = READ_BLOCK_OPEN;
			buf[i + 1] = '\0';
			break;
		}

		if (BLOCK_CLOSING_BRACES.c_str()[0] == buf[i])
		{
			result = READ_BLOCK_CLOSE;
			buf[i + 1] = '\0';
			break;
		}
	}

	char* line = (char*)stringUtils::Trim(buf);

	if ((nullptr == line) || (strlen(line) == 0) || (LINE_COMMENT == line[0]))
		return READ_EMPTY;

	stringUtils::Tokens(line, DELIMITERS, p_tokens);
	return result;
}

        uint32_t QueryableNetstringsDeserializerABCF::fillBuffer(istream& in, stringstream& buffer) {
            char _c = 0;
            uint32_t bytesRead = 0;

            // Peek Container's header: 2 bytes (0xABCF) followed by maximum 8 bytes (uint64_t) length of payload information.
            uint32_t bytesToRead = sizeof(uint16_t) + sizeof(uint64_t);

            // Read Container header + size of payload.
            while (in.good() && (bytesToRead > 0)) {
                // Read next byte.
                in.read(&_c, sizeof(char));
                bytesToRead--; bytesRead++;

                // Add new byte at the end of the buffer.
                buffer.write(&_c, sizeof(char));
            }

            // Decode Container's magic number.
            uint16_t magicNumber = 0;
            buffer.read(reinterpret_cast<char*>(&magicNumber), sizeof(uint16_t));
            magicNumber = ntohs(magicNumber);

            if (magicNumber == 0xABCF) {
                // Decode size of payload (encoded as varint).
                uint64_t value = 0;
                uint8_t size = 0;
                {
                    while (buffer.good()) {
                        char c = 0;
                        buffer.read(&c, sizeof(char));
                        value |= static_cast<unsigned int>( (c & 0x7f) << (0x7 * size++) );
                        if ( !(c & 0x80) ) break;
                    }
                    // Decode as little endian like in Protobuf's case.
                    value = le64toh(value);
                }

                bytesToRead = (value // This is the length of the payload.
                               - (sizeof(uint64_t) // We have already read this amount of bytes while peeking the header.
                                  - size) // This amount of bytes was consumed to encode the length of the payload in the varint field.
                                 )
                               + 1; // And we need to consume the final ','.

                // Add the data at the end of the buffer.
                buffer.seekg(0, ios_base::end);

                // Read remainder of the container.
                while (in.good() && (bytesToRead > 0)) {
                    // Read next byte.
                    in.read(&_c, sizeof(char));
                    bytesToRead--; bytesRead++;

                    // Add new byte at the end of the buffer.
                    buffer.write(&_c, sizeof(char));
                }

                // Move read pointer to the beginning to read container.
                buffer.seekg(0, ios_base::beg);
            }

            return bytesRead;
        }