void ConfigParser::import_stream(std::istream& stream) {
   while(!stream.eof()) {
     std::string line;
     getline(stream, line);
     ConfigParser::Entry* entry = parse_line(line.c_str());
     if(entry) {
       variables.push_back(std::pair<std::string, Entry*>(entry->variable, entry));
     }
   }
 }
Exemple #2
0
 void ConfigParser::import_stream(std::istream& stream) {
   while(!stream.eof()) {
     std::string line;
     getline(stream, line);
     ConfigParser::Entry* entry = parse_line(line.c_str());
     if(entry) {
       variables[entry->variable] = entry;
     }
   }
 }
int TestWindow::num_of_questions(std::istream &input)
{
    int count = 0;
    std::string str;
    while(!input.eof()){
        std::getline(input, str);
        count++;
    }
    return count / 6;
}
Exemple #4
0
void consume(std::istream &in, char ch) {
  while (in.good()) {
    int c;
    c = in.peek();
    if (in.eof()) return;
    if (std::isspace(c)) { in.ignore(); continue; }
    if (c == ch) { in.ignore(); }
    return;
  }
}
Exemple #5
0
// function to output the rot13 of a file on std::cout
// returns false if an error occurred processing the file, true otherwise
// on entry, the argument is must be open for reading
int rot13_stream(std::istream& is)
{
  std::string line;
  while (std::getline(is, line))
  {
    if (!(std::cout << rot13(line) << "\n"))
      return false;
  }
  return is.eof();
}
osgDB::ReaderWriter::ReadResult
ReaderWriterIV::readNode(std::istream& fin,
                         const osgDB::ReaderWriter::Options* options) const
{
    // Notify
    OSG_NOTICE << "osgDB::ReaderWriterIV::readNode() "
              "Reading from stream." << std::endl;
    OSG_INFO << "osgDB::ReaderWriterIV::readNode() "
              "Inventor version: " << SoDB::getVersion() << std::endl;

    // Open the file
    SoInput input;

    // Assign istream to SoInput
    // note: It seems there is no straightforward way to do that.
    // SoInput accepts only FILE by setFilePointer or memory buffer
    // by setBuffer. The FILE is dangerous on Windows, since it forces
    // the plugin and Inventor DLL to use the same runtime library
    // (otherwise there are app crashes).
    // The memory buffer seems much better option here, even although
    // there will not be a real streaming. However, the model data
    // are usually much smaller than textures, so we should not worry
    // about it and think how to stream textures instead.

    // Get the data to the buffer
    size_t bufSize = 126*1024; // let's make it something below 128KB
    char *buf = (char*)malloc(bufSize);
    size_t dataSize = 0;
    while (!fin.eof() && fin.good()) {
        fin.read(buf+dataSize, bufSize-dataSize);
        dataSize += fin.gcount();
        if (bufSize == dataSize) {
           bufSize *= 2;
           char* new_buf = (char*)realloc(buf, bufSize);
           if (!new_buf)
           {
               free(buf);
               return osgDB::ReaderWriter::ReadResult::INSUFFICIENT_MEMORY_TO_LOAD;
           }
           buf = new_buf;
        }
    }
    input.setBuffer(buf, dataSize);
    OSG_INFO << "osgDB::ReaderWriterIV::readNode() "
              "Stream size: " << dataSize << std::endl;

    // Perform reading from SoInput
    osgDB::ReaderWriter::ReadResult r;
    std::string fileName("");
    r = readNodeFromSoInput(input, fileName, options);

    // clean up and return
    free(buf);
    return r;
}
Exemple #7
0
/***********************************************************************
 * Extract contiguous lines of comments
 **********************************************************************/
