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.                             *
   ***************************************************************************/
  
  // This file was created by a source code generator.
  // Do not modify the contents. Change the definition and run the generator
  // again!
  
  
  #define SEISCOMP_COMPONENT DataModel
  #include <seiscomp3/datamodel/strongmotion/simplefilter.h>
  #include <seiscomp3/datamodel/strongmotion/strongmotionparameters.h>
  #include <seiscomp3/datamodel/strongmotion/filterparameter.h>
  #include <algorithm>
  #include <seiscomp3/datamodel/metadata.h>
  #include <seiscomp3/logging/log.h>
  
  
  namespace Seiscomp {
  namespace DataModel {
  namespace StrongMotion {
  
  
  IMPLEMENT_SC_CLASS_DERIVED(SimpleFilter, PublicObject, "SimpleFilter");
  
  
  SimpleFilter::MetaObject::MetaObject(const Core::RTTI* rtti) : Seiscomp::Core::MetaObject(rtti) {
  	addProperty(Core::simpleProperty("type", "string", false, false, false, false, false, false, NULL, &SimpleFilter::setType, &SimpleFilter::type));
  	addProperty(arrayClassProperty<FilterParameter>("parameter", "FilterParameter", &SimpleFilter::filterParameterCount, &SimpleFilter::filterParameter, static_cast<bool (SimpleFilter::*)(FilterParameter*)>(&SimpleFilter::add), &SimpleFilter::removeFilterParameter, static_cast<bool (SimpleFilter::*)(FilterParameter*)>(&SimpleFilter::remove)));
  }
  
  
  IMPLEMENT_METAOBJECT(SimpleFilter)
  
  
  SimpleFilter::SimpleFilter() {
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  SimpleFilter::SimpleFilter(const SimpleFilter& other)
   : PublicObject() {
  	*this = other;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  SimpleFilter::SimpleFilter(const std::string& publicID)
   : PublicObject(publicID) {
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  SimpleFilter::~SimpleFilter() {
  	std::for_each(_filterParameters.begin(), _filterParameters.end(),
  	              std::compose1(std::bind2nd(std::mem_fun(&FilterParameter::setParent),
  	                                         (PublicObject*)NULL),
  	                            std::mem_fun_ref(&FilterParameterPtr::get)));
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  SimpleFilter* SimpleFilter::Create() {
  	SimpleFilter* object = new SimpleFilter();
  	return static_cast<SimpleFilter*>(GenerateId(object));
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  SimpleFilter* SimpleFilter::Create(const std::string& publicID) {
  	if ( Find(publicID) != NULL ) {
  		SEISCOMP_ERROR(
  			"There exists already a PublicObject with Id '%s'",
  			publicID.c_str()
  		);
  		return NULL;
  	}
  
  	return new SimpleFilter(publicID);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  SimpleFilter* SimpleFilter::Find(const std::string& publicID) {
  	return SimpleFilter::Cast(PublicObject::Find(publicID));
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::operator==(const SimpleFilter& rhs) const {
  	if ( _type != rhs._type ) return false;
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::operator!=(const SimpleFilter& rhs) const {
  	return !operator==(rhs);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::equal(const SimpleFilter& other) const {
  	return *this == other;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void SimpleFilter::setType(const std::string& type) {
  	_type = type;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const std::string& SimpleFilter::type() const {
  	return _type;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  StrongMotionParameters* SimpleFilter::strongMotionParameters() const {
  	return static_cast<StrongMotionParameters*>(parent());
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  SimpleFilter& SimpleFilter::operator=(const SimpleFilter& other) {
  	PublicObject::operator=(other);
  	_type = other._type;
  	return *this;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::assign(Object* other) {
  	SimpleFilter* otherSimpleFilter = SimpleFilter::Cast(other);
  	if ( other == NULL )
  		return false;
  
  	*this = *otherSimpleFilter;
  
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::attachTo(PublicObject* parent) {
  	if ( parent == NULL ) return false;
  
  	// check all possible parents
  	StrongMotionParameters* strongMotionParameters = StrongMotionParameters::Cast(parent);
  	if ( strongMotionParameters != NULL )
  		return strongMotionParameters->add(this);
  
  	SEISCOMP_ERROR("SimpleFilter::attachTo(%s) -> wrong class type", parent->className());
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::detachFrom(PublicObject* object) {
  	if ( object == NULL ) return false;
  
  	// check all possible parents
  	StrongMotionParameters* strongMotionParameters = StrongMotionParameters::Cast(object);
  	if ( strongMotionParameters != NULL ) {
  		// If the object has been added already to the parent locally
  		// just remove it by pointer
  		if ( object == parent() )
  			return strongMotionParameters->remove(this);
  		// The object has not been added locally so it must be looked up
  		else {
  			SimpleFilter* child = strongMotionParameters->findSimpleFilter(publicID());
  			if ( child != NULL )
  				return strongMotionParameters->remove(child);
  			else {
  				SEISCOMP_DEBUG("SimpleFilter::detachFrom(StrongMotionParameters): simpleFilter has not been found");
  				return false;
  			}
  		}
  	}
  
  	SEISCOMP_ERROR("SimpleFilter::detachFrom(%s) -> wrong class type", object->className());
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::detach() {
  	if ( parent() == NULL )
  		return false;
  
  	return detachFrom(parent());
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  Object* SimpleFilter::clone() const {
  	SimpleFilter* clonee = new SimpleFilter();
  	*clonee = *this;
  	return clonee;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::updateChild(Object* child) {
  	// Do not know how to fetch child of type FilterParameter without an index
  
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void SimpleFilter::accept(Visitor* visitor) {
  	if ( visitor->traversal() == Visitor::TM_TOPDOWN )
  		if ( !visitor->visit(this) )
  			return;
  
  	for ( std::vector<FilterParameterPtr>::iterator it = _filterParameters.begin(); it != _filterParameters.end(); ++it )
  		(*it)->accept(visitor);
  
  	if ( visitor->traversal() == Visitor::TM_BOTTOMUP )
  		visitor->visit(this);
  	else
  		visitor->finished();
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  size_t SimpleFilter::filterParameterCount() const {
  	return _filterParameters.size();
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  FilterParameter* SimpleFilter::filterParameter(size_t i) const {
  	return _filterParameters[i].get();
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  FilterParameter* SimpleFilter::findFilterParameter(FilterParameter* filterParameter) const {
  	std::vector<FilterParameterPtr>::const_iterator it;
  	for ( it = _filterParameters.begin(); it != _filterParameters.end(); ++it ) {
  		if ( *filterParameter == **it )
  			return (*it).get();
  	}
  
  	return NULL;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::add(FilterParameter* filterParameter) {
  	if ( filterParameter == NULL )
  		return false;
  
  	// Element has already a parent
  	if ( filterParameter->parent() != NULL ) {
  		SEISCOMP_ERROR("SimpleFilter::add(FilterParameter*) -> element has already a parent");
  		return false;
  	}
  
  	// Add the element
  	_filterParameters.push_back(filterParameter);
  	filterParameter->setParent(this);
  
  	// Create the notifiers
  	if ( Notifier::IsEnabled() ) {
  		NotifierCreator nc(OP_ADD);
  		filterParameter->accept(&nc);
  	}
  
  	// Notify registered observers
  	childAdded(filterParameter);
  	
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::remove(FilterParameter* filterParameter) {
  	if ( filterParameter == NULL )
  		return false;
  
  	if ( filterParameter->parent() != this ) {
  		SEISCOMP_ERROR("SimpleFilter::remove(FilterParameter*) -> element has another parent");
  		return false;
  	}
  
  	std::vector<FilterParameterPtr>::iterator it;
  	it = std::find(_filterParameters.begin(), _filterParameters.end(), filterParameter);
  	// Element has not been found
  	if ( it == _filterParameters.end() ) {
  		SEISCOMP_ERROR("SimpleFilter::remove(FilterParameter*) -> 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());
  	
  	_filterParameters.erase(it);
  
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool SimpleFilter::removeFilterParameter(size_t i) {
  	// index out of bounds
  	if ( i >= _filterParameters.size() )
  		return false;
  
  	// Create the notifiers
  	if ( Notifier::IsEnabled() ) {
  		NotifierCreator nc(OP_REMOVE);
  		_filterParameters[i]->accept(&nc);
  	}
  
  	_filterParameters[i]->setParent(NULL);
  	childRemoved(_filterParameters[i].get());
  	
  	_filterParameters.erase(_filterParameters.begin() + i);
  
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void SimpleFilter::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: 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);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  }
  }
  }
  