// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void ParameterSet::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: ParameterSet skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("baseID", _baseID, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("moduleID", _moduleID, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("created", _created, Archive::SPLIT_TIME);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("parameter",
Seiscomp::Core::Generic::containerMember(_parameters,
Seiscomp::Core::Generic::bindMemberFunction<Parameter>(static_cast<bool (ParameterSet::*)(Parameter*)>(&ParameterSet::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("comment",
Seiscomp::Core::Generic::containerMember(_comments,
Seiscomp::Core::Generic::bindMemberFunction<Comment>(static_cast<bool (ParameterSet::*)(Comment*)>(&ParameterSet::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void StrongOriginDescription::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: StrongOriginDescription skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("originID", _originID, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("waveformCount", _waveformCount, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("creationInfo", _creationInfo, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("eventRecordReference",
Seiscomp::Core::Generic::containerMember(_eventRecordReferences,
Seiscomp::Core::Generic::bindMemberFunction<EventRecordReference>(static_cast<bool (StrongOriginDescription::*)(EventRecordReference*)>(&StrongOriginDescription::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("rupture",
Seiscomp::Core::Generic::containerMember(_ruptures,
Seiscomp::Core::Generic::bindMemberFunction<Rupture>(static_cast<bool (StrongOriginDescription::*)(Rupture*)>(&StrongOriginDescription::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void StationMagnitude::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,11>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: StationMagnitude skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("originID", _originID, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("magnitude", _magnitude, Archive::STATIC_TYPE | Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("type", _type, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("amplitudeID", _amplitudeID, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("methodID", _methodID, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("waveformID", _waveformID, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
if ( ar.supportsVersion<0,11>() ) {
ar & NAMED_OBJECT_HINT("passedQC", _passedQC, Archive::XML_ELEMENT);
}
ar & NAMED_OBJECT_HINT("creationInfo", _creationInfo, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("comment",
Seiscomp::Core::Generic::containerMember(_comments,
Seiscomp::Core::Generic::bindMemberFunction<Comment>(static_cast<bool (StationMagnitude::*)(Comment*)>(&StationMagnitude::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void StationGroup::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: StationGroup skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("type", _type, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("code", _index.code, Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("start", _start, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("end", _end, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("description", _description, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("latitude", _latitude, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("longitude", _longitude, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("elevation", _elevation, Archive::XML_ELEMENT);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("stationReference",
Seiscomp::Core::Generic::containerMember(_stationReferences,
Seiscomp::Core::Generic::bindMemberFunction<StationReference>(static_cast<bool (StationGroup::*)(StationReference*)>(&StationGroup::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void RouteSeedlink::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,8>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: RouteSeedlink skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("address", _index.address, Archive::XML_ELEMENT | Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("priority", _priority, Archive::XML_ELEMENT);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void FilterParameter::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: FilterParameter skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("value", _value, Archive::STATIC_TYPE | Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("name", _name, Archive::XML_MANDATORY);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void EventDescription::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: EventDescription skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("text", _text, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("type", _index.type, Archive::XML_ELEMENT | Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void SimpleFilterChainMember::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,10>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: SimpleFilterChainMember skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("sequenceNo", _index.sequenceNo, Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("simpleFilterID", _simpleFilterID, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void StationMagnitudeContribution::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,8>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: StationMagnitudeContribution skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("stationMagnitudeID", _index.stationMagnitudeID, Archive::XML_ELEMENT | Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("residual", _residual, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("weight", _weight, Archive::XML_ELEMENT);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void EnvelopeValue::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: EnvelopeValue skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("value", _value, Archive::XML_CDATA | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("type", _type, Archive::XML_MANDATORY);
ar & NAMED_OBJECT("quality", _quality);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Setup::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: Setup skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("name", _index.name, Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("parameterSetID", _parameterSetID, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("enabled", _enabled, Archive::XML_MANDATORY);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Comment::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: Comment skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("text", _text, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("id", _index.id, Archive::XML_ELEMENT | Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("creationInfo", _creationInfo, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void DataUsed::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: DataUsed skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("waveType", _waveType, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("stationCount", _stationCount, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("componentCount", _componentCount, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("shortestPeriod", _shortestPeriod, Archive::XML_ELEMENT);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void JournalEntry::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: JournalEntry skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("created", _created, Archive::SPLIT_TIME);
ar & NAMED_OBJECT_HINT("objectID", _objectID, Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("sender", _sender, Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("action", _action, Archive::XML_MANDATORY);
ar & NAMED_OBJECT("parameters", _parameters);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void ArclinkLog::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: ArclinkLog skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("arclinkRequest",
Seiscomp::Core::Generic::containerMember(_arclinkRequests,
Seiscomp::Core::Generic::bindMemberFunction<ArclinkRequest>(static_cast<bool (ArclinkLog::*)(ArclinkRequest*)>(&ArclinkLog::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("arclinkUser",
Seiscomp::Core::Generic::containerMember(_arclinkUsers,
Seiscomp::Core::Generic::bindMemberFunction<ArclinkUser>(static_cast<bool (ArclinkLog::*)(ArclinkUser*)>(&ArclinkLog::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Config::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: Config skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("parameterSet",
Seiscomp::Core::Generic::containerMember(_parameterSets,
Seiscomp::Core::Generic::bindMemberFunction<ParameterSet>(static_cast<bool (Config::*)(ParameterSet*)>(&Config::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("module",
Seiscomp::Core::Generic::containerMember(_configModules,
Seiscomp::Core::Generic::bindMemberFunction<ConfigModule>(static_cast<bool (Config::*)(ConfigModule*)>(&Config::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Routing::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: Routing skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("route",
Seiscomp::Core::Generic::containerMember(_routes,
Seiscomp::Core::Generic::bindMemberFunction<Route>(static_cast<bool (Routing::*)(Route*)>(&Routing::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("access",
Seiscomp::Core::Generic::containerMember(_accesss,
Seiscomp::Core::Generic::bindMemberFunction<Access>(static_cast<bool (Routing::*)(Access*)>(&Routing::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void SimpleFilter::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,10>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: SimpleFilter skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("type", _type, Archive::XML_MANDATORY);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("parameter",
Seiscomp::Core::Generic::containerMember(_filterParameters,
Seiscomp::Core::Generic::bindMemberFunction<FilterParameter>(static_cast<bool (SimpleFilter::*)(FilterParameter*)>(&SimpleFilter::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void EnvelopeChannel::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,10>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: EnvelopeChannel skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("name", _name, Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("waveformID", _waveformID, Archive::STATIC_TYPE | Archive::XML_ELEMENT | Archive::XML_MANDATORY);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("value",
Seiscomp::Core::Generic::containerMember(_envelopeValues,
Seiscomp::Core::Generic::bindMemberFunction<EnvelopeValue>(static_cast<bool (EnvelopeChannel::*)(EnvelopeValue*)>(&EnvelopeChannel::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void OriginReference::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,8>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: OriginReference skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("originID", _index.originID, Archive::XML_CDATA | Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Route::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,7>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: Route skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("networkCode", _index.networkCode, Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("stationCode", _index.stationCode, Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("locationCode", _index.locationCode, Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("streamCode", _index.streamCode, Archive::XML_MANDATORY | Archive::INDEX_ATTRIBUTE);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("arclink",
Seiscomp::Core::Generic::containerMember(_routeArclinks,
Seiscomp::Core::Generic::bindMemberFunction<RouteArclink>(static_cast<bool (Route::*)(RouteArclink*)>(&Route::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("seedlink",
Seiscomp::Core::Generic::containerMember(_routeSeedlinks,
Seiscomp::Core::Generic::bindMemberFunction<RouteSeedlink>(static_cast<bool (Route::*)(RouteSeedlink*)>(&Route::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void ConfigModule::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,8>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: ConfigModule skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("name", _name, Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("parameterSetID", _parameterSetID, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("enabled", _enabled, Archive::XML_MANDATORY);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("station",
Seiscomp::Core::Generic::containerMember(_configStations,
Seiscomp::Core::Generic::bindMemberFunction<ConfigStation>(static_cast<bool (ConfigModule::*)(ConfigStation*)>(&ConfigModule::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void MomentTensorStationContribution::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: MomentTensorStationContribution skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("active", _active, Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("waveformID", _waveformID, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
ar & NAMED_OBJECT("weight", _weight);
ar & NAMED_OBJECT("timeShift", _timeShift);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("component",
Seiscomp::Core::Generic::containerMember(_momentTensorComponentContributions,
Seiscomp::Core::Generic::bindMemberFunction<MomentTensorComponentContribution>(static_cast<bool (MomentTensorStationContribution::*)(MomentTensorComponentContribution*)>(&MomentTensorStationContribution::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Envelope::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,12>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: Envelope skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("network", _network, Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("station", _station, Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("timestamp", _timestamp, Archive::SPLIT_TIME | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("creationInfo", _creationInfo, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("channel",
Seiscomp::Core::Generic::containerMember(_envelopeChannels,
Seiscomp::Core::Generic::bindMemberFunction<EnvelopeChannel>(static_cast<bool (Envelope::*)(EnvelopeChannel*)>(&Envelope::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Reading::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,11>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: Reading skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("pickReference",
Seiscomp::Core::Generic::containerMember(_pickReferences,
Seiscomp::Core::Generic::bindMemberFunction<PickReference>(static_cast<bool (Reading::*)(PickReference*)>(&Reading::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("amplitudeReference",
Seiscomp::Core::Generic::containerMember(_amplitudeReferences,
Seiscomp::Core::Generic::bindMemberFunction<AmplitudeReference>(static_cast<bool (Reading::*)(AmplitudeReference*)>(&Reading::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void StrongMotionParameters::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: StrongMotionParameters skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("simpleFilter",
Seiscomp::Core::Generic::containerMember(_simpleFilters,
Seiscomp::Core::Generic::bindMemberFunction<SimpleFilter>(static_cast<bool (StrongMotionParameters::*)(SimpleFilter*)>(&StrongMotionParameters::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("record",
Seiscomp::Core::Generic::containerMember(_records,
Seiscomp::Core::Generic::bindMemberFunction<Record>(static_cast<bool (StrongMotionParameters::*)(Record*)>(&StrongMotionParameters::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("strongOriginDescription",
Seiscomp::Core::Generic::containerMember(_strongOriginDescriptions,
Seiscomp::Core::Generic::bindMemberFunction<StrongOriginDescription>(static_cast<bool (StrongMotionParameters::*)(StrongOriginDescription*)>(&StrongMotionParameters::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void QualityControl::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,8>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: QualityControl skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
if ( ar.hint() & Archive::IGNORE_CHILDS ) return;
ar & NAMED_OBJECT_HINT("log",
Seiscomp::Core::Generic::containerMember(_qCLogs,
Seiscomp::Core::Generic::bindMemberFunction<QCLog>(static_cast<bool (QualityControl::*)(QCLog*)>(&QualityControl::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("waveformQuality",
Seiscomp::Core::Generic::containerMember(_waveformQualitys,
Seiscomp::Core::Generic::bindMemberFunction<WaveformQuality>(static_cast<bool (QualityControl::*)(WaveformQuality*)>(&QualityControl::add), this)),
Archive::STATIC_TYPE);
ar & NAMED_OBJECT_HINT("outage",
Seiscomp::Core::Generic::containerMember(_outages,
Seiscomp::Core::Generic::bindMemberFunction<Outage>(static_cast<bool (QualityControl::*)(Outage*)>(&QualityControl::add), this)),
Archive::STATIC_TYPE);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void ResponseFIR::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: ResponseFIR skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("name", _index.name, Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("gain", _gain, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("decimationFactor", _decimationFactor, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("delay", _delay, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("correction", _correction, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("numberOfCoefficients", _numberOfCoefficients, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("symmetry", _symmetry, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("coefficients", _coefficients, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("remark", _remark, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void PeakMotion::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,10>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: PeakMotion skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
ar & NAMED_OBJECT_HINT("motion", _motion, Archive::STATIC_TYPE | Archive::XML_ELEMENT | Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("type", _type, Archive::XML_MANDATORY);
ar & NAMED_OBJECT_HINT("period", _period, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("damping", _damping, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("method", _method, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("atTime", _atTime, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void ResponseFAP::serialize(Archive& ar) {
// Do not read/write if the archive's version is higher than
// currently supported
if ( ar.isHigherVersion<0,9>() ) {
SEISCOMP_ERROR("Archive version %d.%d too high: ResponseFAP skipped",
ar.versionMajor(), ar.versionMinor());
ar.setValidity(false);
return;
}
PublicObject::serialize(ar);
if ( !ar.success() ) return;
ar & NAMED_OBJECT_HINT("name", _index.name, Archive::INDEX_ATTRIBUTE);
ar & NAMED_OBJECT_HINT("gain", _gain, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("gainFrequency", _gainFrequency, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("numberOfTuples", _numberOfTuples, Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("tuples", _tuples, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
ar & NAMED_OBJECT_HINT("remark", _remark, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
}
