Return many items by a key value

@param  string $key
@param  mixed $value
@param  array $with
@return \Illuminate\Database\Eloquent\Collection
517378
public function getManyBy($key, $value, array $with = array())
    {
        return $this->make($with)->where($key, '=', $value)->get();
    }
277863
public function set(string $key, string $value): HeaderCollection
    {
        return $this->setMultiple([$key => $value]);
    }
1105218
public function SelectKeyValue( $Key , $Value ) {

        $Key = new Expression( $Key );
        $Value = new Expression( $Value );

        $items = array();

        foreach ( $this->repository as $item ) {
            $_k = $Key->execute( $item );
            $_v = $Value->execute( $item );
            $items[$_k] = $_v;
        }

        return new Queryable( $items );

    }
306399
public function findManyBy($key, $value,  $orderBy = null, $limit = null, $offset = null){
        return $this->findMany($key.'=:key', array(':key' => $value), $orderBy, $limit, $offset);
    }
454263
public function with($value)
    {
        $withs = explode(',', $value);
        $model = $this->builder->getModel();
        $withs = collect($withs)->filter(function ($with) use($model) {
            if (str_contains($with, '.')) return ($model->{explode('.', $with)[0]}() instanceof Relation);
            return ($model->{$with}() instanceof Relation);
        })->toArray();
        return $this->builder->when(count($withs), function (Builder $query) use($withs) {
            $query->with($withs);
        });
    }
1016816
public static function fromSchema($entry = null, $with_value = false)
    {
        if (is_null($entry)) {
            return array_keys(static::schema());
        }

        if ($attributes = static::schemaCache($entry.'_'.(int) $with_value)) {
            return $attributes;
        }

        $attributes = [];

        foreach (static::schema() as $key => $config) {
            if (array_has($config, $entry)) {
                if ($with_value) {
                    $attributes[$key] = $config[$entry];
                } else {
                    $attributes[] = $key;
                }
            }
        }

        static::schemaCache($entry.'_'.(int) $with_value, $attributes);

        return $attributes;
    }
789654
protected function forkWith($key, $value)
    {
        $attributes = $this->attributes;
        $attributes[$key] = $value;
        return $this->fork($attributes);
    }
525897
public function withQueryParameter($key, $value)
    {
        $query = $this->getUri()->getQuery();
        parse_str($query, $params);
        $params[$key] = $value;

        return new self(
            $this->getMethod(),
            $this->getUri()->withQuery(http_build_query($params)),
            $this->getHeaders(),
            $this->getBody(),
            $this->getProtocolVersion(),
            $this->getRetries(),
            $this->getOptions(),
            $this->getServiceKey(),
            $this->getRequestKey()
        );
    }
618983
public function withValue($key, $value)
    {
        $copy = $this->values;
        $copy[$key] = $value;
        return new Context($copy);
    }
574987
public function with($key, $value = null): PageInterface
    {
        $this->ui()->getView()->with($key, $value);

        return $this;
    }
65531
public function set($key, $value)
    {
        if (!is_null($key)
            && is_scalar($key)
        ) {
            return $this->_items[$key] = $value;
        } else {
            // given index name is not valid
            throw new EnumeratorException('Element could not be added to list. Index is not valid.', E_NOTICE);
        }
    }
940769
public function withQueryParam($key, $value)
    {
        $params = $this->getQueryParams();
        $params[$key] = $value;
        $this->queryParams = $params;
    }
999993
public function with($key, $value = null)
    {
        if (is_array($key)) {
            return parent::with($this->factory->decorate($key));
        }

        return parent::with($key, $this->factory->decorate($value));
    }
861676
public function pluck($value, $key = null)
    {
        return new static(ArrayHelper::pluck($this->items, $value, $key));
    }
52826
public function allWith($with, $limit = null)
    {
        if ($limit) {
            return $this->model->with($with)->limit($limit)->get();
        }

        return $this->model->with($with)->get();

    }
906035
public function with($key, $value = null)
    {
        if (is_array($key)) {
            $this->_data = array_merge($this->_data, $key);
        } else {
            $this->_data[$key] = $value;
        }

        return $this;
    }
71646
public function set($key, $value)
    {
        $registry = ArrayHelper::set($this->getItems(), $key, $value, $useDotSyntax = true);
        $this->setItems($registry);

        return $this->getItems();
    }