| <?php |
| /** |
| * File containing the ezcWebdavBasicPropertyStorage class. |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| * @package Webdav |
| * @version //autogen// |
| * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0 |
| */ |
| /** |
| * Container class for ezcWebdavProperty objects. |
| * |
| * An instance of this class is used to manage WebDAV properties, namely |
| * instances of {@link ezcWebdavProperty}. Properties are structured by their |
| * name and the namespace they reside in. |
| * |
| * @package Webdav |
| * @version //autogen// |
| */ |
| class ezcWebdavBasicPropertyStorage implements ezcWebdavPropertyStorage |
| { |
| /** |
| * Stores the WebDAV properties. |
| * |
| * The structure of this array is: |
| * <code> |
| * array( |
| * 'DAV:' => array( |
| * '<live property name>' => ezcWebdavLiveProperty, |
| * // ... |
| * ), |
| * '<another namespace URI>'array( |
| * '<dead property name>' => ezcWebdavDeadProperty, |
| * // ... |
| * ), |
| * // ... |
| * ) |
| * </code> |
| * |
| * @var array |
| */ |
| protected $properties = array(); |
| |
| /** |
| * Stores a list of the assigned properties in the order they were |
| * assigned, to make this order accessible for the Iterator. |
| * |
| * @var array |
| */ |
| protected $propertyOrder = array(); |
| |
| /** |
| * Current position of the iterator in the ordered property list. |
| * |
| * @var int |
| */ |
| protected $propertyOrderPosition = 0; |
| |
| /** |
| * Next ID for a element in the ordered property list, to generate valid |
| * IDs even when some contents has been removed. |
| * |
| * @var int |
| */ |
| protected $propertyOrderNextId = 0; |
| |
| /** |
| * Attaches a property to the storage. |
| * |
| * Adds the given $property to the storage. The property can later be |
| * accessed by its name in combination with the namespace through the |
| * {@link get()} method. Live properties (and only these) reside in the |
| * namespace DAV:, which is the default for all accessor methods. |
| * |
| * If a property with the same namespace and name is already contained in |
| * the storage, it will be overwritten. |
| * |
| * @param ezcWebdavProperty $property |
| * @return void |
| */ |
| public function attach( ezcWebdavProperty $property ) |
| { |
| $namespace = $property->namespace; |
| $name = $property->name; |
| |
| // Update list of ordered properties |
| if ( !isset( $this->properties[$namespace] ) || |
| !isset( $this->properties[$namespace][$name] ) ) |
| { |
| $this->propertyOrder[$this->propertyOrderNextId++] = array( $namespace, $name ); |
| } |
| |
| // Add property |
| $this->properties[$namespace][$name] = $property; |
| } |
| |
| /** |
| * Detaches a property from the storage. |
| * |
| * Removes the property with the given $name and $namespace from the |
| * storage. If the property does not exist in the storage, the call is |
| * silently ignored. If no $namespace is given, the default namespace for |
| * live properties ('DAV:') is used. |
| * |
| * @param string $name |
| * @param string $namespace |
| * @return void |
| */ |
| public function detach( $name, $namespace = 'DAV:' ) |
| { |
| if ( isset( $this->properties[$namespace] ) && |
| isset( $this->properties[$namespace][$name] ) ) |
| { |
| unset( $this->properties[$namespace][$name] ); |
| } |
| } |
| |
| /** |
| * Returns if the given property exists in the storage. |
| * |
| * Returns if the property with the given $name and $namespace is contained |
| * in the storage. If the $namespace parameter is omited, the default live |
| * property namespace ('DAV:') is used. |
| * |
| * @param string $name |
| * @param string $namespace |
| * @return bool |
| */ |
| public function contains( $name, $namespace = 'DAV:' ) |
| { |
| return isset( $this->properties[$namespace][$name] ); |
| } |
| |
| /** |
| * Returns a property from the storage. |
| * |
| * Returns the property with the given $name and $namespace. If the |
| * $namespace parameter is omitted, the default live property namespace |
| * ('DAV:') namespace is used. If the desired property is not contained in |
| * the storage, null is returned. |
| * |
| * @param string $name |
| * @param string $namespace |
| * @return ezcWebdavProperty|null |
| */ |
| public function get( $name, $namespace = 'DAV:' ) |
| { |
| if ( isset( $this->properties[$namespace][$name] ) ) |
| { |
| return $this->properties[$namespace][$name]; |
| } |
| return null; |
| } |
| |
| /** |
| * Returns all properties of a given namespace. |
| * |
| * The returned array is indexed by the property names. Live properties can |
| * be accessed by simply ommiting the $namespace parameter, since then the |
| * default namespace for live properties ('DAV:') is used. |
| * |
| * @param string $namespace |
| * @return array(string=>ezcWebdavProperty) |
| */ |
| public function getProperties( $namespace = 'DAV:' ) |
| { |
| if ( !isset( $this->properties[$namespace] ) ) |
| { |
| return array(); |
| } |
| return $this->properties[$namespace]; |
| } |
| |
| /** |
| * Returns all properties contained in the storage. |
| * |
| * Returns the complete array stored in {@link $properties}. |
| * |
| * @return array(string=>array(string=>ezcWebdavProperty)) |
| */ |
| public function getAllProperties() |
| { |
| return $this->properties; |
| } |
| |
| /** |
| * Diff two property storages. |
| * |
| * Returns a property storage, which does only contain properties that are |
| * not present in the $properties parameter. |
| * |
| * @param ezcWebdavPropertyStorage $properties |
| * @return ezcWebdavBasicPropertyStorage |
| */ |
| public function diff( ezcWebdavPropertyStorage $properties ) |
| { |
| $foreign = $properties->getAllProperties(); |
| |
| $diffedProperties = new ezcWebdavBasicPropertyStorage(); |
| foreach ( $this->properties as $namespace => $properties ) |
| { |
| foreach ( $properties as $name => $property ) |
| { |
| if ( !isset( $foreign[$namespace][$name] ) ) |
| { |
| // Only add properties to new property storage, which could |
| // not be found in the foreign property storage. |
| $diffedProperties->attach( $property ); |
| } |
| } |
| } |
| |
| return $diffedProperties; |
| } |
| |
| /** |
| * Intersects between two property storages. |
| * |
| * Calculate and return an instance of {@link |
| * ezcWebdavBasicPropertyStorage} which contains the intersection of two |
| * property storages. This means a new property storage will be return |
| * which contains all values, which are present in the current and the |
| * given $properties property storage. |
| * |
| * @param ezcWebdavPropertyStorage $properties |
| * @return ezcWebdavBasicPropertyStorage |
| */ |
| public function intersect( ezcWebdavPropertyStorage $properties ) |
| { |
| $foreign = $properties->getAllProperties(); |
| |
| $intersection = new ezcWebdavBasicPropertyStorage(); |
| foreach ( $this->properties as $namespace => $properties ) |
| { |
| foreach ( $properties as $name => $property ) |
| { |
| if ( isset( $foreign[$namespace][$name] ) ) |
| { |
| // Only add properties to new property storage, which could |
| // be found in both property storages. |
| $intersection->attach( $property ); |
| } |
| } |
| } |
| |
| return $intersection; |
| } |
| |
| /* |
| * Methods required for Countable |
| */ |
| |
| /** |
| * Return property count. |
| * |
| * Implementation required by interface Countable. Count the numbers of |
| * items contained by the instance. Will return the overall item count |
| * ignoring different namespaces. |
| * |
| * @return int |
| */ |
| public function count() |
| { |
| $count = 0; |
| foreach ( $this->properties as $properties ) |
| { |
| $count += count( $properties ); |
| } |
| |
| return $count; |
| } |
| |
| /** |
| * Methods required for Iterator |
| */ |
| |
| /** |
| * Implements current() for Iterator. |
| * |
| * Returns the currently selected element during iteration with foreach. |
| * |
| * @return ezcWebdavProperty |
| */ |
| public function current() |
| { |
| list( $namespace, $name ) = $this->propertyOrder[$this->propertyOrderPosition]; |
| |
| // Skip detached properties |
| while ( !isset( $this->properties[$namespace][$name] ) ) |
| { |
| if ( !isset( $this->propertyOrder[++$this->propertyOrderPosition] ) ) |
| { |
| // We reached the end. |
| return false; |
| } |
| |
| list( $namespace, $name ) = $this->propertyOrder[$this->propertyOrderPosition]; |
| } |
| |
| return $this->properties[$namespace][$name]; |
| } |
| |
| /** |
| * Implements key() for Iterator |
| * |
| * Returns the key of the currently selected element during iteration with |
| * foreach. |
| * |
| * @return int |
| */ |
| public function key() |
| { |
| return $this->propertyOrderPosition; |
| } |
| |
| /** |
| * Implements next() for Iterator |
| * |
| * Advances the internal pointer to the next element during iteration with |
| * foreach. |
| * |
| * @return mixed |
| */ |
| public function next() |
| { |
| ++$this->propertyOrderPosition; |
| } |
| |
| /** |
| * Implements rewind() for Iterator |
| * |
| * Resets the internal pointer to the first element before iteration with |
| * foreach. |
| * |
| * @return void |
| */ |
| public function rewind() |
| { |
| $this->propertyOrderPosition = 0; |
| } |
| |
| /** |
| * Implements valid() for Iterator |
| * |
| * Returns if the internal pointer still points to a valid element when |
| * iteration with foreach. If this method returns false, iteration ends. |
| * |
| * @return boolean |
| */ |
| public function valid() |
| { |
| do |
| { |
| if ( !isset( $this->propertyOrder[$this->propertyOrderPosition] ) ) |
| { |
| // We reached the end. |
| return false; |
| } |
| |
| list( $namespace, $name ) = $this->propertyOrder[$this->propertyOrderPosition]; |
| |
| if ( isset( $this->properties[$namespace][$name] ) ) |
| { |
| // Found next valid property |
| return true; |
| } |
| ++$this->propertyOrderPosition; |
| } |
| while ( !isset( $this->properties[$namespace][$name] ) ); |
| |
| return true; |
| } |
| |
| /** |
| * Clones the property storage deeply. |
| * |
| * @return void |
| */ |
| public function __clone() |
| { |
| foreach ( $this->properties as $namespace => $props ) |
| { |
| foreach ( $props as $name => $prop ) |
| { |
| $this->properties[$namespace][$name] = clone $prop; |
| } |
| } |
| } |
| } |
| |
| ?> |