static std::vector<CodeBlock> extractContiguousBlocks(std::istream &is)
{
    std::vector<CodeBlock> contiguousCommentBlocks;
    CodeBlock currentCodeBlock;
    size_t lineNo = 0;
    std::string partial, line;

    bool inMultiLineComment = false;
    while (is.good() and not is.eof())
    {
        if (not partial.empty()) line = partial;
        else
        {
            lineNo++; //starts at 1
            std::getline(is, line);
        }
        partial.clear();
        if (line.empty()) continue;

        const std::string lineTrim = Poco::trimLeft(line);
        const auto openMulti = line.find("/*");
        const auto closeMulti = line.find("*/");
        if (not inMultiLineComment and lineTrim.size() >= 2 and lineTrim.substr(0, 2) == "//")
        {
            currentCodeBlock.push_back(CodeLine(line, lineNo));
        }
        else if (not inMultiLineComment and openMulti != std::string::npos)
        {
            inMultiLineComment = true;
            currentCodeBlock.push_back(CodeLine(line.substr(openMulti, std::string::npos), lineNo));
        }
        else if (inMultiLineComment and closeMulti != std::string::npos)
        {
            inMultiLineComment = false;
            currentCodeBlock.push_back(CodeLine(line.substr(0, closeMulti), lineNo));
            partial = line.substr(closeMulti+2);
        }
        else if (inMultiLineComment)
        {
            currentCodeBlock.push_back(CodeLine(line, lineNo));
        }
        else if (not currentCodeBlock.empty())
        {
            contiguousCommentBlocks.push_back(currentCodeBlock);
            currentCodeBlock.clear();
        }
    }

    if (not currentCodeBlock.empty())
    {
        contiguousCommentBlocks.push_back(currentCodeBlock);
    }

    return contiguousCommentBlocks;
}
Exemple #8
0
////////////////////////////////////////////////////////////////////////////
// MemParser constructor
//////////////////////////////////////////////////////////////////////////////
MemParser::MemParser(std::istream& in, UInt32 bytes) 
{
  if (bytes == 0)
  {
    // -----------------------------------------------------------------------------
    // Read all available bytes from the stream
    // -----------------------------------------------------------------------------
    std::string  data;
    const int  chunkSize = 0x10000;
    char* chunkP = new char[chunkSize];
    while (!in.eof()) {
      in.read(chunkP, chunkSize);
      NTA_CHECK (in.good() || in.eof()) 
          << "MemParser::MemParser() - error reading data from stream";
      data.append (chunkP, in.gcount());
    }
    
    bytes_ = (UInt32)data.size();
    bufP_ = new char[bytes_+1];
    NTA_CHECK (bufP_ != NULL) << "MemParser::MemParser() - out of memory";
    ::memmove ((void*)bufP_, data.data(), bytes_);
    ((char*)bufP_)[bytes_] = 0;
    
    delete[] chunkP;
  }
  else
  {
    // -----------------------------------------------------------------------------
    // Read given # of bytes from the stream
    // -----------------------------------------------------------------------------
    bytes_ = bytes;
    bufP_ = new char[bytes_+1];  
    NTA_CHECK (bufP_ != NULL) << "MemParser::MemParser() - out of memory";
    
    in.read ((char*)bufP_, bytes);
    ((char*)bufP_)[bytes] = 0;
    NTA_CHECK (in.good()) << "MemParser::MemParser() - error reading data from stream";
  }
  // Setup start and end pointers
  startP_ = bufP_;
  endP_ = startP_ + bytes_;  
}  
Exemple #9
0
/* input table from csv file */ 
bool RamRelation::load(std::istream &is, SymbolTable& symTable, const SymbolMask& mask) {
    bool error = false; 
    auto arity = getArity();
    while (!is.eof()) {
        std::string line;
        RamDomain tuple[arity];

        getline(is,line);
        if (is.eof()) break;

        size_t start = 0, end = 0;
        for(uint32_t col=0;col<arity;col++) { 
            end = line.find('\t', start);
            if ((size_t)end == std::string::npos) {
                end = line.length();
            }
            std::string element;
            if (start <=  end && (size_t)end <= line.length() ) {
                element = line.substr(start,end-start);
                if (element == "") {
                    element = "n/a";
                }
            } else {
                error = true; 
                element = "n/a";
            }
            if (mask.isSymbol(col)) {
                tuple[col] = symTable.lookup(element.c_str());
            } else {
                tuple[col] = atoi(element.c_str());
            }
            start = end+1;
        }
        if (end != line.length()) {
            error = true; 
        } 
        if (!exists(tuple)) { 
            insert(tuple);
        }
    }
    return error;
}
Exemple #10
0
bool
Parser::strmErr( std::istream & is )
{
    if ( is.eof() )
    {
        M_handler.handleEOF();
        return false;
    }

    return false;
}
Exemple #11
0
bool LoadObj::readHeader(std::istream &is){
    std::string buf;
    //read only to the first line starting with "v"
    while(!is.eof() && is.peek() != 'v'){
        getline(is, buf);
    }
    if (is.good())
        return true;
    else
        return false;
}
Exemple #12
0
void Player::deSerialize(std::istream &is)
{
	Settings args;
	
	for(;;)
	{
		if(is.eof())
			throw SerializationError
					("Player::deSerialize(): PlayerArgsEnd not found");
		std::string line;
		std::getline(is, line);
		std::string trimmedline = trim(line);
		if(trimmedline == "PlayerArgsEnd")
			break;
		args.parseConfigLine(line);
	}

	//args.getS32("version");
	std::string name = args.get("name");
	updateName(name.c_str());
	/*std::string password = "";
	if(args.exists("password"))
		password = args.get("password");
	updatePassword(password.c_str());*/
	m_pitch = args.getFloat("pitch");
	m_yaw = args.getFloat("yaw");
	m_position = args.getV3F("position");
	try{
		craftresult_is_preview = args.getBool("craftresult_is_preview");
	}catch(SettingNotFoundException &e){
		craftresult_is_preview = true;
	}
	try{
		hp = args.getS32("hp");
	}catch(SettingNotFoundException &e){
		hp = 20;
	}
	/*try{
		std::string sprivs = args.get("privs");
		if(sprivs == "all")
		{
			privs = PRIV_ALL;
		}
		else
		{
			std::istringstream ss(sprivs);
			ss>>privs;
		}
	}catch(SettingNotFoundException &e){
		privs = PRIV_DEFAULT;
	}*/

	inventory.deSerialize(is);
}
Exemple #13
0
void Player::deSerialize(std::istream &is, std::string playername)
{
	Settings args;
	
	for(;;)
	{
		if(is.eof())
			throw SerializationError
					(("Player::deSerialize(): PlayerArgsEnd of player \"" + playername + "\" not found").c_str());
		std::string line;
		std::getline(is, line);
		std::string trimmedline = trim(line);
		if(trimmedline == "PlayerArgsEnd")
			break;
		args.parseConfigLine(line);
	}

	//args.getS32("version"); // Version field value not used
	std::string name = args.get("name");
	updateName(name.c_str());
	setPitch(args.getFloat("pitch"));
	setYaw(args.getFloat("yaw"));
	setPosition(args.getV3F("position"));
	try{
		hp = args.getS32("hp");
	}catch(SettingNotFoundException &e){
		hp = 20;
	}
	try{
		m_breath = args.getS32("breath");
	}catch(SettingNotFoundException &e){
		m_breath = 11;
	}

	inventory.deSerialize(is);

	if(inventory.getList("craftpreview") == NULL)
	{
		// Convert players without craftpreview
		inventory.addList("craftpreview", 1);

		bool craftresult_is_preview = true;
		if(args.exists("craftresult_is_preview"))
			craftresult_is_preview = args.getBool("craftresult_is_preview");
		if(craftresult_is_preview)
		{
			// Clear craftresult
			inventory.getList("craftresult")->changeItem(0, ItemStack());
		}
	}

	// Set m_last_*
	checkModified();
}
static string ReadZStr(std::istream& f)
{
	std::string s;
	char c;
	while(!f.eof ()) {
		f >> c;
		if (!c) break;
		s += c;
	}
	return s;
}
Exemple #15
0
std::string getcontent(std::istream &in)
{
    std::string res;
    while(!in.eof()) {
        char c;
        in.get(c);
        if(in.gcount() == 1)
            res+=c;
    }
    return res;
}
Exemple #16
0
bool LoadObj::readData(std::istream & is){
    std::string lineBuf;
    int c;
    int i=0;
    while(!is.eof()){
        c = is.peek();
        switch (c) {
        case 'V':
        case 'v': {
            std::string startBuf;
            is >> startBuf; // get the start of the line
            getline(is, lineBuf); // get the rest of the line
            if(startBuf == "v")
                loadData.verts.push_back(Vector3<float>(lineBuf));
        }
            break;
        case 'F':
        case 'f': {
            std::stringstream buf;
            is.get(*buf.rdbuf(), '\n'); // read a line into buf
            is.get(); // read the not extracted \n
            buf << "\n"; // and add it to the string stream

            std::string tmp;
            buf >> tmp; // get the first f or F (+ whitespace)

            // count the number of faces, delimited by whitespace
            int count = 0;
            while (buf >> tmp)
                count++;

            // reset stream
            buf.clear();
            buf.seekg(0, std::ios::beg);

            // Determine wheter we have a triangle or a quad
            if (count == 3)
                loadData.triangles.push_back(readTri(buf));
            else {
              std::cerr << "Encountered polygon with " << count << " faces. i'm giving up.\n";
              return false;
            }
        }
            break;
        default:
            // otherwise just skip the row
            getline(is, lineBuf);

            break;
        }
        i++;
    }
    return true;
}
S32 LLSDXMLParser::Impl::parse(std::istream& input, LLSD& data)
{
	XML_Status status;

	static const int BUFFER_SIZE = 1024;
	void* buffer = NULL;
	int count = 0;
	while (input.good() && !input.eof())
	{
		buffer = XML_GetBuffer(mParser, BUFFER_SIZE);

		/*
		 * If we happened to end our last buffer right at the end of the llsd, but the
		 * stream is still going we will get a null buffer here.  Check for mGracefullStop.
		 */
		if (!buffer)
		{
			break;
		}
		count = get_till_eol(input, (char *)buffer, BUFFER_SIZE);
		if (!count)
		{
			break;
		}
		status = XML_ParseBuffer(mParser, count, false);

		if (status == XML_STATUS_ERROR)
		{
			break;
		}
	}

	// *FIX.: This code is buggy - if the stream was empty or not
	// good, there is not buffer to parse, both the call to
	// XML_ParseBuffer and the buffer manipulations are illegal
	// futhermore, it isn't clear that the expat buffer semantics are
	// preserved

	status = XML_ParseBuffer(mParser, 0, true);
	if (status == XML_STATUS_ERROR && !mGracefullStop)
	{
		if (buffer)
		{
			((char*) buffer)[count ? count - 1 : 0] = '\0';
		}
		llinfos << "LLSDXMLParser::Impl::parse: XML_STATUS_ERROR parsing:" << (char*) buffer << llendl;
		data = LLSD();
		return LLSDParser::PARSE_FAILURE;
	}

	clear_eol(input);
	data = mResult;
	return mParseCount;
}
Exemple #18
0
bool multiple_alignment::load_phylip( std::istream &is ) {
    size_t nTaxon;
    size_t seqLen;
    
    if( !is.good() ) {
        throw std::runtime_error( "cannot read phylip file" );
    }

    is >> nTaxon;
    is >> seqLen;

    printf( "header: %zd %zd\n", nTaxon, seqLen );

    size_t n = 0;


    while ( !is.eof() ) {
        std::string name;
        std::string seq;

        is >> name;
        is >> seq;

        if( is.eof() ) {
            
            break;
        }
        
        names.push_back(name);
        data.push_back( std::vector<uint8_t>(seq.begin(), seq.end()));
		
		
//         printf( "name: %s\n", name.c_str() );
        n++;
    }

    assert( n == nTaxon );
//     printf( "n: %zd\n", n );

    return n == nTaxon;
}
Exemple #19
0
  bool OptionsList::readnexttoken(std::istream& is, std::string& token)
  {
    token.clear();
    int c = is.get();

    // First get rid of all comments and white spaces
    while (!is.eof() && (isspace(c) || c=='#') ) {
      if (c=='#') {
        is.ignore(10000000, '\n');
      }
      c=is.get();
    }

    // Now read the token
    while (!is.eof() && !isspace(c)) {
      token += c;
      c = is.get();
    }

    return (!is.eof());
  }
