bool Nitf::SensraParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
size_t sizeIn = max(static_cast<ostream::pos_type>(0), output.tellp());
size_t sizeOut(sizeIn);
try
{
output << toString(dv_cast<unsigned int>(input.getAttribute(SENSRA::REF_ROW)), 8, -1,
ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<unsigned int>(input.getAttribute(SENSRA::REF_COL)), 8, -1,
ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(SENSRA::SENSOR_MODEL)), 6);
output << toString(dv_cast<int>(input.getAttribute(SENSRA::SENSOR_MOUNT)), 3, -1,
ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(SENSRA::SENSOR_LOC)), 21);
output << sizeString(dv_cast<string>(input.getAttribute(SENSRA::SENSOR_ALT_SOURCE)), 1);
output << toString(dv_cast<int>(input.getAttribute(SENSRA::SENSOR_ALT)), 6, -1,
ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(SENSRA::SENSOR_ALT_UNIT)), 1);
output << toString(dv_cast<unsigned int>(input.getAttribute(SENSRA::SENSOR_AGL)), 5, -1,
ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::SENSOR_PITCH)), 7, 3, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::SENSOR_ROLL)), 8, 3, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::SENSOR_YAW)), 8, 3, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::PLATFORM_PITCH)), 7, 3, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::PLATFORM_ROLL)), 8, 3, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::PLATFORM_HDG)), 5, 1,
ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(SENSRA::GROUND_SPD_SOURCE)), 1);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::GROUND_SPD)), 6, 1,
ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(SENSRA::GRND_SPD_UNIT)), 1);
output << toString(dv_cast<double>(input.getAttribute(SENSRA::GROUND_TRACK)), 5, 1,
ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(SENSRA::VERT_VEL)), 5, -1,
ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(SENSRA::VERT_VEL_UNIT)), 1);
output << toString(dv_cast<unsigned int>(input.getAttribute(SENSRA::SWATH_FRAMES)), 4, -1,
ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<unsigned int>(input.getAttribute(SENSRA::NUM_SWATHS)), 4, -1,
ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<unsigned int>(input.getAttribute(SENSRA::SPOT_NUM)), 3, -1,
ZERO_FILL, false, false, 3, true);
}
catch (const bad_cast&)
{
return false;
}
sizeOut = output.tellp();
numBytesWritten = sizeOut - sizeIn;
return true;
}
ResourceTableHeader write_resource_table(ostream &out, const ResourceSet &rs)
{
ResourceIndex index;
uint32_t pre_data(out.tellp());
write_resource_data(out, index, rs);
uint32_t post_data(out.tellp());
write_resource_index(out, index);
ResourceTableHeader tbl_header;
tbl_header.data_size = post_data - pre_data;
tbl_header.resource_count = rs.size();
return tbl_header;
}
bool Nitf::PatchbParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
size_t sizeIn = max(static_cast<ostream::pos_type>(0), output.tellp());
size_t sizeOut(sizeIn);
try
{
output << toString(dv_cast<int>(input.getAttribute(PATCHB::PAT_NO)), 4);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::LAST_PAT_FLAG)), 1,
-1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::LNSTRT)), 7);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::LNSTOP)), 7);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::AZL)), 5);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::NVL)), 5,
-1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::FVL)), 3,
-1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::NPIXEL)), 5);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::FVPIX)), 5);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::FRAME)), 3,
-1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(PATCHB::UTC)), 8, 2);
output << toString(dv_cast<double>(input.getAttribute(PATCHB::SHEAD)), 7, 3);
output << toString(dv_cast<double>(input.getAttribute(PATCHB::GRAVITY)), 7, 4,
ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::INS_V_NC)), 5, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::INS_V_EC)), 5, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::INS_V_DC)), 5, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(PATCHB::OFFLAT)), 8, 4, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(PATCHB::OFFLONG)), 8, 4, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::TRACK)), 3);
output << toString(dv_cast<double>(input.getAttribute(PATCHB::GSWEEP)), 6, 2);
output << toString(dv_cast<double>(input.getAttribute(PATCHB::SHEAR)), 8,
-1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(PATCHB::BATCH_NO)), 6,
-1, ZERO_FILL, false, false, 3, true);
}
catch (const bad_cast&)
{
return false;
}
sizeOut = output.tellp();
numBytesWritten = sizeOut - sizeIn;
return true;
}
bool Nitf::StdidcParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
size_t sizeIn = max(static_cast<ostream::pos_type>(0), output.tellp());
size_t sizeOut(sizeIn);
try
{
const DateTime* pMissionDTG = dv_cast<DateTime>(&input.getAttribute(STDIDC::ACQUISITION_DATE));
if (pMissionDTG == NULL)
{
return false;
}
// put date in form CCYYMMDDHHMMSS for this TAG see: strftime() for format info
string yyyymmddhhmmss = pMissionDTG->getFormattedUtc("%Y%m%d%H%M%S");
boost::to_upper(yyyymmddhhmmss);
output << sizeString(yyyymmddhhmmss, 14);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::MISSION)), 14);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::PASS)), 2);
output << toString(dv_cast<unsigned int>(input.getAttribute(STDIDC::OP_NUM)), 3, -1);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::START_SEGMENT)), 2);
output << toString(dv_cast<unsigned int>(input.getAttribute(STDIDC::REPRO_NUM)), 2, -1);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::REPLAY_REGEN)), 3);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::BLANK_FILL)), 1);
output << toString(dv_cast<unsigned int>(input.getAttribute(STDIDC::START_COLUMN)), 3, -1);
output << toString(dv_cast<unsigned int>(input.getAttribute(STDIDC::START_ROW)), 5, -1);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::END_SEGMENT)), 2);
output << toString(dv_cast<unsigned int>(input.getAttribute(STDIDC::END_COLUMN)), 3, -1);
output << toString(dv_cast<unsigned int>(input.getAttribute(STDIDC::END_ROW)), 5, -1);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::COUNTRY)), 2);
output << toString(dv_cast<unsigned int>(input.getAttribute(STDIDC::WAC)),
4, -1, ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::LOCATION)), 11);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::RESERVED2)), 5);
output << sizeString(dv_cast<string>(input.getAttribute(STDIDC::RESERVED3)), 8);
}
catch (const bad_cast&)
{
return false;
}
sizeOut = output.tellp();
numBytesWritten = sizeOut - sizeIn;
return true;
}
bool Nitf::Use00aParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
size_t sizeIn = max(static_cast<ostream::pos_type>(0), output.tellp());
size_t sizeOut(sizeIn);
try
{
output << toString(dv_cast<unsigned int>(input.getAttribute(USE00A::ANGLE_TO_NORTH)), 3, -1);
output << toString(dv_cast<double>(input.getAttribute(USE00A::MEAN_GSD)), 5, 1);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED1)), 1);
output << toString(dv_cast<unsigned int>(input.getAttribute(USE00A::DYNAMIC_RANGE)),
5, -1, ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED2)), 3);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED3)), 1);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED4)), 3);
output << toString(dv_cast<double>(input.getAttribute(USE00A::OBL_ANG)),
5, 2, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(USE00A::ROLL_ANG)),
6, 2, ZERO_FILL, POS_SIGN_TRUE, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED5)), 12);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED6)), 15);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED7)), 4);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED8)), 1);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED9)), 3);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED10)), 1);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED11)), 1);
output << toString(dv_cast<unsigned int>(input.getAttribute(USE00A::N_REF)), 2, -1);
output << toString(dv_cast<unsigned int>(input.getAttribute(USE00A::REV_NUM)), 5, -1);
output << toString(dv_cast<unsigned int>(input.getAttribute(USE00A::N_SEG)), 3, -1);
output << toString(dv_cast<unsigned int>(input.getAttribute(USE00A::MAX_LP_SEG)),
6, -1, ZERO_FILL, false, false, 3, true);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED12)), 6);
output << sizeString(dv_cast<string>(input.getAttribute(USE00A::RESERVED13)), 6);
output << toString(dv_cast<double>(input.getAttribute(USE00A::SUN_EL)), 5, 1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(USE00A::SUN_AZ)), 5, 1);
}
catch (const bad_cast&)
{
return false;
}
sizeOut = output.tellp();
numBytesWritten = sizeOut - sizeIn;
return true;
}
JSize
JTellp
(
ostream& stream
)
{
return stream.tellp();
}
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);
}
bool Nitf::MensrbParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
size_t sizeIn = max(static_cast<ostream::pos_type>(0), output.tellp());
size_t sizeOut(sizeIn);
try
{
output << sizeString(dv_cast<string>(input.getAttribute(MENSRB::ACFT_LOC)), 25);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::ACFT_LOC_ACCY)), 6, 2);
output << toString(dv_cast<int>(input.getAttribute(MENSRB::ACFT_ALT)), 6);
output << sizeString(dv_cast<string>(input.getAttribute(MENSRB::RP_LOC)), 25);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::RP_LOC_ACCY)), 6, 2);
output << toString(dv_cast<int>(input.getAttribute(MENSRB::RP_ELEV)), 6, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::OF_PC_R)), 7, 1, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::OF_PC_A)), 7, 1, ZERO_FILL, POS_SIGN_TRUE,
false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::COSGRZ)), 7);
output << toString(dv_cast<int>(input.getAttribute(MENSRB::RGCRP)), 7);
output << sizeString(dv_cast<string>(input.getAttribute(MENSRB::RLMAP)), 1);
output << toString(dv_cast<int>(input.getAttribute(MENSRB::RP_ROW)), 5, -1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(MENSRB::RP_COL)), 5, -1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_R_NC)), 10, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_R_EC)), 10, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_R_DC)), 10, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_AZ_NC)), 9, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_AZ_EC)), 9, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_AZ_DC)), 9, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_AL_NC)), 9, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_AL_EC)), 9, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(MENSRB::C_AL_DC)), 9, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<int>(input.getAttribute(MENSRB::TOTAL_TILES_COLS)), 3,
-1, ZERO_FILL, false, false, 3, true);
output << toString(dv_cast<int>(input.getAttribute(MENSRB::TOTAL_TILES_ROWS)), 5,
-1, ZERO_FILL, false, false, 3, true);
}
catch (const bad_cast&)
{
return false;
}
sizeOut = output.tellp();
numBytesWritten = sizeOut - sizeIn;
return true;
}
int VariableLengthBuffer::WriteHeader(ostream & stream)const{
int result;
result = IOBuffer::WriteHeader(stream);
if(!result) return 0;
stream.write(headerStr, headerSize);
if(! stream.good()) return 0;
return stream.tellp();
}
bool Nitf::AimidbParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
size_t sizeIn = max(static_cast<ostream::pos_type>(0), output.tellp());
size_t sizeOut(sizeIn);
try
{
// put date in form CCYYMMDDhhmmss for this TAG see: strftime() for format info
const DateTime* pAppDtgAcquisitionDate = dv_cast<DateTime>(&input.getAttribute(AIMIDB::ACQUISITION_DATE));
if (pAppDtgAcquisitionDate == NULL)
{
return false;
}
string CCYYMMDDhhmmss = pAppDtgAcquisitionDate->getFormattedUtc("%Y%m%d%H%M%S");
output << sizeString(CCYYMMDDhhmmss, 14);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::MISSION_NO)), 4);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::MISSION_IDENTIFICATION)), 10);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::FLIGHT_NO)), 2);
output << toString(dv_cast<int>(input.getAttribute(AIMIDB::OP_NUM)), 3);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::CURRENT_SEGMENT)), 2);
output << toString(dv_cast<int>(input.getAttribute(AIMIDB::REPRO_NUM)), 2);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::REPLAY)), 3);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::RESERVED1)), 1);
output << toString(dv_cast<int>(input.getAttribute(AIMIDB::START_TILE_COLUMN)), 3);
output << toString(dv_cast<int>(input.getAttribute(AIMIDB::START_TILE_ROW)), 5);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::END_SEGMENT)), 2);
output << toString(dv_cast<int>(input.getAttribute(AIMIDB::END_TILE_COLUMN)), 3);
output << toString(dv_cast<int>(input.getAttribute(AIMIDB::END_TILE_ROW)), 5);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::COUNTRY)), 2);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::RESERVED2)), 4);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::LOCATION)), 11);
output << sizeString(dv_cast<string>(input.getAttribute(AIMIDB::RESERVED3)), 13);
}
catch (const bad_cast&)
{
return false;
}
sizeOut = output.tellp();
numBytesWritten = sizeOut - sizeIn;
return true;
}
int VariableLengthBuffer::Write(ostream & stream) const{
int recaddr = stream.tellp();
unsigned short bufferSize;
bufferSize = BufferSize;
stream.write((char *)&bufferSize, sizeof(bufferSize));
if(!stream) return -1;
stream.write(Buffer, BufferSize);
if(! stream.good()) return -1;
return recaddr;
}
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 FixedFieldBuffer::WriteHeader(ostream & stream) const{
if(!Initialized) return -1;
int result = FixedLengthBuffer::WriteHeader(stream);
if(!result) return -1;
stream.write((char*)&NumFields, sizeof(NumFields));
for(int i=0; i<NumFields; i++)
stream.write((char*)&FieldSize[i], sizeof(FieldSize[i]));
if(!stream) return -1;
return stream.tellp();
}
//-------------------------------------------------------------------------------------------------
size_t MessageBase::encode(ostream& to) const
{
const std::ios::pos_type where(to.tellp());
for (Positions::const_iterator itr(_pos.begin()); itr != _pos.end(); ++itr)
{
#if defined POPULATE_METADATA
check_set_rlm(itr->second);
#endif
Presence::const_iterator fpitr(_fp.get_presence().end());
if (!_fp.get(itr->second->_fnum, fpitr, FieldTrait::suppress)) // some fields are not encoded until unsuppressed (eg. checksum)
{
itr->second->encode(to);
if (fpitr->_field_traits.has(FieldTrait::group))
encode_group(itr->second->_fnum, to);
}
}
return to.tellp() - where;
}
bool Nitf::SectgaParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
size_t sizeIn = max(static_cast<ostream::pos_type>(0), output.tellp());
size_t sizeOut(sizeIn);
try
{
output << sizeString(dv_cast<string>(input.getAttribute(SECTGA::SEC_ID)), 12);
output << sizeString(dv_cast<string>(input.getAttribute(SECTGA::SEC_BE)), 15);
output << toString(dv_cast<unsigned int>(input.getAttribute(SECTGA::RESERVED001)), 1, -1);
}
catch (const bad_cast&)
{
return false;
}
sizeOut = output.tellp();
numBytesWritten = sizeOut - sizeIn;
return true;
}
bool Nitf::SectgaParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
if (output.tellp() < 0 || static_cast<uint64_t>(output.tellp()) > std::numeric_limits<size_t>::max())
{
return false;
}
size_t sizeIn = max<size_t>(0, static_cast<size_t>(output.tellp()));
size_t sizeOut(sizeIn);
try
{
output << sizeString(dv_cast<string>(input.getAttribute(SECTGA::SEC_ID)), 12);
output << sizeString(dv_cast<string>(input.getAttribute(SECTGA::SEC_BE)), 15);
output << toString(dv_cast<unsigned int>(input.getAttribute(SECTGA::RESERVED001)), 1, -1);
}
catch (const bad_cast&)
{
return false;
}
if (output.tellp() < 0 || static_cast<uint64_t>(output.tellp()) > std::numeric_limits<size_t>::max())
{
return false;
}
sizeOut = static_cast<size_t>(output.tellp());
numBytesWritten = sizeOut - sizeIn;
return true;
}
//-------------------------------------------------------------------------------------------------
size_t MessageBase::encode(ostream& to) const
{
const std::ios::pos_type where(to.tellp());
for (const auto& pp : _pos)
{
#if defined FIX8_POPULATE_METADATA
check_set_rlm(pp.second);
#endif
Presence::const_iterator fpitr(_fp.get_presence().end());
if (!_fp.get(pp.second->_fnum, fpitr, FieldTrait::suppress)) // some fields are not encoded until unsuppressed (eg. checksum)
{
pp.second->encode(to);
if (fpitr->_field_traits.has(FieldTrait::group) && has_group_count(pp.second))
encode_group(pp.second->_fnum, to);
}
}
if (_unknown.size())
to << _unknown;
return to.tellp() - where;
}
int VariableLengthBuffer :: Write (ostream & stream) const
{
int recaddr = stream.tellp();
stream.write(Buffer, BufferSize);
int t=sizeof(BufferSize);
for(int i=0;i<150-t;i++)
{
stream.write(" ",1);
}
stream.write("#",1);
if(!stream.good())
return -1;
return recaddr;
}
void ZipOutputStreambuf::writeCentralDirectory( const vector< ZipCDirEntry > &entries,
EndOfCentralDirectory eocd,
ostream &os ) {
int cdir_start = os.tellp() ;
std::vector< ZipCDirEntry >::const_iterator it ;
int cdir_size = 0 ;
for ( it = entries.begin() ; it != entries.end() ; ++it ) {
os << *it ;
cdir_size += it->getCDirHeaderSize() ;
}
eocd.setOffset( cdir_start ) ;
eocd.setCDirSize( cdir_size ) ;
eocd.setTotalCount( entries.size() ) ;
os << eocd ;
}
int VariableLengthBuffer::WriteHeader(ostream & stream) const
// write a buffer header to the beginning of the stream
// A header consists of the
// IOBUFFER header
// header string
// Variable sized record of length fields
// that describes the file records
{
int result;
// write the parent (IOBuffer) header
result = IOBuffer::WriteHeader(stream);
if(!result)
return FALSE;
// write the header string
stream.write(headerStr, headerSize);
if(!stream.good())
return FALSE;
// write the record description
return stream.tellp();
}
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);
}
}
bool Nitf::RpcParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
if (output.tellp() < 0 || static_cast<uint64_t>(output.tellp()) > std::numeric_limits<size_t>::max())
{
return false;
}
size_t sizeIn = max<size_t>(0, static_cast<size_t>(output.tellp()));
size_t sizeOut(sizeIn);
try
{
output << dv_cast<bool>(input.getAttribute(SUCCESS)) ? "1" : "0";
output << toString(dv_cast<double>(input.getAttribute(ERR_BIAS)), 7, 2);
output << toString(dv_cast<double>(input.getAttribute(ERR_RAND)), 7, 2);
output << toString(dv_cast<unsigned int>(input.getAttribute(LINE_OFFSET)), 6);
output << toString(dv_cast<unsigned int>(input.getAttribute(SAMP_OFFSET)), 5);
output << toString(dv_cast<double>(input.getAttribute(LAT_OFFSET)), 8, 4, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(LONG_OFFSET)), 9, 4, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<int>(input.getAttribute(HEIGHT_OFFSET)), 5, -1, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<unsigned int>(input.getAttribute(LINE_SCALE)), 6);
output << toString(dv_cast<unsigned int>(input.getAttribute(SAMP_SCALE)), 5);
output << toString(dv_cast<double>(input.getAttribute(LAT_SCALE)), 8, 4, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<double>(input.getAttribute(LONG_SCALE)), 9, 4, ZERO_FILL, POS_SIGN_TRUE);
output << toString(dv_cast<int>(input.getAttribute(HEIGHT_SCALE)), 5, -1, ZERO_FILL, POS_SIGN_TRUE);
unsigned int u;
for (u = 1; u <= 20; ++u)
{
output << toString(dv_cast<double>(input.getAttribute(getRpcCoefficient(LINE_NUMERATOR_COEF_PREFIX, u))),
12, 6, ZERO_FILL, POS_SIGN_TRUE, USE_SCIENTIFIC_NOTATION, ONE_EXP_DIGIT);
}
for (u = 1; u <= 20; ++u)
{
output << toString(dv_cast<double>(input.getAttribute(getRpcCoefficient(LINE_DENOMINATOR_COEF_PREFIX, u))),
12, 6, ZERO_FILL, POS_SIGN_TRUE, USE_SCIENTIFIC_NOTATION, ONE_EXP_DIGIT);
}
for (u = 1; u <= 20; ++u)
{
output << toString(dv_cast<double>(input.getAttribute(getRpcCoefficient(SAMPLE_NUMERATOR_COEF_PREFIX, u))),
12, 6, ZERO_FILL, POS_SIGN_TRUE, USE_SCIENTIFIC_NOTATION, ONE_EXP_DIGIT);
}
for (u = 1; u <= 20; ++u)
{
output << toString(dv_cast<double>(input.getAttribute(getRpcCoefficient(SAMPLE_DENOMINATOR_COEF_PREFIX, u))),
12, 6, ZERO_FILL, POS_SIGN_TRUE, USE_SCIENTIFIC_NOTATION, ONE_EXP_DIGIT);
}
}
catch (const bad_cast&)
{
return false;
}
if (output.tellp() < 0 || static_cast<uint64_t>(output.tellp()) > std::numeric_limits<size_t>::max())
{
return false;
}
sizeOut = static_cast<size_t>(output.tellp());
numBytesWritten = sizeOut - sizeIn;
return true;
}
bool Nitf::BandsaParser::fromDynamicObject(const DynamicObject& input, ostream& output, size_t& numBytesWritten,
string &errorMessage) const
{
if (output.tellp() < 0 || static_cast<uint64_t>(output.tellp()) > std::numeric_limits<size_t>::max())
{
return false;
}
size_t sizeIn = max<size_t>(0, static_cast<size_t>(output.tellp()));
size_t sizeOut(sizeIn);
try
{
output << toString(dv_cast<double>(input.getAttribute(BANDSA::ROW_SPACING)), 7, 4);
output << sizeString(dv_cast<string>(input.getAttribute(BANDSA::ROW_SPACING_UNITS)), 1);
output << toString(dv_cast<double>(input.getAttribute(BANDSA::COL_SPACING)), 7, 4);
output << sizeString(dv_cast<string>(input.getAttribute(BANDSA::COL_SPACING_UNITS)), 1);
output << toString(dv_cast<double>(input.getAttribute(BANDSA::FOCAL_LENGTH)), 6, 2);
unsigned int bandcount = dv_cast<unsigned int>(input.getAttribute(BANDSA::BANDCOUNT));
output << toString(bandcount, 4);
for (unsigned int i = 0; i < bandcount; ++i)
{
stringstream bandStreamStr;
bandStreamStr << "#" << i;
string bandStr(bandStreamStr.str());
string fieldName;
fieldName = BANDSA::BANDPEAK + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 2, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDLBOUND + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 2, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDUBOUND + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 2, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDWIDTH + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 2, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDCALDRK + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 6, 1, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDCALINC + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 2, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDRESP + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 1, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDASD + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 2, ZERO_FILL, false, false, 3, true);
fieldName = BANDSA::BANDGSD + bandStr;
output << toString(dv_cast<double>(input.getAttribute(fieldName)), 5, 2, ZERO_FILL, false, false, 3, true);
}
}
catch (const bad_cast&)
{
return false;
}
if (output.tellp() < 0 || static_cast<uint64_t>(output.tellp()) > std::numeric_limits<size_t>::max())
{
return false;
}
sizeOut = static_cast<size_t>(output.tellp());
numBytesWritten = sizeOut - sizeIn;
return true;
}
int FixedLengthBuffer::write(ostream& stream) const{
int recAddr = stream.tellp();
stream.write(this->buffer, this->bufferSize);
if(!stream.good()) return -1;
return recAddr;
}
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);
}
void MemoryMap::pagesizealign(ostream &out)
{
size_t at = out.tellp();
size_t offs = at % pagesize;
if(offs) { out.seekp(pagesize - offs, ios::cur); }
}
pos_type tell_o()const{
hmLib_assert(has_o(),"There is no ostream");
return ptr_o->tellp();
}
void RemoveLastSymbol(ostream& stream)
{
stream.seekp(static_cast<int>(stream.tellp()) - 1);
}
