C++ XMLArchive::close方法代码示例

bool loadEventParam(DataModel::EventParametersPtr &ep, const string &data,
                    bool gzip = false) {
	bool retn = false;
	bool registrationEnabled = DataModel::PublicObject::IsRegistrationEnabled();
	DataModel::PublicObject::SetRegistrationEnabled(false);
	try {
		io::filtering_istreambuf buf;
		container_source<string> src(data);
		if ( gzip ) buf.push(io::gzip_decompressor());
		buf.push(src);

		IO::XMLArchive ar;
		if ( !ar.open(&buf) )
			SEISCOMP_ERROR("[xml] could not open stream buffer for reading");
		else {
			ar >> ep;
			ar.close();
			retn = true;
		}
	}
	catch (string &e) {
		SEISCOMP_ERROR("[xml] %s", e.c_str());
	}
	catch (exception &e) {
		SEISCOMP_ERROR("[xml] %s", e.what());
	}
	DataModel::PublicObject::SetRegistrationEnabled(registrationEnabled);
	return retn;
}

		bool importDatabase() {
			IO::XMLArchive ar;
			if ( _inputFile == "-" )
				ar.open(cin.rdbuf());
			else if ( !ar.open(_inputFile.c_str()) ) {
				cout << "Error: could not open input file '" << _inputFile << "'" << endl;
				return false;
			}

			cout << "Parsing file '" << _inputFile << "'..." << endl;

			Util::StopWatch timer;
			DataModel::ObjectPtr doc;
			ar >> doc;
			ar.close();

			if ( doc == NULL ) {
				cerr << "Error: no valid object found in file '" << _inputFile << "'" << endl;
				return false;
			}

			ObjectDispatcher dispatcher(connection(), _operation, commandline().hasOption("test"), ObjectCounter(doc.get()).count(), 78);
			cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ROUTING TABLE" << endl;
			dispatcher.setRoutingTable(_routingTable);
			cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;

			unsigned int totalCount = ObjectCounter(doc.get()).count();

			cout << "Time needed to parse XML: " << Core::Time(timer.elapsed()).toString("%T.%f") << endl;
			cout << "Document object type: " << doc->className() << endl;
			cout << "Total number of objects: " << totalCount << endl;

			if ( connection() )
				cout << "Dispatching " << doc->className() << " to " << connection()->masterAddress() << endl;
			timer.restart();

			dispatcher(doc.get());
			sync();
			cout << endl;

			cout << "While dispatching " << dispatcher.count() << "/" << totalCount << " objects " << dispatcher.errors() << " errors occured" << endl;
			cout << "Time needed to dispatch " << dispatcher.count() << " objects: " << Core::Time(timer.elapsed()).toString("%T.%f") << endl;

			return true;
		}

// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmpTool::run() {
	if ( !_originID.empty() ) {
		OriginPtr org = Origin::Cast(query()->getObject(Origin::TypeInfo(), _originID));
		if ( !org ) {
			cerr << "Origin not found!" << endl;
			return false;
		}

		_fetchMissingAmplitudes = false;
		query()->loadArrivals(org.get());
		process(org.get());
		return true;
	}

	if ( !_strTimeWindowStartTime.empty() || !_strTimeWindowEndTime.empty() ) {
		if ( database() == NULL ) {
			cerr << "No database currently active for time window reprocessing" << endl;
			return false;
		}

		Core::Time startTime, endTime;

		if ( !_strTimeWindowStartTime.empty()
		  && !startTime.fromString(_strTimeWindowStartTime.c_str(), "%F %T") ) {
			cerr << "Invalid start time: " << _strTimeWindowStartTime << endl;
			return false;
		}

		if ( !_strTimeWindowEndTime.empty()
		  && !endTime.fromString(_strTimeWindowEndTime.c_str(), "%F %T") ) {
			cerr << "Invalid end time: " << _strTimeWindowEndTime << endl;
			return false;
		}

		std::string dbQuery;
		dbQuery += "select PPick." + _T("publicID") + ", Pick.* from Pick,PublicObject as PPick,Amplitude "
		           "where Pick._oid=PPick._oid and Amplitude." + _T("pickID") + "=PPick." + _T("publicID");

		if ( startTime.valid() )
			 dbQuery += " and Pick." + _T("time_value") + ">='" + startTime.toString("%F %T") + "'";

		if ( endTime.valid() )
			 dbQuery += " and Pick." + _T("time_value") + "<'" + endTime.toString("%F %T") + "'";

		dbQuery += " group by Amplitude." + _T("pickID");

		if ( !commandline().hasOption("commit") )
			_testMode = true;

		EventParametersPtr ep;
		if ( _testMode )
			ep = new EventParameters;

		typedef list<PickPtr> PickList;
		PickList picks;

		cerr << "Collecting picks ... " << flush;
		DatabaseIterator db_it = query()->getObjectIterator(dbQuery, Pick::TypeInfo());
		ObjectPtr obj;
		while ( obj = db_it.get() ) {
			Pick *pick = static_cast<Pick*>(obj.get());
			try {
				pick->waveformID().networkCode();
				pick->waveformID().stationCode();
				pick->waveformID().locationCode();
				pick->waveformID().channelCode();

				pick->time().value();
			}
			catch ( ... ) {
				continue;
			}

			++db_it;

			picks.push_back(pick);
			if ( ep ) ep->add(pick);
		}

		db_it.close();

		cerr << picks.size() << endl;

		_report << std::endl;
		_report << "Reprocessing report" << std::endl;
		_report << "-------------------" << std::endl;

		_report << " + Picks" << std::endl;

		int errors = 0;
		int ampsRecomputed = 0;
		int messagesSent = 0;

		int idx = 1;
		for ( PickList::iterator it = picks.begin(); it != picks.end(); ++it, ++idx ) {
			PickPtr pick = *it;
			SingleAmplitudeMap dbAmps;

			if ( isExitRequested() ) break;
//.........这里部分代码省略.........

//.........这里部分代码省略.........

			DataModel::Notifier::SetEnabled(false);

			_currentTask = NULL;

			if ( _exitRequested ) {
				cerr << "Exit requested: abort" << endl;
				return false;
			}

			bool doSyncKeys = false;

			if ( createNotifier ) {
				DataModel::NotifierMessagePtr nmsg;
				size_t notifierCount = DataModel::Notifier::Size();

				if ( notifierCount > 0 ) {
					cerr << notifierCount << " notifiers available" << endl;

					if ( !_output.empty() ) {
						IO::XMLArchive ar;
						if ( !ar.create(_output.c_str()) ) {
							cerr << "Failed to create output file: " << _output << endl;
							DataModel::Notifier::Clear();
							return false;
						}

						cerr << "Generating output ... "  << flush;
						ar.setFormattedOutput(true);

						nmsg = DataModel::Notifier::GetMessage(true);
						ar << nmsg;

						ar.close();
						cerr << "done" << endl;
					}
					else if ( !testMode ) {
						// Notify about start of synchronization
						DataModel::InventorySyncMessagePtr ismsg = new DataModel::InventorySyncMessage(false);
						ismsg->setCreationInfo(DataModel::CreationInfo());
						ismsg->creationInfo().setCreationTime(Core::Time::GMT());
						ismsg->creationInfo().setAuthor(author());
						ismsg->creationInfo().setAgencyID(agencyID());
						connection()->send(Communication::Protocol::STATUS_GROUP, ismsg.get());

						// Send an inital sync command to also wake-up the messaging
						sync();

						// Send notifier
						DataModel::NotifierMessagePtr tmp = new DataModel::NotifierMessage();
						DataModel::NotifierMessage::iterator it;
						int count = 0;

						// Fetch each single notifier message. Fetching all notifiers
						// in one message can take a long time if a huge amount of
						// notifiers is in the queue. Due to memory fragmentation
						// most of the time spent is in malloc.
						while ( (nmsg = DataModel::Notifier::GetMessage(false)) != NULL ) {
							if ( _exitRequested ) break;
							for ( it = nmsg->begin(); it != nmsg->end(); ++it ) {
								DataModel::Notifier* n = DataModel::Notifier::Cast(*it);
								if ( !n ) continue;

								tmp->attach(n);
								++count;

		bool mergeInventory() {
			bool stripUnreferenced = commandline().hasOption("strip");

			// Disable object registration
			DataModel::PublicObject::SetRegistrationEnabled(false);

			vector<string> files;
			collectFiles(files);

			if ( files.empty() ) {
				cerr << "Nothing to merge, no files given" << endl;
				return false;
			}

			DataModel::InventoryPtr finalInventory = new DataModel::Inventory();
			Merge merger(finalInventory.get());
			merger.setLogHandler(this);
			_continueOperation = true;

			_currentTask = &merger;

			for ( size_t i = 0; i < files.size(); ++i ) {
				if ( _exitRequested ) break;

				IO::XMLArchive ar;
				if ( !ar.open(files[i].c_str()) ) {
					cerr << "Could not open file (ignored): " << files[i] << endl;
					continue;
				}

				DataModel::InventoryPtr inv;
				cerr << "Parsing " << files[i] << " ... " << flush;
				ar >> inv;
				cerr << "done" << endl;
				if ( !inv ) {
					cerr << "No inventory found (ignored): " << files[i] << endl;
					continue;
				}

				_inventorySources[inv.get()] = files[i];

				// Pushing the inventory into the merger cleans it
				// completely. The ownership of all childs went to
				// the merger
				merger.push(inv.get());
			}

			_currentTask = NULL;

			if ( _exitRequested ) {
				cerr << "Exit requested: abort" << endl;
				return false;
			}

			cerr << "Merging inventory ... " << flush;
			merger.merge(stripUnreferenced);
			cerr << "done" << endl;

			printLogs();

			if ( !_continueOperation ) {
				cerr << "Unresolvable errors ... aborting" << endl;
				return false;
			}

			if ( _output.empty() ) _output = "-";

			IO::XMLArchive ar;
			if ( !ar.create(_output.c_str()) ) {
				cerr << "Failed to create output file: " << _output << endl;
				return false;
			}

			cerr << "Generating output ... "  << flush;
			ar.setFormattedOutput(true);
			ar << finalInventory;
			ar.close();
			cerr << "done" << endl;

			if ( !_rcdir.empty() ) {
				if ( !syncRCFiles(finalInventory.get()) ) return false;
			}

			return true;
		}

//.........这里部分代码省略.........

				IO::XMLArchive ar;
				if ( !ar.open(files[i].c_str()) ) {
					cerr << "Could not open file (ignored): " << files[i] << endl;
					continue;
				}

				cerr << "Parsing " << files[i] << " ... " << flush;
				DataModel::NotifierMessagePtr msg;
				ar >> msg;
				cerr << "done" << endl;

				if ( !msg ) {
					cerr << "No notifier message found (ignored): " << files[i] << endl;
					continue;
				}

				size_t notifierCount = msg->size();
				cerr << notifierCount << " notifiers available" << endl;

				if ( !_output.empty() ) {
					cerr << "Applying notifier ... " << flush;

					// Apply all notifier
					DataModel::NotifierMessage::iterator it;
					for ( it = msg->begin(); it != msg->end(); ++it ) {
						DataModel::Notifier* n = DataModel::Notifier::Cast(*it);
						if ( !n ) continue;
						n->apply();
					}

					cerr << "done" << endl;
				}
				else {
					// Send all notifier

					// Send an inital sync command to also wake-up the messaging
					sync();

					// Send notifier
					DataModel::NotifierMessagePtr tmp = new DataModel::NotifierMessage();
					DataModel::NotifierMessage::iterator it;
					int count = 0;

					for ( it = msg->begin(); it != msg->end(); ++it ) {
						DataModel::Notifier* n = DataModel::Notifier::Cast(*it);
						if ( !n ) continue;

						tmp->attach(n);
						++count;

						if ( count % 100 == 0 ) {
							cerr << "\rSending notifiers: " << (int)(count*100/notifierCount) << "%" << flush;

							if ( !send(tmp.get()) ) {
								SEISCOMP_ERROR("Failed to send message, abort");
								return false;
							}

							tmp->clear();
							sync();
						}
					}

					sync();

					if ( !tmp->empty() ) {
						if ( !send(tmp.get()) ) {
							SEISCOMP_ERROR("Failed to send message, abort");
							return false;
						}

						cerr << "\rSending notifiers: " << (int)(count*100/notifierCount) << "%" << flush;
					}
				}
			}

			if ( _exitRequested ) {
				cerr << "Exit requested: abort" << endl;
				return false;
			}

			if ( !_output.empty() ) {
				IO::XMLArchive ar;
				if ( !ar.create(_output.c_str()) ) {
					cerr << "Failed to create output file: " << _output << endl;
					return false;
				}

				cerr << "Generating output ... "  << flush;
				ar.setFormattedOutput(true);

				ar << targetInv;

				ar.close();
				cerr << "done" << endl;
			}

			return true;
		}

// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool App::runFromEPFile(const char *fname) {
	IO::XMLArchive ar;

	if ( !ar.open(fname)) {
		SEISCOMP_ERROR("unable to open XML file: %s", fname);
		return false;
	}

	ar >> _ep;
	ar.close();

	if ( !_ep ) {
		SEISCOMP_ERROR("No event parameters found: %s", fname);
		return false;
	}

	SEISCOMP_INFO("finished reading event parameters from XML");
	SEISCOMP_INFO("  number of picks:      %ld", (long int)_ep->pickCount());
	SEISCOMP_INFO("  number of amplitudes: %ld", (long int)_ep->amplitudeCount());
	SEISCOMP_INFO("  number of origins:    %ld", (long int)_ep->originCount());

	typedef std::pair<Core::Time,DataModel::PublicObjectPtr> TimeObject;
	typedef std::vector<TimeObject> TimeObjectVector;

	// retrieval of relevant objects from event parameters
	// and subsequent DSU sort
	TimeObjectVector objs;

	for ( size_t i = 0; i < _ep->pickCount(); ++i ) {
		DataModel::PickPtr pick = _ep->pick(i);
		try {
			Core::Time t = pick->creationInfo().creationTime();
			objs.push_back(TimeObject(t, pick));
		}
		catch ( ... ) {
			SEISCOMP_WARNING("Ignore pick %s: no creation time set",
			                 pick->publicID().c_str());
		}
	}

	for ( size_t i = 0; i < _ep->amplitudeCount(); ++i ) {
		DataModel::AmplitudePtr amplitude = _ep->amplitude(i);
		try {
			Core::Time t = amplitude->creationInfo().creationTime();
			objs.push_back(TimeObject(t, amplitude));
		}
		catch ( ... ) {
			SEISCOMP_WARNING("Ignore amplitude %s: no creation time set",
			                 amplitude->publicID().c_str());
		}
	}

	for ( size_t i = 0; i < _ep->originCount(); ++i ) {
		DataModel::OriginPtr origin = _ep->origin(i);
		try {
			Core::Time t = origin->creationInfo().creationTime();
			objs.push_back(TimeObject(t, origin));
		}
		catch ( ... ) {
			SEISCOMP_WARNING("Ignore origin %s: no creation time set",
			                 origin->publicID().c_str());
		}
	}

	std::sort(objs.begin(), objs.end());
	for (TimeObjectVector::iterator
	     it = objs.begin(); it != objs.end(); ++it) {
		_objects.push(it->second);
	}

	while ( !_objects.empty() && !isExitRequested() ) {
		DataModel::PublicObjectPtr o = _objects.front();

		_objects.pop();
		addObject("", o.get());
		++objectCount;
	}

	_flush();

	ar.create("-");
	ar.setFormattedOutput(true);
	ar << _ep;
	ar.close();

	return true;
}