Update the current context by performing a re-resolve.

        The newly resolved context is only applied if it is a successful solve.

        Returns:
            `ResolvedContext` object, which may be a successful or failed solve.
513165
def resolve_context(self, verbosity=0, max_fails=-1, timestamp=None,
                        callback=None, buf=None, package_load_callback=None):
        
        package_filter = PackageFilterList.from_pod(self.package_filter)

        context = ResolvedContext(
            self.request,
            package_paths=self.packages_path,
            package_filter=package_filter,
            verbosity=verbosity,
            max_fails=max_fails,
            timestamp=timestamp,
            buf=buf,
            callback=callback,
            package_load_callback=package_load_callback,
            caching=self.caching)

        if context.success:
            if self._context and self._context.load_path:
                context.set_load_path(self._context.load_path)
            self._set_context(context)
            self._modified = True
        return context
352030
def resolve(self, *pargs, **kwargs):
        """"""
        self._cached = (pargs, kwargs)
        self._try_then()
1004099
def setcontext(context, _local=local):
    
    oldcontext = getcontext()
    _local.__bigfloat_context__ = oldcontext + context
215035
public function resolve(
        TemplatingFixture $fixture,
        FixtureBag $unresolvedFixtures,
        TemplatingFixtureBag $resolvedFixtures,
        ResolvingContext $context
    ): TemplatingFixtureBag {
        $context->checkForCircularReference($fixture->getId());

        if (false === $fixture->extendsFixtures()) {
            return $resolvedFixtures->with($fixture);
        }

        /**
         * @var FixtureBag           $extendedFixtures
         * @var TemplatingFixtureBag $resolvedFixtures
         */
        list($extendedFixtures, $resolvedFixtures) = $this->resolveExtendedFixtures(
            $fixture,
            $fixture->getExtendedFixturesReferences(),
            $unresolvedFixtures,
            $resolvedFixtures,
            $context
        );
        $fixture = $this->getExtendedFixture($fixture, $extendedFixtures);

        return $resolvedFixtures->with($fixture);
    }
1130983
def restore(self, value, context=None):
        
        context = context or orb.Context()
        value = super(ReferenceColumn, self).restore(value, context=context)

        # check to make sure that we're processing the right values
        if self.testFlag(self.Flags.I18n) and context.locale == 'all':
            return {locale: self._restore(val, context) for locale, val in value.items()}
        else:
            return self._restore(value, context)
496923
async def resolve(self, client):
        """"""
        if self.resolved:
            return

        if not self._resolve_lock:
            self._resolve_lock = asyncio.Lock(loop=client.loop)

        async with self._resolve_lock:
            if not self.resolved:
                await self._resolve(client)
                self.resolved = True
153956
def _sync_and_resolve(self, config, resolver):
        ''''''
        resolved = set()
        for key, theirs in config.items(self._name):
            theirs = self._real_value_of(theirs)
            if key in self:
                mine = self[key]
                value = resolver(self._name, key, mine, theirs)
            else:
                value = theirs
            self._set_value(config, key, value)
            resolved.add(key)
        return resolved
13912
def resolve(self):
        
        values = {}
        for target_name in self.target_names:
            if self.context.is_build_needed(self.parent, target_name):
                self.context.build_task(target_name)

            if len(self.keyword_chain) == 0:
                values[target_name] = self.context.tasks[target_name].value
            else:
                values[target_name] = reduce(
                    lambda task, name: getattr(task, name),
                    self.keyword_chain,
                    self.context.tasks[target_name].task)
        return self.function(**values)
848239
private void commitContexts(boolean accept, boolean all) {
        Stack<IManagedContext<?>> stack = commitStack;
        commitStack = new Stack<>();
        // First, commit or cancel all pending context changes.
        for (IManagedContext<?> managedContext : stack) {
            if (managedContext.isPending()) {
                managedContext.commit(accept);
            }
        }
        // Then notify subscribers of the changes.
        while (!stack.isEmpty()) {
            stack.pop().notifySubscribers(accept, all);
        }
    }
304174
def update(self, context):
        
        #Get a list of all the operations that need to be performed and then
        #execute them.
        self._operations = self._get_operations(context)

        for i in range(len(self._operations)):
            self._operations[i].handle()
            self.update_extent(self._operations[i])

        #Last of all, we update the string content of the cached version of
        #the module to have the latest source code.
        if len(self._operations) > 0:
            context.module.update_refstring(context.refstring)
31927
function resolve (resolve) {
    if (defined(resolve)) {
        // set default
        immutable.defaultResolve = resolve ? true : false
        // return immutable
        return ImmutableCore
    }
    // return default value
    return immutable.defaultResolve
}
287120
private synchronized void onNewContext(final ContextStatusPOJO contextStatus,
                                         final boolean notifyClientOnNewActiveContext) {
    final String contextID = contextStatus.getContextId();
    LOG.log(Level.FINE, "Adding new context {0}.", contextID);

    final Optional<String> parentID = contextStatus.hasParentId() ?
        Optional.of(contextStatus.getParentId()) : Optional.<String>empty();
    final EvaluatorContext context = contextFactory.newContext(contextID, parentID);
    this.addContext(context);
    if (notifyClientOnNewActiveContext) {
      if (driverRestartManager.getEvaluatorRestartState(context.getEvaluatorId())
          == EvaluatorRestartState.REREGISTERED) {
        // if restart, advance restart state and all the restart context active handlers.
        driverRestartManager.setEvaluatorProcessed(context.getEvaluatorId());
        this.messageDispatcher.onDriverRestartContextActive(context);
      }

      this.messageDispatcher.onContextActive(context);
    }
  }
1092029
function Resolve(context, model) {
    if (model == null) {
        // 清空context
        for (var prop in context) {
            var target = context[prop];
            if (target instanceof view_1.View) {
                var propName = target.PropertyName();
                if (propName) {
                    if (target instanceof text_1.TextView || target instanceof choice_1.ChoiceView) {
                        target.Clear();
                    }
                    else if (target instanceof list_1.ListView) {
                        target.SetData([]);
                    }
                    else {
                        console.warn(propName + " clear failed, missing clear method!");
                    }
                }
            }
        }
        return;
    }
    for (var prop in context) {
        var target = context[prop];
        if (target instanceof view_1.View) {
            var propName = target.PropertyName();
            if (propName) {
                var value = model[propName];
                if (value) {
                    // 注入
                    if (target instanceof text_1.TextView || target instanceof choice_1.ChoiceView) {
                        target.SetValue(value);
                    }
                    else if (target instanceof list_1.ListView && $.isArray(value)) {
                        target.SetData(value);
                    }
                    else {
                        console.warn(propName + " resolve failed, control type is mismatching!");
                    }
                }
                else {
                    console.warn(propName + " resolve failed, value invalid!");
                }
            }
        }
    }
}
626143
protected void refresh(ApplicationContext applicationContext) {
		Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
		((AbstractApplicationContext) applicationContext).refresh();
	}
997166
def pass_context(f):
    
    def new_func(*args, **kwargs):
        return f(get_current_context(), *args, **kwargs)
    return update_wrapper(new_func, f)
1229300
def get_context(self):
        
        ctx = self._obj.get_context()
        return _ContextProxy(ctx, self._factory)
827650
def inject_context(self, __context_dict__=None, **context):
        
        context = context or __context_dict__
        self.context_keys |= set(context.keys())
        for key, value in context.items():
            setattr(self, key, value)
        for command in self.subcommands.values():
            command.inject_context(context)