PHP static::add方法代码示例

 /**
  * Parse a query string into a Query object
  *
  * @param string $query Query string to parse
  *
  * @return self
  */
 public static function fromString($query)
 {
     $q = new static();
     if ($query === '') {
         return $q;
     }
     $foundDuplicates = $foundPhpStyle = false;
     foreach (explode('&', $query) as $kvp) {
         $parts = explode('=', $kvp, 2);
         $key = rawurldecode($parts[0]);
         if ($paramIsPhpStyleArray = substr($key, -2) == '[]') {
             $foundPhpStyle = true;
             $key = substr($key, 0, -2);
         }
         if (isset($parts[1])) {
             $value = rawurldecode(str_replace('+', '%20', $parts[1]));
             if (isset($q[$key])) {
                 $q->add($key, $value);
                 $foundDuplicates = true;
             } elseif ($paramIsPhpStyleArray) {
                 $q[$key] = array($value);
             } else {
                 $q[$key] = $value;
             }
         } else {
             $q->add($key, null);
         }
     }
     // Use the duplicate aggregator if duplicates were found and not using
     // PHP style arrays.
     if ($foundDuplicates && !$foundPhpStyle) {
         $q->setAggregator(self::duplicateAggregator());
     }
     return $q;
 }

 /**
  * Parse a query string into a QueryString object
  *
  * @param string $query Query string to parse
  *
  * @return self
  */
 public static function fromString($query)
 {
     $q = new static();
     if (0 !== strlen($query)) {
         if ($query[0] == '?') {
             $query = substr($query, 1);
         }
         foreach (explode('&', $query) as $kvp) {
             $parts = explode('=', $kvp, 2);
             $key = rawurldecode($parts[0]);
             $paramIsPhpStyleArray = substr($key, -2) == '[]';
             if ($paramIsPhpStyleArray) {
                 $key = substr($key, 0, -2);
             }
             if (array_key_exists(1, $parts)) {
                 $value = rawurldecode(str_replace('+', '%20', $parts[1]));
                 if ($paramIsPhpStyleArray && !$q->hasKey($key)) {
                     $value = array($value);
                 }
                 $q->add($key, $value);
             } else {
                 $q->add($key, '');
             }
         }
     }
     return $q;
 }

 public static function request()
 {
     $class = new static();
     !Input::has('deleteShippingMethod') ?: $class->delete(Input::get('deleteShippingMethod'));
     !Input::has('updateShippingMethod') ?: $class->update(Input::get('updateShippingMethod'))->with(Input::get('shipping.fill'));
     !Input::has('addShippingMethod') ?: $class->add()->with(Input::get('shipping.fill'));
 }

 private function nextWorkingDay($current)
 {
     if ($current->format('H') < 19 && !$this->isSunday($current) && !$this->isWeekend($current) && !$this->isHoliday($current)) {
         $next = new static($current->format('Y-m-d ' . static::DEFAULT_OFFICE_CLOSE_TIME), $this->timezone);
     } else {
         $next = new static($current->format('Y-m-d ' . static::DEFAULT_OFFICE_CALL_TIME), $this->timezone);
         $i = 0;
         // We have 0 future dates to start with
         while ($i < 1) {
             $next->add(new DateInterval('P1D'));
             // Add 1 day
             if ($this->isHoliday($next)) {
                 continue;
             }
             // Don't include year to ensure the check is year independent
             // Note that you may need to do more complicated things for special holidays that don't use specific dates like "the last Friday of this month"
             if ($this->isWeekend($next)) {
                 continue;
             }
             // These next lines will only execute if continue isn't called for this iteration
             $i++;
         }
     }
     return $next;
 }

 public static function request()
 {
     $class = new static();
     $class->acton = Input::get('action');
     !Input::has('deleteSearch') ?: $class->delete(Input::get('deleteSearch'));
     $class->action != 'addSearch' ?: $class->add(Input::get('search'), Input::get('users'));
 }

 /**
  * @ignore
  */
 public static function fromFileScan($uPattern)
 {
     $tSep = quotemeta(DIRECTORY_SEPARATOR);
     $tPos = strrpos($uPattern, $tSep);
     if ($tSep !== '/' && $tPos === false) {
         $tSep = '/';
         $tPos = strrpos($uPattern, $tSep);
     }
     if ($tPos !== false) {
         $tPattern = substr($uPattern, $tPos + strlen($tSep));
         $tPath = substr($uPattern, 0, $tPos + strlen($tSep));
     } else {
         $tPath = $uPattern;
         $tPattern = "";
     }
     $tTemp = new static();
     $tHandle = new \DirectoryIterator($tPath);
     $tPatExists = strlen($uPattern) > 0;
     for (; $tHandle->valid(); $tHandle->next()) {
         if (!$tHandle->isFile()) {
             continue;
         }
         $tFile = $tHandle->current();
         if ($tPatExists && !fnmatch($tPattern, $tFile)) {
             continue;
         }
         $tTemp->add($tPath . $tFile);
     }
     return $tTemp;
 }

 public static function request()
 {
     $class = new static();
     Input::get('action') != 'addComment' ?: $class->add(Input::all());
     !Input::has('hideComment') ?: $class->hide(head(Input::get('hideComment', [])));
     !Input::has('unhideComment') ?: $class->unhide(head(Input::get('unhideComment', [])));
     !Input::has('deleteComment') ?: $class->delete(head(Input::get('deleteComment', [])));
 }

 /**
  * @param string $type_
  *
  * @return \Components\Object_Properties
  */
 public static function forType($type_)
 {
     $instance = new static($type_);
     foreach (self::arrayForType($type_) as $property) {
         $instance->add($property['name'], $property['type'], $property['nameMapped'], $property['typeMapped']);
     }
     return $instance;
 }

 /**
  * @param array $strings
  *
  * @return static
  */
 public static function fromArray(array $strings)
 {
     $list = new static();
     foreach ($strings as $oneString) {
         $list->add($oneString);
     }
     return $list;
 }

 /**
  * convenience method to create a simple failure report
  * 
  * @param string $message
  * @param mixed $errors
  * @return common_report_Report
  */
 public static function createFailure($message, $errors = array())
 {
     $report = new static(self::TYPE_ERROR, $message);
     foreach ($errors as $error) {
         $report->add($error);
     }
     return $report;
 }

 public static function fromConfig($config)
 {
     $collection = new static();
     foreach ($config as $key => $config) {
         $collection->add($key, $config);
     }
     return $collection;
 }

 /**
  * A handy starter for creating a button group with buttons.
  * @param array $buttons
  * @return ButtonGroup
  */
 public static function build(array $buttons = [])
 {
     $group = new static();
     foreach ($buttons as $button) {
         $group->add($button);
     }
     return $group;
 }

 /**
  * @param  CommandInterface $cmd
  * @return ResponseCollection
  */
 public function getCommandResult(CommandInterface $cmd)
 {
     $collection = new static();
     foreach (new ResponseFilterIterator($this, $cmd) as $response) {
         $collection->add($response);
     }
     return $collection;
 }

 /**
  * Construct the result based on the given xml.
  * @param SimpleXMLElement $xmlElement
  * @return \CultuurNet\Search\SuggestionsResult
  */
 public static function fromXml(SimpleXMLElement $xmlElement)
 {
     $result = new static();
     foreach ($xmlElement->xpath('//suggestion') as $xmlSuggestion) {
         $result->add(SuggestionsItem::fromXml($xmlSuggestion));
     }
     return $result;
 }

 public static function createRandomProducts($numberOfProducts = 1)
 {
     $collection = new static();
     for ($i = $numberOfProducts; $i > 0; $i--) {
         $collection->add(new Product());
     }
     return $collection;
 }