Exemple #20
0
// returns base64, header, encoded
tuple<std::string, std::string, bool> pem_extract(std::istream& is) {
    std::ostringstream cs;
    std::string line;
    getline(is, line);
    while(line.find("-----BEGIN ") == std::string::npos) {
        if(is.eof()) throw runtime_error("Unexpected End of File - Not a PEM file?");
        getline(is, line);
    }
    std::string name = line.substr(11, line.size()-11-5);
    cs << line << '\n';
    bool encrypted = false;
    do {
        if(is.eof()) throw runtime_error("Unexpected End of File - PEM File corrupted?");
        getline(is, line);
        if (line.find("ENCRYPTED") != std::string::npos)
            encrypted = true;
        cs << line << '\n';
    }
    while(line.find("-----END ") == std::string::npos);
    return tuple<std::string, std::string, bool>(cs.str(), name, encrypted);
}
void GamesAsciiParser::getCI(std::istream& is) 
{

  is.seekg(pivot_begin);
  //look for CI coefficients
  bool notfound=true;
  ci_size=0;
  CIcoeff.clear();
  CIalpha.clear();
  CIbeta.clear();

  do {
    if(is.eof()) {
      cerr<<"Could not find CI expansion. \n";
      abort();
    }
    getwords(currentWords,is);
    if(currentWords.size() < 5 ) continue;
    if(currentWords[0] == "ALPHA" &&
       currentWords[2] == "BETA" &&
       currentWords[4] == "COEFFICIENT" ) {
      getwords(currentWords,is);  // -------- 
      notfound=false;
      getwords(currentWords,is);
      while(currentWords.size() != 0) {
        if(currentWords[0] == "....." || currentWords[1] == "DONE") break;
        ci_size++;
        CIcoeff.push_back(atof(currentWords[4].c_str()));
        CIalpha.push_back(currentWords[0]);
        CIbeta.push_back(currentWords[2]);
        getwords(currentWords,is);
      }
    }
  } while(notfound);

  ci_nea=ci_neb=0;
  for(int i=0; i<CIalpha[0].size(); i++)
    if(CIalpha[0].at(i) == '1') ci_nea++; 
  for(int i=0; i<CIbeta[0].size(); i++)
    if(CIbeta[0].at(i) == '1') ci_neb++; 

  if(CIalpha[0].size() != CIbeta[0].size()) {
    cerr<<"QMCPack can't handle different number of active orbitals in alpha and beta channels right now. Contact developers for help (Miguel).\n";
    abort();
  }
  int ds=SpinMultiplicity-1;
  int neb= (NumberOfEls-ds)/2;
  int nea= NumberOfEls-NumberOfBeta;
  ci_nca = nea-ci_nea;  
  ci_ncb = neb-ci_neb;
  ci_nstates = CIalpha[0].size();
  
}
Exemple #22
0
 static void get_line(std::istream& in,std::string& s) {
   for(;;) {
     s.resize(0);
     if(in.fail() || in.eof()) return;
     getline(in,s);
     std::string::size_type p;
     p=s.find_first_not_of(" \t");
     if(p != std::string::npos) s=s.substr(p);
     if((!s.empty()) && (s[0] != '#')) break;
   };
   return;
 }
