Construct an area at the origin that has the same size as {@code size}.

@param size The area size

@return An area at the origin
327027
public static AreaI area(final AreaSizeI size)
  {
    Objects.requireNonNull(size, "Size");
    return AreaI.of(0, size.sizeX(), 0, size.sizeY());
  }
493251
public void setSize(com.google.api.ads.admanager.axis.v201805.Size size) {
        this.size = size;
    }
451954
public BatcherBuilder sizeBound(int size) {
        checkState(this.maxSize == UNSET_INT, "Max size already set to %s", this.maxSize);
        checkArgument(size > 0, "Required to have a size bound greater than 0");
        this.maxSize = size;
        return this;
    }
1024657
public CacheManagerBuilder<T> withDefaultSizeOfMaxObjectGraph(long size) {
    DefaultSizeOfEngineProviderConfiguration configuration = configBuilder.findServiceByClass(DefaultSizeOfEngineProviderConfiguration.class);
    if (configuration == null) {
      return new CacheManagerBuilder<>(this, configBuilder.addService(new DefaultSizeOfEngineProviderConfiguration(DEFAULT_MAX_OBJECT_SIZE, DEFAULT_UNIT, size)));
    } else {
      ConfigurationBuilder builder = configBuilder.removeService(configuration);
      return new CacheManagerBuilder<>(this, builder.addService(new DefaultSizeOfEngineProviderConfiguration(configuration
        .getMaxObjectSize(), configuration.getUnit(), size)));
    }
  }
111380
protected <K, V> Map<K, V> allocMap(int size) {
      return size == 0 ? Collections.emptyMap() : new HashMap<>(size * 4/3, 0.75f);
   }
192167
public void setIconSize(int size){
        mEmptyIconSize = size;
        int width = mEmptyIconSize == -1 ? WRAP_CONTENT : mEmptyIconSize;
        int height = mEmptyIconSize == -1 ? WRAP_CONTENT : mEmptyIconSize;
        LinearLayout.LayoutParams iconParams = new LinearLayout.LayoutParams(width, height);
        mIcon.setLayoutParams(iconParams);
    }
105844
public Cell<C,T> minSize (Value<C,T> size) {
		minWidth = size;
		minHeight = size;
		return this;
	}
674882
private Region find(long size) {
    validate(!VALIDATING || Long.bitCount(size) == 1);

    Node<Region> currentNode = getRoot();
    Region currentRegion = currentNode.getPayload();
    if (currentRegion == null || (currentRegion.available() & size) == 0) {
      //no region big enough for us...
      return null;
    } else {
      while (true) {
        Region left = currentNode.getLeft().getPayload();
        if (left != null && (left.available() & size) != 0) {
          currentNode = currentNode.getLeft();
          currentRegion = currentNode.getPayload();
        } else if ((currentRegion.availableHere() & size) != 0) {
          long mask = size - 1;
          long a = (currentRegion.start() + mask) & ~mask;
          return new Region(a, a + size - 1);
        } else {
          Region right = currentNode.getRight().getPayload();
          if (right != null && (right.available() & size) != 0) {
            currentNode = currentNode.getRight();
            currentRegion = currentNode.getPayload();
          } else {
            throw new AssertionError();
          }
        }
      }
    }
  }
1081398
public Map<String, Float> getTermAndRank(String content, int size)
    {
        Map<String, Float> map = getTermAndRank(content);
        Map<String, Float> result = top(size, map);

        return result;
    }
1111203
public static Maze2D empty(int size) {
        char[][] maze = new char[size][size];
        for (int i = 0; i < size; i++) {
            Arrays.fill(maze[i], Symbol.EMPTY.value());
        }
        maze[0][0] = Symbol.START.value();
        maze[size][size] = Symbol.GOAL.value();
        return new Maze2D(maze);
    }
35636
public static Area createArea(double x, double y, double width, double height)
    {
        return new AreaImpl(x, y, width, height);
    }
1289363
private void createLoca(int size) throws IOException {
        pad4();
        locaOffset = currentPos;
        writeULong(locaDirOffset + 4, currentPos);
        writeULong(locaDirOffset + 8, size * 4 + 4);
        currentPos += size * 4 + 4;
        realSize += size * 4 + 4;
    }
656500
public static AreaL area(final AreaSizeL size)
  {
    Objects.requireNonNull(size, "Size");
    return AreaL.of(0L, size.sizeX(), 0L, size.sizeY());
  }
732262
public static <S> AreaSizeF toAreaSizeF(final PAreaSizeF<S> a)
  {
    Objects.requireNonNull(a, "area size");
    return AreaSizeF.of(a.sizeX(), a.sizeY());
  }
953516
function( size ) {

        var imageSize = size.clone();
        this.size = size.clone();
        var tiles = new OpenLayers.Size(
            Math.ceil( imageSize.w / this.standardTileSize ),
            Math.ceil( imageSize.h / this.standardTileSize )
            );

        this.tierSizeInTiles = [tiles];
        this.tierImageSize = [imageSize];

        while (imageSize.w > this.standardTileSize ||
               imageSize.h > this.standardTileSize ) {

            imageSize = new OpenLayers.Size(
                Math.floor( imageSize.w / 2 ),
                Math.floor( imageSize.h / 2 )
                );
            tiles = new OpenLayers.Size(
                Math.ceil( imageSize.w / this.standardTileSize ),
                Math.ceil( imageSize.h / this.standardTileSize )
                );
            this.tierSizeInTiles.push( tiles );
            this.tierImageSize.push( imageSize );
        }

        this.tierSizeInTiles.reverse();
        this.tierImageSize.reverse();

        this.numberOfTiers = this.tierSizeInTiles.length;
        var resolutions = [1];
        this.tileCountUpToTier = [0];
        for (var i = 1; i < this.numberOfTiers; i++) {
            resolutions.unshift(Math.pow(2, i));
            this.tileCountUpToTier.push(
                this.tierSizeInTiles[i-1].w * this.tierSizeInTiles[i-1].h +
                this.tileCountUpToTier[i-1]
                );
        }
        if (!this.serverResolutions) {
            this.serverResolutions = resolutions;
        }
    }
1001762
public static <T> Size<T> of(Position.Readable<T> position) {
        return new Size<>(position);
    }
1210740
public Geometry pickGeometry( long position, long size ) throws Exception {
        byte[] geomBytes = new byte[(int) size];
        raf.seek(position);
        raf.read(geomBytes);

        ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(geomBytes));
        return (Geometry) in.readObject();
    }