/* (non-Javadoc)
@see com.att.cadi.Lur#clear(java.security.Principal, java.lang.StringBuilder)
9742
@Override
	public void clear(Principal p, StringBuilder report) {
		report.append(NullLur.class.getSimpleName());
		report.append('\n');
	}
1194544
public void clear() {
		domainsFileLock.writeLock().lock();
		logger.trace("LOCK writelock");
		allDomains = null;
		domainMap = null;
		logger.trace("UNLOCK writelock");
		domainsFileLock.writeLock().unlock();
	}
1249860
@Override
    public void clear() {
        readOnlyGuardCondition();

        for (D item : this) {
            instance.removeRelation(entity, writeAttributeName, item);
        }
        entity.save();
    }
328355
public synchronized void clear(Identifier rootId, boolean enableCache)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(this,cclass, "clear");
    matchTree = null;
    matchTreeGeneration = 0;
    subExpr.clear();
    
    // Now reinitialise the matchspace
    initialise(rootId, enableCache);
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(this,cclass, "clear");
  }
1093654
public void clearAll()
    {
        for (int i = 0; i < textFields.size(); i++)
        {
            JTextField textField = textFields.get(i);
            if (textField == null)
            {
                continue;
            }
            textField.setText("");
        }
    }
667564
public void clear() {
        _uri = null;

        _scheme = null;
        _host = null;
        _port = -1;
        _path = null;
        _param = null;
        _query = null;
        _fragment = null;

        _decodedPath = null;
    }
769229
public void clear() {

        /**
         * Unfortunately log4j's MDC historically never had a mechanism to block remove keys,
         * so we're forced to do this one by one.
         */
        for (String key : allKeys()) {
           mdcBridge.remove(key);
        }

        PER_THREAD_CONTEXTS.getUnchecked(Thread.currentThread()).clear();
    }
48818
public void clear() throws SQLException {
        clearStatements();
        statements.clear();
        parameterSets.clear();
        connections.clear();
        resultSets.clear();
        executeGroups.clear();
    }
290745
public void clear()
  {
    _nullValue = NULL;
    
    for (int i = 0; i < _values.length; i++) {
      _keys[i] = null;
      _flags[i] = 0;
      _values[i] = 0;
    }
    
    _size = 0;
  }
264361
public void clear(String nsid) {
    	Auth a =  this.auths.get(nsid);
    	if(a != null) {
            this.authsByUser.remove(a.getUser().getUsername());
    	}
    	this.auths.remove(nsid);
        this.authsByUser.remove(nsid); // in case username is passed.
        File auth = new File(this.authStoreDir, nsid + ".auth");
        if (auth.exists())
            auth.delete();

    }
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");
        }
    }
1274451
public void clear()
  {
    for (int i = 0; i < _values.length; i++) {
      _keys[i] = null;
      _values[i] = 0;
    }
    
    _size = 0;
  }
1196400
@Override
    public void clear() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Clearing ISC: " + this);
        }
        super.clear();
        this.bCheckedAcceptEncoding = false;
        this.bContainsLargeMessage = false;
        this.remoteUser = "";
        this.forwardedHeaderInitialized = false;
        this.forwardedHost = null;
        this.forwardedProto = null;
        this.forwardedRemoteAddress = null;
        this.forwardedRemotePort = -1;
        if (getHttpConfig().runningOnZOS()) {
            // @311734 - clean the statemap of the final write mark
            getVC().getStateMap().remove(HttpConstants.FINAL_WRITE_MARK);
        }
    }
1222778
public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            int k = count;
            if (k > 0) {
                final Object[] items = this.items;
                final int putIndex = this.putIndex;
                int i = takeIndex;
                do {
                    items[i] = null;
                    if (++i == items.length) i = 0;
                } while (i != putIndex);
                takeIndex = putIndex;
                count = 0;
                if (itrs != null)
                    itrs.queueIsEmpty();
                for (; k > 0 && lock.hasWaiters(notFull); k--)
                    notFull.signal();
            }
        } finally {
            lock.unlock();
        }
    }
753792
protected void _clear_() {
		action = null;
		request = null;
		response = null;
		urlPara = null;
		urlParaArray = null;
		render = null;
		rawData = null;
	}
1133617
protected synchronized void clear()
                    throws ObjectManagerException {
        final String methodName = "clear";
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass, methodName);

        // No call to super.clear() because we use a WeakValueHashMap.
        inMemoryTokens.clear();
        cachedManagedObjects = new java.lang.ref.SoftReference[cachedManagedObjectsSize];
        managedObjectsToWrite.clear();
        tokensToDelete.clear();
        // No need to clear newFreeSpace because the existing one is cleared just before we flush anyway.

        // Allow for two headers to be written at the front of the file.
        storeFileSizeUsed = pageSize * 2;
        freeSpaceByAddressHead = null;
        freeSpaceByLength = new java.util.TreeSet(new LengthComparator());
        freeSpaceStoreArea = null;

        // Sequence numbers 0-200 are reserved.    
        sequenceNumber = initialSequenceNumber;

        directory = makeDirectory(initialDirectoryMinimumNodeSize, 0, 0);
        directoryReservedSize = directory.spaceRequired();
        reservedSize.set(0);
        setAllocationAllowed();

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass, methodName);
    }
621274
@Override
    public void clear() {
        _rows = 0;
        Arrays.fill(_value, null);
        Arrays.fill(_tree, (char) 0);
        Arrays.fill(_key, null);
    }