void WriteSize(ostream& out)
{
unsigned filesize = out.tellp();
unsigned size = filesize - 8;
out.seekp(4, ios_base::beg);
out.write((char*)&size, 4);
unsigned data_size = filesize - 44;
out.seekp(40, ios_base::beg);
out.write((char*)&data_size, 4);
}
int IOBuffer::WriteHeader(ostream & stream) const{
stream.seekp(0, ios::beg);
stream.write(headerStr, headerSize);
if(!stream.good())
return -1;
return headerSize;
}
void DSA1Intro::write(ostream& strm) {
header_size = 20;
count = entries.size(); // WRONG! Come back later to change it
u16 truecount = 0;
write16(strm, count);
for (u8 i=0; i<0x20-2; i++) write8(strm, 0);
u32 offset = 0;
for (u32 i=0; i<count; i++) {
// Nach Duplikaten suchen und diese markieren
u32 j = 0;
for ( ; j<i; j++) {
if (entries[i]->name == entries[j]->name) break;
}
if (j == i) { // Kein Duplikat gefunden
entries[i]->offset = offset;
entries[i]->write(strm);
offset += entries[i]->size;
truecount++;
} else { // Duplikat gefunden
entries[i]->offset = entries[j]->offset;
assert(entries[i]->size == entries[j]->size);
entries[i]->write(strm);
}
}
for (u32 i=count; i < 139 ; i++) {
for (u32 j=0; j < 0x20; j++) write8(strm, 0x00);
}
strm.seekp(0);
write16(strm, truecount-1); // DUMMY nicht mitzählen
}
void
EDFOutputFormat::StopRun( ostream& os )
{
const int NumRecFieldPos = 236;
if( os.seekp( NumRecFieldPos ) )
PutField< Str<8> >( os, NumRecords() );
EDFOutputBase::StopRun( os );
}
int IOBuffer::DWrite(ostream & stream, int recref) const
// write specified record
{
stream.seekp(recref, ios::beg);
if(stream.tellp() != recref)
return -1;
return Write(stream);
}
void
JSeekp
(
ostream& stream,
long position
)
{
stream.seekp((streamoff) position);
}
void
JSeekp
(
ostream& stream,
streampos position
)
{
stream.seekp(position);
}
void
JSeekp
(
ostream& stream,
long offset,
JIOStreamSeekDir direction
)
{
stream.seekp((streamoff) offset, direction);
}
void
JSeekp
(
ostream& stream,
streamoff offset,
JIOStreamSeekDir direction
)
{
stream.seekp(offset, direction);
}
void write_object(ostream &out, ObjectBuilder &obj)
{
ResourceTableHeader tbl_header;
write_header(out, obj.header);
write_resource_header(out, tbl_header);
tbl_header = write_resource_table(out, obj.rs);
// and rewrite the header w/ correct offsets & sizes
out.seekp(0);
write_header(out, obj.header);
write_resource_header(out, tbl_header);
}
void Fl_Canvas::StreamSelectionWiresOut(ostream &s)
{
int total_wires = 0, curpos=0;
curpos = s.tellp();
s<<-1<<endl;
if (m_WireVec.size()>0)
for(vector<CanvasWire>::iterator i=m_WireVec.begin();
i!=m_WireVec.end(); i++)
{
std::vector<int>::iterator output = std::find( m_Selection.m_DeviceIds.begin(), m_Selection.m_DeviceIds.end(), i->OutputID );
std::vector<int>::iterator input = std::find( m_Selection.m_DeviceIds.begin(), m_Selection.m_DeviceIds.end(), i->InputID );
if ((input != m_Selection.m_DeviceIds.end()) && (output != m_Selection.m_DeviceIds.end()))
{
s<<i->OutputID<<" ";
s<<0<<" ";
s<<i->OutputPort<<" ";
s<<i->OutputTerminal<<" ";
s<<i->InputID<<" ";
s<<0<<" ";
s<<i->InputPort<<" ";
s<<i->InputTerminal<<endl;
total_wires += 1;
}
}
if (total_wires >= 1)
{
s.seekp(curpos, ios::beg);
s<<total_wires<<endl;
s.seekp(0, ios::end);
}
}
void SerializeSummary(FPackageFileSummary Summary, ostream& stream)
{
/// reset compression flags
Summary.CompressionFlags = 0;
Summary.PackageFlags ^= (uint32_t)UPackageFlags::Compressed;
Summary.NumCompressedChunks = 0;
/// serialize summary
stream.seekp(0);
stream.write(reinterpret_cast<char*>(&Summary.Signature), 4);
int32_t tmpVer = Summary.Version + (Summary.LicenseeVersion << 16);
stream.write(reinterpret_cast<char*>(&tmpVer), 4);
stream.write(reinterpret_cast<char*>(&Summary.HeaderSize), 4);
stream.write(reinterpret_cast<char*>(&Summary.FolderNameLength), 4);
if (Summary.FolderNameLength > 0)
{
stream.write(Summary.FolderName.c_str(), Summary.FolderNameLength);
}
stream.write(reinterpret_cast<char*>(&Summary.PackageFlags), 4);
stream.write(reinterpret_cast<char*>(&Summary.NameCount), 4);
stream.write(reinterpret_cast<char*>(&Summary.NameOffset), 4);
stream.write(reinterpret_cast<char*>(&Summary.ExportCount), 4);
stream.write(reinterpret_cast<char*>(&Summary.ExportOffset), 4);
stream.write(reinterpret_cast<char*>(&Summary.ImportCount), 4);
stream.write(reinterpret_cast<char*>(&Summary.ImportOffset), 4);
stream.write(reinterpret_cast<char*>(&Summary.DependsOffset), 4);
stream.write(reinterpret_cast<char*>(&Summary.SerialOffset), 4);
stream.write(reinterpret_cast<char*>(&Summary.Unknown2), 4);
stream.write(reinterpret_cast<char*>(&Summary.Unknown3), 4);
stream.write(reinterpret_cast<char*>(&Summary.Unknown4), 4);
stream.write(reinterpret_cast<char*>(&Summary.GUID), sizeof(Summary.GUID));
stream.write(reinterpret_cast<char*>(&Summary.GenerationsCount), 4);
for (unsigned i = 0; i < Summary.GenerationsCount; ++i)
{
stream.write(reinterpret_cast<char*>(&Summary.Generations[i].ExportCount), 4);
stream.write(reinterpret_cast<char*>(&Summary.Generations[i].NameCount), 4);
stream.write(reinterpret_cast<char*>(&Summary.Generations[i].NetObjectCount), 4);
}
stream.write(reinterpret_cast<char*>(&Summary.EngineVersion), 4);
stream.write(reinterpret_cast<char*>(&Summary.CookerVersion), 4);
stream.write(reinterpret_cast<char*>(&Summary.CompressionFlags), 4);
stream.write(reinterpret_cast<char*>(&Summary.NumCompressedChunks), 4);
if (Summary.UnknownDataChunk.size() > 0)
{
stream.write(Summary.UnknownDataChunk.data(), Summary.UnknownDataChunk.size());
}
}
void createPrimary(istream& read, ostream& primary){
int number,byte = 0;
map<int,int> mymap;
PrimaryIndex p;
ClientData client;
read.clear();
read.seekg(0);
primary.seekp(0);
if(read.eof())return;
read >> client;
while(!read.eof()){
if(number = client.getAccountNumber()){
mymap[number] = byte;
byte = read.tellg();
}
read >> client;
}
for(map<int,int>::iterator it = mymap.begin(); it != mymap.end(); it++){
p.AccountNumber = it->first;
p.Byte = it->second;
primary.write(reinterpret_cast<char*>(&p), sizeof(PrimaryIndex));
}
}
void MemoryMap::pagesizealign(ostream &out)
{
size_t at = out.tellp();
size_t offs = at % pagesize;
if(offs) { out.seekp(pagesize - offs, ios::cur); }
}
void RemoveLastSymbol(ostream& stream)
{
stream.seekp(static_cast<int>(stream.tellp()) - 1);
}
//***************************************************************************
// PUBLIC METHOD:
// void ossimFfRevb::write(ostream& os) const
//
// Writes an EOSAT Fast Format Rev B formatted header.
//***************************************************************************
void ossimFfRevb::write(ostream& os) const
{
const char PRODUCT_ID_DESC [PRODUCT_ORDER_NUMBER_DESC_SIZE + 1]
= "PRODUCT =";
const char WRS_DESC [WRS_DESC_SIZE + 1]
= " WRS =";
const char DATE_DESC [DATE_DESC_SIZE + 1]
= " ACQUISITION DATE =";
const char SATELLITE_NUMBER_DESC [SAT_NUMBER_DESC_SIZE + 1]
= " SATELLITE =";
const char INSTRUMENT_TYPE_DESC [INSTRUMENT_TYPE_DESC_SIZE + 1]
= " INSTRUMENT =";
const char PRODUCT_TYPE_DESC [PRODUCT_TYPE_DESC_SIZE + 1]
= " PRODUCT TYPE =";
const char PRODUCT_SIZE_DESC [PRODUCT_SIZE_DESC_SIZE + 1]
= " PRODUCT SIZE =";
const char PROCESSING_TYPE_DESC [PROCESSING_TYPE_DESC_SIZE + 1]
= " TYPE OF GEODETIC PROCESSING =";
const char RESAMPLING_ALGO_DESC [RESAMPLING_ALGO_DESC_SIZE + 1]
= " RESAMPLING =";
const char RADIANCE_DESC [RADIANCE_DESC_SIZE + 1]
= " RAD GAINS/BIASES = ";
const char VOLUME_NUMBER_DESC [VOLUME_NUMBER_DESC_SIZE + 1]
= " TAPE SPANNING FLAG=";
const char FIRST_LINE_DESC [FIRST_LINE_DESC_SIZE + 1]
= " START LINE #=";
const char LINES_PER_VOLUME_DESC [LINES_PER_VOLUME_DESC_SIZE + 1]
= " LINES PER VOL=";
const char ORIENTATION_ANGLE_DESC [ORIENTATION_ANGLE_DESC_SIZE + 1]
= " ORIENTATION =";
const char MAP_PROJ_NAME_DESC [MAP_PROJ_NAME_DESC_SIZE + 1]
= " PROJECTION =";
const char USGS_PROJ_NUMBER_DESC [USGS_PROJ_NUMBER_DESC_SIZE + 1]
= " USGS PROJECTION # =";
const char USGS_MAP_ZONE_DESC [USGS_MAP_ZONE_DESC_SIZE + 1]
= " USGS MAP ZONE =";
const char PROJECTION_PARAMETER_DESC [USGS_PROJ_PARAMS_DESC_SIZE + 1]
= " USGS PROJECTION PARAMETERS =";
const char ELLIPSOID_DESC [ELLIPSOID_DESC_SIZE + 1]
= " EARTH ELLIPSOID =";
const char MAJOR_AXIS_DESC [MAJOR_AXIS_DESC_SIZE+ 1]
= " SEMI-MAJOR AXIS =";
const char MINOR_AXIS_DESC [MINOR_AXIS_DESC_SIZE+ 1]
= " SEMI-MINOR AXIS =";
const char PIXEL_GSD_DESC [PIXEL_GSD_DESC_SIZE + 1]
= " PIXEL SIZE =";
const char PIXELS_PER_LINE_DESC [PIXELS_PER_LINE_DESC_SIZE + 1]
= " PIXELS PER LINE=";
const char LINES_PER_IMAGE_DESC [LINES_PER_IMAGE_DESC_SIZE + 1]
= " LINES PER IMAGE=";
const char UL_DESC [CORNER_DESC_SIZE + 1]
= " UL ";
const char UR_DESC [CORNER_DESC_SIZE + 1]
= " UR ";
const char LR_DESC [CORNER_DESC_SIZE + 1]
= " LR ";
const char LL_DESC [CORNER_DESC_SIZE + 1]
= " LL ";
const char BANDS_PRESENT_DESC [BANDS_PRESENT_DESC_SIZE + 1]
= " BANDS PRESENT =";
const char BLOCKING_FACTOR_DESC [BLOCKING_FACTOR_DESC_SIZE + 1]
= " BLOCKING FACTOR =";
const char RECORD_LENGTH_DESC [RECORD_LENGTH_DESC_SIZE + 1]
= " RECORD LENGTH =";
const char SUN_ELEVATION_DESC [SUN_ELEVATION_DESC_SIZE + 1]
= " SUN ELEVATION =";
const char SUN_AZIMUTH_DESC [SUN_AZIMUTH_DESC_SIZE + 1]
= " SUN AZIMUTH =";
const char CENTER_DESC [CENTER_DESC_SIZE + 1]
= " CENTER ";
const char OFFSET_DESC [OFFSET_DESC_SIZE + 1]
= " OFFSET=";
const char REV_DESC [REV_DESC_SIZE + 1]
= " REV";
const char SPACE[] = " ";
//***
// Start at beginning of the stream.
//***
os.seekp(0, ios::beg);
os << setiosflags(ios::fixed) // Disable scientific mode.
<< setiosflags(ios::left)
<< PRODUCT_ID_DESC
<< setw(PRODUCT_ORDER_NUMBER_SIZE)
<< theProductOrderNumber
<< WRS_DESC
<< setw(PATH_ROW_NUMBER_SIZE)
<< thePathRowNumber
<< DATE_DESC
<< setw(DATE_SIZE)
<< theAcquisitionDate
<< SATELLITE_NUMBER_DESC
<< setw(SAT_NUMBER_SIZE)
<< theSatNumber
<< INSTRUMENT_TYPE_DESC
<< setw(INSTRUMENT_TYPE_SIZE)
<< theInstrumentType
<< PRODUCT_TYPE_DESC
<< setw(PRODUCT_TYPE_SIZE)
<< theProductType
<< PRODUCT_SIZE_DESC
<< setw(PRODUCT_SIZE_SIZE)
<< theProductSize
<< setw(MAP_SHEET_SIZE)
<< theMapSheetName
<< PROCESSING_TYPE_DESC
<< setw(PROCESSING_TYPE_SIZE)
<< theProcessingType
<< RESAMPLING_ALGO_DESC
<< setw(RESAMPLING_ALGO_SIZE)
<< theResampAlgorithm
<< RADIANCE_DESC;
int i;
for (i=0; i<NUMBER_OF_BANDS-1; i++) // Output six of the seven bands.
{
os << setw(RADIANCE_SIZE) << theBandRadiance[i] << SPACE;
}
os << setw(RADIANCE_SIZE) << theBandRadiance[6] // Last one no space.
<< VOLUME_NUMBER_DESC
<< setw(VOLUME_NUMBER_SIZE)
<< theVolumeNumber
<< resetiosflags(ios::left)
<< setiosflags(ios::right)
<< FIRST_LINE_DESC
<< setw(FIRST_LINE_IN_VOLUME_SIZE)
<< the1stLineInVolume
<< LINES_PER_VOLUME_DESC
<< setw(LINES_PER_VOLUME_SIZE)
<< theLinesPerVolume
<< ORIENTATION_ANGLE_DESC
<< setprecision(2) << setw(ORIENTATION_ANGLE_SIZE)
<< theOrientationAngle
<< MAP_PROJ_NAME_DESC
<< setw(MAP_PROJ_NAME_SIZE)
<< theMapProjName
<< USGS_PROJ_NUMBER_DESC
<< setw(USGS_PROJ_NUMBER_SIZE)
<< theUsgsProjNumber
<< USGS_MAP_ZONE_DESC
<< setw(USGS_MAP_ZONE_SIZE)
<< theUsgsMapZone
<< PROJECTION_PARAMETER_DESC;
for (i=0; i<NUMBER_OF_PROJECTION_PARAMETERS; i++)
{
os << setw(USGS_PROJ_PARAMS_SIZE)
<< theUsgsProjParam[i];
}
os << setiosflags(ios::left)
<< ELLIPSOID_DESC
<< setw(ELLIPSOID_SIZE)
<< theEllipsoid
<< resetiosflags(ios::left)
<< setprecision(3)
<< setiosflags(ios::right)
<< MAJOR_AXIS_DESC
<< setw(MAJOR_AXIS_SIZE)
<< theSemiMajorAxis
<< MINOR_AXIS_DESC
<< setw(MINOR_AXIS_SIZE)
<< theSemiMinorAxis
<< setprecision(2)
<< PIXEL_GSD_DESC
<< setw(PIXEL_GSD_SIZE)
<< theGsd
<< PIXELS_PER_LINE_DESC
<< setw(PIXELS_PER_LINE_SIZE)
<< thePixelsPerLine
<< LINES_PER_IMAGE_DESC
<< setw(LINES_PER_IMAGE_SIZE)
<< theLinesPerImage
<< setprecision(3)
<< UL_DESC
<< setw(LON_SIZE)
<< theUlLon
<< SPACE
<< setw(LAT_SIZE)
<< theUlLat
<< SPACE
<< setw(EASTING_SIZE)
<< theUlEasting
<< SPACE
<< setw(NORTHING_SIZE)
<< theUlNorthing
<< UR_DESC
<< setw(LON_SIZE)
<< theUrLon
<< SPACE
<< setw(LAT_SIZE)
<< theUrLat
<< SPACE
<< setw(EASTING_SIZE)
<< theUrEasting
<< SPACE
<< setw(NORTHING_SIZE)
<< theUrNorthing
<< LR_DESC
<< setw(LON_SIZE)
<< theLrLon
<< SPACE
<< setw(LAT_SIZE)
<< theLrLat
<< SPACE
<< setw(EASTING_SIZE)
<< theLrEasting
<< SPACE
<< setw(NORTHING_SIZE)
<< theLrNorthing
<< LL_DESC
<< setw(LON_SIZE)
<< theLlLon
<< SPACE
<< setw(LAT_SIZE)
<< theLlLat
<< SPACE
<< setw(EASTING_SIZE)
<< theLlEasting
<< SPACE
<< setw(NORTHING_SIZE)
<< theLlNorthing
<< resetiosflags(ios::right);
os << BANDS_PRESENT_DESC
<< setw(BANDS_PRESENT_SIZE)
<< theBandsPresentString
<< BLOCKING_FACTOR_DESC
<< setw(BLOCKING_FACTOR_SIZE)
<< theBlockingFactor
<< RECORD_LENGTH_DESC
<< setw(RECORD_LENGTH_SIZE)
<< theRecordSize
<< SUN_ELEVATION_DESC
<< setw(SUN_ELEVATION_SIZE)
<< theSunElevation
<< SUN_AZIMUTH_DESC
<< setw(SUN_AZIMUTH_SIZE)
<< theSunAzimuth
<< CENTER_DESC
<< setw(LON_SIZE)
<< theCenterLon
<< SPACE
<< setw(LAT_SIZE)
<< theCenterLat
<< SPACE
<< setiosflags(ios::right)
<< setw(EASTING_SIZE)
<< theCenterEasting
<< SPACE
<< setw(NORTHING_SIZE)
<< theCenterNorthing
<< setw(CENTER_SAMPLE_SIZE)
<< theCenterSample
<< setw(CENTER_LINE_SIZE)
<< theCenterLine
<< OFFSET_DESC
<< setw(OFFSET_SIZE)
<< theOffset
<< REV_DESC
<< setw(FORMAT_VERSION_SIZE)
<< theFormatVersion << flush; // Byte count of file should be 1536.
}
void Model::save(ostream & out) {
// write a signature
char chunk[16] = {'l','g','d','p', 'j', 0};
out.write(chunk, 16);
unsigned int tmp;
int off = out.tellp();
unsigned basic_offset = 0;
unsigned postag_offset = 0;
unsigned deprels_offset = 0;
unsigned feature_offset = 0;
unsigned parameter_offset = 0;
// write pseduo position
write_uint(out, 0); // basic offset
write_uint(out, 0); // postag offset
write_uint(out, 0); // deprels offset
write_uint(out, 0); // features offset
write_uint(out, 0); // parameters offset
// model and feature information
// labeled model
basic_offset = out.tellp();
tmp = model_opt.labeled;
write_uint(out, tmp);
// decode order
strncpy(chunk, model_opt.decoder_name.c_str(), 16);
out.write(chunk, 16);
// use dependency
tmp = feat_opt.use_dependency;
write_uint(out, tmp);
// use dependency unigram
tmp = feat_opt.use_dependency_unigram;
write_uint(out, tmp);
// use dependency bigram
tmp = feat_opt.use_dependency_bigram;
write_uint(out, tmp);
// use dependency surrounding
tmp = feat_opt.use_dependency_surrounding;
write_uint(out, tmp);
// use dependency between
tmp = feat_opt.use_dependency_between;
write_uint(out, tmp);
// use sibling
tmp = feat_opt.use_sibling;
write_uint(out, tmp);
// use sibling basic
tmp = feat_opt.use_sibling_basic;
write_uint(out, tmp);
// use sibling linear
tmp = feat_opt.use_sibling_linear;
write_uint(out, tmp);
// use grand
tmp = feat_opt.use_grand;
write_uint(out, tmp);
// use grand basic
tmp = feat_opt.use_grand_basic;
write_uint(out, tmp);
// use grand linear
tmp = feat_opt.use_grand_linear;
write_uint(out, tmp);
// save postag lexicon
postag_offset = out.tellp();
postags.dump(out);
// save dependency relation lexicon
deprels_offset = out.tellp();
deprels.dump(out);
feature_offset = out.tellp();
space.save(out);
parameter_offset = out.tellp();
param.dump(out);
out.seekp(off);
write_uint(out, basic_offset);
write_uint(out, postag_offset);
write_uint(out, deprels_offset);
write_uint(out, feature_offset);
write_uint(out, parameter_offset);
// out.seekp(0, std::ios::end);
}
