Get all substances
 @return [Array<OpenTox::Substance>]
179888
def substances
      @substances ||= data_entries.keys.collect{|id| OpenTox::Substance.find id}.uniq
      @substances
    end
206606
public function getIngestManifestFileList()
    {
        $propertyList = $this->_getEntityList('IngestManifestFiles');
        $result = [];

        foreach ($propertyList as $properties) {
            $result[] = IngestManifestFile::createFromOptions($properties);
        }

        return $result;
    }
1057491
def all(opts={})

      res = fetch_all(opts)

      res.is_a?(Array) ? res.map { |hwi| Ruote::Workitem.new(hwi) } : res
    end
263569
private function getAllLinks()
    {
        return $this->getCachedProperty(
            'links',
            function () {
                $result = [];
                // No REQUIRED — no exception.
                $nodes = $this->query('atom:link');
                foreach ($nodes as $node) {
                    /** @var Element $this */
                    $result[] = $this->getExtensions()->parseElement($this, $node);
                }

                return $result;
            }
        );
    }
877501
public static function getAll()
    {
        $class = get_called_class();
        if (!isset(static::$values[$class])) {
            $reflection = new \ReflectionClass($class);
            static::$values[$class] = $reflection->getConstants();
        }

        return static::$values[$class];
    }
1071837
public function getAll()
    {
        if(!$this->skipCriteria) {
            foreach($this->getterCriteria as $criteria) {
                $this->repository = $this->repository->pushCriteria(app($criteria));
            }
        }
        if(!$this->skipRelations) {
            $this->repository = $this->repository->with($this->relations);
        }

        return $this->repository->all();
    }
226455
def get_all_items(query = {})
      response = self.get('items', nil, query).body
      parsed = JSON.parse(response)
      all_items = []
      parsed.each do |item_hash|
        all_items.push OmekaClient::OmekaItem.new(self, item_hash)
      end
      return all_items
    end
1080199
public function getAll() 
    {
        return [
            self::ENTRY_ID         => $this->getId(),
            self::ENTRY_NAME       => $this->getName(),
            self::ENTRY_TYPE       => $this->getType(),
        ];
    }
487745
public static function all()
    {
        foreach (self::getAllPaths() as $path) {
            //Gets all files for each path
            $files = (new Folder($path))->findRecursive('^.+\.ctp$', true);

            foreach ($files as $file) {
                $pages[] = new Entity([
                    'filename' => pathinfo($file, PATHINFO_FILENAME),
                    'path' => rtr($file),
                    'slug' => self::getSlug($file, $path),
                    'title' => self::title(pathinfo($file, PATHINFO_FILENAME)),
                    'modified' => new FrozenTime(filemtime($file)),
                ]);
            }
        }

        return $pages;
    }
1326913
def all():
    
    return [goal for _, goal in sorted(Goal._goal_by_name.items()) if goal.active]
303215
public function getAll()
    {
        if (null === $this->all) {
            $this->all = Reflection::getConstants($this);
        }

        return $this->all;
    }
1362072
public function getAll()
    {
        $this->_validate();
        if (array_key_exists($this->_namespaceName, $_SESSION[$this->publicStorage]['store'])) {
            return $_SESSION[$this->publicStorage]['store'][$this->_namespaceName];
        }
        return false;
    }
989888
public static function getAll()
    {
        return [
            self::SWITCHING_PROTOCOLS             => 'Switching Protocols',
            self::PROCESSING                      => 'Processing',
            self::OK                              => 'OK',
            self::CREATED                         => 'Created',
            self::ACCEPTED                        => 'Accepted',
            self::NONAUTHORITATIVE_INFORMATION    => 'Non-Authoritative Information',
            self::NO_CONTENT                      => 'No Content',
            self::RESET_CONTENT                   => 'Reset Content',
            self::PARTIAL_CONTENT                 => 'Partial Content',
            self::MULTIPLE_CHOICES                => 'Multiple Choices',
            self::MOVED_PERMANENTLY               => 'Moved Permanently',
            self::MOVED_TEMPORARILY               => 'Moved Temporarily',
            self::SEE_OTHER                       => 'See Other',
            self::NOT_MODIFIED                    => 'Not Modified',
            self::USE_PROXY                       => 'Use Proxy',
            self::BAD_REQUEST                     => 'Bad Request',
            self::UNAUTHORIZED                    => 'Unauthorized',
            self::PAYMENT_REQUIRED                => 'Payment Required',
            self::FORBIDDEN                       => 'Forbidden',
            self::NOT_FOUND                       => 'Not Found',
            self::METHOD_NOT_ALLOWED              => 'Method Not Allowed',
            self::NOT_ACCEPTABLE                  => 'Not Acceptable',
            self::PROXY_AUTHENTICATION_REQUIRED   => 'Proxy Authentication Required',
            self::REQUEST_TIMEOUT                 => 'Request Time-out',
            self::CONFLICT                        => 'Conflict',
            self::GONE                            => 'Gone',
            self::LENGTH_REQUIRED                 => 'Length Required',
            self::PRECONDITION_FAILED             => 'Precondition Failed',
            self::REQUEST_ENTITY_TOO_LARGE        => 'Request Entity Too Large',
            self::REQUESTURI_TOO_LARGE            => 'Request-URL Too Long',
            self::UNSUPPORTED_MEDIA_TYPE          => 'Unsupported Media Type',
            self::REQUESTED_RANGE_NOT_SATISFIABLE => 'Requested range not satisfiable',
            self::EXPECTATION_FAILED              => 'Expectation Failed',
            self::IM_A_TEAPOT                     => 'I\'m a teapot',
            self::UNAVAILABLE_FOR_LEGAL_REASONS   => 'Unavailable For Legal Reasons',
            self::INTERNAL_SERVER_ERROR           => 'Internal Server Error',
            self::NOT_IMPLEMENTED                 => 'Not Implemented',
            self::BAD_GATEWAY                     => 'Bad Gateway',
            self::SERVICE_UNAVAILABLE             => 'Service Unavailable',
            self::GATEWAY_TIMEOUT                 => 'Gateway Time-out',
            self::HTTP_VERSION_NOT_SUPPORTED      => 'HTTP Version not supported',
        ];
    }
867697
public Observable<List<Product>> getAllProducts() {
    return Observable.zip(getProducts(0), getProducts(1), getProducts(2), getProducts(3),
        (products0, products1, products2, products3) -> {
          List<Product> productList = new ArrayList<Product>();
          productList.addAll(products0);
          productList.addAll(products1);
          productList.addAll(products2);
          productList.addAll(products3);
          return productList;
        });
  }
552117
def getAll(self):
        """"""
        if self._jconf is not None:
            return [(elem._1(), elem._2()) for elem in self._jconf.getAll()]
        else:
            return self._conf.items()
655688
public function all()
    {
        if ($this->isEmpty()) {
            return [];
        }

        $arResult = [];
        foreach ($this->arElementIDList as $iElementID) {
            $obElementItem = $this->makeItem($iElementID, null);
            if ($obElementItem->isEmpty()) {
                continue;
            }

            $arResult[$iElementID] = $obElementItem;
        }

        return $arResult;
    }
702984
public static IAtomContainerSet getAllProducts(IReaction reaction) {
        IAtomContainerSet moleculeSet = reaction.getBuilder().newInstance(IAtomContainerSet.class);
        IAtomContainerSet products = reaction.getProducts();
        for (int i = 0; i < products.getAtomContainerCount(); i++) {
            moleculeSet.addAtomContainer(products.getAtomContainer(i));
        }
        return moleculeSet;
    }