Clears the heap.
197720
public void clear() {
    for (int i = 0; i < this.heap.size(); i++)
      this.indices.set(this.heap.get(i), -1);
    this.heap.clear();
  }
1168429
public void clear() {
    int max = bits.length;
    for (int i = 0; i < max; i++) {
      bits[i] = 0;
    }
  }
683521
public void clearBuffer()
    {
        super.clearBuffer();
        if (m_vector == null)
            m_vector = new Vector<Object>();
        else
            m_vector.removeAllElements();
        m_iCurrentIndex = 0;
    }
514890
@Override
  public void clear() {
    // Subtract the amount of memory being used for the dictionary
    memoryEstimate.decrementDictionaryMemory(byteArray.size());
    byteArray.clear();
    // Add the new size
    memoryEstimate.incrementDictionaryMemory(byteArray.size());
    htDictionary.clear();
    // Make sure the memory estimate reflects the new array sizes
    memoryEstimate.decrementTotalMemory(getSizeOfIntArrays());
    offsets = new int[DynamicIntArray.DEFAULT_SIZE];
    hashcodes = new int[DynamicIntArray.DEFAULT_SIZE];
    nexts = new int[DynamicIntArray.DEFAULT_SIZE];
    counts = new int[DynamicIntArray.DEFAULT_SIZE];
    indexStrides = new int[DynamicIntArray.DEFAULT_SIZE];
    memoryEstimate.incrementTotalMemory(getSizeOfIntArrays());
    numElements = 0;
  }
1278759
public void clear() {
        if (mSize != 0) {
            freeArrays(mHashes, mArray, mSize);
            mHashes = EMPTY_INTS;
            mArray = EMPTY_OBJECTS;
            mSize = 0;
        }
    }
865648
public void clear() {
		this.hashSize = this.startHashSize;
		this.numTables = this.startNumTables;
		this.numElements = 0;

		this.hashfunctions.clear();
		this.tables.clear();
		int sizeTables = 1 << this.startHashSize;
		for (int i = 0; i < this.startNumTables; i++) {
			this.hashfunctions.add(new DietzfelbingerHash(this.startHashSize,
					this.random));
			List<Entry<T>> table = new ArrayList<Entry<T>>(sizeTables);
			for (int j = 0; j < sizeTables; j++) {
				table.add(null);
			}
			this.tables.add(table);
		}

		this.stash.clear();
		this.stashSize = 0;
	}
493393
@Override
    public void clear()
    {
        int size = _size;
        if (size > 0)
        {
            size = size * 2;
            for (int i = 0; i < size; i++)
            {
                _array[i] = null;
            }

            _size = 0;
        }
    }
1156818
public void clearMemory() {
        zeroArray(k);
        k = null;
        zeroArray(n);
        n = null;
        zeroArray(e);
        e = null;
        zeroArray(d);
        d = null;
        zeroArray(dp);
        dp = null;
        zeroArray(dq);
        dq = null;
        zeroArray(qi);
        qi = null;
        zeroArray(p);
        p = null;
        zeroArray(q);
        q = null;
        zeroArray(t);
        t = null;
        zeroArray(x);
        x = null;
        zeroArray(y);
        y = null;
    }
512380
def _clear(self):
        
        self.__names.clear()
        self.__queue.clear()
        self.__context = None
1047049
public static synchronized void clear() {
        for (final Map.Entry<String, Cache> entry : CACHES.entrySet()) {
            final Cache cache = entry.getValue();
            cache.clear();
            LOGGER.log(Level.TRACE, "Cleared cache [name={0}]", entry.getKey());
        }
    }
942846
@Override
    public final void clear() {
        evaluatedMove = null;
        evaluation = null;
        validatedMove = null;
        validation = null;
    }
472628
public synchronized void clear() {
		for (int i = 0; i < planes; i++) {
			readPointer[i] = writePointer[i] = 0;
			bytesToRead[i] = 0;
			bytesToWrite[i] = buffer[i].capacity();
		}
	}
822592
public void clear()
    {
        Iterator it = cachesByClass.values().iterator();
        while (it.hasNext())
        {
            ObjectCache cache = (ObjectCache) it.next();
            if (cache != null)
            {
                cache.clear();
            }
        }
    }
185702
public void clear() {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        if (bTrace && tc.isEntryEnabled()) {
            Tr.entry(tc, "clear");
        }

        clearAllHeaders();
        this.eohPosition = HeaderStorage.NOTSET;
        this.currentElem = null;
        this.stateOfParsing = PARSING_CRLF;
        this.binaryParsingState = GenericConstants.PARSING_HDR_FLAG;
        this.parsedToken = null;
        this.parsedTokenLength = 0;
        this.bytePosition = 0;
        this.byteLimit = 0;
        this.currentReadBB = null;
        clearBuffers();
        this.debugContext = this;
        this.numCRLFs = 0;
        this.bIsMultiLine = false;
        this.lastCRLFBufferIndex = HeaderStorage.NOTSET;
        this.lastCRLFPosition = HeaderStorage.NOTSET;
        this.lastCRLFisCR = false;
        this.headerChangeCount = 0;
        this.headerAddCount = 0;
        this.bOverChangeLimit = false;
        this.compactHeaderFlag = false;
        this.table = null;
        this.isPushPromise = false;
        this.processedXForwardedHeader = false;
        this.processedForwardedHeader = false;
        this.forwardHeaderErrorState = false;
        this.forwardedByList = null;
        this.forwardedForList = null;
        this.forwardedHost = null;
        this.forwardedPort = null;
        this.forwardedProto = null;

        if (bTrace && tc.isEntryEnabled()) {
            Tr.exit(tc, "clear");
        }
    }
415414
public void clear() {

        m_cache = null;
        m_objectList.clear();
        m_objectsById.clear();
        m_orderedObjectList.clear();
        m_objectsListsById.clear();
    }
1150263
def clear(self):
        """"""

        if self.default_value is None:
            self.current_value = bytearray()
        else:
            self.current_value = bytearray(self.default_value)
813267
void clear() {
        offset = intLen = 0;
        for (int index=0, n=value.length; index < n; index++)
            value[index] = 0;
    }