@param string $lookup
@param string $value
@param bool   $use_private

@returns bool
515515
public static function getLookupValue($lookup, &$value, $use_private = false)
    {
        if (empty($lookup)) {
            return false;
        }

        $_parts = explode('.', $lookup);
        if (count($_parts) > 1) {
            $_section = array_shift($_parts);
            $_lookup = implode('.', $_parts);
            if (!empty($_section)) {
                switch ($_section) {
                    case 'session':
                        switch ($_lookup) {
                            case 'id':
                            case 'token':
                                $value = static::getSessionToken();

                                return true;

//                            case 'ticket':
//                                $value = static::_generateTicket();
//
//                                return true;
                        }
                        break;

                    case 'user':
                    case 'role':
                        // get fields here
                        if (!empty($_lookup)) {
                            $info = static::get($_section);
                            if (isset($info, $info[$_lookup])) {
                                $value = $info[$_lookup];

                                return true;
                            }
                        }
                        break;

                    case 'app':
                        switch ($_lookup) {
                            case 'id':
                                $value = static::get('app.id');;

                                return true;

                            case 'api_key':
                                $value = static::getApiKey();

                                return true;
                        }
                        break;

                    case 'df':
                        switch ($_lookup) {
                            case 'host_url':
                                $value = Curl::currentUrl(false, false);

                                return true;
                            case 'name':
                                $value = \Config::get('app.name');

                                return true;
                            case 'version':
                                $value = \Config::get('app.version');

                                return true;
                            case 'api_version':
                                $value = \Config::get('df.api_version');

                                return true;
                            case 'confirm_invite_url':
                                $value = url(\Config::get('df.confirm_invite_url'));

                                return true;
                            case 'confirm_register_url':
                                $value = url(\Config::get('df.confirm_register_url'));

                                return true;
                            case 'confirm_reset_url':
                                $value = url(\Config::get('df.confirm_reset_url'));

                                return true;
                        }
                        break;
                }
            }
        }

        if ($use_private) {
            $lookups = static::get('lookup_secret');
            if (array_key_exists($lookup, (array)$lookups)) {
                $value = $lookups[$lookup];

                return true;
            }
        }
        // non-private
        $lookups = static::get('lookup');
        if (array_key_exists($lookup, (array)$lookups)) {
            $value = $lookups[$lookup];

            return true;
        }

        return false;
    }
471875
static function createShowInvisibleSQLString( $useSettings, $fetchHidden = true )
    {
        $showInvisibleNodesCond = '';
        $showInvisible          = $fetchHidden;

        if ( $useSettings )
            $showInvisible = eZContentObjectTreeNode::showInvisibleNodes();

        if ( !$showInvisible )
            $showInvisibleNodesCond = 'AND ezcontentobject_tree.is_invisible = 0';

        return $showInvisibleNodesCond;
    }
454
public function setUseCustomerKey( $use_customer_key )
	{
		$this->use_customer_key = ($use_customer_key == 1 || $use_customer_key == 'Y' || $use_customer_key === TRUE) ? TRUE : FALSE;

		return $this;
	}
1168018
public function asAliasOf($lookup)
    {
        $endPoint = &$this->getEndPoint();
        $endPoint['lookupType'] = self::TYPE_ALIAS;
        $endPoint['ref'] = $lookup;

        return $this;
    }
757239
def lookup_accessor(accessor, options = {})
      headers = extract_headers!(options)
      json = client.post("/v1/auth/token/lookup-accessor", JSON.fast_generate(
        accessor: accessor,
      ), headers)
      return Secret.decode(json)
    end
883867
function with($meta, $operator = null, $value = null)
	{
		
		list($value, $operator) = $this->prepareValueAndOperator(
			$value, $operator, func_num_args() == 2
		);

		static $count;
		if (empty($count)) {
			$count = 0;
		}
		
		if (!is_array($meta)) {
			$meta = [ $meta => $value ];
		}

		foreach($meta as $key => $value) {
			$alias = '_with_condition_'.(++$count);
			$this->query->join("postmeta as {$alias}", "{$alias}.post_id", '=', 'ID');
			$this->query->where("{$alias}.meta_key", '_' . $key);
			$this->query->where("{$alias}.meta_value", $operator, $value);
		}

		return $this;
	}
234734
public function setUseHasCache($useHasCache = true, $hasCacheLength = null)
    {
        $this->useHasCache = (bool)$useHasCache;

        if ($hasCacheLength !== null) {
            $this->hasCacheLength = (int)$hasCacheLength;
        }

        return $this;
    }
272361
public function getHavingString($usePlaceholders = true, $includeText = true)
    {
        $statement = $this->getCriteriaString($this->having, $usePlaceholders, $this->havingPlaceholderValues);

        if ($includeText && $statement) {
            $statement = "HAVING " . $statement;
        }

        return $statement;
    }
126917
public static function get($identifier, $use_expiration = true)
	{
		$cache = static::forge($identifier);
		return $cache->get($use_expiration);
	}
