same as datapacket
traverse through all
packets and make sure
none have been fetched
already

@param strict: check for initial dispatch or not
@return multidimensional array
174597
public function get($strict=FALSE)
    {
      $data = array();

      if ($strict && !$this->dispatched)
        foreach ($this->data as $d)
          if ($d->dispatched)
            throw new \CatapultApiException("One of the packets was already dispatched");

      elseif ($strict && $this->dispatched)
        throw new \CatapultApiException("This packet collection was already dispatched");

      foreach ($this->data as $d)
        $data[] = $d->get();

      /* lowercase a state */			
      if (array_key_exists("state", $data))	
        $data['state'] = strtolower($data['state']);

      $this->dispatched = true;

      return $data;
    }
87003
public function isStatusBetween($from = null, $to = null, $strict = false, $strictTo = null)
    {
        return in_array($this->status, static::getStatusBetween($from, $to, $strict, $strictTo));
    }
1035195
async function getAll(options) {
    const data = {};
    const keys = filterPaths(await module.exports.keys(), options);

    for (let key of keys) {
      data[key] = await module.exports.get(key, {
        before: options.before,
        after: options.after,
      });
    }

    await Promise.all(keys);

    return data;
  }
1055474
public static function isList(array $array, $strict = false)
    {
        $isNumbers = ctype_digit(implode('', array_keys($array)));

        if (!$strict) {
            return $isNumbers;
        } elseif (!$isNumbers) {
            return false;
        }

        return array_keys($array) === range(0, count($array) - 1);
    }
1328328
function strictString(value, notSet) {
  if (Array.isArray(value)) return strictString(value[0], notSet)
  if (typeof value !== 'string') return notSet

  value = value.trim()
  return value === '' ? notSet : value
}
745524
public function search($value, bool $strict = false)
    {
        if (!$strict) {
            /** @var Collection $values */
            $values = $this->copy();
            $values->apply(function ($value) {
                if (is_string($value)) {
                    return strtolower($value);
                }

                return $value;
            });

            $value = strtolower($value);
        } else {
            $values = $this;
        }

        return array_search($value, $values->toArray(), $strict);
    }
330120
public function whereNotIn($key, $values, $strict = false)
    {
        $values = $this->getArrayableItems($values);

        return $this->reject(function ($item) use ($key, $values, $strict) {
            return \in_array(Helper::data_get($item, $key), $values, $strict);
        });
    }
895909
public function contains($value, $key = null, $strict = false)
    {
        if ($key !== null) {
            foreach ($this->items as $item) {
                $v = isset($item[$key]) ? $item[$key] : null;
                if ((!$strict && $v == $value) || $v === $value) {
                    return true;
                }
            }
            return false;
        }

        if ($this->useAsCallable($value)) {
            return $this->first($value) !== null;
        }

        return in_array($value, $this->items, $strict);
    }
351773
public static function iin_array($needle, $haystack, bool $strict=true) {
		return (false !== static::array_isearch($needle, $haystack, $strict));
	}
750271
function getIdsFromPayload(payload, conf, path) {
    return payload.map(function (payloadPiece) { return getId(payloadPiece, conf, path, payload); });
}
767819
public ParseTree getDeepestLocation( int iStart, int iEnd, boolean strict )
  {
    return getDeepestLocation( false, iStart, iEnd, strict );
  }
1342375
public function getByPropertyValues($property, $values, $strict = false)
    {
        $results = [];
        foreach ($this as $item) {
            foreach ($values as $value) {
                if ($strict) {
                    if ($item->$property === $value) {
                        $results[] = $item;
                    }
                } else {
                    if ($item->$property == $value) {
                        $results[] = $item;
                    }
                }
            }
        }
        return new static($results);
    }
861126
public static function fromArray(array $array, $strict = true)
    {
        $details = (object)$array;
        $packageNameDetails = self::parseVendorAndPackage(object_get($details, 'name', null));

        $description = object_get($details, 'description', null);
        $license = object_get($details, 'license', null);
        $authors = object_get($details, 'authors', null);

        // Throw exceptions if the developer wants us to be super strict.
        if ($strict) {
            self::throwInvalidArgumentException($description, 'Invalid package description.');
            self::throwInvalidArgumentException($license, 'Invalid package license.');
            self::throwInvalidArgumentException($authors, 'Invalid package authors.');
        }

        $package = new Package;
        $package->setAuthors($authors);
        $package->setDescription($description);
        $package->setLicense($license);
        $package->setVendor($packageNameDetails[0]);
        $package->setPackage($packageNameDetails[1]);

        return $package;
    }
1122097
function getDeepest(collection) {
	'use strict';

	return collection.sort(function(a, b) {
		if (axe.utils.contains(a, b)) {
			return 1;
		}
		return -1;
	})[0];
}
568080
public List<GeoLocation> search(boolean strict, GeoSearch... searches)
    {
        List<GeoLocation> list = new ArrayList<>();
        for (GeoFile gf : files)
        {
            gf.search(strict, list, searches);
        }
        return list;
    }
552294
private static Iterable<String> getParametersFromMap(final Map<String, String> paramMap, final boolean strict) {
        return Iterables.transform(paramMap.entrySet(), new Function<Map.Entry<String, String>, String>() {
            @Override public String apply(final Map.Entry<String, String> input) {
                return input == null ? null : ENTRY_JOINER.join(UriEscaper.escapeQueryParam(input.getKey(), strict),
                                                                UriEscaper.escapeQueryParam(input.getValue(), strict));
            }
        });
    }
82401
public function where($key, $value, $strict = true)
    {
        return $this->filter(function ($item) use ($key, $value, $strict) {
            return $strict ? ArrayHelper::getValue($item, $key) === $value
                : ArrayHelper::getValue($item, $key) == $value;
        });
    }