void playWithHomeTheater() {
// Create all the parts of the home theatre system
Amplifier amp("Top-O-Line Amplifier");
CdPlayer cd("Top-O-Line CD Player", &);
DvdPlayer dvd("Top-O-Line DVD Player", &);
Screen screen("My Theater Screen");
PopcornPopper popper("My Popcorn Popper");
Tuner tuner("Top-O-Line AM/FM Tuner", &);
TheaterLights lights("Theater Ceiling Lights");
Projector projector("Top-O-Line Projector");
popper.on(); // Turn on the popcorn popper...
popper.pop(); // and start popping...
lights.dim(10); // Dim the lights to 10%...
screen.down(); // Put the screen down...
projector.on(); // Turn on the projector...
projector.setInput(&dvd); // set it to DVD...
projector.wideScreenMode(); // and put it on wide screen mode for the movie...
amp.on(); // Turn on the amp...
amp.setInput(&dvd); // set it to DVD and...
amp.setSurroundSound(); // put it into surround sound mode...
amp.setVolume(11); // and set the volume to 11...
dvd.on(); // Turn on the DVD player...
dvd.play("Raiders of the lost ark"); // and FINALLY, play the movie!
// What about shutting everything down again?!
// How would you play a CD? etc...
}
// Doxygen skip:
/// @cond
void QueueManager::addStructureToSubmissionQueue_(Structure* s, int optStep)
{
Q_ASSERT(trackerContainsStructure(s, &m_newSubmissionTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_newSubmissionTracker);
// Update structure
s->lock().lockForWrite();
if (s->getStatus() != Structure::Optimized) {
s->setStatus(Structure::WaitingForOptimization);
if (optStep != -1) {
s->setCurrentOptStep(optStep);
}
}
s->lock().unlock();
// Perform writing
m_opt->queueInterface(s->getCurrentOptStep())->writeInputFiles(s);
m_jobStartTracker.lockForWrite();
m_jobStartTracker.append(s);
m_jobStartTracker.unlock();
m_runningTracker.lockForWrite();
m_runningTracker.append(s);
m_runningTracker.unlock();
emit structureUpdated(s);
}
// Doxygen skip:
/// @cond
void QueueManager::handleSubmittedStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_submittedTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_submittedTracker);
if (s->getStatus() != Structure::Submitted) {
return;
}
switch (m_opt->queueInterface(s->getCurrentOptStep())->getStatus(s)) {
case QueueInterface::Running:
case QueueInterface::Queued:
case QueueInterface::Success:
case QueueInterface::Started:
// Update the structure as "InProcess"
s->lock().lockForWrite();
s->setStatus(Structure::InProcess);
s->lock().unlock();
emit structureUpdated(s);
break;
case QueueInterface::Error:
s->lock().lockForWrite();
s->setStatus(Structure::Restart);
s->lock().unlock();
emit structureUpdated(s);
break;
case QueueInterface::CommunicationError:
case QueueInterface::Unknown:
case QueueInterface::Pending:
default:
// nothing to do but wait
break;
}
}
// Doxygen skip:
/// @cond
void QueueManager::handleRestartStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_restartTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_restartTracker);
if (s->getStatus() != Structure::Restart) {
return;
}
stopJob(s);
addStructureToSubmissionQueue(s);
}
Ret operator[](const Policies& p)
{
typedef typename find_conversion_policy<0, Policies>::type converter_policy;
typename converter_policy::template generate_converter<Ret, lua_to_cpp>::type converter;
m_called = true;
lua_State* L = m_obj->lua_state();
detail::stack_pop popper(L, 2); // pop the return value and the self reference
// get the function
m_obj->pushvalue();
lua_pushstring(L, m_member_name);
lua_gettable(L, -2);
// push the self-object
m_obj->pushvalue();
detail::push_args_from_tuple<1>::apply(L, m_args, p);
if (lua_pcall(L, boost::tuples::length<Tuple>::value + 1, 1, 0))
{
#ifndef LUABIND_NO_EXCEPTIONS
throw error(L);
#else
error_callback_fun e = detail::error_callback::get().err;
if (e) e(L);
assert(0 && "the lua function threw an error and exceptions are disabled."
"If you want to handle this error use luabind::set_error_callback()");
std::terminate();
#endif
}
#ifndef LUABIND_NO_ERROR_CHECKING
if (converter.match(L, LUABIND_DECORATE_TYPE(Ret), -1) < 0)
{
#ifndef LUABIND_NO_EXCEPTIONS
throw cast_failed(L, LUABIND_TYPEID(Ret));
#else
cast_failed_callback_fun e = detail::error_callback::get().cast;
if (e) e(L, LUABIND_TYPEID(Ret));
assert(0 && "the lua function's return value could not be converted."
"If you want to handle this error use luabind::set_error_callback()");
std::terminate();
#endif
}
#endif
return converter.apply(L, LUABIND_DECORATE_TYPE(Ret), -1);
}
void playWithHomeTheaterFacade() {
// Create all the parts of the home theatre system
// Not encapsulated or owned by the facade.
Amplifier amp("Top-O-Line Amplifier");
CdPlayer cd("Top-O-Line CD Player", &);
DvdPlayer dvd("Top-O-Line DVD Player", &);
Screen screen("My Theater Screen");
PopcornPopper popper("My Popcorn Popper");
Tuner tuner("Top-O-Line AM/FM Tuner", &);
TheaterLights lights("Theater Ceiling Lights");
Projector projector("Top-O-Line Projector");
HomeTheaterFacade theater(&, &tuner, &dvd, &cd, &projector, &lights, &screen, &popper);
theater.watchMovie("Raiders of the Lost Ark");
theater.endMovie();
}
// Doxygen skip:
/// @cond
void QueueManager::handleSupercellStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_newSupercellTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_newSupercellTracker);
if (s->getStatus() != Structure::Supercell) {
return;
}
// Ensure that the job is not tying up the queue
stopJob(s);
// Remove from running tracker
m_runningTracker.lockForWrite();
m_runningTracker.remove(s);
m_runningTracker.unlock();
}
// Doxygen skip:
/// @cond
void QueueManager::handleInProcessStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_inProcessTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_inProcessTracker);
// Revalidate assumptions
if (s->getStatus() != Structure::InProcess) {
return;
}
QueueInterface* qi = m_opt->queueInterface(s->getCurrentOptStep());
switch (qi->getStatus(s)) {
case QueueInterface::Running:
case QueueInterface::Queued:
case QueueInterface::CommunicationError:
case QueueInterface::Unknown:
case QueueInterface::Pending:
case QueueInterface::Started:
{
// Kill the structure if it has exceeded the allowable time.
// Only perform this for remote queues.
if (m_opt->cancelJobAfterTime() &&
s->getOptElapsedHours() > m_opt->hoursForCancelJobAfterTime() &&
qi->getIDString().toLower() != "local") {
killStructure(s);
emit structureUpdated(s);
return;
}
// Nothing to do but wait
break;
}
case QueueInterface::Success:
updateStructure(s);
break;
case QueueInterface::Error:
s->lock().lockForWrite();
s->setStatus(Structure::Error);
s->lock().unlock();
emit structureUpdated(s);
break;
}
return;
}
virtual bool readProject( const QString &uri, QIODevice *ioDevice, QgsReadWriteContext &context ) override
{
QgsReadWriteContextCategoryPopper popper( context.enterCategory( "memory storage" ) );
QStringList lst = uri.split( ":" );
Q_ASSERT( lst.count() == 2 );
QString projectName = lst[1];
if ( !mProjects.contains( projectName ) )
{
context.pushMessage( "project not found", Qgis::Critical );
return false;
}
QByteArray content = mProjects[projectName];
ioDevice->write( content );
ioDevice->seek( 0 );
return true;
}
// Doxygen skip:
/// @cond
void QueueManager::handleKilledStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_newlyKilledTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_newlyKilledTracker);
if (s->getStatus() != Structure::Killed &&
// Remove structures end up here, too, so check this (see
// handleRemovedStructure below)
s->getStatus() != Structure::Removed) {
return;
}
// Ensure that the job is not tying up the queue
stopJob(s);
// Remove from running tracker
m_runningTracker.lockForWrite();
m_runningTracker.remove(s);
m_runningTracker.unlock();
}
// Doxygen skip:
/// @cond
void QueueManager::handleOptimizedStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_newlyOptimizedTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_newlyOptimizedTracker);
// Revalidate assumptions
if (s->getStatus() != Structure::Optimized) {
return;
}
// Ensure that the job is not tying up the queue
stopJob(s);
// Remove from running tracker
m_runningTracker.lockForWrite();
m_runningTracker.remove(s);
m_runningTracker.unlock();
emit structureFinished(s);
}
Ret operator[](const Policies& p)
{
typedef typename detail::find_conversion_policy<0, Policies>::type converter_policy;
typename converter_policy::template generate_converter<Ret, lua_to_cpp>::type converter;
m_called = true;
lua_State* L = m_func->lua_state();
#ifndef LUABIND_NO_ERROR_CHECKING
if (L == 0)
{
#ifndef LUABIND_NO_EXCEPTIONS
throw error(L);
#else
error_callback_fun e = get_error_callback();
if (e) e(L);
/*assert(0 && "tried to call uninitialized functor object."
"if you want to handle this error use luabind::set_error_callback()");
std::terminate();*/
#endif
}
#endif
detail::stack_pop popper(L, 1); // pop the return value
// get the function
m_func->pushvalue();
detail::push_args_from_tuple<1>::apply(L, m_args, p);
if (pcall(L, boost::tuples::length<Tuple>::value, 1))
{
#ifndef LUABIND_NO_EXCEPTIONS
throw error(L);
#else
error_callback_fun e = get_error_callback();
if (e) e(L);
/*assert(0 && "the lua function threw an error and exceptions are disabled."
"if you want to handle this error use luabind::set_error_callback()");
std::terminate();*/
#endif
}
#ifndef LUABIND_NO_ERROR_CHECKING
if (converter.match(L, LUABIND_DECORATE_TYPE(Ret), -1) < 0)
{
#ifndef LUABIND_NO_EXCEPTIONS
throw cast_failed(L, LUABIND_TYPEID(Ret));
#else
cast_failed_callback_fun e = get_cast_failed_callback();
if (e) e(L, LUABIND_TYPEID(Ret));
/*assert(0 && "the lua function's return value could not be converted."
"if you want to handle this error use luabind::set_error_callback()");
std::terminate();*/
#endif
}
#endif
return converter.apply(L, LUABIND_DECORATE_TYPE(Ret), -1);
}
inline template<typename T> T pop() {
janus_data_stack_popper<stack_t, T> popper;
return popper(raw_stack());
}
// Doxygen skip:
/// @cond
void QueueManager::handleErrorStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_errorTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_errorTracker);
if (s->getStatus() != Structure::Error) {
return;
}
if (!m_opt->usingGUI()) {
qDebug() << "Structure"
<< QString::number(s->getGeneration()) + "x" +
QString::number(s->getIDNumber())
<< "failed";
}
stopJob(s);
// Lock for writing
QWriteLocker locker(&s->lock());
s->addFailure();
// If the number of failures has exceed the limit, take
// appropriate action
if (s->getFailCount() >= m_opt->failLimit) {
switch (OptBase::FailActions(m_opt->failAction)) {
case OptBase::FA_DoNothing:
default:
// resubmit job
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
case OptBase::FA_KillIt:
locker.unlock();
killStructure(s);
emit structureUpdated(s);
return;
case OptBase::FA_Randomize:
s->setStatus(Structure::Empty);
locker.unlock();
m_opt->replaceWithRandom(s, tr("excessive failures"));
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
case OptBase::FA_NewOffspring:
s->setStatus(Structure::Empty);
locker.unlock();
m_opt->replaceWithOffspring(s, tr("excessive failures"));
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
}
}
// Resubmit job if failure limit hasn't been reached
else {
s->setStatus(Structure::Restart);
emit structureUpdated(s);
return;
}
}
// Doxygen skip:
/// @cond
void QueueManager::handleStepOptimizedStructure_(Structure* s)
{
Q_ASSERT(trackerContainsStructure(s, &m_stepOptimizedTracker));
removeFromTrackerWhenScopeEnds popper(s, &m_stepOptimizedTracker);
QWriteLocker locker(&s->lock());
// Validate assumptions
if (s->getStatus() != Structure::StepOptimized) {
return;
}
s->stopOptTimer();
QString err;
if (!m_opt->checkStepOptimizedStructure(s, &err)) {
// Structure failed a post optimization step:
m_opt->warning(QString("Structure %1 failed a post-optimization step: %2")
.arg(s->getIDString())
.arg(err));
s->setStatus(Structure::Killed);
locker.unlock();
emit structureUpdated(s);
return;
}
// update optstep and relaunch if necessary
if (s->getCurrentOptStep() + 1 <
static_cast<unsigned int>(m_opt->getNumOptSteps())) {
// Print an update to the terminal if we are not using the GUI
if (!m_opt->usingGUI()) {
qDebug() << "Structure"
<< QString::number(s->getGeneration()) + "x" +
QString::number(s->getIDNumber())
<< "completed step" << s->getCurrentOptStep();
}
s->setCurrentOptStep(s->getCurrentOptStep() + 1);
// Update status
s->setStatus(Structure::WaitingForOptimization);
m_runningTracker.lockForWrite();
m_runningTracker.append(s);
m_runningTracker.unlock();
locker.unlock();
emit structureUpdated(s);
addStructureToSubmissionQueue(s);
return;
}
// Otherwise, it's done
else {
// Print an update to the terminal if we are not using the GUI
if (!m_opt->usingGUI()) {
qDebug() << "Structure"
<< QString::number(s->getGeneration()) + "x" +
QString::number(s->getIDNumber())
<< "is optimized!";
}
s->setStatus(Structure::Optimized);
locker.unlock();
handleOptimizedStructure(s);
}
}
