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

    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

/************************************************************************
 * 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];
}

        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;
        }

//Ask user what string they would like to find.
void userFind(stringstream& ss) {

	extern char** environ;
	char* choice = new char [WORD_SIZE];
	char* word   = new char [WORD_SIZE];
	char* environment = new char [WORD_SIZE];
	char temp;
	int numLine = 0;
	int count = 0;
	int lines = 0;
	streampos gpos, ppos;

	ss.str(ss.str());
	ss.seekp(0, ss.beg);
	ss.seekg(0, ss.beg);
	ss.clear();

	//Ask user what string they would like to search for.
	cout << "Please enter a string to search or \"END\" to quit. \n";
	cin >> choice;
	transform(choice, (choice + strlen(choice)), choice, ::toupper);

	while(strcmp(choice, "END") != 0) {
		//Search the stringstream for each occurance of the string.
		while(ss.getline(word, WORD_SIZE, ' ')) {
			transform(word, (word + strlen(word)), word, ::toupper);

			if(strcmp(word, choice) == 0) {
				//cout << "Word found!" << endl;
				count++;
			
				while(environ[lines]) {
					transform(environ[lines], (environ[lines] + strlen(environ[lines])), environment, ::toupper);
					if(strstr(environment, word)) cout << environ[lines] << endl;
					lines++;
				}

				//Incrememnt numLine for each newline character we find.

				//And print out the corresponding line.

			}



		}
	 
	 	//Then print out how many times the string appeared.
		cout << "Found " << count << " results!\n";
		cout << endl;
		cout << "Please enter a string to search or \"END\" to quit. \n";
		cin >> choice;
		transform(choice, (choice + strlen(choice)), choice, ::toupper);

		ss.str(ss.str());
		ss.seekp(0, ss.beg);
		ss.seekg(0, ss.beg);
		ss.clear();

		count = 0;

	}

	//delete environment;
	delete choice;
	delete word;

	return;
}