text: /***************************************************************************
   *   Copyright (C) by GFZ Potsdam                                          *
   *                                                                         *
   *   You can redistribute and/or modify this program under the             *
   *   terms of the SeisComP Public License.                                 *
   *                                                                         *
   *   This program is distributed in the hope that it will be useful,       *
   *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
   *   SeisComP Public License for more details.                             *
   ***************************************************************************/
  
  
  #define SEISCOMP_COMPONENT DataModel
  #include <seiscomp3/datamodel/stationmagnitude.h>
  #include <seiscomp3/datamodel/origin.h>
  #include <algorithm>
  #include <seiscomp3/datamodel/metadata.h>
  #include <seiscomp3/logging/log.h>
  
  
  namespace Seiscomp {
  namespace DataModel {
  
  
  IMPLEMENT_SC_CLASS_DERIVED(StationMagnitude, PublicObject, "StationMagnitude");
  
  
  StationMagnitude::MetaObject::MetaObject(const Core::RTTI* rtti) : Seiscomp::Core::MetaObject(rtti) {
  	addProperty(Core::simpleProperty("originID", "string", false, false, false, true, false, false, NULL, &StationMagnitude::setOriginID, &StationMagnitude::originID));
  	addProperty(objectProperty<RealQuantity>("magnitude", "RealQuantity", false, false, false, &StationMagnitude::setMagnitude, &StationMagnitude::magnitude));
  	addProperty(Core::simpleProperty("type", "string", false, false, false, false, false, false, NULL, &StationMagnitude::setType, &StationMagnitude::type));
  	addProperty(Core::simpleProperty("amplitudeID", "string", false, false, false, true, false, false, NULL, &StationMagnitude::setAmplitudeID, &StationMagnitude::amplitudeID));
  	addProperty(Core::simpleProperty("methodID", "string", false, false, false, false, false, false, NULL, &StationMagnitude::setMethodID, &StationMagnitude::methodID));
  	addProperty(objectProperty<WaveformStreamID>("waveformID", "WaveformStreamID", false, false, true, &StationMagnitude::setWaveformID, &StationMagnitude::waveformID));
  	addProperty(Core::simpleProperty("passedQC", "boolean", false, false, false, false, true, false, NULL, &StationMagnitude::setPassedQC, &StationMagnitude::passedQC));
  	addProperty(objectProperty<CreationInfo>("creationInfo", "CreationInfo", false, false, true, &StationMagnitude::setCreationInfo, &StationMagnitude::creationInfo));
  	addProperty(arrayClassProperty<Comment>("comment", "Comment", &StationMagnitude::commentCount, &StationMagnitude::comment, static_cast<bool (StationMagnitude::*)(Comment*)>(&StationMagnitude::add), &StationMagnitude::removeComment, static_cast<bool (StationMagnitude::*)(Comment*)>(&StationMagnitude::remove)));
  }
  
  
  IMPLEMENT_METAOBJECT(StationMagnitude)
  
  
  StationMagnitude::StationMagnitude() {
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StationMagnitude::StationMagnitude(const StationMagnitude& other)
  : PublicObject() {
  	*this = other;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StationMagnitude::StationMagnitude(const std::string& publicID)
  : PublicObject(publicID) {
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StationMagnitude::~StationMagnitude() {
  	std::for_each(_comments.begin(), _comments.end(),
  	              std::compose1(std::bind2nd(std::mem_fun(&Comment::setParent),
  	                                         (PublicObject*)NULL),
  	                            std::mem_fun_ref(&CommentPtr::get)));
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StationMagnitude* StationMagnitude::Create() {
  	StationMagnitude* object = new StationMagnitude();
  	return static_cast<StationMagnitude*>(GenerateId(object));
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StationMagnitude* StationMagnitude::Create(const std::string& publicID) {
  	if ( PublicObject::IsRegistrationEnabled() && Find(publicID) != NULL ) {
  		SEISCOMP_ERROR(
  			"There exists already a PublicObject with Id '%s'",
  			publicID.c_str()
  		);
  		return NULL;
  	}
  
  	return new StationMagnitude(publicID);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StationMagnitude* StationMagnitude::Find(const std::string& publicID) {
  	return StationMagnitude::Cast(PublicObject::Find(publicID));
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::operator==(const StationMagnitude& rhs) const {
  	if ( _originID != rhs._originID ) return false;
  	if ( _magnitude != rhs._magnitude ) return false;
  	if ( _type != rhs._type ) return false;
  	if ( _amplitudeID != rhs._amplitudeID ) return false;
  	if ( _methodID != rhs._methodID ) return false;
  	if ( _waveformID != rhs._waveformID ) return false;
  	if ( _passedQC != rhs._passedQC ) return false;
  	if ( _creationInfo != rhs._creationInfo ) return false;
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::operator!=(const StationMagnitude& rhs) const {
  	return !operator==(rhs);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::equal(const StationMagnitude& other) const {
  	return *this == other;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setOriginID(const std::string& originID) {
  	_originID = originID;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const std::string& StationMagnitude::originID() const {
  	return _originID;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setMagnitude(const RealQuantity& magnitude) {
  	_magnitude = magnitude;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  RealQuantity& StationMagnitude::magnitude() {
  	return _magnitude;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const RealQuantity& StationMagnitude::magnitude() const {
  	return _magnitude;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setType(const std::string& type) {
  	_type = type;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const std::string& StationMagnitude::type() const {
  	return _type;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setAmplitudeID(const std::string& amplitudeID) {
  	_amplitudeID = amplitudeID;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const std::string& StationMagnitude::amplitudeID() const {
  	return _amplitudeID;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setMethodID(const std::string& methodID) {
  	_methodID = methodID;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const std::string& StationMagnitude::methodID() const {
  	return _methodID;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setWaveformID(const OPT(WaveformStreamID)& waveformID) {
  	_waveformID = waveformID;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  WaveformStreamID& StationMagnitude::waveformID() {
  	if ( _waveformID )
  		return *_waveformID;
  	throw Seiscomp::Core::ValueException("StationMagnitude.waveformID is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const WaveformStreamID& StationMagnitude::waveformID() const {
  	if ( _waveformID )
  		return *_waveformID;
  	throw Seiscomp::Core::ValueException("StationMagnitude.waveformID is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setPassedQC(const OPT(bool)& passedQC) {
  	_passedQC = passedQC;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::passedQC() const {
  	if ( _passedQC )
  		return *_passedQC;
  	throw Seiscomp::Core::ValueException("StationMagnitude.passedQC is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::setCreationInfo(const OPT(CreationInfo)& creationInfo) {
  	_creationInfo = creationInfo;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  CreationInfo& StationMagnitude::creationInfo() {
  	if ( _creationInfo )
  		return *_creationInfo;
  	throw Seiscomp::Core::ValueException("StationMagnitude.creationInfo is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const CreationInfo& StationMagnitude::creationInfo() const {
  	if ( _creationInfo )
  		return *_creationInfo;
  	throw Seiscomp::Core::ValueException("StationMagnitude.creationInfo is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  Origin* StationMagnitude::origin() const {
  	return static_cast<Origin*>(parent());
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StationMagnitude& StationMagnitude::operator=(const StationMagnitude& other) {
  	PublicObject::operator=(other);
  	_originID = other._originID;
  	_magnitude = other._magnitude;
  	_type = other._type;
  	_amplitudeID = other._amplitudeID;
  	_methodID = other._methodID;
  	_waveformID = other._waveformID;
  	_passedQC = other._passedQC;
  	_creationInfo = other._creationInfo;
  	return *this;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::assign(Object* other) {
  	StationMagnitude* otherStationMagnitude = StationMagnitude::Cast(other);
  	if ( other == NULL )
  		return false;
  
  	*this = *otherStationMagnitude;
  
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::attachTo(PublicObject* parent) {
  	if ( parent == NULL ) return false;
  
  	// check all possible parents
  	Origin* origin = Origin::Cast(parent);
  	if ( origin != NULL )
  		return origin->add(this);
  
  	SEISCOMP_ERROR("StationMagnitude::attachTo(%s) -> wrong class type", parent->className());
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::detachFrom(PublicObject* object) {
  	if ( object == NULL ) return false;
  
  	// check all possible parents
  	Origin* origin = Origin::Cast(object);
  	if ( origin != NULL ) {
  		// If the object has been added already to the parent locally
  		// just remove it by pointer
  		if ( object == parent() )
  			return origin->remove(this);
  		// The object has not been added locally so it must be looked up
  		else {
  			StationMagnitude* child = origin->findStationMagnitude(publicID());
  			if ( child != NULL )
  				return origin->remove(child);
  			else {
  				SEISCOMP_DEBUG("StationMagnitude::detachFrom(Origin): stationMagnitude has not been found");
  				return false;
  			}
  		}
  	}
  
  	SEISCOMP_ERROR("StationMagnitude::detachFrom(%s) -> wrong class type", object->className());
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::detach() {
  	if ( parent() == NULL )
  		return false;
  
  	return detachFrom(parent());
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  Object* StationMagnitude::clone() const {
  	StationMagnitude* clonee = new StationMagnitude();
  	*clonee = *this;
  	return clonee;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::updateChild(Object* child) {
  	Comment* commentChild = Comment::Cast(child);
  	if ( commentChild != NULL ) {
  		Comment* commentElement = comment(commentChild->index());
  		if ( commentElement != NULL ) {
  			*commentElement = *commentChild;
  			commentElement->update();
  			return true;
  		}
  		return false;
  	}
  
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void StationMagnitude::accept(Visitor* visitor) {
  	if ( visitor->traversal() == Visitor::TM_TOPDOWN )
  		if ( !visitor->visit(this) )
  			return;
  
  	for ( std::vector<CommentPtr>::iterator it = _comments.begin(); it != _comments.end(); ++it )
  		(*it)->accept(visitor);
  
  	if ( visitor->traversal() == Visitor::TM_BOTTOMUP )
  		visitor->visit(this);
  	else
  		visitor->finished();
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  size_t StationMagnitude::commentCount() const {
  	return _comments.size();
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  Comment* StationMagnitude::comment(size_t i) const {
  	return _comments[i].get();
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  Comment* StationMagnitude::comment(const CommentIndex& i) const {
  	for ( std::vector<CommentPtr>::const_iterator it = _comments.begin(); it != _comments.end(); ++it )
  		if ( i == (*it)->index() )
  			return (*it).get();
  
  	return NULL;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::add(Comment* comment) {
  	if ( comment == NULL )
  		return false;
  
  	// Element has already a parent
  	if ( comment->parent() != NULL ) {
  		SEISCOMP_ERROR("StationMagnitude::add(Comment*) -> element has already a parent");
  		return false;
  	}
  
  	// Duplicate index check
  	for ( std::vector<CommentPtr>::iterator it = _comments.begin(); it != _comments.end(); ++it ) {
  		if ( (*it)->index() == comment->index() ) {
  			SEISCOMP_ERROR("StationMagnitude::add(Comment*) -> an element with the same index has been added already");
  			return false;
  		}
  	}
  
  	// Add the element
  	_comments.push_back(comment);
  	comment->setParent(this);
  
  	// Create the notifiers
  	if ( Notifier::IsEnabled() ) {
  		NotifierCreator nc(OP_ADD);
  		comment->accept(&nc);
  	}
  
  	// Notify registered observers
  	childAdded(comment);
  	
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::remove(Comment* comment) {
  	if ( comment == NULL )
  		return false;
  
  	if ( comment->parent() != this ) {
  		SEISCOMP_ERROR("StationMagnitude::remove(Comment*) -> element has another parent");
  		return false;
  	}
  
  	std::vector<CommentPtr>::iterator it;
  	it = std::find(_comments.begin(), _comments.end(), comment);
  	// Element has not been found
  	if ( it == _comments.end() ) {
  		SEISCOMP_ERROR("StationMagnitude::remove(Comment*) -> child object has not been found although the parent pointer matches???");
  		return false;
  	}
  
  	// Create the notifiers
  	if ( Notifier::IsEnabled() ) {
  		NotifierCreator nc(OP_REMOVE);
  		(*it)->accept(&nc);
  	}
  
  	(*it)->setParent(NULL);
  	childRemoved((*it).get());
  	
  	_comments.erase(it);
  
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::removeComment(size_t i) {
  	// index out of bounds
  	if ( i >= _comments.size() )
  		return false;
  
  	// Create the notifiers
  	if ( Notifier::IsEnabled() ) {
  		NotifierCreator nc(OP_REMOVE);
  		_comments[i]->accept(&nc);
  	}
  
  	_comments[i]->setParent(NULL);
  	childRemoved(_comments[i].get());
  	
  	_comments.erase(_comments.begin() + i);
  
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool StationMagnitude::removeComment(const CommentIndex& i) {
  	Comment* object = comment(i);
  	if ( object == NULL ) return false;
  	return remove(object);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  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);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  }
  }
  