C++ istream::setstate方法代码示例

void safeGetline(istream& is, string& t)
{
    t.clear();
    std::istream::sentry se(is, true);
    std::streambuf* sb = is.rdbuf();
    
    while (true)
    {
        int c = sb->sbumpc();
        switch (c)
        {
            case '\n':
                return;
            case '\r':
                if (sb->sgetc() == '\n')
                    sb->sbumpc();
                return;
            case EOF:
                if (t.empty())
                    is.setstate(std::ios::eofbit);
                return;
            default:
                t += (char)c;
        }
    }
}

Triangle::Triangle(istream& is) {
    try {
        is >> get<0>(vertices_) >> get<1>(vertices_) >> get<2>(vertices_);
    } catch (string s) {
        is.setstate(ios_base::failbit);
        cout << s << endl;
    }
}

//-----------------------------------------------------------------------------
//    Class:			CTime
//	  Method:			void CTime::input(istream& sin)
//	  Description:		input method for CTime objects
//	  Input:			sin
//    Called By:		constructor from DateTime/CTime, mutators, saferead
//    Parameters:		istream& sin - input istream
//    Returns:          n/a
//    History Log:
//                      4/29/15  KG  completed version 1.0
// ----------------------------------------------------------------------------
	void CTime::input(istream& sin)
	{
		int hour = 0;
		int minute = 0;
		int second = 0;
		m_hour = hour;
		m_second = second;
		m_minute = minute;
		char c = ' ';
		sin.get(c);
		if(c == '\n') //checks for no input if datetime
		{
			sin.putback(c);
			return;
		}
		sin.putback(c); //puts back character if normal input
		if(sin >> hour)
		{
			if(hour > MINTIME && hour <= MAXHOUR)
				m_hour = hour;
			sin.get(c);
			if(c == '\n')
			{
				sin.putback(c);
				return;
			}
			if(c == ':')
			{
				if(sin >> minute)
				{
					if(minute > MINTIME && minute < MAXMINSEC)
					{
						m_minute = minute;
					}
					sin.get(c);
					if(c == '\n')
					{
						sin.putback(c);
						return;
					}
					if(c == ':')
					{
						if(sin >> second)
						{
							if(second > MINTIME && second < MAXMINSEC)
							{
								m_second = second;
							}
						}
					}
					else
						sin.setstate(std::ios::failbit);
				}
			}
			else

Player Player::OfGtpStream (istream& in) {
  string s;
  in >> s;
  if (!in) return Invalid ();
  if (s == "b" || s == "B" || s == "Black" || s == "BLACK "|| s == "black") { 
    return Black();
  }
  if (s == "w" || s == "W" || s == "White" || s == "WHITE "|| s == "white") {
    return White();
  }
  in.setstate (ios_base::badbit); // TODO undo read?
  return Invalid();
}

void GLUINavigationProgram::ReadDisplaySettings(istream& in)
{
  int dx,dy,dw,dh;
  dx = viewport.x; dy = viewport.y;
  dw = width-viewport.w; dh = height-viewport.h;
  in>>viewport;
  string str;
  in>>str;
  if(str != "ORBITDIST") { in.setstate(ios::badbit); return; }
  in>>camera.dist;

  camera.fromCamera(viewport,camera.dist);
  glutReshapeWindow(viewport.w+dw+dx,viewport.h+dh+dy);
}

void from_string_vec(istream & sstr, vector<T> & vecValue)
{
  T value;
  while (isspace(sstr.peek())) 
    sstr.get();
  int c = sstr.get();
  if (c!='[') {
    sstr.setstate(ios::failbit);
    return;
  }
  while (isspace(sstr.peek())) 
    sstr.get(); 
  c = sstr.peek();
  if (c==']') {
    sstr.get();
    return;    
  }
  sstr >> value; 
  if (!sstr) 
    return;
  vecValue.push_back(value);
  while(true) {
    while (isspace(sstr.peek())) 
      sstr.get();
    c = sstr.get();      
    if (c!=',' && c!=']') {
      sstr.setstate(ios::failbit);
      return;
    }
    if (c==']') 
      return;
    sstr >> value; 
    if (!sstr) 
      return;
    vecValue.push_back(value);      
  }
}

	template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream)
	{
		string temp;
		char_traits<char>::int_type c;
		while(true){
			c = stream.rdbuf()->sgetc();
			if(c != char_traits<char>::eof() && isspace(c) == false){
				stream.rdbuf()->sbumpc();
				temp.append(1, char_traits<char>::to_char_type(c));
			}else{
				break;
			}
		}
		if (temp.size() == 0)
			stream.setstate(ios_base::eofbit|ios_base::failbit);

		return temp;
        }

void ReadOneRecord(istream& in, value& val)

{
  if (in.peek() != '{') { 		// bail if not at record start
    in.setstate(ios::failbit);  	// set stream failure, so we can detect it
    return; 
  }
  
  in.ignore(1024, '\n');
  while (true) {
    string line;
    getline(in, line, '\n');
    istringstream istr(line.c_str());
    if (istr.peek() == '}') break;
    std::pair<string, value> entry;
    ReadFieldname(istr, entry.first);
    ReadValue(istr, entry.second);
    cout << "pair<attribute : value> = <" << entry.first << " : " 
	 << entry.second << ">" << endl;
  }
}

int getMyNum(istream& is,char delim,bool & emptyFlag,bool & delimFlag,bool allowWS=false)  // deliminator is '/' or '\n' 
{
	stringstream ss;
	bool foundFirst=false;
	delimFlag=false;  //ensure it starts out FALSE
	char c='0';
	int myNum=-99; // init number
	is>>ws;  // built in skip leading whitespace
	//while(is.get(c) &&  !(delimFlag=delimFound(c,delim)) && c!=sysEOL)//c!=delim)
	while(is.get(c) &&  !(delimFlag=delimFound(c,delim)) && c!=sysEOL)//c!=delim)
		{
			//cout<<":"<<c<<":"<<endl;
			//cout<<"!"<<is.tellg()<<"!"<<endl;
			if((!foundFirst)&& c=='-') //check for a leading negative
			{
				ss<<c; //first char can b negative (-)
				foundFirst=true;
			}
			else if(!isIntChar(c))
			{
				if(!( allowWS && isWhiteSpaceChar(c))) // TODO could be combined w/ above if?
				
				{
					//TODO do not strip \n
					is.ignore(256,delim); // fails for >256 chars, okay by me
					is.setstate(ios::failbit);
					delimFlag=true;
				}
				
			}
			else
			{
				foundFirst=true; //set found first, if no negative and 
				ss<<c;
			}
		}
	// get size
	/*
	ss.seekg(0,ios::end);
	int size=ss.tellg();
	ss.seekg(0,ios::beg);
	*/
	int size=ss.str().size();
	if( size==0 ||(size=1 && ss.str()=="-")) // check for empty, or single '-'
	{
		emptyFlag=true;
		
	}
	
	
	
	
	ss>> myNum; //stuff result into an int
	/*
	if(is.fail()&& !allowWS) // kluge 12 3/345 doesnt => 12
	{
		cout <<"magic3"<<endl;
		is.unget();
		is.putback(delim);
	}
	*/
	if(delim != sysEOL && is.peek()==sysEOL)  //kluge for 88/<LF>, otherwise grabs next line
	{
		cout <<"Magic2"<<endl;
		is.unget();
	}
		
	if(delim== sysEOL || c== sysEOL) // put back EOL or (c == sysEOL) kinda duplication
	
	//if(c== sysEOL&&(emptyFlag&&delim==sysEOL)) // put back EOL or (c == sysEOL) kinda duplication
		{
			//cout<<"putting LF back"<<endl;
			is.unget();

		}
		
	//kluge
	
	if( emptyFlag && delim == sysEOL) // check for empty, or single '-' for case of 7 <lf>, is.get(c) processed before delimFlag=delimFound...
	{
		is.unget();
		delimFlag=true;
		cout <<"Magic set flag"<<endl;
		myNum=1;
		
	}
	
		is.clear(); //clear all flags
		
	return myNum;
}