Short description of method removeType

@access public
@author Joel Bout, <joel.bout@tudor.lu>
@param  Resource resource
@param  Class class
@return boolean
9321
public function removeType( core_kernel_classes_Resource $resource,  core_kernel_classes_Class $class)
    {
        $returnValue = (bool) false;

        
        
        $query =  'DELETE FROM statements 
		    		WHERE subject = ? AND predicate = ? AND '. $this->getPersistence()->getPlatForm()->getObjectTypeCondition() .' = ?';
        
        //be sure the property we try to remove is included in an updatable model
		$query .= ' AND '.$this->getModelWriteSqlCondition();
        
        $returnValue = $this->getPersistence()->exec($query,array(
        	$resource->getUri(),
			OntologyRdf::RDF_TYPE,
        	$class->getUri()
        ));
        
        $returnValue = true;
        
        

        return (bool) $returnValue;
    }
711422
public function changeClass(core_kernel_classes_Resource $instance, core_kernel_classes_Class $destinationClass)
    {
        if ($instance->isClass()) {
            try {
                /** @var core_kernel_classes_Class $instance */
                return $instance->editPropertyValues($this->getProperty(OntologyRdfs::RDFS_SUBCLASSOF), $destinationClass);
            } catch (\Exception $e) {
                return false;
            }
        } else {
            try {
                foreach ($instance->getTypes() as $type) {
                    $instance->removeType($type);
                }
                $instance->setType($destinationClass);
                foreach ($instance->getTypes() as $type) {
                    if ($type->getUri() == $destinationClass->getUri()) {
                        return true;
                    }
                }
            } catch (\common_Exception $ce) {
                print $ce;
                return false;
            }
        }
    }
816108
def record_remove_types(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/removeTypes' % object_id, input_params, always_retry=always_retry, **kwargs)
1194579
public function remove_class( $class ) {
		if ( !isset( $this->attr['class'] ) || !is_array( $this->attr['class'] ) ) {
			$this->_sanitize_class();
		}
		$this->attr['class'] = array_diff( $this->attr['class'], array( $class ) );
		return $this;
	}
587429
private void remove(Class<?> type, Object object)
    {
        final Set<?> set = items.get(type);
        if (set != null)
        {
            set.remove(object);
        }
    }
234339
public static base_response clear(nitro_service client, Interface resource) throws Exception {
		Interface clearresource = new Interface();
		clearresource.id = resource.id;
		return clearresource.perform_operation(client,"clear");
	}
842613
public function removeClass($class_name='')
    {
        $remove_names = \is_array($class_name) ? $class_name : explode(' ', $class_name);

        foreach ($this->nodes as $node) {
            if ($node instanceof \DOMElement && $node->hasAttribute('class')) {
                $node_classes = preg_split('#\s+#s', $node->getAttribute('class'));
                $class_removed = false;

                if ($class_name === '') { // remove all
                    $node_classes = array();
                    $class_removed = true;
                } else {
                    foreach ($remove_names as $remove_name) {
                        $key = array_search($remove_name, $node_classes, true);
                        if ($key !== false) {
                            unset($node_classes[$key]);
                            $class_removed = true;
                        }
                    }
                }
                if ($class_removed) {
                    $node->setAttribute('class', implode(' ', $node_classes));
                }
            }
        }

        return $this;
    }
927203
public static <T extends Tag, V> void unregister(Class<T> tag, Class<V> type) {
        tagToConverter.remove(tag);
        typeToConverter.remove(type);
    }
46540
public function remove( Resource $resource )
    {
        $cnt = 0;
        if( false !== $key = array_search( $resource, $this->instances, true ) ) {
            unset( $this->instances[$key] );
            $cnt++;
        }
        return $cnt;
    }
338728
function remove($resource)
    {
        $rid = spl_object_hash($resource);
        if (!isset($this->resourcePool[$rid]))
        {
            return false;
        }
        //从resourcePool中删除
        unset($this->resourcePool[$rid]);
        $this->resourceNum--;
        return true;
    }
211845
@Override
    public T deleteClass(Class<?> clazz) throws IllegalArgumentException {
        Validate.notNull(clazz, "Class must be specified");

        return deleteClasses(clazz);
    }
1012690
public static Class<?> erase(Type type) {
		if (type instanceof Class<?>) {
			return (Class<?>) type;
		}
		else if (type instanceof ParameterizedType) {
			return (Class<?>) ((ParameterizedType) type).getRawType();
		}
		else if (type instanceof TypeVariable<?>) {
			TypeVariable<?> tv = (TypeVariable<?>) type;
			if (tv.getBounds().length == 0)
				return Object.class;
			else
				return erase(tv.getBounds()[0]);
		}
		else if (type instanceof GenericArrayType) {
			GenericArrayType aType = (GenericArrayType) type;
			Class<?> componentType = erase(aType.getGenericComponentType());
			return Array.newInstance(componentType, 0).getClass();
		}
		else {
			throw new RuntimeException("not supported: " + type.getClass());
		}
	}
751244
@Override
	public boolean remove(Object object) {
		if (booleanTerms == null) {
			return false;
		}
		return booleanTerms.remove(object);
	}
915233
public function removeType(string $type)
    {
        if (!$this->removing && Type::hasType($type)) {
            $this->removing = true;
            Type::overrideType($type, null);
        }

        $this->removing = false;
        unset($this->types[$type]);
    }
612343
protected static function deleteTaxClassByIdAsyncWithHttpInfo($tax_class_id) 
    {
        $returnType = '';  
        $request = self::deleteTaxClassByIdRequest($tax_class_id); 

        return self::getHttpClient()
            ->sendAsync($request, self::createHttpClientOption())
            ->then(
                function ($response) use ($returnType) {
                    return [null, $response->getStatusCode(), $response->getHeaders()];
                },
                function ($exception) {
                    $response = $exception->getResponse();
                    $statusCode = $response->getStatusCode();
                    throw new ApiException(
                        sprintf(
                            '[%d] Error connecting to the API (%s)',
                            $statusCode,
                            $exception->getRequest()->getUri()
                        ),
                        $statusCode,
                        $response->getHeaders(),
                        $response->getBody()
                    );
                }
            );
    }
1127571
public function removeClass($class)
    {
        $this->setOption(self::OPTION_METHOD, "removeClass");
        $this->setOption(self::OPTION_REMOVE_CLASS, $class);

        return $this;
    }
935203
public static function isRpayLiteClassType($class, $type)
    {
        if (array_key_exists($class, self::$types)
            && in_array($type, self::$types[$class])) {
            return true;
        }
        return false;
    }