R_Tree::R_Tree(std::ifstream& in)
{
error_code = 0;
tree = 0;
reverse_bytes = false;
f_offset = in.tellg();
const unsigned int header_size = 48;
char* header_bytes = new char[header_size];
in.read(header_bytes, header_size);
if(!in.good()){
error_code = 1;
std::cerr << "R_Tree Unable to read in index from file " << std::endl;
delete []header_bytes;
return;
}
header_magic = *(unsigned int*)header_bytes;
if(header_magic != R_TREE_MAGIC){
reverse_bytes = true;
header_magic = __builtin_bswap32(header_magic);
}
if(header_magic != R_TREE_MAGIC){
std::cerr << "R_Tree Unable to find correct magic got: " << header_magic
<< "Wanted : " << R_TREE_MAGIC << std::endl;
error_code = 2;
delete []header_bytes;
return;
}
ByteReader br(header_bytes, header_size, reverse_bytes);
blockSize = br.ui(4);
itemCount = br.ul(8);
startChromIx = br.ui(16);
startBase = br.ui(20);
endChromIx = br.ui(24);
endBase = br.ui(28);
endFileOffset = br.ul(32);
itemsPerSlot = br.ui(40);
reserved = br.ui(44);
delete []header_bytes;
tree = new R_TreeNode(in, 0, in.tellg(), reverse_bytes);
}
void
Producer::populateSegments(std::ifstream& ifs)
{
BOOST_ASSERT(m_segments.size() == 0);
// calculate how many segments are needed
std::streampos begin, end;
begin = ifs.tellg();
ifs.seekg(0, std::ios::end);
end = ifs.tellg();
int num_segments = (end-begin) / m_maxSegmentSize;
if ((end-begin) % m_maxSegmentSize != 0)
num_segments++;
std::cout << "Size of the file: " << (end-begin) << " bytes." << std::endl;
std::cout << "Maximum size of a segment: " << m_maxSegmentSize << " bytes." << std::endl;
std::cout << "Number of segments: " << num_segments << std::endl;
std::vector<uint8_t> buffer(m_maxSegmentSize);
ifs.seekg(0, std::ios::beg);
for (int i = 0; i < (end-begin) / m_maxSegmentSize; ++i) {
ifs.read(reinterpret_cast<char*>(buffer.data()), m_maxSegmentSize);
auto data = make_shared<Data>(Name(m_prefix).appendSegment(i));
data->setFreshnessPeriod(m_freshnessPeriod);
data->setContent(&buffer[0], m_maxSegmentSize);
//std::cout << *data << std::endl;
m_segments.push_back(data);
}
if ((end-begin) % m_maxSegmentSize != 0) {
ifs.read(reinterpret_cast<char*>(buffer.data()), (end-begin) % m_maxSegmentSize);
auto data = make_shared<Data>(Name(m_prefix).appendSegment(m_segments.size()));
data->setFreshnessPeriod(m_freshnessPeriod);
data->setContent(&buffer[0], (end-begin) % m_maxSegmentSize);
//std::cout << *data << std::endl;
m_segments.push_back(data);
}
auto finalBlockId = name::Component::fromSegment(m_segments.size() - 1);
for (const auto& data : m_segments) {
data->setFinalBlockId(finalBlockId);
m_keyChain.sign(*data, m_signingInfo);
}
}
unsigned long getFileLength(std::ifstream& file)
{
if(!file.good()) return 0;
file.seekg(0, std::ios::end);
std::streamoff len = file.tellg();
file.seekg(std::ios::beg);
return (unsigned long)len;
}
//father:Material Block
//child : sub color chunk
void ParseSpecularColor()
{
uint64_t filePos = 0;
do
{
ReadAndParseColorChunk(static_materialList.back().baseMaterial.mBaseSpecularColor);
filePos = fileIn.tellg();
} while (filePos<static_currentChunkFileEndPos);
}
static void copyKeyword( std::ifstream& is , std::ofstream& os) {
std::ios::pos_type start_pos = is.tellg();
skipKeyword( is );
{
std::ios::pos_type end_pos = is.tellg();
long length = end_pos - start_pos;
{
char * buffer = new char[length];
{
is.seekg( start_pos );
is.read( buffer , length );
}
os.write( buffer , length );
delete[] buffer;
}
}
}
/**
* @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();
}
}
}
}
bool WLMatLib::MATReader::readMatrixDouble( Eigen::MatrixXd* const matrix, const ElementInfo_t& element, std::ifstream& ifs,
const FileInfo_t& info )
{
// Check some errors //
// ----------------- //
if( matrix == NULL )
{
wlog::error( LIBNAME ) << "Matrix object is null!";
return false;
}
if( info.fileSize <= static_cast< size_t >( element.posData ) )
{
wlog::error( LIBNAME ) << "Data position is beyond file end!";
return false;
}
if( element.dataType != DataTypes::miMATRIX )
{
wlog::error( LIBNAME ) << "Data type is not a matrix: " << element.dataType;
return false;
}
const mArrayType_t arrayType = ArrayFlags::getArrayType( element.arrayFlags );
if( arrayType != ArrayTypes::mxDOUBLE_CLASS )
{
wlog::error( LIBNAME ) << "Numeric Types does not match!";
return false;
}
const std::streampos pos = ifs.tellg();
// Read data //
// --------- //
ifs.seekg( element.posData );
mDataType_t type;
mNumBytes_t bytes;
if( !readTagField( &type, &bytes, ifs ) )
{
wlog::error( LIBNAME ) << "Could not read Data Element!";
ifs.seekg( pos );
return false;
}
if( type != DataTypes::miDOUBLE )
{
wlog::error( LIBNAME ) << "Numeric Types does not match or compressed data, which is not supported: " << type;
ifs.seekg( pos );
return false;
}
matrix->resize( element.rows, element.cols );
ifs.read( ( char* )matrix->data(), bytes );
nextElement( ifs, element.posData, bytes );
return true;
}
unsigned long Shader::getFileLength(std::ifstream& in)
{
if (!in.good()) return 0;
in.seekg(0, in.end);
unsigned long length = in.tellg();
in.seekg(0, in.beg);
return length;
}
/**
* initialize the laserxa files
*/
void
init ()
{
// read the info header
this->close ();
file_in_.open (filename_, std::ios::in | std::ios::binary);
file_in_.seekg (0, std::ios::beg);
file_in_.read ((char*) &info_, sizeof(LaserxaInfo));
// length of size
auto current_pos = file_in_.tellg ();
file_in_.seekg (0, std::ios::end);
auto end = file_in_.tellg ();
data_count_ = (static_cast<size_t> (end)
- static_cast<size_t> (current_pos)
/ static_cast<size_t> (sizeof(LaserxaData)));
}
int GetCommand::getFileSize(std::ifstream &ifs)
{
//http://washieagle.blogspot.jp/2010/01/stdfstream.html
int eofPos;
int begPos;
//末尾
ifs.seekg(0, std::ifstream::end);
eofPos = ifs.tellg();
ifs.clear();
//å…ˆé
ifs.seekg(0, std::ifstream::beg);
begPos = ifs.tellg();
return eofPos - begPos;
}
bool open(const char* path) {
std::streampos tmp,tmp2;
close();
m_fp.close();
m_fp.open(path,std::ios::binary);
if (!m_fp.is_open())
return false;
m_fp.seekg(0,std::ios::beg);
tmp = m_fp.tellg();
m_fp.seekg(0,std::ios::end);
tmp2 = m_fp.tellg();
m_fp_size = (uint64_t)(tmp2 - tmp);
m_fp.seekg(0,std::ios::beg);
m_fp_offs = 0U;
return true;
}
unsigned long jE::getFileLength(std::ifstream& file)
{
if(!file.good()) return 0;
//unsigned long pos=file.tellg();
file.seekg(0, std::ios::end);
unsigned long len = file.tellg();
file.seekg(std::ios::beg);
return len;
}
Csv_input_pointset_dialog::Csv_input_pointset_dialog( std::ifstream& infile,
QWidget* parent ,
const char* name )
: QWidget( parent) {
setupUi(this);
std::streampos mark = infile.tellg();
std::string str;
std::getline(infile, str);
QString qstr(str.c_str());
// QTextStream inFileStream(infile,QIODevice::ReadWrite);
// QString str;
// inFileStream >> str;
// inFileStream.readLine();
QStringList property_names = qstr.split(",");
X_col_name_->addItems(property_names);
X_col_name_->addItem("None");
Y_col_name_->addItems(property_names);
Y_col_name_->addItem("None");
Z_col_name_->addItems(property_names);
Z_col_name_->addItem("None");
//Set default selection
X_col_name_->setCurrentIndex(0);
Y_col_name_->setCurrentIndex(std::min(1,property_names.size()));
Z_col_name_->setCurrentIndex(std::min(2,property_names.size()));
// make a preview of the file
QString text;
std::string line;
int count = 0;
const int limit = 50;
// Read up to "limit" lines
while( std::getline( infile, line ) && count < limit ) {
line += "\n";
text.append( line.c_str() );
count ++;
}
text_preview_->setPlainText( text );
// set the stream back to where it was
infile.clear();
infile.seekg( mark );
name_->setFocus();
}
CPU::E_CPU PE::extract_information_from_binary(std::ifstream &file)
{
RP_IMAGE_DOS_HEADER imgDosHeader = {0};
RP_IMAGE_NT_HEADERS32 imgNtHeaders32 = {0};
CPU::E_CPU cpu = CPU::CPU_UNKNOWN;
std::cout << "Loading PE information.." << std::endl;
/* Remember where the caller was in the file */
std::streampos off = file.tellg();
file.seekg(0, std::ios::beg);
file.read((char*)&imgDosHeader, sizeof(RP_IMAGE_DOS_HEADER));
file.seekg(imgDosHeader.e_lfanew, std::ios::beg);
/*
* Yeah, in fact, we don't know yet if it is a x86/x64 PE ;
* so just we grab the signature field, FILE_HEADER and the field Magic
*/
file.read((char*)&imgNtHeaders32, sizeof(unsigned int) + sizeof(RP_IMAGE_FILE_HEADER) + sizeof(unsigned int));
if(imgNtHeaders32.Signature != RP_IMAGE_NT_SIGNATURE)
RAISE_EXCEPTION("This file doesn't seem to be a correct PE (bad IMAGE_NT_SIGNATURE)");
switch(imgNtHeaders32.OptionalHeader.Magic)
{
case RP_IMAGE_NT_OPTIONAL_HDR32_MAGIC:
{
cpu = CPU::CPU_x86;
/* Ok, now we can allocate the good version of the PE Layout */
/* The 32bits version there! */
init_properly_PELayout<x86Version>();
break;
}
case RP_IMAGE_NT_OPTIONAL_HDR64_MAGIC:
{
cpu = CPU::CPU_x64;
init_properly_PELayout<x64Version>();
break;
}
default:
RAISE_EXCEPTION("Cannot determine the CPU type");
}
/* Now we can fill the structure */
std::memcpy(&m_pPELayout->imgDosHeader, &imgDosHeader, m_pPELayout->get_image_dos_header_size());
m_pPELayout->fill_nt_structures(file);
file.seekg(off);
return cpu;
}
bool open(const char_type* file_name)
{
in.open(file_name,std::ios::binary);
if(in)
{
in.seekg(0,std::ios::end);
size_ = in.tellg();
in.seekg(0,std::ios::beg);
}
return in.good();
}
//father:Material Block
//child : Mapping File Path (Map option)
void ParseSpecularMap()
{
//data:sub chunks
uint64_t filePos = 0;
do
{
//mapName-mapFilePath pair will be added in this function
ReadAndParseMapChunk(static_materialList.back().specularMapName);
filePos = fileIn.tellg();
} while (filePos<static_currentChunkFileEndPos);
}
//*************************************************
//father:Material Block
//child : sub color chunk
void ParseAmbientColor()
{
//data:sub chunks
uint64_t filePos = 0;
do
{
ReadAndParseColorChunk(static_materialList.back().baseMaterial.mBaseAmbientColor);
filePos = fileIn.tellg();
} while (filePos<static_currentChunkFileEndPos);
}
void initAstFromString(std::ifstream & in_file) {
SgScopeStatement * scope = SageBuilder::buildBasicBlock();
AstFromString::c_sgnode = scope;
SageBuilder::pushScopeStack(scope);
SgName pow_name("pow");
SgFunctionDeclaration * pow_decl = SageBuilder::buildNondefiningFunctionDeclaration(
pow_name,
SageBuilder::buildDoubleType(),
SageBuilder::buildFunctionParameterList(
SageBuilder::buildInitializedName("base", SageBuilder::buildDoubleType()),
SageBuilder::buildInitializedName("exp", SageBuilder::buildDoubleType())
),
scope,
NULL
);
scope->insert_symbol(pow_name, new SgFunctionSymbol(pow_decl));
SgName sqrt_name("sqrt");
SgFunctionDeclaration * sqrt_decl = SageBuilder::buildNondefiningFunctionDeclaration(
sqrt_name,
SageBuilder::buildDoubleType(),
SageBuilder::buildFunctionParameterList(
SageBuilder::buildInitializedName("v", SageBuilder::buildDoubleType())
),
scope,
NULL
);
scope->insert_symbol(sqrt_name, new SgFunctionSymbol(sqrt_decl));
SgName abs_name("fabs");
SgFunctionDeclaration * abs_decl = SageBuilder::buildNondefiningFunctionDeclaration(
abs_name,
SageBuilder::buildDoubleType(),
SageBuilder::buildFunctionParameterList(
SageBuilder::buildInitializedName("v", SageBuilder::buildDoubleType())
),
scope,
NULL
);
scope->insert_symbol(abs_name, new SgFunctionSymbol(abs_decl));
in_file.seekg (0, in_file.end);
int length = in_file.tellg();
in_file.seekg (0, in_file.beg);
char * tmp_char_str = new char [length + 1];
in_file.read(tmp_char_str, length);
tmp_char_str[length] = 0;
AstFromString::c_char = tmp_char_str;
AstFromString::afs_skip_whitespace();
}
size_t getFileSize(std::ifstream& file)
{
if(!file.good()) return 0;
//size_t pos = file.tellg();
file.seekg(0,std::ios::end);
std::streamoff len = file.tellg();
file.seekg(std::ios::beg);
return (size_t)len;
}
/******************** SUPPORT FUNCTIONS *********************/
size_t nextReadPosition(std::ifstream& ifs, size_t off = 0) {
ifs.seekg(off);
size_t candidate = off;
char line[MAX_BUFFER_SIZE];
line[0] = 0;
// look for the first occurance of '@' at the beginning of a line
while(line[0] != '@' && !ifs.eof()) {
candidate = ifs.tellg();
ifs.getline(line, MAX_BUFFER_SIZE);
}
// end of file reached and no reads have been found
if (ifs.eof()) {
return off;
}
size_t tmp = ifs.tellg();
// read the next line to double check that '@' defines a proper start of a read
ifs.getline(line, MAX_BUFFER_SIZE);
candidate = (line[0] != '@') ? candidate : tmp;
return candidate;
}
bool FRAME::read(std::ifstream & s, PIXELTYPE pixelFormat) {
bool result = s & size
&& s & magicNumber
&& s & chunks_old
&& s & duration
&& s & reserved
&& s & chunkCount;
if (result) {
//std::cout << std::hex << "DEBUG Frame: magicNumber: " << magicNumber << " chunks_old: " << chunks_old << std::dec << "\n";
chunks.reserve(chunkCount);
for (size_t c = 0; c < chunkCount && result; c++) {
DWORD size;
WORD type;
constexpr size_t CHUNK_HEADER_SIZE = sizeof(size) + sizeof(type);
auto p = s.tellg();
result = result && s & size && s & type;
//auto p2 = s.tellg();
//std::cout << std::hex << "0x" << p2 << ":DEBUG Chunk: size: " << size << " type: " << type << std::dec << "\n";
switch (type) {
case PALETTE_OLD_0x0004: {
case PALETTE_OLD_0x0011:
chunks.emplace_back(PALETTE_OLD_CHUNK(s), type);
break;
}
case LAYER_0x2004: {
chunks.emplace_back(LAYER_CHUNK(s), type);
break;
}
case CEL_0x2005: {
chunks.emplace_back(CEL_CHUNK(s, pixelFormat, size - CHUNK_HEADER_SIZE), type);
break;
}
case FRAME_TAGS_0x2018: {
chunks.emplace_back(TAG_CHUNK(s), type);
break;
}
case PALETTE_0x2019: {
chunks.emplace_back(PALETTE_CHUNK(s), type);
break;
}
case SLICE_0x2022: {
chunks.emplace_back(SLICE_CHUNK(s), type);
break;
}
default:
//std::cout << "^ not parsed\n";
s.seekg(size + p); // skip data
}
result = result && s.good();
}
}
return result;
}
unsigned long getFileLength(std::ifstream& file)
{
if (!file.good())
{
return 0;
}
file.seekg(0, std::ios::end);
unsigned long length = file.tellg();
file.seekg(std::ios::beg);
return length;
}
uint16_t _read_16(uint32_t offset) {
uint16_t value;
uint32_t tell;
tell = _in.tellg();
_in.seekg(_offset + offset, std::ios::beg);
_in.read((char*)&value, 2);
_in.seekg(tell, std::ios::beg);
return BIG2LE_16(value);
}
Utils::Utils(int size, std::ifstream &f)
: clearFirst(false), data(""), size(0), row(0), col(0) {
std::streampos cPos = f.tellg();
std::string theline;
this->size = size;
getline(f, theline);
for (int i = 0; i < size; i++) {
getline( f, theline );
data += theline.substr(0,size);
}
// reset the file stream
f.seekg(cPos);
}
void DTMImage::ReadBinaryHeader( std::ifstream & ifs )
{
ifs.seekg(0,std::ios::beg);
int Dimensions[3];
for ( int i = 0; i < 3; ++i ) ifs.read(reinterpret_cast<char *>(&Dimensions[i]), sizeof(int));
this->SetDimensions(Dimensions);
for ( int i = 0; i < 3; ++i ) ifs.read(reinterpret_cast<char *>(&this->ImageData::origin[i]), sizeof(double));
for ( int i = 0; i < 3; ++i ) ifs.read(reinterpret_cast<char *>(&this->ImageData::spacing[i]), sizeof(double));
for ( int i = 0; i < 3; ++i ) ifs.read(reinterpret_cast<char *>(&this->ImageData::indexIncrement[i]), sizeof(int));
ifs.read(reinterpret_cast<char *>(&this->scalarType), sizeof(int));
this->startOfScalars = ifs.tellg();
}
int utr_io_count_string_in_file(
std::ifstream & File,
const string & To_find
)
{
int starting_point = File.tellg();
int count = std::count(std::istream_iterator<string>(File),
std::istream_iterator<string>(),
To_find);
File.clear();
File.seekg(starting_point);
assert(File.good());
return count;
}
inline uint32_t lookup3(std::ifstream &stream, uint32_t length, const uint32_t &init)
{
auto hash = init;
std::vector<char> buffer(length);
auto pos = stream.tellg();
stream.read(buffer.data(), length);
hash = hashlittle(buffer.data(), length, hash);
stream.seekg(pos);
return hash;
}
bool Field::Load(std::ifstream& f, int shift){
S_LOG("Load");
auto current = std::ios_base::cur;
if (f.good()){
f.seekg(shift, current);
log(logxx::debug) << "Current position: 0x" << std::hex << f.tellg() << std::dec << logxx::endl;
uint32_t fieldLength(0);
char optionalField[2];
f.read(optionalField, 2);
check_error(optionalField);
if (
std::strncmp(optionalField, "PN", 2) == 0 ||
std::strncmp(optionalField, "LO", 2) == 0 ||
std::strncmp(optionalField, "DA", 2) == 0
){
uint16_t shortFieldLength(0);
fread(shortFieldLength);
fieldLength = shortFieldLength;
} else{
f.seekg(-2, std::ios_base::cur);
fread(fieldLength);
}
static const decltype(fieldLength) maxLength = 100;
if (fieldLength == 0){
log(logxx::warning) << "Field length is zero, nothing to read!" << logxx::endl;
return false;
} else if (fieldLength > maxLength){
log(logxx::warning) << "Too large field: " << fieldLength <<
"; maximum allowed is: " << maxLength << logxx::endl;
return false;
}
std::unique_ptr<char[]> cValue(new char[fieldLength]);
f.read(cValue.get(), fieldLength);
check_error(cValue);
try {
value.assign(cValue.get(), fieldLength);
ProcessValue();
return true;
} catch (const std::exception& e){
log(logxx::warning) << "Cought an exception: " << e.what() << logxx::endl;
value.assign('%', fieldLength);
return true;
}
} else {
log(logxx::error) << "Can't read file" << logxx::endl;
return false;
}
}
void AudioStreamingServer::StreamFile(const std::shared_ptr<ISocket>& clientSocket, std::ifstream& file, HttpContentType contentType) const {
file.seekg(0, file.end);
int fileLength = file.tellg();
HttpResponse response(HTTP_1_1, OK, contentType, fileLength);
SendResponseHeader(clientSocket, response);
file.seekg(0, file.beg);
char sendbuf[DEFAULT_BUFFER_SIZE] = { 0 };
file.read(sendbuf, DEFAULT_BUFFER_SIZE);
while(file.gcount() > 0) {
clientSocket->Send(sendbuf, file.gcount());
file.read(sendbuf, DEFAULT_BUFFER_SIZE);
}
}
bool rspfFgdcTxtDoc::findKey(
std::ifstream& str, bool seekBack, const std::string& key, std::string& value)
{
bool result = false;
std::vector<rspfString> fgdcKeyValue;
rspfString separator = ":";
rspfString line;
rspfKeywordlist projectionKwl;
std::streampos currentPosition = str.tellg();
while ( !str.eof() )
{
// Read line:
std::getline( str, line.string() );
if ( line.size() )
{
// Eat white space.
line.trim();
// Split between ':'
fgdcKeyValue.clear();
line.split(fgdcKeyValue, separator, false);
if ( fgdcKeyValue.size() == 2 )
{
fgdcKeyValue[0].trim();
if ( fgdcKeyValue[0].size() )
{
if ( fgdcKeyValue[0] == key )
{
// Found it. Initialize value and get out.
result = true;
fgdcKeyValue[1].trim();
value = fgdcKeyValue[1].string();
break; // from while loop.
}
}
}
}
}
if ( seekBack )
{
str.seekg(currentPosition);
}
return result;
}
