PHP Collection::__construct方法代码示例

 public function __construct($data)
 {
     parent::__construct($data);
     $this->_dataStore = $this->data = $data;
     $this->pages = 1;
     $this->perPage = count($this->_dataStore);
 }

 /**
  * @param array $elements
  * @param int $currentPage
  * @param int $count
  * @param int $pageSize
  */
 public function __construct(array $elements, int $currentPage, int $count = null, $pageSize = 20)
 {
     parent::__construct($elements);
     $this->currentPage = $currentPage;
     $this->count = $count;
     $this->pageSize = $pageSize;
 }

 /**
  * Constructor
  *
  * @param array $points An array of at least two points with
  * which to build the LineString
  */
 public function __construct($points = array())
 {
     if (count($points) == 1) {
         throw new Exception("Cannot construct a LineString with a single point");
     }
     // Call the Collection constructor to build the LineString
     parent::__construct($points);
 }

 public function __construct()
 {
     parent::__construct();
     foreach ($this->types as $type_id => $class_name) {
         $item = $this->create_item($type_id);
         $this->members[$type_id] = $item;
     }
 }

 public function __construct($data = null)
 {
     if (null !== $data && is_string($data)) {
         $this->fromString($data);
     } else {
         parent::__construct($data);
     }
 }

 /**
  * Constructor
  *
  * The first linestring is the outer ring
  * The subsequent ones are holes
  * All linestrings should be a closed LineString
  *
  * @param array $linestrings The LineString array
  */
 public function __construct(array $linestrings)
 {
     if (count($linestrings) > 0) {
         parent::__construct($linestrings);
     } else {
         throw new Exception("Polygon without an exterior ring");
     }
 }

 /**
  * Constructor
  *
  * @param array $positions The Point array
  */
 public function __construct(array $positions)
 {
     if (count($positions) > 1) {
         parent::__construct($positions);
     } else {
         throw new Exception("Linestring with less than two points");
     }
 }

 /**
  * @param Route $route a Route thru which the IWebContext was passed
  * @param IRouteTable $routeTable table of routes that was looked up to find the appropriate Route
  * @param IWebContext $webContext context that was passed thru the Route
  * @param Trace $parentTrace inital Trace which's handling failed cascading usage of a fallback Route
  */
 function __construct(Route $route, IRouteTable $routeTable, IWebContext $webContext, Trace $parentTrace = null)
 {
     $this->route = $route;
     $this->routeTable = $routeTable;
     $this->webContext = $webContext;
     $this->parentTrace = $parentTrace;
     parent::__construct();
 }

 public function __construct($data = array())
 {
     $newData = [];
     foreach ($data as $item) {
         $newData[] = new TodoItem($item);
     }
     parent::__construct($newData);
 }

 public function __construct($refresh = false, $callback = null)
 {
     parent::__construct($this->repository);
     $this->fetch($refresh, $callback);
     $this->data = json_decode($this->raw);
     foreach ($this->data as $slug => $data) {
         $this->items[$slug] = new Package($data, $this->type);
     }
 }

 function __construct($id, $scheme, $table, $fields = "*", $from = "", $where = "", $limit_size = 30)
 {
     $sql = "SELECT * FROM `{$table}` WHERE `id` = {$id}";
     //		dbg($sql);
     $this->v = $this->queryRow($sql);
     //		dbg($this->v);
     $this->scheme = $scheme;
     parent::__construct($table, $fields = "*", $from = "", $where = "", $limit_size);
 }

 /**
  * Class construct
  * @param array|\ArrayObject|null $array
  * @return void
  */
 public function __construct($array = null, array $options = null)
 {
     $options = array_merge(null === $options ? array() : $options, array('indexType' => static::INDEX_ASSOCIATIVE, 'readonly' => false));
     if (array_key_exists('name', $options)) {
         $this->setName($options['name']);
     }
     parent::__construct($array, $options);
     $this->setFlags(self::ARRAY_AS_PROPS);
 }

 /**
  * Constructor
  *
  * The first linestring is the outer ring
  * The subsequent ones are holes
  * All linestrings should be linearrings
  *
  * @param array $linestrings The LineString array
  */
 public function __construct(array $linestrings)
 {
     // the GeoJSON spec (http://geojson.org/geojson-spec.html) says nothing about linestring count.
     // What should we do ?
     if (count($linestrings) > 0) {
         parent::__construct($linestrings);
     } else {
         throw new Exception("Polygon without an exterior ring");
     }
 }

 function __construct($name, $config)
 {
     parent::__construct($config);
     $this->statut_id = substr($this->get_code_from_name($name), 1);
     $query = "select gestion_libelle from notice_statut where id_notice_statut = " . $this->statut_id;
     $result = mysql_query($query);
     if (mysql_num_rows($result)) {
         $this->statut_libelle = mysql_result($result, 0, 0);
     }
     $this->type = "statut";
 }

 public function __construct($cSaveMode, array $aItems = array())
 {
     if ($aItems) {
         if (!self::isAModelArray($aItems)) {
             throw new \Exception(__METHOD__ . "() : L'argument #2 doit être un tableau d'instance(s) de Model.");
         }
         $this->_sModelName = self::getModelNameFromInstance($aItems[array_rand($aItems)]);
     }
     $this->setDefaultSaveMode($cSaveMode);
     parent::__construct($aItems);
 }