PHP Map::set方法代码示例

 /** @test */
 public function setAssignsNewValue()
 {
     $map = new Map(array('foo' => 'bar'));
     $map->set('foo', 'baz');
     $this->assertEquals('baz', $map->get('foo'));
     $map->set('ping', 'pong');
     $this->assertEquals('pong', $map->get('ping'));
 }

 /**
  * In PHP, float and boolean keys are truncated to integers, thus if you
  * want to store $a[1] and $a[1.0], you can't, without hashing the key
  * yourself. Map does not behave this way: these are distinct keys.
  *
  * @see http://php.net/manual/en/language.types.array.php
  */
 public function test_key_normalization()
 {
     $map = new Map();
     $map->set(true, 'foo');
     $map->set(1, 'bar');
     $map->set(1.0, 'baz');
     $this->assertCount(3, $map);
 }

 /**
  * Loads the list from a sql query.
  *
  * @param Recipe_Database_Statement_Abstract $result	Result set
  * @param integer $start	Rank/Counter start
  *
  * @return Bengine_Game_Alliance_List
  */
 public function load($result, $start = 0)
 {
     foreach ($result->fetchAll() as $row) {
         $row["counter"] = $start;
         $start++;
         $row["rank"] = $start;
         $row = $this->formatRow($row);
         $key = !is_null($this->key) ? (int) $row[$this->key] : $start;
         $this->list->set($key, $row);
     }
     $result->closeCursor();
     return $this;
 }

 /**
  * Set the value at a given key, provided that the value passes the
  * defined guard. Optionally, normalize the value before setting.
  *
  * {@inheritDoc}
  * @throws \UnexpectedValueException
  */
 public function set($key, $value)
 {
     $result = $this->allowed($value);
     if ($this->passes($result)) {
         parent::set($key, $this->normalize($value));
     } else {
         throw new \UnexpectedValueException(sprintf('Value of type "%s" forbidden in this instance of %s', gettype($value), get_class($this)));
     }
 }

 private static function toCollection($data)
 {
     if (is_object($data)) {
         $map = new Map();
         foreach ($data as $k => $v) {
             if (is_object($v) || is_array($v)) {
                 $map->set($k, self::toCollection($v));
             } else {
                 $map->set($k, $v);
             }
         }
         return $map;
     } else {
         if (is_array($data)) {
             $list = new ArrayList();
             foreach ($data as $v) {
                 $list->add(is_object($v) || is_array($v) ? self::toCollection($v) : $v);
             }
             return $list;
         }
     }
 }

 /**
  * @dataProvider provider__construct
  */
 public function test_set($base, $diff)
 {
     $map = new Map($base);
     foreach ($base as $key => $value) {
         $this->assertEquals($map->get($key), $value);
     }
     foreach ($diff as $key => $value) {
         $map->set($key, $value);
         $base[$key] = $value;
     }
     foreach ($base as $key => $value) {
         $this->assertEquals($map->get($key), $value);
     }
 }

 /**
  * Put something in the map
  *
  * @param int|string $key   The key. Strings that are ints are cast to ints.
  * @param mixed      $value The value to cache
  *
  * @return LRUMap
  */
 public function set($key, $value)
 {
     if (parent::get($key)->isDefined()) {
         parent::set($key, $value);
         $this->recordAccess($key);
     } else {
         parent::set($key, $value);
         if ($this->length() > $this->maximumSize) {
             // remove least recently used element (front of array)
             reset($this->elements);
             unset($this->elements[key($this->elements)]);
         }
     }
     return $this;
 }

 /**
  * Loads the alliance relations.
  *
  * @return Bengine_Game_User_Relation
  */
 protected function loadAllianceRelations()
 {
     if ($this->alliancesLoaded) {
         return $this;
     }
     $select = array("ar.rel1", "ar.rel2", "ar.mode", "rt.acs", "rt.name", "rt.css");
     $joins = "LEFT JOIN " . PREFIX . "ally_relationship_type rt ON (rt.type_id = ar.mode)";
     $where = Core::getDB()->quoteInto("(ar.rel1 = ? OR ar.rel2 = ?)", $this->aid);
     $result = Core::getQuery()->select("ally_relationships ar", $select, $joins, $where);
     foreach ($result->fetchAll() as $row) {
         $rel = $row["rel1"] == $this->aid ? $row["rel2"] : $row["rel1"];
         $data = new stdClass();
         $data->mode = $row["mode"];
         $data->css = $row["css"];
         $data->name = $row["name"];
         $data->acs = $row["acs"];
         $this->alliances->set($rel, $data);
     }
     $result->closeCursor();
     $this->alliancesLoaded = true;
     Hook::event("AllianceRelationsLoaded", array(&$this->alliances));
     return $this;
 }

 /**
  * @param callable $fn
  *
  * @return Map
  */
 public function map($fn)
 {
     $map = new Map();
     foreach ($this->data as $data) {
         $map->set($data['offset'], $fn($data['value'], $data['offset']));
     }
     return $map;
 }

 public function testKeysLocked()
 {
     $map = new Map(['foo6' => 'bar6'], true);
     $success = false;
     try {
         $map->set('foo7', 'bar7');
     } catch (\RuntimeException $e) {
         $success = true;
     }
     $this->assertTrue($success);
     $this->assertTrue($map->remove('foo6')->has('foo6'));
     $this->assertEquals('bar6', $map->set('foo6', 'bar6')->get('foo6'));
     $this->assertEquals(['foo6' => null], $map->clear()->toArray());
 }

 public static function add($a, $b, $options = null)
 {
     $out = new Map($a->lines, $a->columns, $options);
     $map_a = $a->map();
     $map_b = $b->map();
     $l_start = 0;
     $c_start = 0;
     $transparent = false;
     if (!$options) {
         $options = $b->options;
     }
     if ($options) {
         foreach ($options as $key => $value) {
             ${$key} = $value;
         }
     }
     for ($l = $l_start; $l < $a->lines; $l++) {
         if (!isset($map_b[$l])) {
             for ($c = $c_start; $c < $a->columns; $c++) {
                 $out->set($l, $c, $map_a[$l][$c]);
             }
         } else {
             for ($c = $c_start; $c < $a->columns; $c++) {
                 if (isset($map_b[$l][$c])) {
                     $bc = $map_b[$l][$c];
                     if ($bc != $transparent) {
                         $out->set($l, $c, $bc);
                     } else {
                         $out->set($l, $c, $map_a[$l][$c]);
                     }
                 } else {
                     $out->set($l, $c, $map_a[$l][$c]);
                 }
             }
         }
     }
     return $out;
 }

 /**
  * Puts the given key-value pair into the map.
  * @param mixed $key
  * @param mixed $value
  * @throws \InvalidArgumentException if $value is not numeric
  */
 public function set($key, $value)
 {
     $this->assertIsNumeric($value);
     parent::set($key, $value);
 }