890472
public function addConstructorLookup($lookup)
        {
            $endPoint =& $this->_getEndPoint();
            if (!isset($this->_endPoint['args'])) {
                $endPoint['args'] = array();
            }
            $endPoint['args'][] = array(
                'type' => 'lookup',
                'item' => $lookup
            );

            return $this;
        }
20494
function(text, lang, callback) {

        if (arguments.length == 4) {
            var options = callback;
            callback = arguments[arguments.length - 1];
        }

        var uri = url.format({
            pathname: url.resolve(baseAddress, 'lookup'),
            query: {
                key: dis.APIkey,
                lang: lang,
                text: text,
                ui: options ? options.ui : null,
                flags: options ? options.flags : null,
            }
        });

        makeRequest(uri, callback);
    }
1302819
public function populateWithQueryResult(QueryResult $queryResult, $useHeaders = true)
  {
    $this->data = $queryResult->getDatasInArray(true, true);
    $this->useHeaders = $useHeaders;
    $this->useAssociativeArray = true;
  }
634484
public function setUseAWStats(string $use_awstats = "F") : CNabuDataObject
    {
        if ($use_awstats === null) {
            throw new ENabuCoreException(
                    ENabuCoreException::ERROR_NULL_VALUE_NOT_ALLOWED_IN,
                    array("\$use_awstats")
            );
        }
        $this->setValue('nb_site_use_awstats', $use_awstats);
        
        return $this;
    }
1293466
function use(value) {
    var settings

    assertUnfrozen('use', frozen)

    if (value === null || value === undefined) {
      // Empty.
    } else if (typeof value === 'function') {
      addPlugin.apply(null, arguments)
    } else if (typeof value === 'object') {
      if ('length' in value) {
        addList(value)
      } else {
        addPreset(value)
      }
    } else {
      throw new Error('Expected usable value, not `' + value + '`')
    }

    if (settings) {
      namespace.settings = extend(namespace.settings || {}, settings)
    }

    return processor

    function addPreset(result) {
      addList(result.plugins)

      if (result.settings) {
        settings = extend(settings || {}, result.settings)
      }
    }

    function add(value) {
      if (typeof value === 'function') {
        addPlugin(value)
      } else if (typeof value === 'object') {
        if ('length' in value) {
          addPlugin.apply(null, value)
        } else {
          addPreset(value)
        }
      } else {
        throw new Error('Expected usable value, not `' + value + '`')
      }
    }

    function addList(plugins) {
      var length
      var index

      if (plugins === null || plugins === undefined) {
        // Empty.
      } else if (typeof plugins === 'object' && 'length' in plugins) {
        length = plugins.length
        index = -1

        while (++index < length) {
          add(plugins[index])
        }
      } else {
        throw new Error('Expected a list of plugins, not `' + plugins + '`')
      }
    }

    function addPlugin(plugin, value) {
      var entry = find(plugin)

      if (entry) {
        if (plain(entry[1]) && plain(value)) {
          value = extend(entry[1], value)
        }

        entry[1] = value
      } else {
        attachers.push(slice.call(arguments))
      }
    }
  }
1290089
public function getReadableValue($useName = null, $useValue = null)
  {
    $useName = $useName ?: ucwords(Strings::humanize($this->key));
    $useValue = $useValue ?: $this->value;
    if(is_array($useValue))
    {
      $useValue = implode(', ', ValueAs::arr($useValue));
    }

    $nonIsComparators = [
      AdvancedFilterComparator::STARTS_WITH,
      AdvancedFilterComparator::NOT_STARTS_WITH,
      AdvancedFilterComparator::ENDS_WITH,
      AdvancedFilterComparator::NOT_ENDS_WITH,
    ];

    if(!in_array($this->comparator, $nonIsComparators))
    {
      $useName .= ' is';
    }

    if(in_array(
      $this->comparator,
      [AdvancedFilterComparator::BETWEEN, AdvancedFilterComparator::NOT_BETWEEN]
    ))
    {
      list($min, $max) = explode(',', $useValue);
      return $useName . ' between ' . trim($min) . ' and ' . trim($max);
    }

    if(is_bool($useValue))
    {
      return $useName . ' ' . ($useValue ? 'true' : 'false');
    }

    return $useName . ' '
      . AdvancedFilterComparator::getDisplayValue($this->comparator) . ' '
      . $useValue;
  }
708840
public function addUse(string $use, string $useAlias = null): void
    {
        $this->generator->addUse($use, $useAlias);
    }
243311
protected static void lookupFieldResource(javax.naming.Context context,
            Object instance, Field field, String name)
            throws NamingException, IllegalAccessException
    {

        Object lookedupResource;

        if ((name != null) && (name.length() > 0))
        {
            // TODO local or global JNDI
            lookedupResource = context.lookup(JAVA_COMP_ENV + name);
        }
        else
        {
            // TODO local or global JNDI 
            lookedupResource = context.lookup(JAVA_COMP_ENV + instance.getClass().getName() + "/" + field.getName());
        }

        boolean accessibility = field.isAccessible();
        field.setAccessible(true);
        field.set(instance, lookedupResource);
        field.setAccessible(accessibility);
    }