Join the user table.

@param bool $strict When strict uses a JOIN rather than a LEFT JOIN.
431242
public function join_user($strict = false) {
        $join = $strict ? 'JOIN' : 'LEFT JOIN';
        $this->joins[] = sprintf("$join {user} %s ON %s = %s",
            self::ALIAS_USER, self::resolve_field('id', 'user'), self::resolve_field('userid', 'entries'));
    }
1031668
function search($needle, bool $strict = true) {
        return \array_search($needle, $this->data, $strict);
    }
961087
public function match($value, string $field, bool $strict = false): bool
    {
        if ($strict) {
            return $value === $this->getValidator()->getValue($field, null);
        }

        return $value == $this->getValidator()->getValue($field, null);
    }
35194
public static function isValidValue($value, $strict = false)
    {
        $values = self::getConstantValues();

        return in_array($value, $values, $strict);
    }
913226
public function where($key, $value, bool $strict = true): ArrayCollection
    {
        return $this->filter(function ($item) use ($key, $value, $strict) {
            if (!isset($item[$key])) {
                return false;
            }

            return $strict ? $item[$key] === $value : $item[$key] == $value;
        });
    }
1238994
public function containsAll($value, $strict = false)
    {
        return in_array($value, Arr::collapse($this->dump(true)), $strict);
    }
597934
public function isAuthentic($strict = false)
    {
        $result = $this->getSession()->get('user.authentic');

        if ($strict) {
            $result = $result && $this->_authentic;
        }

        return $result;
    }
416494
public function matches($value, $strict = true)
    {
        return $strict ? $this->value === $value : $this->value == $value;
    }
773486
public function join(
		string $table, 
		string $match, 
		string $against
	) {
		// secure parameters
		list($table) 	= Query\Convert::columnToPlaceholder($this->Quote ,$table);
		list($match) 	= Query\Convert::columnToPlaceholder($this->Quote ,$match);
		list($against) 	= Query\Convert::columnToPlaceholder($this->Quote ,$against);
		// push the join condition
		$this->Joins[] = "JOIN {$table} ON {$match} = {$against}";
		// return self to the next method
		return $this;
	}
157498
public function buildTree(Collection $nodes, $strict = true)
    {
        $refs  = []; // Reference table to store records in the construction of the tree
        $count = 0;
        $roots = new Collection();
        foreach ($nodes as &$node) {
            /* @var Tree $node */
            $node->initChildrenRelation(); // We need to init relation to avoid LAZY LOADING in future
            $refs[$node->getKey()] = &$node; // Adding to ref table (we identify after the id)
            if ($count === 0) {
                $roots->add($node);
                $count++;
            } else {
                if ($this->siblingOfRoot($node, $roots)) { // We use this condition as a factor in building subtrees
                    $roots->add($node);
                } else { // This is not a root, so add them to the parent
                    $index = $node->{$this->getTreeColumn('parent')};
                    if (!empty($refs[$index])) { // We should already have parent for our node added to refs array
                        $refs[$index]->addChildToCollection($node);
                    } else {
                        if ($strict) { // We don't want to ignore orphan nodes
                            throw new MissingParentException();
                        }
                    }
                }
            }
        }

        if (!empty($roots)) {
            if (count($roots) > 1) {
                return $roots;
            } else {
                return $roots->first();
            }
        } else {
            return false;
        }
    }
543138
function Join(Table $table, JoinType $join, Condition $condition, $prepend = false)
    {
        $result = $this->Duplicate();
        if ($prepend)
        {
            array_unshift($result->tables, $table);
            array_unshift($result->joins, $join);
            array_unshift($result->conditions, $condition);
        }
        else
        {    
            $result->tables[] = $table;
            $result->joins[] = $join;
            $result->conditions[] = $condition;
        }
        return $result;
    }
438525
public function forever($key, $value, $strict = true) {
        return $this->set($key, $value, 0, $strict);
    }
360209
public function remove($value, $strict = false)
    {
        while ($index = $this->search($value, $strict)) {
            $this->delete($index);
        }

        return $this;
    }
764209
function LeftJoin(Table $table, Condition $condition, $prepend = false)
    {
        return $this->Join($table, JoinType::Left(), $condition, $prepend);
    }
715350
public function strict($condition) {
      $query = $this->buildStrategyCondition($condition, Strict::create());
      return $this->process($query);
    }
858983
protected function isValueTypeValid($value, $strict = false): bool
    {
        return parent::isValueTypeValid($value, $strict) ?: ($value instanceof self);
    }
314385
public function contains($needle, $strict = false)
    {
        $this->addCondition(__METHOD__, [$needle, $strict]);

        return $this;
    }