Fetch Activereference for an execution. Returns null, if execution not in queue
3928
public ExecutionReference getReference(final int executionId) {
    if (hasExecution(executionId)) {
      return this.queuedFlowMap.get(executionId).getFirst();
    }
    return null;
  }
27920
def get(self, sid):
        
        return ExecutionContext(self._version, flow_sid=self._solution['flow_sid'], sid=sid, )
384277
@Override
	public synchronized T get()
	{
		T val;

		synchronized(this)
		{
			if(valRef==null || (val = valRef.get())==null)
			{
				val = make();
				valRef = new WeakReference<T>(val);
			}
		}
		return val;
	}
1173704
def referenced(self):
        
        if not hasattr(self, '_referenced'):
            self._referenced = conf.lib.clang_getCursorReferenced(self)

        return self._referenced
513018
def get(path: nil, headers: {}, query: {})
      execute(method: :get, path: path, query: query, headers: headers)
    end
925661
def runGetReference(self, id_):
        
        compoundId = datamodel.ReferenceCompoundId.parse(id_)
        referenceSet = self.getDataRepository().getReferenceSet(
            compoundId.reference_set_id)
        reference = referenceSet.getReference(id_)
        return self.runGetRequest(reference)
95217
def fetch_reference_restriction(self, ):
        
        inter = self.get_refobjinter()
        restricted = self.status() is not None
        return restricted or inter.fetch_action_restriction(self, 'reference')
509710
def get_trace(self, reference=None):
        
        item = self
        while item:
            yield item
            if item == reference:
                return
            item = item.parent

        if reference is not None:
            raise Exception(
                'Reference {} is not in Ancestry'.format(reference))
346523
@SuppressWarnings("unchecked")
    public V get(Object key) {
        synchronized( this ) {
            //WeakReference ref;
            SoftReference ref;
            V item;
            
            if( !containsKey(key) ) {
                return null;
            }
            ref = cache.get(key);
            item = (V)ref.get();
            if( item == null ) {
                return null;
            }
            if( item instanceof CachedItem ) {
                CachedItem ci = (CachedItem)item;
                
                if( ci.isValidForCache() ) {
                    return item;
                }
                remove(key);
                return null;
            }
            return item;
        }
    }
1112136
def queue_exc(*arg, **kw):
    """"""
    _self = arg[0]
    if not isinstance(_self, AnsibleUndefinedVariable):
        # Run for AnsibleUndefinedVariable instance
        return
    _rslt_q = None
    for stack_trace in inspect.stack():
        # Check if method to be skipped
        if stack_trace[3] in SKIP_METHODS:
            continue
        _frame = stack_trace[0]
        _locals = inspect.getargvalues(_frame).locals
        if 'self' not in _locals:
            continue
        # Check if current frame instance of worker
        if isinstance(_locals['self'], WorkerProcess):
            # Get queue to add exception
            _rslt_q = getattr(_locals['self'], '_rslt_q')
    if not _rslt_q:
        raise ValueError("No Queue found.")
    # Add interceptor exception
    _rslt_q.put(arg[3].message, interceptor=True)
1123635
function fetchCache(target, cache) {
        var x,
            length = cache.length,
            curr;

        for (x = 0; x < length; x += 1) {
            curr = cache[x];
            if (curr.target === target) {
                return curr.inspect;
            }
        }

        return null;
    }
813581
def get_result(self):
        
        self._process()
        if not self.has_result:
            raise NoResult
        return self.res_queue.popleft()
997027
function (err, node, next) {
                var func = node.action + 'Action';
                var obj = eval(func + '(node.params)');
                logger.log('debug', 'M|actionQueue::execute|obj=%j', +obj, meta);
                return null;
            }
893792
function(executionStep) {
    // In order to use and index for implementing a join, the entire relation
    // must be fed to the JoinStep, otherwise the index can't be used.
    if (!(executionStep instanceof lf.proc.TableAccessFullStep)) {
      return null;
    }
    var candidateColumn = getColumnForTable(executionStep.table);
    return goog.isNull(candidateColumn.getIndex()) ? null : candidateColumn;
  }
651102
def get_execution(self, id_execution, access_token=None, user_id=None):
        
        if access_token:
            self.req.credential.set_token(access_token)
        if user_id:
            self.req.credential.set_user_id(user_id)
        if not self.check_credentials():
            raise CredentialsError('credentials invalid')
        execution = self.req.get('/Executions/' + id_execution)
        if "codeId" in execution:
            execution['code'] = self.get_code(execution["codeId"])
        return execution
581396
def call(obj, args, ctx)
      cache_key = [CacheQL::Railtie.config.global_key, obj.cache_key, ctx.field.name]
      CacheQL::Railtie.config.cache.fetch(cache_key,
        expires_in: CacheQL::Railtie.config.expires_range.sample.minutes) do
        @resolver_func.call(obj, args, ctx)
      end
    end
1088962
@Override
  public Executor fetchExecutor(final int executorId) throws ExecutorManagerException {
    for (final Executor executor : this.activeExecutors.getAll()) {
      if (executor.getId() == executorId) {
        return executor;
      }
    }
    return this.executorLoader.fetchExecutor(executorId);
  }