Reset the cache of element sets.

@param size the new cache size
323791
public static void resetCaches(int size) {
        nodesCache = new LinkedHashMap<String, List<Node>>() {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, List<Node>> foo) {
                return size() == size;
            }
        };

        vmsCache = new LinkedHashMap<String, List<VM>>() {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, List<VM>> foo) {
                return size() == size;
            }
        };
    }
1095636
public function setCacheSize($size)
    {
        $this->cacheSize = $size;
        $this->logger->debug('LRUcache: set size: ' . $size );
        return true;
    }
166253
private void setSizeRatio(double size) {
        double width = widthHeightRatio * size;
        double height = size / widthHeightRatio;
        if (width <= size) {
            setSize(width, size);
        } else if (height <= size) {
            setSize(size, height);
        } else {
            setSize(size, size);
        }
    }
965255
public final void reset(boolean resetChunkSize) {
        markBufferChanged();
        firstChunk = null;
        lastChunk = null;
        totalCharsInList = 0;
        totalCharsInDynamicChunks = -1;
        sizeAtLeast = -1;
        if (resetChunkSize) {
            chunkSize = firstChunkSize;
            totalChunkSize = 0;
        }
        if (allocBuffer == null) {
            allocBuffer = new AllocatedBuffer(chunkSize);
        } else {
            allocBuffer.clear();
        }
        if (dynamicChunkMap == null) {
            dynamicChunkMap = new HashMap<StreamCharBufferKey, StreamCharBufferSubChunk>();
        } else {
            dynamicChunkMap.clear();
        }
    }
137816
public static void setCacheSize(int size) {
        if (size > 3276700) size = 3276700;
        if (size <= byteCacheSize) return;
        byte[][] tmpCache = new byte[size][];
        System.arraycopy(byteCache, 0, tmpCache, 0, byteCacheSize);
        byteCache = tmpCache;
        byteCacheSize = size;
    }
1281649
public void reset(int resultCount, int pageSize, boolean fireChanged) {

        m_lastPage = resultCount == 0 ? 0 : (resultCount - 1) / pageSize;
        m_resultCount = resultCount;
        m_pageSize = pageSize;
        setPage(0, false);
        updateButtons();
        if (fireChanged) {
            firePageChanged(0);
        }
    }
352275
public void setBufferSize(int size)
    {
        HttpOutputStream out = (HttpOutputStream)_httpResponse.getOutputStream();
        if (out.isWritten()  || _writer!=null && _writer.isWritten())
            throw new IllegalStateException("Output written");
        out.setBufferSize(size);
    }
788632
public function ensureCapacity(int $size) : void
    {
        if ($size > count($this->bits) << 5) {
            $this->bits->setSize(($size + 31) >> 5);
        }
    }
1285613
void setSize(int size) {
        if (this.size != 0) {
            final String fmt = "column size is known: %d";
            final String msg = format(fmt, this.size);
            throw new IllegalStateException(msg);
        }
        this.size = size;
        this.hash = hash();
    }
248665
public void setNeedleSize(final NeedleSize SIZE) {
        if (null == needleSize) {
            _needleSize = null == SIZE ? NeedleSize.STANDARD : SIZE;
            fireUpdateEvent(RESIZE_EVENT);
        } else {
            needleSize.set(SIZE);
        }
    }
473571
def _reset(self):
        """"""
        self.log.info("Clearing the cache, resetting event offsets")
        self.raw_header = None
        self.event_offsets = []
        self.index = 0
59269
protected void setContentSize(final long size) {
        try {
            getDescriptionNode().setProperty(CONTENT_SIZE, size);
        } catch (final RepositoryException e) {
            throw new RepositoryRuntimeException(e);
        }
    }
525173
public void setCacheCapacity(int capacity) {
        if (capacity > 0) {
            cache = new ConcurrentLinkedHashMap<K, V>(capacity);
        } else {
            cache = new ConcurrentHashMap<K, V>();
        }
    }
816618
public void reset()
   {
      min.set(Long.MAX_VALUE);
      max.set(0);
      total.set(0);
      times.set(0);
   }
960434
@Override
	protected void resetCache() {
		super.resetCache();
		cacheProperties.put(JAWR_SERVLET_MAPPING, config.getServletMapping());
		String binaryServletMapping = getBinaryServletMapping();
		if (binaryServletMapping != null) {
			cacheProperties.put(JAWR_BINARY_SERVLET_MAPPING, binaryServletMapping);
		} else {
			cacheProperties.remove(JAWR_BINARY_SERVLET_MAPPING);
		}
		cacheProperties.put(JawrConfig.JAWR_CSS_CLASSPATH_HANDLE_IMAGE,
				Boolean.toString(config.isCssClasspathImageHandledByClasspathCss()));
		cacheProperties.put(JawrConfig.JAWR_BINARY_HASH_ALGORITHM, config.getBinaryHashAlgorithm());
	}
57804
@Override
    public void reset() {
        updatesLock.writeLock().lock();

        if (storage != null) {
            storage.assign(0.0f);
        }

        if (updates != null)
            updates.assign(0.0f);

        updatesLock.writeLock().unlock();
    }
493251
public void setSize(com.google.api.ads.admanager.axis.v201805.Size size) {
        this.size = size;
    }