void BoundingVolume::ReadBV(fstream &fin, BoundingVolume* &bvPtr)
{
unsigned int bvType;
fin.read( (char*)&bvType, sizeof(unsigned int) );
switch(bvType)
{
case EDCO_SPHERE:
{
bvPtr = new Sphere;
Sphere* spherePtr = (Sphere*)bvPtr;
fin.read( (char*)spherePtr->center.v, sizeof(Float3) );
fin.read( (char*)&spherePtr->radius, sizeof(float) );
}
break;
case EDCO_AABB:
{
bvPtr = new Aabb;
Aabb* aabbPtr = (Aabb*)bvPtr;
fin.read( (char*)aabbPtr->min.v, sizeof(Float3) );
fin.read( (char*)aabbPtr->max.v, sizeof(Float3) );
}
break;
default:
break;
}
}
void
ScaleBarObject::load(fstream& fin)
{
clear();
int len;
bool done = false;
char keyword[100];
while (!done)
{
fin.getline(keyword, 100, 0);
if (strcmp(keyword, "scalebarobjectend") == 0)
done = true;
else if (strcmp(keyword, "position") == 0)
{
float x, y;
fin.read((char*)&x, sizeof(float));
fin.read((char*)&y, sizeof(float));
m_pos = QPointF(x,y);
}
else if (strcmp(keyword, "voxels") == 0)
fin.read((char*)&m_voxels, sizeof(float));
else if (strcmp(keyword, "type") == 0)
fin.read((char*)&m_type, sizeof(bool));
else if (strcmp(keyword, "textpos") == 0)
fin.read((char*)&m_textpos, sizeof(bool));
}
}
/**********************************************************************
Wczytuje bufor atrybutow dla mesh'a z pliku. Bufor atrybutow ma
postac: indeks macierzy, waga, indeks macierzy, waga...
**********************************************************************/
void SkinnedMesh::loadAttributes(fstream &file)
{
//Maksymalna ilosc kosci, wplywajacych na wierzcholek.
file.read((char*)&wmax,sizeof(int));
abuf=new float[vnum*wmax*2];
file.read((char*)abuf,sizeof(float)*wmax*vnum*2);
//Przygotowanie VBO dla buforow atrybutow.
avbo=new GLuint[wmax];
glGenBuffersARB(wmax, avbo);
unsigned int offset=0;
for(unsigned int i=0; i<wmax; i++)
{
glBindBufferARB(GL_ARRAY_BUFFER_ARB,avbo[i]);
glBufferDataARB(GL_ARRAY_BUFFER_ARB,vnum*2*sizeof(float),abuf+offset,GL_STATIC_DRAW_ARB);
offset+=vnum*2;
}
//Deaktywacja buforow.
glBindBufferARB(GL_ARRAY_BUFFER_ARB,0);
if(abuf) { delete[] abuf; abuf=NULL; }
}
void BLOCK::read(fstream &fp){
fp.read((char*)&bytesUsed, sizeof(bytesUsed));
for(int i = 0; i < bytesUsed; i++){
fp.read((char*)&data[i], sizeof(char));
}
fp.read((char*)&next, sizeof(next));
}
// create formatted text file for printing
void createTextFile(fstream &readFromFile)
{
// create text file
ofstream outPrintFile("print.txt", ios::out);
// exit program if ofstream cannot create file
if (!outPrintFile)
{
cerr << "File could not be created" << endl;
exit(1);
} // end if
outPrintFile << left << setw(10) << "Account" << setw(16)
<< "Last name" << setw(11) << "First Name" << right << setw(10)
<< "Balance" << endl;
// ** SET FILE POSITION POINTER TO BEGINNING OF readFromFile
readFromFile.seekg(0);
// read first record from record file
ClientData client;
readFromFile.read( reinterpret_cast<char *>(&client), sizeof ( ClientData) );
// copy all records from record file into text file
while (!readFromFile.eof() ) // While not the end of file
{
// Write single record to text file
if (client.getAccountNumber() != 0) // skip empty records
outputLine(outPrintFile, client);
// read next record from record file
readFromFile.read(reinterpret_cast<char * >(&client), sizeof( ClientData ) );
} // end while
} // end function createTextFile
bool CCoder::decodeRLE( fstream& in, CFastOStream& out ) {
uint32_t blockSize = 0;
uint32_t lastBlockSize = 0;
uint32_t blockCount = 0;
in.seekg( -12, in.end );
logger.setFileSize( (size_t) in.tellg() + 12 );
in.read( (char *) &blockSize, 4 );
in.read( (char *) &lastBlockSize, 4 );
in.read( (char *) &blockCount, 4 );
in.seekg( -12 - (int64_t)blockCount * 4, in.end );
vector<uint32_t> header;
header.resize( blockCount, 0 );
in.read( (char *) &header.front(), blockCount * 4 );
if ( in.fail() )
return false;
logger.updateInput( blockCount * 4 + 12 );
in.clear();
in.seekg( 0, in.beg );
CFISFromStream inStream( in );
return decodeRLE( inStream, out, header, blockSize, lastBlockSize, blockCount );
}
void update1() //sorted file,sorted emp.no;
{
table temp;
char tname[15];
cout<<"Enter temporary filename:";
gets(tname);
f.open(fname,ios::in);
fstream f1;
f1.open(tname,ios::out);
int EMPNO;
f.read((char*)&temp,s);
cout<<"Enter Employee number whose record to be updated:";
cin>>EMPNO;
while(f)
{
if(temp.empno==EMPNO)
{
cout<<"Give new data:\n";
getdata(temp);
cout<<"Enter next Employee number, which is to be updated "
<<"(0 if no more updation):";
cin>>EMPNO;
}
f1.write((char*)&temp,s);
f.read((char*)&temp,s);
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::DeserializeBasicType(char* pMem, TypeNode* pType, fstream& eye)
{
int size = m_basicTypeSize[pType->Type];
bool isNull = false;
if (pType->Indirection)
{
eye.read(reinterpret_cast<char*>(&isNull), sizeof(bool));
char* memChunk = NULL;
if (!isNull)
{
memChunk = new char[size];
eye.read(memChunk, size);
}
unsigned* addr32 = reinterpret_cast<unsigned*>(pMem);
*addr32 = reinterpret_cast<unsigned>(memChunk);
size = sizeof(unsigned);
}
else
{
eye.read(pMem, size);
}
return size;
}
// Create formatted text file for printing
void textFile( fstream &readFromFile )
{
ofstream outPrintFile( "print.txt", ios::out );
if ( !outPrintFile ) {
cerr << "File could not be opened." << endl;
exit( 1 );
}
outPrintFile << setiosflags( ios::left ) << setw( 10 )
<< "Account" << setw( 16 ) << "Last Name" << setw( 11 )
<< "First Name" << resetiosflags( ios::left )
<< setw( 10 ) << "Balance" << endl;
readFromFile.seekg( 0 );
clientData client;
readFromFile.read( reinterpret_cast<char *>( &client ),
sizeof( clientData ) );
while ( !readFromFile.eof() ) {
if ( client.accountNumber != 0 )
outputLine( outPrintFile, client );
readFromFile.read( reinterpret_cast<char *>( &client ),
sizeof( clientData ) );
}
}
void write_comb_c(fstream &f)
{
cout<<"Combinations are being processed.........\nPlease Wait........";
char cb[6][3][3],cb_n[6][3][3],cb_o[6][3][3];
int max_mv=0;
long int s=0,cur_rec;
cb_comb c,c_n,c_o;
f.open("combinat.dat",ios::in|ios::binary|ios::nocreate);
f.seekg(-sizeof(c),ios::end);
f.read((char*)(&c),sizeof(c));
f.close();
max_mv=c.r_moves()-1;
f.open("combinat.dat",ios::in|ios::binary|ios::nocreate);
f.seekg(0);
while(f.read((char*)(&c),sizeof(c)))
if(max_mv==c.r_moves())
{
cur_rec=(f.tellg()/sizeof(c))-1;
break;
}
f.close();
cout<<cur_rec;
getch();
c.cpy_cube(cb);
while(max_mv==c.r_moves())
{
for(int i=0;i<6;i++)
for(int j=0;j<2;j++)
{
c_n.new_comb(cb,v[i],dr[j],max_mv);
c_n.cpy_cube(cb_n);
s=0;
f.open("combinat.dat",ios::in|ios::binary|ios::nocreate);
f.seekg(0);
while(f.read((char*)(&c_o),sizeof(c)))
{
c_o.cpy_cube(cb_o);
if(c_o.r_moves()<=c_n.r_moves())
s+=cmp_cb(cb_n,cb_o);
if(s>0)
break;
}
f.close();
if(s==0)
{
f.open("combinat.dat",ios::app|ios::binary|ios::nocreate);
f.write((char*)(&c_n),sizeof(c));
f.close();
}
}
cur_rec++;
f.open("combinat.dat",ios::in|ios::binary|ios::nocreate);
f.seekg(sizeof(c)*cur_rec);
f.read((char*)(&c),sizeof(c));
c.cpy_cube(cb);
f.close();
}
return;
}
void Henchman::read(fstream& saveFile){
StringRead(saveFile,Tag);
powers.read(saveFile);
saveFile.read((char *) &CharacterLevel,4);
saveFile.read((char *) &TalentPoints,4);
currentLoadout.read(saveFile);
StringRead(saveFile,MappedPower);
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::DeserializeUserDefinedType(char* p_fieldAddress, TypeNode* p_type, bool p_isPtr, fstream& p_eye)
{
int size = 0;
UserObject* object = NULL;
bool isNull = false;
if(p_isPtr)
{
unsigned* addr32;
p_eye.read(reinterpret_cast<char*>(&isNull), sizeof(bool));
addr32 = reinterpret_cast<unsigned*>(p_fieldAddress);
if(!isNull)
{
string typeName;
char buffer[MaxTypeNameLength + 1];
p_eye.read(buffer, MaxTypeNameLength + 1);
typeName = buffer;
object = static_cast<UserObject*>(g_ObjectFactory.GetObject(typeName)->Prototype());
PerformLateBinding(object, p_type);
object->InitializeAddresses();
Iterator* addresses = object->GetIterator();
unsigned* addr32;
for(int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < p_type->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
DeserializeType(reinterpret_cast<char*>(*addr32), p_type->Children[memberIdx].Ptr32, p_eye);
}
}
*addr32 = reinterpret_cast<unsigned>(object);
size = sizeof(unsigned);
}
else
{
object = reinterpret_cast<UserObject*>(p_fieldAddress);
object->InitializeAddresses();
Iterator* addresses = object->GetIterator();
unsigned* addr32;
for(int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < p_type->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
DeserializeType(reinterpret_cast<char*>(*addr32), p_type->Children[memberIdx].Ptr32, p_eye);
}
size = object->TypeSize();
}
return size;
}
void Chunk::Read(fstream &InputFile)
{
InputFile.read(ChunkID, sizeof(ChunkID));
InputFile.read((char *)&ChunkSize, sizeof(ChunkSize));
#ifdef WAVEFILE_DEBUG
cout << " Chunk ID : \"" << ChunkID[0] << ChunkID[1] << ChunkID[2] << ChunkID[3] << "\"" << endl;
cout << " Chunk Size: " << ChunkSize << endl;
#endif
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::DeserializeUserDefinedType(ISerializable* pMem, TypeNode* pType, bool isPtr, fstream& eye)
{
int size = 0;
ISerializable* pObj = NULL;
bool isNull = false;
if (isPtr)
{
unsigned* addr32;
eye.read(reinterpret_cast<char*>(&isNull), sizeof(bool));
addr32 = reinterpret_cast<unsigned*>(pMem);
if (!isNull)
{
string typeName;
char buffer[MaxTypeNameLength + 1];
eye.read(buffer, MaxTypeNameLength + 1);
typeName = buffer;
pObj = static_cast<ISerializable*>(g_ObjectFactory.Create(typeName));
PerformLateBinding(pObj, pType);
auto objLayout = pObj->GetObjectLayout();
Iterator* addresses = objLayout.GetIterator();
unsigned* addr32;
for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < pType->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
DeserializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, eye);
}
}
*addr32 = reinterpret_cast<unsigned>(pObj);
size = sizeof(unsigned);
}
else
{
pObj = reinterpret_cast<ISerializable*>(pMem);
auto objLayout = pObj->GetObjectLayout();
Iterator* addresses = objLayout.GetIterator();
unsigned* addr32;
for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < pType->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
DeserializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, eye);
}
size = objLayout.TypeSize();
}
return size;
}
void Weapon::read(fstream& saveFile){
StringRead(saveFile,name);
saveFile.read((char *) &AmmoUsedCount,4);
saveFile.read((char *) &TotalAmmo,4);
saveFile.read((char *) &CurrentWeapon,1);
std::cout << "Skipping ===>" << saveFile.seekg(3,ios_base::cur)<<"<=== on Line: " << __LINE__ << endl;
saveFile.read((char *) &LastWeapon,1);
std::cout << "Skipping ===>" << saveFile.seekg(3,ios_base::cur)<<"<=== on Line: " << __LINE__ << endl;
StringRead(saveFile,ammoName);
}
void Hme_tree::init(fstream &load_stream, double leaves_error_multiplier) {
load_stream.read((char*) ¶meters_count_, sizeof(parameters_count_));
bool root_is_leaf = false;
load_stream.read((char*) &root_is_leaf, sizeof(root_is_leaf));
if (root_is_leaf) {
root_node_ = new Hme_tree_expert(load_stream, parameters_count_, leaves_error_multiplier);
} else {
root_node_ = new Hme_tree_gateway(load_stream, parameters_count_, leaves_error_multiplier);
}
}
//get the Index arrange of the Index area from infile
//param: fstream& infile
//return: true or false
bool EvaIPSeeker::getIndexOffset(fstream& infile)
{
infile.seekg(ios::beg);
infile.read(byte4, 4);
firstIndexOffset = READINT4(byte4);
infile.read(byte4, 4);
lastIndexOffset = READINT4(byte4);
if(( firstIndexOffset == -1 )||( lastIndexOffset == -1 ))
{
return false;
}
return true;
}
void Configuration::readBin_ (fstream& f, Configuration& dest)
{
size_t tmp1, tmp2;
char* s;
string name;
Configuration buf;
string value;
// reading all Configuration type variables
f.read ( (char*) &tmp1, sizeof ( tmp1 ) );
for ( size_t i = 0; i < tmp1; i++ )
{
// reading the size and then the name itself
f.read ( (char*) &tmp2, sizeof ( tmp2 ) );
s = new char[ tmp2 + 1 ];
f.read ( s, tmp2 );
s[ tmp2 ] = '\0';
name = s;
delete[] s;
readBin_ ( f, buf );
try {
dest.insertConfig ( name, buf );
}
catch (VarAlreadyExisting& e)
{
dest.setConfig ( name, buf );
}
}
// reading all data variables
f.read ( (char*) &tmp1, sizeof ( tmp1 ) );
for ( size_t i = 0; i < tmp1; i++ )
{
// reading the size and then the name itself
f.read ( (char*) &tmp2, sizeof ( tmp2 ) );
s = new char[ tmp2 + 1 ];
f.read ( s, tmp2 );
s[ tmp2 ] = '\0';
name = s;
delete[] s;
// reading the size and then the value itself of data variable
f.read ( (char*) &tmp2, sizeof ( tmp2 ) );
s = new char[ tmp2 + 1 ];
f.read ( s, tmp2 );
s[ tmp2 ] = '\0';
value = s;
delete[] s;
try {
dest.insertStr ( name, value );
}
catch (VarAlreadyExisting& e)
{
dest.setStr ( name, value );
}
}
}
void pic(char name[30]) // for picture
{ fstream file;
file.open(name,ios::binary|ios::in);
if(!file)
{ outtextxy(250,150,"Unable to open");
getch();
exit(0); }
unsigned color;
file.read((char*)&color,sizeof(color));
for(int i=0;i<getmaxx();i++)
for(int j=0;j<getmaxy();j++)
{ putpixel(i,j,color);
file.read((char*)&color,sizeof(color)); }
putpixel(i,j,color);
file.close(); }
int main(int argc, char **argv) {
if(argc == 1) {
cout << "<RibbonLife.exe> <M2 file>\n";
return 1;
}
if(strstr(argv[1], ".m2")) {
m2File.open(argv[1], ios::in | ios::out | ios::binary);
if(!m2File) {
cout << "File could not be opened!\n";
return 1;
}
m2File.seekg(0x134);
m2File.read(reinterpret_cast<char *>(&nRibbons), sizeof(unsigned int));
if(nRibbons == 0) {
cout << "No ribbons exist in the model!\n";
return 1;
}
m2File.read(reinterpret_cast<char *>(&ofsRibbons), sizeof(unsigned int));
int offset = 0x94;
for(int i = 0; i < nRibbons; i++, offset += 0xDC) {
m2File.seekg(ofsRibbons + offset);
m2File.read(reinterpret_cast<char *>(&life1), sizeof(float));
m2File.read(reinterpret_cast<char *>(&life2), sizeof(float));
cout << "Ribbon #" << i + 1 << ":\n"
<<"\nLife1: " << life1
<<"\nLife2: " << life2 << '\n';
float newLife = -1;
while(newLife < 0 || newLife > 100) {
cout << "\nEnter a new life (0 to 100): ";
cin >> newLife;
}
life1 = life2 = newLife;
m2File.seekp(ofsRibbons + offset);
m2File.write(reinterpret_cast<const char *>(&life1), sizeof(float));
m2File.write(reinterpret_cast<const char *>(&life2), sizeof(float));
cout << '\n';
}
cout << "\n *** Lives both written. Saving file...\n\n";
}
int main()
{
//insertar Arcos
struct arcoArch reg1;
strcpy(reg1.destino, "Ana");
strcpy(reg1.dirigido, "TRUE");
reg1.distancia = 100;
reg1.velocidad = 80;
reg1.sig=-1;
archivoArcos.write(reinterpret_cast<char *>(®1),sizeof(reg1));
//Insertar Archivo Ciudades
struct conductoresArch reg2;
strcpy(reg2.nombreConductor, "Kenneth");
strcpy(reg2.tipoVehiculo, "New");
reg2.der=3;
reg2.izq = -1;
reg2.id = 30;
archivoConductores.write(reinterpret_cast<char *>(®2),sizeof(reg2));
archivoArcos.seekg(sizeof(0,ios::beg));
archivoArcos.read(reinterpret_cast<char*>(®1),sizeof(reg1));
cout<<sizeof(reg1);
return 0;
}
// function that lists tools in file
void listTools( fstream &fRef )
{
Tool temp;
// display column headings
cout << setw( 7 ) << "Record#" << " " << left
<< setw( 30 ) << "Tool name" << left
<< setw( 13 ) << "Quantity" << left << setw( 10 ) << "Cost" << endl;
// continue until 100 tools are displayed or end of file reached
for ( int count = 0; count < 100 && !fRef.eof(); count++ )
{
// set file position pointer and begin reading
fRef.seekg( count * sizeof( Tool ) );
fRef.read( reinterpret_cast< char * >( &temp ), sizeof( Tool ) );
// if part number is valid, display Tool information
if ( temp.getPartNumber() >= 0 && temp.getPartNumber() < 100 )
{
cout << fixed << showpoint;
cout << left << setw( 7 ) << temp.getPartNumber() << " "
<< left << setw( 30 ) << temp.getToolName() << left
<< setw( 13 ) << temp.getInStock() << setprecision( 2 )
<< left << setw( 10 ) << temp.getUnitPrice() << '\n';
} // end if
} // end for
} // end function listTools
// update balance in record
void updateRecord( fstream &updateFile )
{
// obtain number of account to update
int accountNumber = getAccount( "Enter account to update" );
// move file-position pointer to correct record in file
updateFile.seekg( ( accountNumber - 1 ) * sizeof( ClientData ) );
// read first record from file
ClientData client;
updateFile.read( reinterpret_cast< char * >( &client ),
sizeof( ClientData ) );
// update record
if ( client.getAccountNumber() != 0 )
{
outputLine( cout, client ); // display the record
// request user to specify transaction
cout << "\nEnter charge (+) or payment (-): ";
double transaction; // charge or payment
cin >> transaction;
// update record balance
double oldBalance = client.getBalance();
client.setBalance( oldBalance + transaction );
outputLine( cout, client ); // display the record
// move file-position pointer to correct record in file
updateFile.seekp( ( accountNumber - 1 ) * sizeof( ClientData ) );
// write updated record over old record in file
updateFile.write( reinterpret_cast< const char * >( &client ),
sizeof( ClientData ) );
} // end if
void read_bmp_data()
{
src_buff=new unsigned char[bih.biHeight*bih.biWidth*3];
input_file.read((char*)src_buff,sizeof(unsigned char)*bih.biHeight*bih.biWidth*3);
}
static OffsetsArray read(fstream& fs, const uint32_t offset_count)
{
static constexpr uint32_t OFFSET_WIDTH = 4;
std::string raw_offsets;
const uint32_t raw_offset_size = offset_count * OFFSET_WIDTH;
raw_offsets.resize(raw_offset_size);
fs.read(&raw_offsets[0], raw_offset_size);
OffsetsArray ret;
for (uint32_t i = 0; i < offset_count; ++i)
{
const std::string value_as_string = raw_offsets.substr(OFFSET_WIDTH * static_cast<size_t>(i),
OFFSET_WIDTH * (static_cast<size_t>(i) + 1));
const auto value = reinterpret_bytes<uint32_t>(value_as_string.c_str());
// Ignore offsets that point to offset 0. See vcpkg github #223 #288 #292
if (value != 0)
{
ret.data.push_back(value);
}
}
// Sort the offsets, because it is possible for them to be unsorted. See vcpkg github #292
std::sort(ret.data.begin(), ret.data.end());
return ret;
}
void display()
{
table temp;
f.open(fname,ios::in);
cout<<"Content(s) of "<<fname<<" is/are ........\n";
f.read((char*)&temp,s);
while(f)
{
cout<<"\nEmployee number:"<<temp.empno<<"\nEmployee name:"<<temp.name
<<"\nEmployee designation:"<<temp.desig;
f.read((char*)&temp,s);
}
f.close();
cout<<"\nPress any key to continue";
getch();
}
void listTools(fstream &fRef)
{
Tool temp;
cout << setw(7) << "Record#" << " " << left
<< setw(30) << "Tool name" << left
<< setw(13) << "Quantity" << left << setw(10) << " Cost" << endl;
for(int count = 0; count < 100 && !fRef.eof(); count++)
{
fRef.seekg(count * sizeof(Tool));
fRef.read(reinterpret_cast<char *>(&temp), sizeof(Tool));
if(temp.getPartNumber() >= 0 && temp.getPartNumber() < 100)
{
cout << fixed << showpoint;
cout << left << setw(10) << temp.getPartNumber() << " "
<< left << setw(30) << temp.getToolName() << left
<< setw(13) << temp.getInStock() << setprecision(2)
<< left << setw( 10 ) << temp.getUnitPrice() << '\n';
}
}
}
int Initialize(int argc, char *argv[])
{
g_mode = atoi(argv[1]);
if (g_mode != 1 && g_mode != 2)
{
cout << "mode must be 1 or 2" << endl;
return 0;
}
g_fileIn.open(argv[2], ios::binary | _IOS_Nocreate | ios::in);
if (!g_fileIn)
{
cout << argv[1] << " can not be open!\n";
return 0;
}
strcpy_s(g_flvFile, argv[3]);
g_fileIn.seekg(0, ios::end);
std::streampos ps = g_fileIn.tellg();
g_nFileSize = ps;
g_fileIn.seekg(0, ios_base::beg);
g_pBufferIn = new unsigned char[g_nFileSize];
g_pBufferOut = new unsigned char[g_nFileSize];
if (g_pBufferIn == NULL && g_pBufferOut == NULL)
return 0;
g_fileIn.read((char *)g_pBufferIn, g_nFileSize);
if (g_nFileSize != g_fileIn.gcount())
return 0;
return 1;
}
Boolean PrimesTable::TableBuffer::RetrieveBlock(Ulong Index_, long Offset_, fstream& Fin_)
{
Ulong BlockNum_ = Index_ / PrimesTable::TABLESIZE;
Fin_.seekg(0, ios::end);
Fin_.clear();
long StartPos_ = BlockNum_ * TABLESIZE * sizeof(long);
long Fsize_ = Fin_.tellg();
Fsize_ -= Offset_;
if (StartPos_ < Fsize_)
if (Fin_.seekg(StartPos_ + Offset_).good())
{
Fin_.read((char*)_Table, TABLESIZE * sizeof(long));
size_t i;
long BufSize_ = TABLESIZE;
for (i = TABLESIZE - 1; i != size_t(-1); --i)
if (!_Table[i])
--BufSize_;
else
break;
if (BufSize_)
{
StartPos_ /= sizeof(long);
SetLimit(StartPos_, BufSize_);
return Fin_.good();
}
}
return FALSE;
}
static CoffFileHeader read(fstream& fs)
{
CoffFileHeader ret;
ret.data.resize(HEADER_SIZE);
fs.read(&ret.data[0], HEADER_SIZE);
return ret;
}
