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 );
}
