Remove meta

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

        return false;
    }
1116249
public function removeWhere($property, $value)
    {
        $results = array();
        foreach ($this->objects as $key => $obj) {
            if ($obj->{$property} === $value) {
                $this->deletedObjects[] = $this->objects[$key];
                $results[] = $this->objects[$key];
                unset($this->objects[$key]);
                $this->numObjects--;
            }
        }
        $this->objects = array_values($this->objects);
        return $results;
    }
1156205
public function removeValidation($property, $validation)
    {
        $validations = $this->getValidations($property);
        unset($validations[$validation]);

        return $this;
    }
870409
public function __isset($property)
    {
        if (null !== $this->findProperty($property)) {
            return true;
        } else {
            return isset($this->$property);
        }
    }
1220886
public function remove($property) {

		$property = trim(strtolower($property));

		unset($this->css[$property]);
		
		return $this;
	}
197660
public function dec($property, $value = 1) {
		if (isset($this->_data[$property])) {
			$this->_data[$property] -= $value;
		} else {
			$this->_data[$property] =- $value;
		}
		
		$this->_changed[$property] = true;
		
		return $this->_data[$property];
	}
561366
protected function reFormatForCompatibility($property)
    {
        switch (true) {
            case ($property == 'header'):
                $property = 'context';
                break;

            case ($property == 'stack'):
                $property = 'stack_traces';
                break;

            case ($property == 'filePath'):
                $property = 'file_path';
                break;

            default:
                # code...
                break;
        }

        return $property;
    }
319682
public function isModified($property = null)
    {
        $result = false;

        if($property)
        {
            if (isset($this->_modified[$property]) && $this->_modified[$property]) {
                $result = true;
            }
        }
        else $result = (bool) count($this->_modified);

        return $result;
    }
976447
public function replaceWith($properties)
    {
        $removed = array_diff(array_keys($this->_values), array_keys($properties));
        foreach ($removed as $k) {
            unset($this->$k);
        }

        foreach ($properties as $k => $v) {
            $this->$k = $v;
        }
    }
565672
public function isModified(string $property) : bool
    {
        if (!isset($this->__state->$property) && isset($this->__initial->$property)) {
            return true;
        }
        if (isset($this->__state->$property) && !isset($this->__initial->$property)) {
            return true;
        }
        if ($this->__state->$property != $this->__initial->$property) {
            return true;
        }
        return false;
    }
594252
public function isMetaProperty($property) {
    if (array_key_exists($property->getName(), $this->forcedMetaProperties)) return $this->forcedMetaProperties[$property->getName()];
    
    return TRUE;
  }
165228
public function delete($metadata = array())
    {
        $this->setMetadata($metadata);

        return $this->filesystem->delete($this->key);
    }
920876
public function shouldSkipProperty(PropertyMetadata $property)
    {
        if ((null !== $version = $property->getSinceVersion()) && version_compare($this->version, $version, '<')) {
            return true;
        }

        if ((null !== $version = $property->getUntilVersion()) && version_compare($this->version, $version, '>')) {
            return true;
        }

        return false;
    }
1345396
protected function hasProperty($property, ClassMetadataInfo $metadata)
    {
        if ($this->extendsClass() || (!$this->isNew && class_exists($metadata->name))) {
            // don't generate property if its already on the base class.
            $reflClass = new \ReflectionClass($this->getClassToExtend() ?: $metadata->name);
            if ($reflClass->hasProperty($property)) {
                return true;
            }
        }

        // check traits for existing property
        foreach ($this->getTraits($metadata) as $trait) {
            if ($trait->hasProperty($property)) {
                return true;
            }
        }

        return (
            isset($this->staticReflection[$metadata->name]) &&
            in_array($property, $this->staticReflection[$metadata->name]['properties'])
        );
    }
491759
public function isValidProperty(string $property)
    {
        if (!empty($this->validProperties) && !array_key_exists($property, $this->validProperties)) {
            return false;
        }

        return true;
    }
566292
function delete_meta($meta_key) {
		return $this->edit_meta( $meta_key, function($id, $key, $path) {
			if ( $path ) {
				# Patch -- XXX unserialize and count up?
				$old = static::_get_meta($id, $key);
				if ( $old === false ) $old = array();
				$traverser = new RecursiveDataStructureTraverser($old);
				while ( $path ) {
					# nothing to delete?
					if ( ! $traverser->exists($path[0]) ) return;
					$traverser = $traverser->traverse_to(array($path[0]));
					array_shift($path);
				}
				$traverser->unset_on_parent();
				static::_set_meta($id, $key, $old);  # XXX reserialize and count down?
			} else {
				static::_delete_meta($id, $key);
			}
		});
	}
1218495
public function removeMeta(PostMeta $meta)
    {
        if ($this->metas->contains($meta)) {
            $this->metas->remove($meta);
        }

        return $this;
    }