// 
// Decompiled by Procyon v0.6.0
// 

package io.netty.handler.codec.http.multipart;

import io.netty.buffer.ByteBufHolder;
import io.netty.util.ReferenceCounted;
import io.netty.channel.ChannelException;
import io.netty.buffer.ByteBuf;
import java.io.IOException;
import io.netty.util.internal.ObjectUtil;
import io.netty.handler.codec.http.HttpConstants;
import java.nio.charset.Charset;
import io.netty.util.AbstractReferenceCounted;

public abstract class AbstractHttpData extends AbstractReferenceCounted implements HttpData
{
    private final String name;
    protected long definedSize;
    protected long size;
    private Charset charset;
    private boolean completed;
    private long maxSize;
    
    protected AbstractHttpData(final String name, final Charset charset, final long size) {
        this.charset = HttpConstants.DEFAULT_CHARSET;
        this.maxSize = -1L;
        ObjectUtil.checkNotNull(name, "name");
        this.name = ObjectUtil.checkNonEmpty(cleanName(name), "name");
        if (charset != null) {
            this.setCharset(charset);
        }
        this.definedSize = size;
    }
    
    private static String cleanName(final String name) {
        final int len = name.length();
        StringBuilder sb = null;
        int start;
        int end;
        for (start = 0, end = len; start < end && Character.isWhitespace(name.charAt(start)); ++start) {}
        while (end > start && Character.isWhitespace(name.charAt(end - 1))) {
            --end;
        }
        for (int i = start; i < end; ++i) {
            final char c = name.charAt(i);
            if (c == '\n') {
                if (sb == null) {
                    sb = new StringBuilder(len);
                    sb.append(name, start, i);
                }
            }
            else if (c == '\r' || c == '\t') {
                if (sb == null) {
                    sb = new StringBuilder(len);
                    sb.append(name, start, i);
                }
                sb.append(' ');
            }
            else if (sb != null) {
                sb.append(c);
            }
        }
        return (sb == null) ? name.substring(start, end) : sb.toString();
    }
    
    @Override
    public long getMaxSize() {
        return this.maxSize;
    }
    
    @Override
    public void setMaxSize(final long maxSize) {
        this.maxSize = maxSize;
    }
    
    @Override
    public void checkSize(final long newSize) throws IOException {
        if (this.maxSize >= 0L && newSize > this.maxSize) {
            throw new IOException("Size exceed allowed maximum capacity");
        }
    }
    
    @Override
    public String getName() {
        return this.name;
    }
    
    @Override
    public boolean isCompleted() {
        return this.completed;
    }
    
    protected void setCompleted() {
        this.setCompleted(true);
    }
    
    protected void setCompleted(final boolean completed) {
        this.completed = completed;
    }
    
    @Override
    public Charset getCharset() {
        return this.charset;
    }
    
    @Override
    public void setCharset(final Charset charset) {
        this.charset = ObjectUtil.checkNotNull(charset, "charset");
    }
    
    @Override
    public long length() {
        return this.size;
    }
    
    @Override
    public long definedLength() {
        return this.definedSize;
    }
    
    @Override
    public ByteBuf content() {
        try {
            return this.getByteBuf();
        }
        catch (final IOException e) {
            throw new ChannelException(e);
        }
    }
    
    @Override
    protected void deallocate() {
        this.delete();
    }
    
    @Override
    public HttpData retain() {
        super.retain();
        return this;
    }
    
    @Override
    public HttpData retain(final int increment) {
        super.retain(increment);
        return this;
    }
    
    @Override
    public abstract HttpData touch();
    
    @Override
    public abstract HttpData touch(final Object p0);
}