remove a single triple with this subject and predicate

@access public
@author Joel Bout, <joel.bout@tudor.lu>
@param  Property property
@param  mixed value
@return boolean
761778
public function removePropertyValue( core_kernel_classes_Property $property, $value)
    {
        $returnValue = (bool) false;
        $returnValue = $this->getImplementation()->removePropertyValues($this, $property, array(
        	'pattern'	=> (is_object($value) && $value instanceof self ? $value->getUri() : $value),
        	'like'		=> false 
        ));
        $this->onUpdate();
        return (bool) $returnValue;
    }
1021690
public function removeValue($value, array &$array): bool
    {
        if (false !== ($intPosition = array_search($value, $array))) {
            unset($array[$intPosition]);

            return true;
        }

        return false;
    }
424838
public function removeProperty($property) {
        foreach (array_keys($this->optionalProperties, $property) as $key) {
            unset($this->optionalProperties[$key]);
        }
        return $this->optionalProperties;
    }
1312150
public function add($property, $value)
	{
		if ('_' == substr($property, 0, 1))
		{
			$this->setError("Can't access private properties");
			return false;
		}

		if (property_exists(__CLASS__, $property) || property_exists(__CLASS__, '_auxs_' . $property))
		{
			$this->setError("Can't add value(s) to non-array property.");
			return false;
		}

		if (!property_exists(__CLASS__, '_auxv_' . $property))
		{
			$this->setError("Unknown property: $property");
			return false;
		}

		if (empty($value))
		{
			return true;
		}

		if (!is_array($value))
		{
			$value = array($value);
		}

		$property = '_auxv_' . $property;

		foreach ($value as $v)
		{
			$v = strval($v);

			if (!in_array($v, $this->$property))
			{
				array_push($this->$property, $v);
			}
		}

		sort($this->$property);

		return true;
	}
7218
public function remove($value): bool
    {
        if (!isset($this->hashMap[$value])) {
            return false;
        }

        unset($this->hashMap[$value]);

        return true;
    }
577221
public function set($property, $value = null)
        {
            $this->One->set($property, $value);

            return $this;
        }
862755
def delete_triple(self, subject, predicate, object):
        

        def filter_ontid(ontid):
            if ontid.startswith('http://'):
                pass
            elif ontid.prefix == 'ILXTEMP':
                ontid = 'tmp_' + ontid.suffix
            else:
                ontid = 'ilx_' + ontid.suffix
            return ontid

        # this split between annotations and relationships is severely annoying
        # because you have to know before hand which one it is (sigh)
        s = OntId(subject)
        p = OntId(predicate)
        o = self._get_type(object)
        if type(o) == str:
            func = self.ilx_cli.delete_annotation
        elif type(o) == OntId:
            func = self.ilx_cli.delete_relationship
            o = filter_ontid(o)
        else:
            raise TypeError(f'what are you giving me?! {object!r}')

        s = filter_ontid(s)
        p = filter_ontid(p)

        # TODO: check if add_relationship works
        resp = func(s, p, o)
        return resp
1161336
private function addPropertyToObject(Property $property, array &$object, $value)
    {
        $propertyName = $property->getName();
        if ($property->isArray()) {
            $keys = explode('.', $propertyName);
            $objectProp = array_pop($keys);
            $value = array_map(function ($value) use ($objectProp) {
                $object = [];
                $object[$objectProp] = $value;

                return $object;
            }, explode(',', $value));

            $propertyName = implode('.', $keys);
        }

        if ('integer' === $property->getType()) {
            $value = (int) $value;
        }

        if ('boolean' === $property->getType()) {
            $value = (bool) $value;
        }

        ArrayUtils::set($object, $propertyName, $value);
    }
911708
public static function hasValue($subject, $property, $value) {
    $rval = false;
    if(self::hasProperty($subject, $property)) {
      $val = $subject->{$property};
      $is_list = self::_isList($val);
      if(is_array($val) || $is_list) {
        if($is_list) {
          $val = $val->{'@list'};
        }
        foreach($val as $v) {
          if(self::compareValues($value, $v)) {
            $rval = true;
            break;
          }
        }
      } else if(!is_array($value)) {
        // avoid matching the set of values with an array value parameter
        $rval = self::compareValues($value, $val);
      }
    }
    return $rval;
  }
