PHP false::load_many_for_cache方法代码示例

 /**
  * Retrieves an array of values for an array of keys.
  *
  * Using this function comes with potential performance implications.
  * Not all cache stores will support get_many/set_many operations and in order to replicate this functionality will call
  * the equivalent singular method for each item provided.
  * This should not deter you from using this function as there is a performance benefit in situations where the cache store
  * does support it, but you should be aware of this fact.
  *
  * @param array $keys The keys of the data being requested.
  *      Each key can be any structure although using a scalar string or int is recommended in the interests of performance.
  *      In advanced cases an array may be useful such as in situations requiring the multi-key functionality.
  * @param int $strictness One of IGNORE_MISSING or MUST_EXIST.
  * @return array An array of key value pairs for the items that could be retrieved from the cache.
  *      If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown.
  *      Otherwise any key that did not exist will have a data value of false within the results.
  * @throws coding_exception
  */
 public function get_many(array $keys, $strictness = IGNORE_MISSING)
 {
     $keysparsed = array();
     $parsedkeys = array();
     $resultpersist = array();
     $resultstore = array();
     $keystofind = array();
     // First up check the persist cache for each key.
     $isusingpersist = $this->is_using_persist_cache();
     foreach ($keys as $key) {
         $pkey = $this->parse_key($key);
         $keysparsed[$key] = $pkey;
         $parsedkeys[$pkey] = $key;
         $keystofind[$pkey] = $key;
         if ($isusingpersist) {
             $value = $this->get_from_persist_cache($pkey);
             if ($value !== false) {
                 $resultpersist[$pkey] = $value;
                 unset($keystofind[$pkey]);
             }
         }
     }
     // Next assuming we didn't find all of the keys in the persist cache try loading them from the store.
     if (count($keystofind)) {
         $resultstore = $this->store->get_many(array_keys($keystofind));
         // Process each item in the result to "unwrap" it.
         foreach ($resultstore as $key => $value) {
             if ($value instanceof cache_ttl_wrapper) {
                 if ($value->has_expired()) {
                     $value = false;
                 } else {
                     $value = $value->data;
                 }
             }
             if ($value instanceof cache_cached_object) {
                 $value = $value->restore_object();
             }
             if ($value !== false && $this->is_using_persist_cache()) {
                 $this->set_in_persist_cache($key, $value);
             }
             $resultstore[$key] = $value;
         }
     }
     // Merge the result from the persis cache with the results from the store load.
     $result = $resultpersist + $resultstore;
     unset($resultpersist);
     unset($resultstore);
     // Next we need to find any missing values and load them from the loader/datasource next in the chain.
     $usingloader = $this->loader !== false;
     $usingsource = !$usingloader && $this->datasource !== false;
     if ($usingloader || $usingsource) {
         $missingkeys = array();
         foreach ($result as $key => $value) {
             if ($value === false) {
                 $missingkeys[] = $parsedkeys[$key];
             }
         }
         if (!empty($missingkeys)) {
             if ($usingloader) {
                 $resultmissing = $this->loader->get_many($missingkeys);
             } else {
                 $resultmissing = $this->datasource->load_many_for_cache($missingkeys);
             }
             foreach ($resultmissing as $key => $value) {
                 $result[$keysparsed[$key]] = $value;
                 if ($value !== false) {
                     $this->set($key, $value);
                 }
             }
             unset($resultmissing);
         }
         unset($missingkeys);
     }
     // Create an array with the original keys and the found values. This will be what we return.
     $fullresult = array();
     foreach ($result as $key => $value) {
         $fullresult[$parsedkeys[$key]] = $value;
     }
     unset($result);
     // Final step is to check strictness.
     if ($strictness === MUST_EXIST) {
         foreach ($keys as $key) {
//.........这里部分代码省略.........