//////////////////////////////////////////////////////////
// PRE: If in is a file input stream, then in has already been connected
// to a file.
// POST: vector<LogEntry> result is filled with LogEntry's from lines of
// istream
//
std::vector<LogEntry> parse(std::istream& in)
{
    std::vector<LogEntry> result;
    
    do {
        String line = getline(in);
        LogEntry log(line);
        result.push_back(log);
    } while (!in.eof());
    
    return result;
}
bool ObjIO::ReadHeader(std::istream & is){
  std::string buf;
  // just read to the first line starting with a 'v'
  while(!is.eof() && is.peek() != 'v'){
    getline(is, buf);
    //std::cerr << "\"" << buf << "\"\n";
  }
  if (is.good())
    return true;
  else
    return false;
}
Exemple #25
0
void pocketcalculator(std::istream &in, std::ostream &out) {
	std::stringstream result;
	unsigned scale{3};

	while (in) {
		result = calc(in);
		if(!in.eof()) {
			sevenSegment(result, scale, out);
		}
	}

}
Exemple #26
0
int readLine(std::istream& is, std::stringstream& currentLine)
{
  if (is.eof())
    return -1;
  currentLine.str("");
  currentLine.clear();
  is.get(*currentLine.rdbuf());
  if (is.fail()) // fail is set on empty lines
    is.clear();
  G2O_FSKIP_LINE(is); // read \n not read by get()
  return static_cast<int>(currentLine.str().size());
}
Exemple #27
0
void JobList::init(std::istream &in, Tape *tape)
{
	PCB t(tape);
	while(!(in.eof() || in.bad() || in.fail()))
	{
		in >> *(t.name) >> t.pid >> t.stime >> t.ntime >> t.memory >> t.tapeNum >> t.super;
		jlist.push_back(t);
	}
	auto i = jlist.end();
	i--;
	jlist.erase(i);
}
Exemple #28
0
void ucs4getline(std::istream& is, ucs4string& ustr)
{
	while (!is.eof())
	{
		ucs4_t ch = ucs4_t('\n');
		is.read(reinterpret_cast<char *>(&ch), 4);

		if (ch == ucs4_t('\n'))
			break;
		ustr.push_back(ch);
	}
}
// ---------------------------------------------------------------------------
//	importPartials
// ---------------------------------------------------------------------------
//	Clients should be prepared to catch ImportExceptions.
//
//	THIS WON'T WORK IF CHUNKS ARE IN A DIFFERENT ORDER!!!
//	Fortunately, they never will be, since only the research 
//	version of Lemur ever wrote these files anyway.
//
static void
importPartials( std::istream & s, PartialList & partials, double bweCutoff )
{
	try 
	{
		//	the Container chunk must be first, read it:
		readContainer( s );
		
		//	read other chunks:
		bool foundParams = false, foundTracks = false;
		while ( ! foundParams || ! foundTracks )
		{
			//	read a chunk header, if it isn't the one we want, skip over it.
			CkHeader h;
			readChunkHeader( s, h );
			
			if ( h.id == AnalysisParamsID )
			{
				readParamsChunk( s );
				foundParams = true;
			}
			else if ( h.id == TrackDataID )
			{
				if (! foundParams) 	//	 I hope this doesn't happen
				{
					Throw( ImportException, 
							"Mia culpa! I am not smart enough to read the Track data before the Analysis Parameters data." );
				}							
				//	read Partials:
				for ( long counter = readTracksChunk( s ); counter > 0; --counter ) 
				{
					getPartial(s, partials, bweCutoff);
				}
				foundTracks = true;
			}
			else
			{
				s.ignore( h.size );
			}
		}

	}
	catch ( Exception & ex ) 
	{
		if ( s.eof() )
		{
			ex.append("Reached end of file before finding both a Tracks chunk and a Parameters chunk.");
		}
		ex.append( "Import failed." );
		Throw( ImportException, ex.str() );
	}

}
Exemple #30
0
//std::getline(std::istream,std::string);
SpellDict::SpellDict(std::istream & DictSource)
{
    std::string S;
    while (!DictSource.eof())
    {
        std::getline(DictSource,S);
        if (S != "")
        {
            D.push_back(S);
        }
    }
}