void get_next_line(std::ifstream& file, std::string& line)
{
bool comment=false;
do {
getline(file,line);
if (file.good() && line.size()>0)
if (line[0]=='#')
comment=true;
else
comment=false;
} while (file.good() && comment);
}
bool ContainerRecord::loadFromStream(std::ifstream& inStream)
{
if (!inStream.good())
{
DuskLog() << "ContainerRecord::loadFromStream: ERROR: stream contains errors!\n";
return false;
}
uint32_t len = 0;
inStream.read((char*) &len, sizeof(uint32_t));
if (len != cHeaderCont)
{
DuskLog() << "ContainerRecord::loadFromStream: ERROR: stream contains unexpected header!\n";
return false;
}
char ID_Buffer[256];
memset(ID_Buffer, 0, 256);
//read ID
len = 0;
inStream.read((char*) &len, sizeof(uint32_t));
if (len>255)
{
DuskLog() << "ContainerRecord::loadFromStream: ERROR: ID is "
<< "longer than 255 characters!\n";
return false;
}
inStream.read(ID_Buffer, len);
if (!inStream.good())
{
DuskLog() << "ContainerRecord::loadFromStream: ERROR while "
<< "reading ID from stream!\n";
return false;
}
//read Mesh
char Mesh_Buffer[256];
memset(Mesh_Buffer, 0, 256);
len = 0;
inStream.read((char*) &len, sizeof(uint32_t));
if (len>255)
{
DuskLog() << "ContainerRecord::loadFromStream: ERROR: mesh path "
<< "is longer than 255 characters!\n";
return false;
}
inStream.read(Mesh_Buffer, len);
if (!inStream.good())
{
DuskLog() << "ContainerRecord::loadFromStream: ERROR while "
<< "reading mesh path from stream!\n";
return false;
}
Inventory temp;
if (!temp.loadFromStream(inStream))
{
DuskLog() << "ContainerRecord::loadFromStream: ERROR while "
<< "reading inventory contens from stream!\n";
return false;
}
//all right so far
return inStream.good();
}
void getNextWord(std::ifstream& inFile, std::string& token, std::string tokenizer, int64_t endOffSet)
{
token.clear();
char byte[1];
while(inFile.good())
{
if(inFile.tellg() >= endOffSet)
return;
byte[0] =inFile.peek();
if(byte[0]=='\n' || byte[0] == tokenizer.c_str()[0]){
inFile.get();
}else{
break;
}
}
while(inFile.good()){
byte[0] = inFile.get();
if(byte[0]=='\n' || byte[0] == tokenizer.c_str()[0]){
return;
}
token.append(byte,1);
}
}
srzMetaDataStruct loadGlobalSerializationMetadata(std::ifstream& f) {
srzMetaDataStruct md;
// isk version
f.read((char *) &(md.iskVersion), sizeof(int));
if (!f.good()) {
cerr << "ERROR bad file while reading isk version" << endl;
return md;
}
// binding language
f.read((char *) &(md.bindingLang), sizeof(int));
if (!f.good()) {
cerr << "ERROR bad file while reading lang" << endl;
return md;
}
// trial or full
if (md.iskVersion < SRZ_V0_7_0) {
f.read((char *) &(md.isTrial), sizeof(int));
}
// platform
f.read((char *) &(md.compilePlat), sizeof(int));
if (!f.good()) {
cerr << "ERROR bad file while reading platf" << endl;
return md;
}
// ok, I have some valid metadata
md.isValidMetadata = 1;
return md;
}
std::string CppLogger::getVar(std::ifstream& file)
{
std::string result = "";
while (file.good())
{
char c = file.get();
if (c == '=' || c == '\n')
{
break;
}
else if (c == '#')
{
while (file.good() && file.get() != '\n')
{
}
break;
}
else if (c == ' ')
{
continue;
}
result += c;
}
return result;
}
bool BSAFolderRecord::loadFromStream(std::ifstream& in_File)
{
if (!in_File.good())
{
std::cout << "BSAFolderRecord::loadFromStream: Error: bad stream given!\n";
return false;
}
//read folder record's stuff
in_File.read((char*) &nameHash, sizeof(BSAHash));
if (!in_File.good())
{
std::cout << "BSAFolderRecord::loadFromStream: Error: could not read hash!\n";
return false;
}
//rest of it
in_File.read((char*) &count, 4);
in_File.read((char*) &offset, 4);
if (!in_File.good())
{
std::cout << "BSAFolderRecord::loadFromStream: Error while reading data!\n";
return false;
}
//all's well
return true;
}
bool XTextureFileName::ParseFromFStream(std::ifstream& in)
{
std::streampos pos;
char separator;
if (!in.good())
{
return false;
}
in.clear();
pos = in.tellg();
if (!FileName.ParseFromFStream(in))
{
in.clear();
in.seekg(pos);
return false;
}
in >> separator;
if (!in.good() || separator != ';')
{
in.clear();
in.seekg(pos);
return false;
}
return true;
}
void Profile::read(std::ifstream& fin) {
std::string line;
while (getline(fin, line)) {
if (line.substr(0, 8) == "#Profile") break;
}
assert(fin.good());
int tmp_prolen, tmp_ncodes;
fin>> tmp_prolen>> tmp_ncodes;
assert(fin.good() && (tmp_ncodes == NCODES));
if (tmp_prolen != proLen) {
delete[] p;
proLen = tmp_prolen;
size = proLen * NCODES * NCODES;
p = new double[proLen][NCODES][NCODES];
memset(p, 0, sizeof(double) * size);
}
for (int i = 0; i < proLen; ++i)
for (int j = 0; j < NCODES; ++j)
for (int k = 0; k < NCODES; ++k)
assert(fin>> p[i][j][k]);
getline(fin, line);
}
CircularNanoparticle::CircularNanoparticle(std::ifstream & stream) : Nanoparticle(stream, Nanoparticle::CIRCLE)
{
/* FORMAT
* <parent_data><mRadius><mBoundary>
*
*/
//we not set badState here as parent constructor may of set it to bad
stream.read( (char*) &mRadius,sizeof(int));
if(!stream.good())
{
cerr << "Error: Couldn't create CircularNanoparticle. Failed to read mRadius" << endl;
badState=true;
}
stream.read( (char*) &mBoundary,sizeof(enum boundary));
if(!stream.good())
{
cerr << "Error: Couldn't create CircularNanoparticle. Failed to read mBoundary" << endl;
badState=true;
}
}
ossim_uint32 ossimRpfToc::getNumberOfFrames(std::ifstream& dotRpfStr) const
{
ossim_uint32 result = 0;
if ( !dotRpfStr.good() )
{
// see if we can clear it. Someone might have hit end of file(eof).
dotRpfStr.clear();
}
dotRpfStr.seekg(0, ios_base::beg);
// Eat the first line which is the bounding rect.
std::string line;
std::getline(dotRpfStr, line);
while( dotRpfStr.good() )
{
std::getline(dotRpfStr, line);
if ( dotRpfStr.good() )
{
++result;
}
}
dotRpfStr.clear();
dotRpfStr.seekg(0, ios_base::beg);
return result;
}
bool XAnimationKey::ParseFromFStream(std::ifstream& in)
{
std::streampos pos;
char separator;
if (!in.good())
{
return false;
}
in.clear();
pos = in.tellg();
if (!KeyType.ParseFromFStream(in))
{
in.clear();
in.seekg(pos);
return false;
}
in >> separator;
if (!in.good() || separator != ';')
{
in.clear();
in.seekg(pos);
return false;
}
if (!NKeys.ParseFromFStream(in))
{
in.clear();
in.seekg(pos);
return false;
}
in >> separator;
if (!in.good() || separator != ';')
{
in.clear();
in.seekg(pos);
return false;
}
if (!Keys.ParseFromFStream(in, NKeys))
{
in.clear();
in.seekg(pos);
return false;
}
in >> separator;
if (!in.good() || separator != ';')
{
in.clear();
in.seekg(pos);
return false;
}
return true;
}
bool LccrFeaturizer::ReadOneSentence(std::ifstream &src,
std::vector<std::string> &sentence) {
if (!src.good()) {
LOG(INFO) << "stream in bad state";
return false;
}
sentence.clear();
std::string line;
std::getline(src, line);
boost::algorithm::trim(line);
while (src.good() && (line.size() < 1)) {
std::getline(src, line);
boost::algorithm::trim(line);
}
if ((!src.good()) && (!src.eof())) {
LOG(FATAL) << "error when read files";
return false;
}
while (src.good() && line.size() > 0) {
sentence.push_back(line);
std::getline(src, line);
boost::algorithm::trim(line);
}
return true;
}
//-------------------------INTERFACE------------------------
BOOL IFileManager::ImportFile_3DS(
NFilePath pFilePath,
std::vector<NVECTOR3>& outVertexBuffer,
std::vector<NVECTOR2>& outTexCoordList,
std::vector<UINT>& outIndexBuffer,
std::vector<N_MeshSubsetInfo>& outSubsetList,
std::vector<N_Material>& outMaterialList,
std::unordered_map<std::string, NFilePath>& out_TexName2FilePathPairList)
{
static_meshObjList.clear();
static_materialList.clear();
static_TexName2FilePathPairList.clear();
fileIn.open(pFilePath, std::ios::binary);
if (!fileIn.good())
{
DEBUG_MSG1("Noise File Manager : Import .3ds file failed!!");
return FALSE;
}
fileIn.seekg(0, std::ios::end);
static_currentChunkFileEndPos = 0;
static_fileSize = fileIn.tellg();
fileIn.seekg(0);
//maybe linearly deal with chunks is also OK....
//stack will be used when necessary because recursive solution
//can sometimes be rewritten in non-recursive form using stack.
while (!fileIn.eof() && fileIn.good())
{
ReadChunk();
}
fileIn.close();
//Finish Parsing,check if Vertices/Indices had been loaded
auto& vertexList = static_meshObjList.back().verticesList;
if (vertexList.size() == 0 || vertexList.size() == 0)
{
DEBUG_MSG1("Noise File Manager :Data Damaged!!!No Vertices or Indices loaded!");
return FALSE;
}
//std::move transform lval into rval to avoid copying happens
N_Load3ds_MeshObject finalMeshObj;
IntegratePartialMeshIntoOnePiece(finalMeshObj);
outIndexBuffer = std::move(finalMeshObj.indicesList);
outVertexBuffer = std::move(finalMeshObj.verticesList);
outTexCoordList = std::move(finalMeshObj.texcoordList);
outSubsetList = std::move(finalMeshObj.subsetList);
outMaterialList = std::move(static_materialList);
out_TexName2FilePathPairList = std::move(static_TexName2FilePathPairList);
//used to generate unique name
++static_MeshIndex;
return TRUE;
}
bool ObjectRecord::loadFromStream(std::ifstream& inStream)
{
unsigned int len;
uint32_t Header = 0;
char ID_Buffer[256], Mesh_Buffer[256];
//read header "ObjS" (Object, Static)
inStream.read((char*) &Header, sizeof(uint32_t));
if (Header!=cHeaderObjS)
{
DuskLog() << "ObjectRecord::loadFromStream: ERROR: Stream contains invalid "
<< "record header.\n";
return false;
}//if
//read length of ID
inStream.read((char*) &len, sizeof(unsigned int));
if (len>255)
{
DuskLog() << "ObjectRecord::loadFromStream: ERROR: ID cannot be longer than "
<< "255 characters.\n";
return false;
}
//read ID
memset(ID_Buffer, 0, 256);
inStream.read(ID_Buffer, len);
ID_Buffer[len] = '\0'; //add terminating null character
if (!inStream.good())
{
DuskLog() << "ObjectRecord::loadFromStream: ERROR while reading data.\n";
return false;
}
//read length of mesh name
inStream.read((char*) &len, sizeof(unsigned int));
if (len>255)
{
DuskLog() << "ObjectRecord::loadFromStream: ERROR: Name of Mesh cannot be "
<< "longer than 255 characters.\n";
return false;
}
//read mesh
memset(Mesh_Buffer, 0, 256);
inStream.read(Mesh_Buffer, len);
Mesh_Buffer[len] = '\0'; //add terminating null character
//read collision flag
bool collision_flag = true;
inStream.read((char*) &collision_flag, sizeof(bool));
if (!inStream.good())
{
DuskLog() << "ObjectRecord::loadFromStream: ERROR while reading data.\n";
return false;
}
//now set the data
ID = std::string(ID_Buffer);
Mesh = std::string(Mesh_Buffer);
collide = collision_flag;
return true;
}
/**
* @brief read correlator meta-data and map to file positions
* @description Nissa text correlator files contain meta-data in the form
* of comment lines. One line gives information about the
* contracted propagators in the form
*
* S0_th0_m0_r0_ll ^ \dag S0_th0_m0_r0_ll
*
* where we are (currently) interested in the indices
* on the m and r tokens. Another comment line specifies
* the spin content of the correlator in the form
* "P5P5" or "V1A0", for example. This function
* reads through the whole file and extracts the two
* m and two r indices as well as the spin combination.
* It constructs a key based on this information and stores
* the file position of the character after the newline behind
* the spin combination tag. Thus it stores the position of the
* beginning of the correlator corresponding to the constructed key.
*
* @param ifs file to be parsed
* @param filemap output, map of file positions for the various correlators in the file
*/
inline void map_file(std::ifstream &ifs, std::map<std::string, std::iostream::pos_type> & filemap){
if( !ifs.good() ){
stop("map_file: input file stream not in a good state!");
}
std::string linebuf;
std::string::size_type comment_pos;
// currently the key for a two-point function consists of four unsigned integers (two mass and two r indices)
// and the name of the spin combination stored in the correlator
// a generalisation of the reader will have to modify this as well as the key construction
// for now we store the numeric key components in this array
unsigned int key_components[4];
while( ifs.good() ){
std::getline(ifs, linebuf);
// we search for commented lines
comment_pos = linebuf.find("#");
if( comment_pos != std::string::npos ){
// in these commented lines, we extract either
// the current set of mass / r parameter combinations
// or the current spin combination
// the line looks like so:
// " # Contraction of S0_th0_m0_r0_ll ^ \dag and S0_th0_m0_r0_ll"
std::string::size_type contr_pos = linebuf.find("Contraction");
if( contr_pos != std::string::npos ){
std::vector<char> lbcopy( linebuf.size() + 1 );
lbcopy[ linebuf.size() ] = '\0';
memcpy( lbcopy.data(), linebuf.c_str(), linebuf.size() );
unsigned int key_components_counter = 0;
char * token = strtok(lbcopy.data(), "_");
while( key_components_counter != 4 | token != NULL ){
if( token[0] == 'm' || token[0] == 'r'){
key_components[key_components_counter] = atoi(token+1);
key_components_counter++;
}
token = strtok(NULL, "_");
}
if(key_components_counter != 4 && token == NULL){
char message[200];
snprintf(message, 200, "map_file: unable to construct key components in parsing of '%s'", linebuf.c_str());
stop(message);
}
} else {
// the line looks like so:
// " # P5S0"
std::string::size_type last_space_pos = linebuf.find_last_of(" ");
std::string spin_comb = linebuf.substr(last_space_pos+1);
// now we can build the key
std::string key = make_key_2pt(key_components[0], key_components[2], key_components[1], key_components[3], spin_comb);
// and store the position after the current newline as the starting point
// of the present correlator
filemap[ key ] = ifs.tellg();
}
}
}
}
ossimFilename ossimRpfToc::getSourceTocFile(std::ifstream& dotRpfStr) const
{
ossimFilename tocFile;
if ( !dotRpfStr.good() )
{
dotRpfStr.clear();
}
dotRpfStr.seekg(0, ios_base::beg);
// Eat the first line which is the bounding rect.
std::string line;
std::getline(dotRpfStr, line);
// Get the second line which is first file.
std::getline(dotRpfStr, line);
// Get the file name and make the sub directory if needed.
ossimFilename file;
if ( getFile(line, file) )
{
ossimFilename subDir = file.path();
tocFile = subDir.dirCat("a.toc");
if ( !tocFile.exists() )
{
tocFile = subDir.dirCat("A.TOC");
if ( !tocFile.exists() )
{
subDir = subDir.path();
tocFile = subDir.dirCat("a.toc");
if ( !tocFile.exists() )
{
tocFile = subDir.dirCat("A.TOC");
if ( !tocFile.exists() )
{
tocFile.clear();
}
}
}
}
}
if ( !dotRpfStr.good() )
{
dotRpfStr.clear();
}
dotRpfStr.seekg(0, ios_base::beg);
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRpfToc::getSourceTocFile result: " << tocFile << "\n";
}
return tocFile;
}
bool file_manager::load_file(std::ifstream &fs, string_t& out_buf) const
{
if (!fs.is_open() || !fs.good()) return false;
while (fs.good()) {
out_buf.push_back(fs.get());
}
out_buf.erase(out_buf.size()-1,1);
return true;
}
void sigintHandler(int a)
{
while(footer_kml.good())
{
char c = footer_kml.get(); // get character from file
if (footer_kml.good())
kml_file << c;
}
kml_file << std::endl;
ros::requestShutdown();
}
bool LightRecord::loadFromStream(std::ifstream& inStream)
{
if (!inStream.good())
{
DuskLog() << "LightRecord::loadFromStream: ERROR: stream contains errors.\n";
return false;
}
char ID_Buffer[256];
uint32_t Header = 0;
inStream.read((char*) &Header, sizeof(uint32_t));
if (Header != cHeaderLight)
{
DuskLog() << "LightRecord::loadFromStream: ERROR: invalid record header.\n";
return false;
}
//read ID length
Header = 0;
inStream.read((char*) &Header, sizeof(uint32_t));
if (Header>255)
{
DuskLog() << "LightRecord::loadFromStream: ERROR: ID is longer than 255"
<< "characters.\n";
return false;
}
//read ID
memset(ID_Buffer, 0, Header+1);
inStream.read(ID_Buffer, Header);
if (!inStream.good())
{
DuskLog() << "LightRecord::loadFromStream: ERROR while reading light's"
<< " ID from stream.\n";
return false;
}
ID_Buffer[Header] = '\0'; //make sure it's NUL-terminated
ID = std::string(ID_Buffer);
//read RGB and radius
inStream.read((char*) &red, sizeof(float));
inStream.read((char*) &green, sizeof(float));
inStream.read((char*) &blue, sizeof(float));
inStream.read((char*) &radius, sizeof(float));
//read light type
inStream.read((char*) &type, sizeof(Ogre::Light::LightTypes));
if (!inStream.good())
{
DuskLog() << "LightRecord::loadFromStream: ERROR while reading light's"
<< " colour values from stream.\n";
return false;
}
//normalise values, just to be safe
normalise();
return true;
}
bool NodePartitionedMeshReader::openASCIIFiles(std::string const& file_name_base,
std::ifstream& is_cfg, std::ifstream& is_node, std::ifstream& is_elem) const
{
const std::string fname_header = file_name_base + "_partitioned_";
const std::string fname_num_p_ext = std::to_string(_mpi_comm_size) + ".msh";
{ // Configuration.
std::string const filename = fname_header + "cfg" + fname_num_p_ext;
is_cfg.open(filename);
if( !is_cfg.good() )
{
ERR("Error opening file %s for input.", filename.c_str());
return false;
}
std::string tmp_line;
std::getline(is_cfg, tmp_line);
int num_parts;
is_cfg >> num_parts >> std::ws;
if(num_parts != _mpi_comm_size)
{
ERR("Aborting computation because of number of cores"
"/ subdomains mismatch.");
return false;
}
}
{ // Nodes.
std::string const filename = fname_header + "nodes_" + fname_num_p_ext;
is_node.open(filename);
if( !is_node.good() )
{
ERR("Error opening file %s for input.", filename.c_str());
return false;
}
}
{ // Elements.
std::string const filename = fname_header + "elems_" + fname_num_p_ext;
is_elem.open(filename);
if( !is_elem.good() )
{
ERR("Error opening file %s for input.", filename.c_str());
return false;
}
}
return true;
}
bool TGAImage::load_rle_data(std::ifstream &in) {
unsigned long pixelcount = width*height;
unsigned long currentpixel = 0;
unsigned long currentbyte = 0;
TGAColor colorbuffer;
do {
unsigned char chunkheader = 0;
chunkheader = in.get();
if (!in.good()) {
std::cerr << "an error occured while reading the data\n";
return false;
}
if (chunkheader<128) {
chunkheader++;
for (int i = 0; i<chunkheader; i++) {
in.read((char *)colorbuffer.raw, bytespp);
if (!in.good()) {
std::cerr << "an error occured while reading the header\n";
return false;
}
for (int t = 0; t<bytespp; t++)
data[currentbyte++] = colorbuffer.raw[t];
currentpixel++;
if (currentpixel>pixelcount) {
std::cerr << "Too many pixels read\n";
return false;
}
}
}
else {
chunkheader -= 127;
in.read((char *)colorbuffer.raw, bytespp);
if (!in.good()) {
std::cerr << "an error occured while reading the header\n";
return false;
}
for (int i = 0; i<chunkheader; i++) {
for (int t = 0; t<bytespp; t++)
data[currentbyte++] = colorbuffer.raw[t];
currentpixel++;
if (currentpixel>pixelcount) {
std::cerr << "Too many pixels read\n";
return false;
}
}
}
} while (currentpixel < pixelcount);
return true;
}
bool SoundRecord::loadFromStream(std::ifstream& inStream)
{
uint32_t len = 0;
//read header "Soun" (Sound)
inStream.read((char*) &len, sizeof(uint32_t));
if (len!=cHeaderSoun)
{
DuskLog() << "SoundRecord::loadFromStream: ERROR: Stream contains invalid "
<< "record header.\n";
return false;
}//if
//read length of ID
inStream.read((char*) &len, sizeof(uint32_t));
if (len>255)
{
DuskLog() << "SoundRecord::loadFromStream: ERROR: ID cannot be longer than "
<< "255 characters.\n";
return false;
}
//read ID
char buffer[256];
memset(buffer, 0, 256);
inStream.read(buffer, len);
if (!inStream.good())
{
DuskLog() << "SoundRecord::loadFromStream: ERROR while reading ID.\n";
return false;
}
ID = std::string(buffer);
//read length of path
inStream.read((char*) &len, sizeof(uint32_t));
if (len>255)
{
DuskLog() << "SoundRecord::loadFromStream: ERROR: File path cannot "
<< "be longer than 255 characters.\n";
return false;
}
//read mesh
memset(buffer, 0, 256);
inStream.read(buffer, len);
if (!inStream.good())
{
DuskLog() << "SoundRecord::loadFromStream: ERROR while reading path data.\n";
return false;
}
filePath = std::string(buffer);
return (!filePath.empty() and !ID.empty());
}
//-------------------------------------------------------------------------//
bool Material::Load(std::ifstream& ifs)
{
//-----------------------------------------------------------------------//
// Throw assertion is file streams is not open.
assert(ifs.is_open() && ifs.good());
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// If the file stream is not open return false.
if(!ifs.is_open() || !ifs.good())
return false;
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// This string will hold the label that describes some camera parameter.
string strLabel;
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// This unsigned short will count the number of camera parameters read in
// and will be used to verify that the correct number of parameters have
// been initialized.
unsigned short usParameterCount = 0;
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// The for loop will read in data from the file stream and will set
// the objects data members accordingly.
for(unsigned short i = 0; i < NUMBER_OF_MATERIAL_PARAMETERS; i++)
{
//---------------------------------------------------------------------//
// Read in the label
ifs >> strLabel;
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
// Match the label to some predefined token and set the proper data member.
float fR, fG, fB, fA;
if(strLabel == DIFFUSE_COLOR_LABEL)
{
ifs >> fR;
ifs >> fG;
ifs >> fB;
ifs >> fA;
this->SetDiffuse(fR, fG, fB);
usParameterCount++;
}
else if(strLabel == AMBIENT_FACTOR_LABEL)
bool FastaFile::readLine() {
int n;
ifsIn.getline(pcLine, nMaxLineLength);
if ( pcLine[0] == '>' ) {
if ( curSeqIndex >= 0 ) {
updateCurrentSequenceInfo();
}
std::vector<std::string> tokens;
tokenizeString(pcLine, tokens);
curSeqName = tokens[0].substr(1); // make SeqName without leading '>'
MD5Init(&curMD5Ctx);
curSeqLength = 0;
++curSeqIndex;
}
else {
n = strlen(pcLine);
// convert to upper-case for calculating FASTA MD5
for(int i = 0; i < n; ++i)
{
pcLine[i] = toupper(pcLine[i]);
}
MD5Update(&curMD5Ctx, (unsigned char*)pcLine, n);
curSeqLength += n;
}
++nCurrentLine;
return ifsIn.good();
}
void tokenizePatternFile(std::ifstream& in) {
// tokenize a line from the pattern file. The first part will be the pattern and the second
// part is the file to write to.
std::string lineptr;
while(in.good()) {
std::getline(in, lineptr);
if(lineptr.empty()) {
continue;
}
std::vector<std::string> fields;
split(fields, lineptr, "\t");
switch(fields.size()) {
case 0:
break;
case 1:
manager.add(fields[0]);
if(opts.r_flag) {
std::string rcpattern = fields[0];
reverseComplement(rcpattern);
manager.add(rcpattern);
}
break;
default:
manager.add(fields[0], fields[1]);
if(opts.r_flag) {
std::string rcpattern = fields[0];
reverseComplement(rcpattern);
manager.add(rcpattern, fields[1]);
}
break;
}
}
}
bool InpNativeInfo::read_file()
{
if(already_read)
std::cout << "Warning: trying to substitute ninfo for already initiated object."
<< std::endl;
already_read = true;
if(!inpfile.good())
{
throw std::invalid_argument("file open error");
}
bool read(false);
while(!inpfile.eof())
{
std::string line;
std::getline(inpfile, line);
if(line.empty()) continue;
if(line[0] == '\x2a') continue;
if(eq_ignorecase(line.substr(0,20), "<<<< native_info_sim"))
{
read = true;
std::string temp(line, 20);
simN = std::stoi(temp);
read_block(inpfile);
}
}
return read;
}
void displaytext_delay(std::ifstream& File)
{
std::string Lines = "";
int j=0;
sleep_for(seconds(3));
if (File)
{
while (File.good ())
{
std::string TempLines;
std::getline (File , TempLines);
TempLines += "\n";
char myArray[TempLines.size()+1];
strcpy(myArray, TempLines.c_str());
for (int i=0; i<TempLines.size();i++)
{
mvaddch(j,(40+i),myArray[i]);
refresh();
sleep_for(milliseconds(50));
}
j=j+1;
refresh();
sleep_until(system_clock::now() + seconds(1));
}
printw("###################$$$$$$$$$$$$$$$$###################\n");
printw(" WELCOME TO DORK\n");
printw("###################$$$$$$$$$$$$$$$$###################\n");
}
else //Return error
{
cout<< "ERROR File does not exist.";
}
}
void l1menu::TriggerMenu::loadMenuInOldFormat( std::ifstream& file )
{
const size_t bufferSize=200;
char buffer[bufferSize];
while( file.good() )
{
try
{
// Get one line at a time
file.getline( buffer, bufferSize );
// split the line by whitespace into columns
std::vector<std::string> tableColumns=l1menu::tools::splitByWhitespace( buffer );
if( tableColumns.size()==1 && tableColumns[0].empty() ) continue; // Allow blank lines without giving a warning
if( tableColumns.size()!=12 ) throw std::runtime_error( "The line does not have the correct number of columns" );
addTriggerFromOldFormat( tableColumns );
} // end of try block
catch( std::runtime_error& exception )
{
std::cout << "Some error occured while processing the line \"" << buffer << "\":" << exception.what() << std::endl;
}
}
}
std::vector <points> read (std::ifstream &f,int a,int b,int c,int d){
std::vector <points> v;
f.clear();
f.seekg(0, std::ios::beg);
while (f.good()){
std::string s;
f>>s;
std::stringstream ss;
ss<<s;
int temp_x,temp_y;
ss>>temp_x;
s.clear();ss.clear();
f>>s;
ss<<s;
ss>>temp_y;
points temp(temp_x,temp_y,a,b,c,d);
v.push_back(temp);
}
return v;
}
void GlowNodeGroup::open(std::ifstream& fp)
{
int type = 0;
int end_found = 0;
char dummy[40];
for (;;) {
if (!fp.good()) {
fp.clear();
fp.getline(dummy, sizeof(dummy));
printf("** Read error GlowNodeGroup: \"%d %s\"\n", type, dummy);
}
fp >> type;
switch (type) {
case glow_eSave_NodeGroup:
break;
case glow_eSave_NodeGroup_nodeclass_part:
GlowNodeClass::open(fp);
break;
case glow_eSave_End:
end_found = 1;
break;
default:
std::cout << "GrowGroup:open syntax error\n";
fp.getline(dummy, sizeof(dummy));
}
if (end_found)
break;
}
}
