removes pointer from the type definition

    If type is not pointer type, it will be returned as is.
424305
def remove_pointer(type_):
    
    nake_type = remove_alias(type_)
    if not is_pointer(nake_type):
        return type_
    elif isinstance(nake_type, cpptypes.volatile_t) and \
            isinstance(nake_type.base, cpptypes.pointer_t):
        return cpptypes.volatile_t(nake_type.base.base)
    elif isinstance(nake_type, cpptypes.const_t) and \
            isinstance(nake_type.base, cpptypes.pointer_t):
        return cpptypes.const_t(nake_type.base.base)
    elif isinstance(nake_type, cpptypes.volatile_t) \
            and isinstance(nake_type.base, cpptypes.const_t) \
            and isinstance(nake_type.base.base, cpptypes.pointer_t):
        return (
            cpptypes.volatile_t(cpptypes.const_t(nake_type.base.base.base))
        )

    return nake_type.base
1224312
public TypeUsage.Builder clear() {
    TypeUsage_Builder defaults = new TypeUsage.Builder();
    start = defaults.start;
    end = defaults.end;
    type = defaults.type;
    scope = defaults.scope;
    _unsetProperties.clear();
    _unsetProperties.addAll(defaults._unsetProperties);
    return (TypeUsage.Builder) this;
  }
992798
@Override
  public int removeAll(final KTypeLookupContainer<? super KType> c) {
    // We know c holds sub-types of KType and we're not modifying c, so go unchecked.
    return this.removeAll(new KTypePredicate<KType>() {
      public boolean apply(KType k) {
        return c.contains(k);
      }
    });
  }
572311
public boolean removeSpecification(AbstractRslNode node) {
        if (_specifications == null || node == null) return false;
        return _specifications.remove(node);
    }
990904
def destroy(self):
        
        if self.library:
            return self.library.Par_Destroy(ctypes.byref(self.pointer))
955865
def remove_headerReference(self, type_):
        """"""
        headerReference = self.get_headerReference(type_)
        rId = headerReference.rId
        self.remove(headerReference)
        return rId
773315
function() {
        // unsubscribe to all events
        me.event.unsubscribe(this.pointerEvent);
        me.event.unsubscribe(this.viewportEvent);
        me.input.releasePointerEvent("pointermove", me.game.viewport);
    }
475961
public void removeLast() {
		if (this.numTypes>0) {
			switch(this.types[this.numTypes-1]) {
			case CLOSE:
				// no coord to remove
				break;
			case MOVE_TO:
			case LINE_TO:
				this.numCoords -= 3;
				break;
			case CURVE_TO:
				this.numCoords -= 9;
				this.isPolyline = null;
				break;
			case QUAD_TO:
				this.numCoords -= 6;
				this.isPolyline = null;
				break;
			default:
				throw new IllegalStateException();
			}
			--this.numTypes;
			this.isEmpty = null;
			this.graphicalBounds = null;
			this.logicalBounds = null;
		}
	}
762265
public static void removeByC_C_T_ST(long classNameId, long classPK,
		int type, int status) {
		getPersistence().removeByC_C_T_ST(classNameId, classPK, type, status);
	}
143745
public void remove(Class<? extends T> type) throws IOException {
        for (T t : data) {
            if(t.getClass()==type) {
                data.remove(t);
                onModified();
                return;
            }
        }
    }
680499
def is_pointer(type_):
    """"""
    return does_match_definition(type_,
                                 cpptypes.pointer_t,
                                 (cpptypes.const_t, cpptypes.volatile_t)) \
        or does_match_definition(type_,
                                 cpptypes.pointer_t,
                                 (cpptypes.volatile_t, cpptypes.const_t))
936929
private void eliminateDeadCode(TypeElement type, AbstractTypeDeclaration node) {
    List<BodyDeclaration> decls = node.getBodyDeclarations();
    String clazz = elementUtil.getBinaryName(type);
    if (deadCodeMap.containsClass(clazz)) {
      stripClass(node);
    } else {
      removeDeadMethods(clazz, decls);
      removeDeadFields(clazz, decls);
    }
  }
121030
public void remove() {
    for (int i = 0; i < buf.length; i++) {
      buf[i] = null;// force null for easier garbage
    }
    buf = null;
  }
1179077
def remove_volatile(type_):
    
    nake_type = remove_alias(type_)
    if not is_volatile(nake_type):
        return type_
    else:
        if isinstance(nake_type, cpptypes.array_t):
            is_c = is_const(nake_type)
            if is_c:
                base_type_ = nake_type.base.base.base
            else:
                base_type_ = nake_type.base.base
            result_type = base_type_
            if is_c:
                result_type = cpptypes.const_t(result_type)
            return cpptypes.array_t(result_type, nake_type.size)
        return nake_type.base
1261176
function ( type ) {
            if ( /pointerdown/i.test(type) ) {
                type = 'touchstart';
            } else if ( /pointermove/i.test(type) ) {
                type = 'touchmove';
            } else if ( /pointerup/i.test(type) ) {
                type = 'touchend';
            } else if ( /pointercancel/i.test(type) ) {
                type = 'touchcancel';
            }
    
            return type;
        }
7047
def drop(self):
        
        if self._ptr:
            LIBRARY.call(self._drop_ffi_fn, self._ptr)
            self._ptr = None
751423
private Boolean removeSerialPort() {
        Boolean ret = true;

        if (serialPort != null) {
            ret = serialPort.disconnect();
            serialPort = null;
        }

        return ret;
    }