ActionList DispatcherPrivate::getContainers(const QString &ns) const { ActionList ret; if (ns != QLatin1String("/")) { int pos = ns.size(); // qDebug() << pos << ns.mid(0, pos); while (pos > 0) { // qDebug() << pos << ns.mid(0, pos); ret.append(actionContainer.value(ns.mid(0, pos))); pos = ns.lastIndexOf(QLatin1Char('/'), pos - 1); } } // qDebug() << actionContainer.size() << rootActions; ret.append(rootActions); return ret; }
ActionList ActionsWidget::actionList() const { // return a copy of our action list ActionList list; foreach( ClipAction* action, m_actionList ) { if ( !action ) { qCDebug(KLIPPER_LOG) << "action is null"; continue; } list.append( new ClipAction( *action ) ); } return list; }
ActionList * ActionWidget::actionList() { Q3ListViewItem *item = listView->firstChild(); Q3ListViewItem *child = 0L; ClipAction *action = 0L; ActionList *list = new ActionList; list->setAutoDelete( true ); while ( item ) { action = new ClipAction( item->text( 0 ), item->text( 1 ) ); child = item->firstChild(); // add the commands while ( child ) { action->addCommand( child->text( 0 ), child->text( 1 ), true ); child = child->nextSibling(); } list->append( action ); item = item->nextSibling(); } return list; }
void Driver::BuildUniversalActions(const ArgList &Args, ActionList &Actions) const { llvm::PrettyStackTraceString CrashInfo("Building actions for universal build"); // Collect the list of architectures. Duplicates are allowed, but // should only be handled once (in the order seen). llvm::StringSet<> ArchNames; llvm::SmallVector<const char *, 4> Archs; for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); it != ie; ++it) { Arg *A = *it; if (A->getOption().getId() == options::OPT_arch) { const char *Name = A->getValue(Args); // FIXME: We need to handle canonicalization of the specified // arch? A->claim(); if (ArchNames.insert(Name)) Archs.push_back(Name); } } // When there is no explicit arch for this platform, make sure we // still bind the architecture (to the default) so that -Xarch_ is // handled correctly. if (!Archs.size()) Archs.push_back(0); // FIXME: We killed off some others but these aren't yet detected in // a functional manner. If we added information to jobs about which // "auxiliary" files they wrote then we could detect the conflict // these cause downstream. if (Archs.size() > 1) { // No recovery needed, the point of this is just to prevent // overwriting the same files. if (const Arg *A = Args.getLastArg(options::OPT_save_temps)) Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs) << A->getAsString(Args); } ActionList SingleActions; BuildActions(Args, SingleActions); // Add in arch binding and lipo (if necessary) for every top level // action. for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) { Action *Act = SingleActions[i]; // Make sure we can lipo this kind of output. If not (and it is an // actual output) then we disallow, since we can't create an // output file with the right name without overwriting it. We // could remove this oddity by just changing the output names to // include the arch, which would also fix // -save-temps. Compatibility wins for now. if (Archs.size() > 1 && !types::canLipoType(Act->getType())) Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) << types::getTypeName(Act->getType()); ActionList Inputs; for (unsigned i = 0, e = Archs.size(); i != e; ++i) Inputs.push_back(new BindArchAction(Act, Archs[i])); // Lipo if necessary, We do it this way because we need to set the // arch flag so that -Xarch_ gets overwritten. if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing) Actions.append(Inputs.begin(), Inputs.end()); else Actions.push_back(new LipoJobAction(Inputs, Act->getType())); } }
void Dispatcher::setupActions(const QVector<Controller*> &controllers, const QVector<Cutelyst::DispatchType *> &dispatchers, bool printActions) { Q_D(Dispatcher); d->dispatchers = dispatchers; ActionList registeredActions; for (Controller *controller : controllers) { bool instanceUsed = false; const auto actions = controller->actions(); for (Action *action : actions) { bool registered = false; if (!d->actions.contains(action->reverse())) { if (!action->attributes().contains(QLatin1String("Private"))) { // Register the action with each dispatcher for (DispatchType *dispatch : dispatchers) { if (dispatch->registerAction(action)) { registered = true; } } } else { // We register private actions registered = true; } } // The Begin, Auto, End actions are not // registered by Dispatchers but we need them // as private actions anyway if (registered) { d->actions.insert(action->ns() + QLatin1Char('/') + action->name(), action); d->actionContainer[action->ns()] << action; registeredActions.append(action); instanceUsed = true; } else { qCDebug(CUTELYST_DISPATCHER) << "The action" << action->name() << "of" << action->controller()->objectName() << "controller was not registered in any dispatcher." " If you still want to access it internally (via actionFor())" " you may make it's method private."; } } if (instanceUsed) { d->controllers.insert(controller->objectName(), controller); } } // Cache root actions, BEFORE the controllers set them d->rootActions = d->actionContainer.value(QLatin1String("")); for (Controller *controller : controllers) { controller->d_ptr->setupFinished(); } // Unregister any dispatcher that is not in use int i = 0; while (i < d->dispatchers.size()) { DispatchType *type = d->dispatchers.at(i); if (!type->inUse()) { d->dispatchers.removeAt(i); continue; } ++i; } if (printActions) { d->printActions(); } }
void SimpleActionData::set_action( Action* action_P ) { ActionList* tmp = new ActionList( "Simple_action_data" ); tmp->append( action_P ); set_actions( tmp ); }