| /* |
| * FilterAllocator.java February 2001 |
| * |
| * Copyright (C) 2001, Niall Gallagher <niallg@users.sf.net> |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| */ |
| |
| package org.simpleframework.common.buffer; |
| |
| import java.io.IOException; |
| |
| /** |
| * The <code>FilterAllocator</code> object is used to provide a means |
| * to provide a general set of constraints around buffer allocation. |
| * It can ensure that a minimum capacity is used for default allocation |
| * and that an upper limit is used for allocation. In general this can |
| * be used in conjunction with another <code>Allocator</code> which may |
| * not have such constraints. It ensures that a set of requirements can |
| * be observed when allocating buffers. |
| * |
| * @author Niall Gallagher |
| */ |
| public class FilterAllocator implements Allocator { |
| |
| /** |
| * This is the allocator the underlying buffer is allocated with. |
| */ |
| protected Allocator source; |
| |
| /** |
| * This is the default initial minimum capacity of the buffer. |
| */ |
| protected long capacity; |
| |
| /** |
| * This is the maximum number of bytes that can be allocated. |
| */ |
| protected long limit; |
| |
| /** |
| * Constructor for the <code>FilterAllocator</code> object. This is |
| * used to instantiate the allocator with a default buffer size of |
| * half a kilobyte. This ensures that it can be used for general |
| * purpose byte storage and for minor I/O tasks. |
| * |
| * @param source this is where the underlying buffer is allocated |
| */ |
| public FilterAllocator(Allocator source) { |
| this(source, 512, 1048576); |
| } |
| |
| /** |
| * Constructor for the <code>FilterAllocator</code> object. This is |
| * used to instantiate the allocator with a specified buffer size. |
| * This is typically used when a very specific buffer capacity is |
| * required, for example a request body with a known length. |
| * |
| * @param source this is where the underlying buffer is allocated |
| * @param capacity the initial capacity of the allocated buffers |
| */ |
| public FilterAllocator(Allocator source, long capacity) { |
| this(source, capacity, 1048576); |
| } |
| |
| /** |
| * Constructor for the <code>FilterAllocator</code> object. This is |
| * used to instantiate the allocator with a specified buffer size. |
| * This is typically used when a very specific buffer capacity is |
| * required, for example a request body with a known length. |
| * |
| * @param source this is where the underlying buffer is allocated |
| * @param capacity the initial capacity of the allocated buffers |
| * @param limit this is the maximum buffer size created by this |
| */ |
| public FilterAllocator(Allocator source, long capacity, long limit) { |
| this.limit = Math.max(capacity, limit); |
| this.capacity = capacity; |
| this.source = source; |
| } |
| |
| /** |
| * This method is used to allocate a default buffer. This will |
| * allocate a buffer of predetermined size, allowing it to grow |
| * to an upper limit to accommodate extra data. If the buffer |
| * requested is larger than the limit an exception is thrown. |
| * |
| * @return this returns an allocated buffer with a default size |
| */ |
| public Buffer allocate() throws IOException { |
| return allocate(capacity); |
| } |
| |
| /** |
| * This method is used to allocate a default buffer. This will |
| * allocate a buffer of predetermined size, allowing it to grow |
| * to an upper limit to accommodate extra data. If the buffer |
| * requested is larger than the limit an exception is thrown. |
| * |
| * @param size the initial capacity of the allocated buffer |
| * |
| * @return this returns an allocated buffer with a default size |
| */ |
| public Buffer allocate(long size) throws IOException { |
| if(size > limit) { |
| throw new BufferException("Specified size %s beyond limit", size); |
| } |
| if(capacity > size) { |
| size = capacity; |
| } |
| return source.allocate(size); |
| } |
| } |