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/compositetime.h>
  #include <seiscomp3/datamodel/origin.h>
  #include <seiscomp3/datamodel/metadata.h>
  #include <seiscomp3/logging/log.h>
  
  
  namespace Seiscomp {
  namespace DataModel {
  
  
  IMPLEMENT_SC_CLASS_DERIVED(CompositeTime, Object, "CompositeTime");
  
  
  CompositeTime::MetaObject::MetaObject(const Core::RTTI* rtti) : Seiscomp::Core::MetaObject(rtti) {
  	addProperty(objectProperty<IntegerQuantity>("year", "IntegerQuantity", false, false, true, &CompositeTime::setYear, &CompositeTime::year));
  	addProperty(objectProperty<IntegerQuantity>("month", "IntegerQuantity", false, false, true, &CompositeTime::setMonth, &CompositeTime::month));
  	addProperty(objectProperty<IntegerQuantity>("day", "IntegerQuantity", false, false, true, &CompositeTime::setDay, &CompositeTime::day));
  	addProperty(objectProperty<IntegerQuantity>("hour", "IntegerQuantity", false, false, true, &CompositeTime::setHour, &CompositeTime::hour));
  	addProperty(objectProperty<IntegerQuantity>("minute", "IntegerQuantity", false, false, true, &CompositeTime::setMinute, &CompositeTime::minute));
  	addProperty(objectProperty<RealQuantity>("second", "RealQuantity", false, false, true, &CompositeTime::setSecond, &CompositeTime::second));
  }
  
  
  IMPLEMENT_METAOBJECT(CompositeTime)
  
  
  CompositeTime::CompositeTime() {
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  CompositeTime::CompositeTime(const CompositeTime& other)
   : Object() {
  	*this = other;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  CompositeTime::~CompositeTime() {
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool CompositeTime::operator==(const CompositeTime& rhs) const {
  	if ( !(_year == rhs._year) )
  		return false;
  	if ( !(_month == rhs._month) )
  		return false;
  	if ( !(_day == rhs._day) )
  		return false;
  	if ( !(_hour == rhs._hour) )
  		return false;
  	if ( !(_minute == rhs._minute) )
  		return false;
  	if ( !(_second == rhs._second) )
  		return false;
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool CompositeTime::operator!=(const CompositeTime& rhs) const {
  	return !operator==(rhs);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool CompositeTime::equal(const CompositeTime& other) const {
  	return *this == other;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::setYear(const OPT(IntegerQuantity)& year) {
  	_year = year;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  IntegerQuantity& CompositeTime::year() throw(Seiscomp::Core::ValueException) {
  	if ( _year )
  		return *_year;
  	throw Seiscomp::Core::ValueException("CompositeTime.year is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const IntegerQuantity& CompositeTime::year() const throw(Seiscomp::Core::ValueException) {
  	if ( _year )
  		return *_year;
  	throw Seiscomp::Core::ValueException("CompositeTime.year is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::setMonth(const OPT(IntegerQuantity)& month) {
  	_month = month;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  IntegerQuantity& CompositeTime::month() throw(Seiscomp::Core::ValueException) {
  	if ( _month )
  		return *_month;
  	throw Seiscomp::Core::ValueException("CompositeTime.month is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const IntegerQuantity& CompositeTime::month() const throw(Seiscomp::Core::ValueException) {
  	if ( _month )
  		return *_month;
  	throw Seiscomp::Core::ValueException("CompositeTime.month is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::setDay(const OPT(IntegerQuantity)& day) {
  	_day = day;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  IntegerQuantity& CompositeTime::day() throw(Seiscomp::Core::ValueException) {
  	if ( _day )
  		return *_day;
  	throw Seiscomp::Core::ValueException("CompositeTime.day is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const IntegerQuantity& CompositeTime::day() const throw(Seiscomp::Core::ValueException) {
  	if ( _day )
  		return *_day;
  	throw Seiscomp::Core::ValueException("CompositeTime.day is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::setHour(const OPT(IntegerQuantity)& hour) {
  	_hour = hour;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  IntegerQuantity& CompositeTime::hour() throw(Seiscomp::Core::ValueException) {
  	if ( _hour )
  		return *_hour;
  	throw Seiscomp::Core::ValueException("CompositeTime.hour is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const IntegerQuantity& CompositeTime::hour() const throw(Seiscomp::Core::ValueException) {
  	if ( _hour )
  		return *_hour;
  	throw Seiscomp::Core::ValueException("CompositeTime.hour is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::setMinute(const OPT(IntegerQuantity)& minute) {
  	_minute = minute;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  IntegerQuantity& CompositeTime::minute() throw(Seiscomp::Core::ValueException) {
  	if ( _minute )
  		return *_minute;
  	throw Seiscomp::Core::ValueException("CompositeTime.minute is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const IntegerQuantity& CompositeTime::minute() const throw(Seiscomp::Core::ValueException) {
  	if ( _minute )
  		return *_minute;
  	throw Seiscomp::Core::ValueException("CompositeTime.minute is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::setSecond(const OPT(RealQuantity)& second) {
  	_second = second;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  RealQuantity& CompositeTime::second() throw(Seiscomp::Core::ValueException) {
  	if ( _second )
  		return *_second;
  	throw Seiscomp::Core::ValueException("CompositeTime.second is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  const RealQuantity& CompositeTime::second() const throw(Seiscomp::Core::ValueException) {
  	if ( _second )
  		return *_second;
  	throw Seiscomp::Core::ValueException("CompositeTime.second is not set");
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  Origin* CompositeTime::origin() const {
  	return static_cast<Origin*>(parent());
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  CompositeTime& CompositeTime::operator=(const CompositeTime& other) {
  	_year = other._year;
  	_month = other._month;
  	_day = other._day;
  	_hour = other._hour;
  	_minute = other._minute;
  	_second = other._second;
  	return *this;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool CompositeTime::assign(Object* other) {
  	CompositeTime* otherCompositeTime = CompositeTime::Cast(other);
  	if ( other == NULL )
  		return false;
  
  	*this = *otherCompositeTime;
  
  	return true;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool CompositeTime::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("CompositeTime::attachTo(%s) -> wrong class type", parent->className());
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool CompositeTime::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 {
  			CompositeTime* child = origin->findCompositeTime(this);
  			if ( child != NULL )
  				return origin->remove(child);
  			else {
  				SEISCOMP_DEBUG("CompositeTime::detachFrom(Origin): compositeTime has not been found");
  				return false;
  			}
  		}
  	}
  
  	SEISCOMP_ERROR("CompositeTime::detachFrom(%s) -> wrong class type", object->className());
  	return false;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  bool CompositeTime::detach() {
  	if ( parent() == NULL )
  		return false;
  
  	return detachFrom(parent());
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  Object* CompositeTime::clone() const {
  	CompositeTime* clonee = new CompositeTime();
  	*clonee = *this;
  	return clonee;
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::accept(Visitor* visitor) {
  	visitor->visit(this);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  void CompositeTime::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: CompositeTime skipped",
  		               ar.versionMajor(), ar.versionMinor());
  		ar.setValidity(false);
  		return;
  	}
  
  	ar & NAMED_OBJECT_HINT("year", _year, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
  	ar & NAMED_OBJECT_HINT("month", _month, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
  	ar & NAMED_OBJECT_HINT("day", _day, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
  	ar & NAMED_OBJECT_HINT("hour", _hour, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
  	ar & NAMED_OBJECT_HINT("minute", _minute, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
  	ar & NAMED_OBJECT_HINT("second", _second, Archive::STATIC_TYPE | Archive::XML_ELEMENT);
  }
  // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  
  
  
  
  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  }
  }
  