Reset the Cleanup size and interval

The size and interval when started are 500 items (memory size unknown) checked every minute in a background thread.

@param size
@param interval
196899
public void cleanupParams(int size, long interval) {
		timer.cancel();
		timer.schedule(new Cleanup(content,size), interval, interval);
	}
493251
public void setSize(com.google.api.ads.admanager.axis.v201805.Size size) {
        this.size = size;
    }
654096
public void set(long count, long startTime, long lastSampleTime) {
        this.count = count;
        this.startTime = startTime;
        this.lastSampleTime = lastSampleTime;
    }
1126468
public void setStorageSize(java.util.Collection<Range> storageSize) {
        if (storageSize == null) {
            this.storageSize = null;
            return;
        }

        this.storageSize = new java.util.ArrayList<Range>(storageSize);
    }
1124038
synchronized public void reset(long value) {

        if (value < minValue || value > maxValue) {
            throw Error.error(ErrorCode.X_42597);
        }

        startValue = currValue = lastValue = value;
    }
482329
public void truncate(long size) throws IOException {
        super.truncate(size);
        if (size == 0) {
            synchronized (this) {
                mTranCount = 0;
                // Clear the bit to indicate clean.
                mBitlist.clear(mBitlistPos);
            }
        }
    }
806238
public void makeSpace(int sizeNeeded) {
        int needed = count + sizeNeeded - buf.length;
        if (needed > 0) {
            bump(needed);
        }
    }
1351545
@Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);

        clear();
    }
743500
public void setInterval(Interval interval) {
        if (interval == null) {
            interval = INTERVAL_FACTORY.getInstance();
        }
        this.interval = interval;
    }
72357
private int allocate(int size)
    {
        while (true)
        {
            int prev = allocatePosition.get();
            int next = prev + size;
            if (next >= buffer.capacity())
                return -1;
            if (allocatePosition.compareAndSet(prev, next))
                return prev;
        }
    }
414967
public void setMenuSize(final MenuSize size) {
        if (size != null)
            attrMixin.setAttribute(SIZE, size.getValue());
        else
            attrMixin.removeAttribute(SIZE);
    }
393701
public final void setInterval(LocalTime startTime, LocalTime endTime) {
        setInterval(startTime, endTime, ZoneId.systemDefault());
    }
592294
public synchronized void resetAll(long value) throws IOException {
      if(_elementSize != 8) {
          throw new IOException("Operation aborted: elementSize=" + _elementSize);
      }
      
      _writer.flush();
      _writer.position(DATA_START_POSITION);
      for(int i = 0; i < this._arrayLength; i++) {
          _writer.writeLong(value);
      }
      _writer.flush();
  }
1024757
void setInterval(String interval) {

        final int i = CmsSerialDateUtil.toIntWithDefault(interval, -1);
        if (m_model.getInterval() != i) {
            removeExceptionsOnChange(new Command() {

                public void execute() {

                    m_model.setInterval(i);
                    onValueChange();
                }
            });
        }

    }
127927
private void handleChangeCleaningInterval(final HttpServletRequest req,
      final Map<String, Object> ret) {
    try {
      final long newInterval = getLongParam(req, STATS_MAP_CLEANINGINTERVAL);
      if (MetricReportManager.isAvailable()) {
        final MetricReportManager metricManager = MetricReportManager.getInstance();
        final InMemoryMetricEmitter memoryEmitter =
            extractInMemoryMetricEmitter(metricManager);
        memoryEmitter.setReportingInterval(newInterval);
        ret.put(STATUS_PARAM, RESPONSE_SUCCESS);
      } else {
        ret.put(RESPONSE_ERROR, "MetricManager is not available");
      }
    } catch (final Exception e) {
      logger.error(e);
      ret.put(RESPONSE_ERROR, e.getMessage());
    }
  }
211957
public void setCacheSize(int cacheSize) {
    this.cacheSize = cacheSize;

    long toDelete = map.size() - this.cacheSize;
    if(toDelete <= 0) {
      return;
    }

    List<Integer> keys = new ArrayList<>(map.keySet());
    Collections.reverse(keys);

    for(Integer id : keys) {
      P page = map.remove(id);
      file.writePage(page);
    }
  }
536436
public void setSize(UnsignedInteger64 size) {
		this.size = size;

		// Set the flag
		if (size != null) {
			flags |= SSH_FILEXFER_ATTR_SIZE;
		} else {
			flags ^= SSH_FILEXFER_ATTR_SIZE;
		}
	}