ClobProxy_360.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package  org.hibernate.engine.jdbc;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Clob;
import java.sql.SQLException;
import org.hibernate.type.descriptor.java.DataHelper;
 
public class ClobProxy_360 implements InvocationHandler {
    private static final Class[] PROXY_INTERFACES = new Class[] { Clob.class, ClobImplementer.class };
 
    private String string;
    private Reader reader;
    private long length;
    private boolean needsReset = false;
 
 
    protected ClobProxy_360(String string) {
        this.string = string;
        reader = new StringReader(string);
        length = string.length();
    }
 
    protected ClobProxy_360(Reader reader, long length) {
        this.reader = reader;
        this.length = length;
    }
 
    protected long getLength() {
        return length;
    }
 
    protected InputStream getAsciiStream() throws SQLException {
        resetIfNeeded();
        return new ReaderInputStream( reader );
    }
 
    protected Reader getCharacterStream() throws SQLException {
        resetIfNeeded();
        return reader;
    }
 
    protected String getSubString(long start, int length) {
        if ( string == null ) {
            throw new UnsupportedOperationException( "Clob was not created from string; cannot substring" );
        }
        // semi-naive implementation
        int endIndex = Math.min( ((int)start)+length, string.length() );
        return string.substring( (int)start, endIndex );
    }
 
    @SuppressWarnings({ "UnnecessaryBoxing" })
  @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        final String methodName = method.getName();
        final int argCount = method.getParameterTypes().length;
 
        if ( "length".equals( methodName ) && argCount == 0 ) {
            return Long.valueOf( getLength() );
        }
        if ( "getAsciiStream".equals( methodName ) && argCount == 0 ) {
            return getAsciiStream();
        }
        if ( "getCharacterStream".equals( methodName ) ) {
            if ( argCount == 0 ) {
                return getCharacterStream();
            }
            else if ( argCount == 2 ) {
                long start = (Long) args[0];
                if ( start < 1 ) {
                    throw new SQLException( "Start position 1-based; must be 1 or more." );
                }
                if ( start > getLength() ) {
                    throw new SQLException( "Start position [" + start + "] cannot exceed overall CLOB length [" + getLength() + "]" );
                }
                int length = (Integer) args[1];
                if ( length < 0 ) {
                    // java docs specifically say for getCharacterStream(long,int) that the start+length must not exceed the
                    // total length, however that is at odds with the getSubString(long,int) behavior.
                    throw new SQLException( "Length must be great-than-or-equal to zero." );
                }
                return DataHelper.subStream( getCharacterStream(), start-1, length );
            }
        }
        if ( "getSubString".equals( methodName ) && argCount == 2 ) {
            long start = (Long) args[0];
            if ( start < 1 ) {
                throw new SQLException( "Start position 1-based; must be 1 or more." );
            }
            // from start to start -1 on buggy 3.6.0
      if ( start - 1 > getLength() ) {
                throw new SQLException( "Start position [" + start + "] cannot exceed overall CLOB length [" + getLength() + "]" );
            }
            int length = (Integer) args[1];
            if ( length < 0 ) {
                throw new SQLException( "Length must be great-than-or-equal to zero." );
            }
            return getSubString( start-1, length );
        }
        if ( "free".equals( methodName ) && argCount == 0 ) {
            reader.close();
            return null;
        }
        if ( "toString".equals( methodName ) && argCount == 0 ) {
            return this.toString();
        }
        if ( "equals".equals( methodName ) && argCount == 1 ) {
            return Boolean.valueOf( proxy == args[0] );
        }
        if ( "hashCode".equals( methodName ) && argCount == 0 ) {
            return new Integer( this.hashCode() );
        }
 
        throw new UnsupportedOperationException( "Clob may not be manipulated from creating session" );
    }
 
    protected void resetIfNeeded() throws SQLException {
        try {
            if ( needsReset ) {
                reader.reset();
            }
        }
        catch ( IOException ioe ) {
            throw new SQLException( "could not reset reader" );
        }
        needsReset = true;
    }
 
    public static Clob generateProxy(String string) {
        return ( Clob ) Proxy.newProxyInstance(getProxyClassLoader(),
                PROXY_INTERFACES,
                new ClobProxy_360( string )
        );
    }
 
    public static Clob generateProxy(Reader reader, long length) {
        return ( Clob ) Proxy.newProxyInstance(getProxyClassLoader(),
                PROXY_INTERFACES,
                new ClobProxy_360( reader, length )
        );
    }
 
    protected static ClassLoader getProxyClassLoader() {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        if ( cl == null ) {
            cl = ClobImplementer.class.getClassLoader();
        }
        return cl;
    }
}