Find multiple entities.

@return  CollectionFinderInterface  The responsible Finder object

@throws  OrmException  if there was an error getting the entities
551909
public function findAll()
    {
        $finder = $this->dataMapper->findAll();

        foreach ($this->restrictions as $filter) {
            $finder = $finder->with($filter['field'], $filter['op'], $filter['value']);
        }

        return $finder;
    }
297432
public function findOne()
    {
        $finder = $this->dataMapper->findOne();

        foreach ($this->restrictions as $filter) {
            $finder = $finder->with($filter['field'], $filter['op'], $filter['value']);
        }

        return $finder;
    }
1345803
public function find($entityName, $where = [], $joinConditions = [])
    {
        return $this->getRepository($entityName)->find($where, 'u', false, $joinConditions);
    }
1272594
public function findAll()
    {
        $ret = $this->conn()->selectCollection($this->table_name)->find($this->where, $this->field);
        if ($this->limit) {
            $ret->limit($this->limit)->skip($this->skip);
        }
        if ($this->orderby) {
            $ret->sort($this->orderby);
        }

        $this->sql = array(
                     'table'=> $this->table_name,
                     'query'=>$this->where,
                     'field'=> $this->field,
                     'limit'=> $this->limit,
                     'skip'=> $this->skip,
                   );
        $this->_clear_var();
        return $ret;
    }
849856
public function findOnlines(){
        $query_builder = $this->createQueryBuilder("e");
        $query_builder = $this->filterOnlines($query_builder);
        
        return $query_builder->getQuery()->getResult();
    }
891069
public function findFor(AbstractEntity $entity)
    {
        return $this->findOneBy(array('refId' => $entity->getId(), 'refEntityName' => ClassLookup::getClass($entity)));
    }
995705
public function findAll(): array
    {
        $queryBuilder = $this->entityManager->createQueryBuilder();
        $queryBuilder->select('mc')
                     ->from(ModCombination::class, 'mc');

        return $queryBuilder->getQuery()->getResult();
    }
853333
public function find($conditions = 'TRUE')
    {
        $collection = [];
        $this->adapter->select($this->entityTable, $conditions);

        if (($data = $this->adapter->fetch()) !== false) {
            $collection[] = $this->createEntity($data);
        }

        return $collection;
    }
642627
@Override
    public Iterable<T> findAll() {
        return inTransaction(new Callable<Iterable<T>>() {
            @Override
            public Iterable<T> call() throws Exception {
                CriteriaQuery<T> cq = entityManager.getCriteriaBuilder().createQuery(entity);
                Root<T> pet = cq.from(entity);
                cq.select(pet);
                return entityManager.createQuery(cq).getResultList();
            }
        });
    }
1182383
public function findAll()
    {
        return new CsvCollectionFinder($this->gateway, $this->table, $this->entityClass, $this->entityRegistry);
    }
74590
public function findOne()
    {
        return new CsvEntityFinder($this->gateway, $this->table, $this->entityClass, $this->entityRegistry);
    }
46274
public function collection() : EmbeddedCollectionDefiner
    {
        return new EmbeddedCollectionDefiner(
            $this->orm,
            function (callable $mapperLoader, $tableName, $primaryKeyName, $foreignKeyName) {
                call_user_func($this->callback, function (
                    $idString,
                    Table $parentTable,
                    IObjectMapper $parentMapper
                ) use (
                    $mapperLoader,
                    $tableName,
                    $primaryKeyName,
                    $foreignKeyName
                ) {
                    return new EmbeddedCollectionRelation(
                        $idString,
                        $mapperLoader($parentMapper),
                        $parentTable->getName(),
                        $this->orm->getNamespace() . $tableName,
                        $parentTable->getPrimaryKeyColumn()->withName($primaryKeyName),
                        new Column($foreignKeyName, PrimaryKeyBuilder::primaryKeyType()),
                        $parentTable->getPrimaryKeyColumn()
                    );
                });
            }
        );
    }
743281
public function getModel()
    {
        $collection = $this->getCollection();

        /** @var EntityDataModel $model */
        $model = $collection->getModel();
        $model->setEntityManager($this);

        return $model;
    }
1007014
protected function _findBy(string $key, $value): ArrayCollection
    {
        return $this->collection->filter(
            function (Entity $entity) use ($key, $value) {
                return PropertyHelper::getProperty($entity, $key) == $value;
            }
        );
    }
929361
public function find($id)
    {
        if (!($object = $this->getDoctrineEntityRepository()->find($id))) {
            $this->throwException(sprintf('The resource \'%s\' was not found', $id), 'not-found');
        }

        return $object;
    }
646477
public function find($entityName, $identifier, $lockMode = LockMode::NONE, $lockVersion = null)
    {
        return $this->getRepository($entityName)->find($identifier, $lockMode, $lockVersion);
    }
1317814
private function doFind($id)
    {
        $id = $this->toIdentity($id);
        $entity = null === $id ? null : $this->em->find($this->class, $id);

        if (null === $entity) {
            throw EntityNotFoundException::createForId($this->class, $id);
        }

        return $entity;
    }