define a tumbling ingestion time window

@param size window size
13640
public BaseWindowedBolt<T> ingestionTimeWindow(Time size) {
        long s = size.toMilliseconds();
        ensurePositiveTime(s);

        setSizeAndSlide(s, DEFAULT_SLIDE);
        this.windowAssigner = TumblingIngestionTimeWindows.of(s);
        return this;
    }
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);
            }
        }
    }
601021
public BaseWindowedBolt<T> timeWindow(Time size) {
        long s = size.toMilliseconds();
        ensurePositiveTime(s);

        setSizeAndSlide(s, DEFAULT_SLIDE);
        this.windowAssigner = TumblingProcessingTimeWindows.of(s);
        return this;
    }
504987
public void setTextSize(final TextSize SIZE) {
        if (null == textSize) {
            _textSize = SIZE;
            fireTileEvent(REDRAW_EVENT);
        } else {
            textSize.set(SIZE);
        }
    }
433389
public void setSizeRefsByMsgSize(boolean sizeByMsgSize)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setSizeRefsByMsgSize", Boolean.valueOf(sizeByMsgSize));

        this._sizeRefsByMsgSize = sizeByMsgSize;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setSizeRefsByMsgSize");
    }
493251
public void setSize(com.google.api.ads.admanager.axis.v201805.Size size) {
        this.size = size;
    }
918051
public void ensureCapacity(int size) {
    if (size > elements.length) {
      reallocate(Math.max(size, 2 * elements.length));
    }
  }
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;
            }
        };
    }
357273
public void writeWindowFrame(int windowSize) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();

        output.write(PROTOCOL_VERSION.getBytes(UTF_8));//Protocol version
        output.write(WINDOW_SIZE_FRAME_TYPE.getBytes(UTF_8)); //Frame type 'W'
        output.write(ByteBuffer.allocate(4).putInt(windowSize).array());//32-bit window size

        lastUsedTime = System.currentTimeMillis();
        out.write(output.toByteArray());
        out.flush();
    }
1265483
public AutofitHelper setMinTextSize(int unit, float size) {
        Context context = mTextView.getContext();
        Resources r = Resources.getSystem();

        if (context != null) {
            r = context.getResources();
        }

        setRawMinTextSize(TypedValue.applyDimension(unit, size, r.getDisplayMetrics()));
        return this;
    }
399059
function(size) { 
        if (this.singleTile) {
            size = this.map.getSize();
            size.h = parseInt(size.h * this.ratio, 10);
            size.w = parseInt(size.w * this.ratio, 10);
        } 
        OpenLayers.Layer.HTTPRequest.prototype.setTileSize.apply(this, [size]);
    }
717341
public PythonWindowedStream time_window(Time size, Time slide) {
		return new PythonWindowedStream<TimeWindow>(this.stream.timeWindow(size, slide));
	}
619725
public Cell<C,T> size (float size) {
		size(new FixedValue<C, T>(layout.toolkit, size));
		return this;
	}
1219033
public void fillTo(int size)
   {
      if (size <= 0)
         return;

      if (pool.getLogger().isTraceEnabled())
      {
         synchronized (this)
         {
            pool.getLogger().trace(ManagedConnectionPoolUtility.fullDetails(this,
               "fillTo(" + size + ")",
               pool.getConnectionManager().getManagedConnectionFactory(),
               pool.getConnectionManager(),
               pool, pool.getConfiguration(),
               listeners, pool.getInternalStatistics(),
               credential.getSubject(),
               credential.getConnectionRequestInfo()));
         }
      }
      else if (pool.getLogger().isDebugEnabled())
      {
         pool.getLogger().debug(ManagedConnectionPoolUtility.details(
            "fillTo(" + size + ")",
            pool.getConfiguration().getId(),
            getCount(IN_USE, listeners),
            pool.getConfiguration().getMaxSize()));
      }

      while (!pool.isFull())
      {
         // Get a permit - avoids a race when the pool is nearly full
         // Also avoids unnessary fill checking when all connections are checked out
         try
         {
            //TODO:statistics
            if (pool.getRequestSemaphore()
                  .tryAcquire(pool.getConfiguration().getBlockingTimeout(), TimeUnit.MILLISECONDS))
            {
               try
               {
                  if (pool.isShutdown())
                  {
                     return;
                  }

                  // We already have enough connections
                  if (listeners.size() >= size)
                  {
                     return;
                  }

                  // Create a connection to fill the pool
                  try
                  {
                     ConnectionListener cl = pool.createConnectionListener(credential, this);

                     if (Tracer.isEnabled())
                        Tracer.createConnectionListener(pool.getConfiguration().getId(), this, cl,
                                                        cl.getManagedConnection(),
                                                        false, true, false,
                                                        Tracer.isRecordCallstacks() ?
                                                        new Throwable("CALLSTACK") : null);

                     boolean added = false;

                     if (listeners.size() < size)
                     {

                        listeners.add(cl);
                        added = true;
                     }

                     if (!added)
                     {

                        if (Tracer.isEnabled())
                           Tracer.destroyConnectionListener(pool.getConfiguration().getId(), this, cl,
                                                            false, false, false, false,
                                                            false, true, false,
                                                            Tracer.isRecordCallstacks() ?
                                                            new Throwable("CALLSTACK") : null);
                     
                        pool.destroyConnectionListener(cl);
                        return;
                     }
                  }
                  catch (ResourceException re)
                  {
                     return;
                  }
               }
               finally
               {
                  pool.getRequestSemaphore().release();
               }
            }
         }
         catch (InterruptedException ignored)
         {
            Thread.interrupted();
            //TODO:trace
         }
      }
   }
866768
public function setChunkSize($size)
    {
        if(static::MODE == 'cli' && is_numeric($size))
        {
            $this->chunkSize = (int)$size;
        }
        elseif(static::MODE == 'web')
        {
            throw new Exception('Chunk size is not supported on web mode');
        }
        else
        {
            throw new Exception("$size is not a valid chunk size");
        }

        return $this;
    }
947577
public void setTextSize(int unit, float size) {
        if (!mSizeToFit) {
            mTextView.setTextSize(unit, size);
        }

        Context context = mTextView.getContext();
        Resources r = Resources.getSystem();

        if (context != null) {
            r = context.getResources();
        }

        setRawTextSize(TypedValue.applyDimension(unit, size, r.getDisplayMetrics()));
    }
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);
    }