513971
public static function config($property, $value)
    {
        switch ($property) {
            case 'excludeShortcodes':
                self::$excludedShortcodes = [];

                if (!is_array($value)) {
                    $value = [$value];
                }

                foreach ($value as $code) {
                    if (is_string($code)) {
                        self::$excludedShortcodes[] = $code;
                    }
                }

                // Invalidate shortcode cache
                self::$shortcodes = [];
                break;
        }
    }
977245
public function removeMeta($property)
    {
        foreach(static::$storage as $i => $meta) {
            if($meta->getProperty() == $property) {
                unset(static::$storage[$i]);
                return true;
            }
        }

        return false;
    }
1220886
public function remove($property) {

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

		unset($this->css[$property]);
		
		return $this;
	}
732202
public static function prop($value, $chain)
    {
        if (empty($chain)) {
            throw new \InvalidArgumentException("Value property name cannot be empty.");
        }

        if (!is_string($chain)) {
            throw new \InvalidArgumentException(sprintf(
                "Value property name must be a string, %s given.",
                gettype($chain)
            ));
        }

        $chain = explode('.', $chain);
        foreach ($chain as $property) {
            if (is_object($value)) {
                $getter = 'get' . ucfirst($property);
                if (is_callable(array($value, $getter))) {
                    $value = $value->$getter();
                } elseif (isset($value->{$property})) {
                    $value = $value->{$property};
                } else {
                    return null;
                }
            } elseif (Arrays::isArray($value)) {
                if (!isset($value[$property])) {
                    return null;
                }
                $value = $value[$property];
            } elseif (is_null($value)) {
                return null;
            } else {
                throw new \InvalidArgumentException(sprintf(
                    "Value property '%s' in chain '%s' has invalid type: '%s'.",
                    $property,
                    $chain,
                    gettype($value)
                ));
            }
        }

        return $value;
    }
320978
public void removeByValue(Object value)
    {
        Object key = valueTable.remove(value);
        if (key != null)
        {
            keyTable.remove(key);
        }
    }
60156
public function set($property, $value = null)
	{
		if ($property == 'password')
		{
			if ($value != '')
			{
				$this->userPassword = \Hubzero\User\Password::getPasshash($value);
			}
			else
			{
				$this->userPassword = '';
			}

			$this->_password = $value;

			return true;
		}

		if ('_' == substr($property, 0, 1))
		{
			$this->setError("Can't access private properties");
			return false;
		}

		if (!property_exists(__CLASS__, $property))
		{
			if (property_exists(__CLASS__, '_auxs_' . $property))
			{
				$property = '_auxs_' . $property;
			}
			else if (property_exists(__CLASS__, '_auxv_' . $property))
			{
				$property = '_auxv_' . $property;
			}
			else
			{
				$this->setError("Unknown property: $property");
				return false;
			}
		}

		if ('_auxv_' == substr($property, 0, 6))
		{
			if (empty($value))
			{
				$value = array();
			}
			else
			{
				if (!is_array($value))
				{
					$value = array($value);
				}

				$list = array_unique($value);
				sort($list);
				unset($value);

				foreach ($list as $v)
				{
					$value[] = strval($v);
				}
			}
		}
		elseif (is_string($value))
		{
			$value = strval($value);
		}

		$this->$property = $value;

		if ($property == 'userPassword')
		{
			$this->_password = '';
		}

		return true;
	}
146116
public function remove($value)
    {
        foreach ($this->values as $i => $v) {
            if ($value == $v) {
                unset($this->values[$i]);
                break;
            }
        }
        $this->stateChanged();
    }
269822
public function unsetProperty($property) {
		foreach ($this->_data as &$item) {
			unset($item[$property]);
		}
		unset($item);
		
		return $this;
	}