Clears this SegmentManager.

@param clearMeta - whether to clear the segment meta file
762703
private void clearInternal(boolean clearMeta) {
        // Close all known segments
        for(int segId = 0, cnt = _segList.size(); segId < cnt; segId++) {
            Segment seg = _segList.get(segId);
            if(seg != null) {
                try {
                    if(seg.getMode() == Segment.Mode.READ_WRITE) {
                        seg.force();
                    }
                    seg.close(false);
                } catch (IOException e) {
                    _log.warn("failed to close segment " + seg.getSegmentId());
                } finally {
                    _segList.set(segId, null);
                }
            }
        }
        
        if(clearMeta) {
            try {
                updateMeta();
            } catch (IOException e) {
                _log.warn("failed to clear segment meta");
            }
        }
        
        _segList.clear();
        _recycleList.clear();
    }
1300976
void doneWithMeta()
    {
        parsingMeta = false;
        anyToVerify = !sigFileSigners.isEmpty();
        baos = null;
        sigFileData = null;
        pendingBlocks = null;
        signerCache = null;
        manDig = null;
        // MANIFEST.MF is always treated as signed and verified,
        // move its signers from sigFileSigners to verifiedSigners.
        if (sigFileSigners.containsKey(JarFile.MANIFEST_NAME)) {
            verifiedSigners.put(JarFile.MANIFEST_NAME,
                    sigFileSigners.remove(JarFile.MANIFEST_NAME));
        }
    }
427543
@VisibleForTesting
  void clear() {
    insertServiceName.clear();
    if (insertRemoteServiceName != null) insertRemoteServiceName.clear();
    insertSpanName.clear();
    indexer.clear();
    if (insertAutocompleteValue != null) insertAutocompleteValue.clear();
  }
138959
@Override
	public void clear() {
		modCount++;

		// Let gc do its work
		for (int i = 0; i < size; i++)
			elementData[i] = 0;

		size = 0;
	}
1163767
public void clear() {
        int currentCount = threadCounter.decrementAndGet();
        if (log.isLoggable(Level.FINEST)) {
            log.finest("Clear: Disassociate Thread from FragmentBuilder(1): current thread count=" + currentCount);
            synchronized (threadNames) {
                threadNames.remove(Thread.currentThread().getName());
            }
        }
        FragmentBuilder currentBuilder = builders.get();
        if (currentBuilder != null) {
            currentBuilder.decrementThreadCount();
        }
        builders.remove();
    }
744484
public synchronized void clear()
    {
        for (String keyspaceName : getNonSystemKeyspaces())
        {
            KSMetaData ksm = getKSMetaData(keyspaceName);
            for (CFMetaData cfm : ksm.cfMetaData().values())
                purge(cfm);
            clearKeyspaceDefinition(ksm);
        }

        updateVersionAndAnnounce();
    }
993948
protected synchronized void clear()
                    throws ObjectManagerException
    {
        final String methodName = "clear";
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass, methodName);

        super.clear();
        inMemoryManagedObjects = new ConcurrentHashMap(concurrency);

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass, "clear");
    }
725917
public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }
1240246
public function removeMetum(\Fulgurio\LightCMSBundle\Entity\PageMeta $meta)
    {
        $this->meta->removeElement($meta);
    }
133220
public static void clear(final double[][] m) {
    for(int i = 0; i < m.length; i++) {
      Arrays.fill(m[i], 0.0);
    }
  }
252162
public void close() {
		synchronized (this) {
			if (this.closed) {
				return;
			}
			this.closed = true;
		}
		
		this.numRecordsInBuffer = 0;
		this.numRecordsReturned = 0;
		
		// add the full segments to the empty ones
		for (int i = this.fullSegments.size() - 1; i >= 0; i--) {
			this.emptySegments.add(this.fullSegments.remove(i));
		}
		
		// release the memory segment
		this.memoryManager.release(this.emptySegments);
		this.emptySegments.clear();
		
		if (LOG.isDebugEnabled()) {
			LOG.debug("Block Resettable Iterator closed.");
		}
	}
52169
private void clearMemberData()
   {
      m_reader = null;
      m_eventManager = null;
      m_file = null;
      m_root = null;
      m_resourceMap = null;
      m_projectDir = null;
      m_viewDir = null;
      m_outlineCodeVarData = null;
      m_outlineCodeVarMeta = null;
      m_projectProps = null;
      m_fontBases = null;
      m_taskSubProjects = null;
      m_parentTasks = null;
      m_taskOrder = null;
      m_nullTaskOrder = null;
   }
298220
public function clear()
    {
        $this->documentMap = [];
        $this->documentNodeMap = [];
        $this->nodeMap = [];
        $this->nodeDocumentMap = [];
        $this->documentLocaleMap = [];
        $this->hydrationState = [];
    }
1236810
def clear(self):
        

        for sub in self.sub_sections.values():
            sub.clear()
        self.sub_sections.clear()

        ManifestSection.clear(self)
1007035
private function handleDeletedModelMetas()
	{
		if ($this->metableTableSoftDeletes()) {
			foreach ($this->metas as $meta) {
				$this->syncMetableTableAttributes();
				$meta->decrement('num_items');
			}
			
			return;
		}
		
		$this->unsetMeta();
	}
837210
@Override
    public void clear() {
        try {
            lockAllSegments();
            for (LinkedHashMapSegment<K, V> seg : segments) {
                seg.clear();
            }
        } finally {
            unlockAllSegments();
        }
    }
1258056
public function clear()
    {
        if (null !== $this->aSkillRelatedByPartId) {
            $this->aSkillRelatedByPartId->removePart($this);
        }
        if (null !== $this->aSkillRelatedByCompositeId) {
            $this->aSkillRelatedByCompositeId->removeComposite($this);
        }
        $this->part_id = null;
        $this->composite_id = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }