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

std::vector<std::string> qdbbot::getBashNums(std::stringstream& src)
{
	std::vector<std::string> nums;
	std::cout << "qdbbot::getBashNums: entering loop" << std::endl;
	while(!src.eof())
	{
		//char* buf = new char[GLBUFFERSIZE];
		//src.getline(buf, GLBUFFERSIZE);
	
		std::string line;
		std::getline(src, line, '\n');

		if(src.bad()){}
			//try to fail gracefully

		//delete buf;


		if(line.find("<span class=qt") != std::string::npos)
		{
			std::cout << "qdbbot::getBashNums: found a num" << std::endl;
			nums.push_back(getNum(line));
		}
	}

	std::cout << "basbot::getBashNums: finished parseing nums" << std::endl;
	return nums;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
std::vector<std::string> RifEclipseUserDataParserTools::headerReader(std::stringstream& streamData, std::string& line)
{
    std::vector<std::string> header;

    while (!isANumber(line) && !streamData.eof())
    {
        header.push_back(line);
        std::getline(streamData, line);
    }
    return header;
}

void
print_stderr(std::stringstream& aStr)
{
#if defined(ANDROID)
  // On Android logcat output is truncated to 1024 chars per line, and
  // we usually use std::stringstream to build up giant multi-line gobs
  // of output. So to avoid the truncation we find the newlines and
  // print the lines individually.
  char line[1024];
  while (!aStr.eof()) {
    aStr.getline(line, sizeof(line));
    if (!aStr.eof() || strlen(line) > 0) {
      printf_stderr("%s\n", line);
    }
    if (aStr.fail()) {
      // line was too long, skip to next newline
      aStr.clear();
      aStr.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
  }
#else
  printf_stderr("%s", aStr.str().c_str());
#endif
}

	/**
	 * Helper function for show_wml_messages(), which gathers
	 * the messages from a stringstream.
	 */
	void t_pump::fill_wml_messages_map(std::map<std::string, int>& msg_map, std::stringstream& source)
	{
		while(true) {
			std::string msg;
			std::getline(source, msg);

			if(source.eof()) {
				break;
			}

			if(msg == "") {
				continue;
			}

			if(msg_map.find(msg) == msg_map.end()) {
				msg_map[msg] = 1;
			} else {
				msg_map[msg]++;
			}
		}
		// Make sure the eof flag is cleared otherwise no new messages are shown
		source.clear();
	}

// ---------------------------------------------------------------------------
// DeserializeTree
//		Given the functionset, and a stringstream to read from this will
//		deserialize a tree from its 'text' form. Returns true on success.
//
//	Limitations:
//		Function names cannot have spaces or it will give errors deserializing
//
bool DeserializeTree( const GPFunctionLookup& functions, GPTree*& tree, std::stringstream& in_serialized )
{
	tree = NULL;
	typedef std::map< int, IntermediateNode > IntermediateNodes;
	IntermediateNodes nodes;

	in_serialized.seekg( 0, std::ios::beg );

	while( !in_serialized.eof() )
	{
		// read in one node
		std::string functionName;
		int this_node_index = -1;

		try
		{
			in_serialized >> this_node_index;
		}
		catch( const std::exception &e )
		{
			continue;
		}

		if ( nodes.find( this_node_index ) != nodes.end() || this_node_index == -1 )
		{
			continue;
		}

		in_serialized >> functionName;
		
		// grab the delayed version since we might need it. we can get the original function from the delayed info.
		const GPFuncID delayed_function_id = functions.GetFunctionIDByName( functionName.c_str(), true );
		if ( delayed_function_id == GPFunctionLookup::NULLFUNC ) 
		{
			return false;
		}
		const GPFunctionDesc&	delayed_function		= functions.GetFunctionByID( delayed_function_id );
		const GPFuncID			original_function_id	= delayed_function.m_original_function_id;

		IntermediateNode int_node;
		int_node.delayedID			= delayed_function_id;
		int_node.functionID			= original_function_id;
		int_node.finalNode			= NULL;
		int_node.referencedByIndex	= -1;
		int_node.originalReturnType	= functions.GetFunctionByID( original_function_id ).m_return_type;
		int_node.delayedReturnType	= delayed_function.m_return_type;

		for( int i = 0; i < delayed_function.m_nparams; ++i )
		{
			in_serialized >> int_node.params[ i ];
		}
		
		nodes[ this_node_index ] = int_node;
	}

	//
	// Create some placeholder nodes for the entire tree
	for( IntermediateNodes::iterator iter = nodes.begin(); iter != nodes.end(); ++iter )
	{
		IntermediateNode&		this_node		= iter->second;

		this_node.finalNode = new GPTreeNode(	this_node.functionID, 
												NULL,
												NULL,
												NULL
											);
	}

	//
	// for every node found, set its parent
	bool tree_is_intact = true;
	for( IntermediateNodes::iterator iter = nodes.begin(); iter != nodes.end() && tree_is_intact; ++iter )
	{
		IntermediateNode&		this_node		= iter->second;
		const GPFunctionDesc&	this_function	= functions.GetFunctionByID( this_node.functionID );

		for( int i = 0; i < this_function.m_nparams; ++i )
		{
			// make sure the referenced node exists!
			if ( nodes.find( this_node.params[ i ] ) == nodes.end() ) 
			{
				tree_is_intact = false;
				break;
			}

			IntermediateNode&	parameter_node		= nodes[ this_node.params[ i ] ];
			GPTypeID		param_type_required	= this_function.m_param_types[ i ];

			//
			// up until now we dont know if any node needs to use the delayed version of its function
			// since we're now linking the tree together, we can swap a node if its parent requires
			// it to be delayed.
//.........这里部分代码省略.........

//------------------------------------------------------------------------------
LHDictionary::LHDictionary(std::stringstream& fileIN)
{     
    ++numberOfDicts;
    std::string lastKey = "";
    int objCounter = 0;
    std::string objText;
    
    //printf("DICT START\n");
    //printf("........................................................\n");
    //std::cout << fileIN.str() << std::endl;
    //printf("................................................................\n");    
    //file needs to start with <dict> else its not a LHDictionary file
        
    while(!fileIN.eof())
    {
        std::string line;
        getline(fileIN,line);
            
        //printf("D: c:%d %s\n", objCounter, line.c_str());
            
        if (std::string::npos != line.find("<key>")){
            if(1 < objCounter){
                objText+= line+"\n";
            }else{
                lastKey = valueForField(line);                    
            }
        }
        else if (std::string::npos != line.find("<string>")){
                
            if(1 < objCounter){
                objText+= line+"\n";
            }else{
                setObjectForKey(new LHObject(valueForField(line)), lastKey);
            }
        }
        else if (std::string::npos != line.find("<real>")){
            if(1 < objCounter){
                objText+= line+"\n";
            }else{
                setObjectForKey(new LHObject(floatFromString(valueForField(line))), lastKey);
            }
        }
        else if (std::string::npos != line.find("<integer>")){
            if(1 < objCounter){
                objText+= line+"\n";
            }else{
                setObjectForKey(new LHObject(intFromString(valueForField(line))), lastKey);
            }
        }
        else if (std::string::npos != line.find("<true/>")){
            if(1 < objCounter){
                objText+= line+"\n";
            }else{
                setObjectForKey(new LHObject(true), lastKey);
            }
        }
        else if (std::string::npos != line.find("<false/>")){
            if(1 < objCounter){
                objText+= line+"\n";
            }else{
                setObjectForKey(new LHObject(false), lastKey);
            }
        }
        else if (std::string::npos != line.find("<dict>")){
            ++objCounter;
            if(1 < objCounter){
                objText+= line+"\n";
            }
        }
        else if (std::string::npos != line.find("</dict>")){
            if(1 < objCounter){
                objText+= line+"\n";
            }
                
            --objCounter;
            if(1 == objCounter)
            {
                std::stringstream infoText(objText);
                setObjectForKey(new LHObject(new LHDictionary(infoText)), lastKey);
                objText = "";
            }
                
            if(0 > objCounter)
            {
                objText = "";
                objCounter = 1;
            }
        }
        else if (std::string::npos != line.find("<dict/>")){
            std::stringstream dummyText;
            setObjectForKey(new LHObject(new LHDictionary(dummyText)), lastKey);
        }
        else if (std::string::npos != line.find("<array>")){
            ++objCounter;
            if(1 != objCounter){
                    objText+= line+"\n";
            }
        }
        else if (std::string::npos != line.find("</array>")){
//.........这里部分代码省略.........