Remove a $property from Template
@param array $property
@return Properties
424838
public function removeProperty($property) {
        foreach (array_keys($this->optionalProperties, $property) as $key) {
            unset($this->optionalProperties[$key]);
        }
        return $this->optionalProperties;
    }
1230924
protected function filterNotSavedProperties(array $properties)
    {
        foreach ($this->getMetadata()->getRelationships() as $fieldKey => $propMeta) {
            if (true === $propMeta->shouldSave() || !isset($properties[$fieldKey])) {
                continue;
            }
            unset($properties[$fieldKey]);
        }
        return parent::filterNotSavedProperties($properties);
    }
1341489
public function removePropertyValues( core_kernel_classes_Property $property, $options = array())
    {
        $returnValue = (bool) false;
        $returnValue = $this->getImplementation()->removePropertyValues($this, $property, $options);
        $this->onUpdate();
        return (bool) $returnValue;
    }
588373
public function unassign($property)
	{
		if (null === $this->object)
		{
			$this->object = new Object;
		}

		$this->object->unassign($property);

		return $this;
	}
329312
public function set($property, $value = null)
    {
        if (is_array($property)) {
            foreach ($property as $k => $v) {
                $this->set($k, $v);
            }

            return $this;
        }

        if ($this->has($property)) {
            $method = 'set' . Str::studly($property);
            $value  = $this->sanitizeSetterValue($method, $value);

            $this->message->{$method}($value);
        }

        return $this;
    }
648048
public function unindex($property, $class = null)
    {
        $commandClass = $this->getCommandClass('index.drop');
        $this->command = new $commandClass($property, $class);

        return $this->command;
    }
758363
public function setClean($property = null)
    {
        if ($property === null) {
            $this->_dirty = [];
        } else {
            unset($this->_dirty[$property]);
        }

        return $this;
    }
208529
public function &__get($property)
    {
        $get[ $property ] = false;

        if (property_exists($this, $property)) {
            return $this->{$property};
        }

        return $get[ $property ];
    }
1156205
public function removeValidation($property, $validation)
    {
        $validations = $this->getValidations($property);
        unset($validations[$validation]);

        return $this;
    }
1031066
public static function create($object, $property)
    {
        $template = 'Property \'%s\' does not exist in instance of class \'%s\'. Did you use proper name of property?';
        $message = sprintf($template, $property, get_class($object));

        return new static($message);
    }
765954
public function setProperties(array $properties) {
		foreach ($this->properties as $prop) {
			$prop->setParent(null);
		}

		$this->properties->clear();

		foreach ($properties as $prop) {
			$this->setProperty($prop);
		}

		return $this;
	}
328184
public function setProperties(array $properties = null)
    {
        ValidationUtility::ensureNullOrArrayOfType(
            '$properties', $properties, __NAMESPACE__ . '\Property');

        $this->properties = $properties;

        return $this;
    }
234831
private function getKeyValueProperty($property)
    {
        $result = array();

        // extract key/value pairs
        $valuePairs = explode(',', $property);
        foreach ($valuePairs as $valuePair) {
            // extract key/value of a single value
            $keyValue = explode(':', $valuePair);

            // key and value must be present
            if (!isset($keyValue[1]) || !isset($keyValue[0])) {
                continue;
            }

            $key = trim($keyValue[0]);
            $value = trim($keyValue[1]);

            // key and value must be present
            if (!strlen($key) || !strlen($value)) {
                continue;
            }

            $result[$key] = $value;
        }

        return $result;
    }
719144
public function get($property)
    {
        $value = null;

        if ($this->_convert) {
            $property = str_replace( "_", "-", $property );
        } else {
            $property = str_replace( "-", "_", $property );
        }

        if (array_key_exists($property, $this->_values)) {
            return $this->_values[$property];
        } else {
            return null;
        }

    }
817524
public function removeAllProperties(array $exclusions = [])
    {
        $this->parseStyleAttribute();

        $preservedProperties = [];

        foreach ($exclusions as $propertyName) {
            if (!is_string($propertyName)) {
                throw new InvalidArgumentException(sprintf('Property name must be a string, %s given', (is_object($propertyName) ? get_class($propertyName) : gettype($propertyName))));
            }

            if (!array_key_exists($propertyName, $this->properties)) {
                continue;
            }

            $preservedProperties[$propertyName] = $this->properties[$propertyName];
        }

        $this->properties = $preservedProperties;

        $this->updateStyleAttribute();

        return $this;
    }
394219
public static function indexBy(Array $array, $property) {
    $ret = array();

    if (count($array) > 0) {
      $index = Util::castGetterFromSample($property, current($array));

      foreach ($array as $item) {
        $ret[$index($item)] = $item;
      }
    }

    return $ret;
  }
977245
public function removeMeta($property)
    {
        foreach(static::$storage as $i => $meta) {
            if($meta->getProperty() == $property) {
                unset(static::$storage[$i]);
                return true;
            }
        }

        return false;
    }