com.feilong.lib.xstream.core.util.ThreadSafePropertyEditor Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of feilong Show documentation

feilong is a suite of core and expanded libraries that include utility classes, http, excel,cvs, io classes, and much much more.

There is a newer version: 4.0.8

Show newest version

/*
 * Copyright (c) 2007, 2008, 2016 XStream Committers.
 * All rights reserved.
 *
 * The software in this package is published under the terms of the BSD
 * style license a copy of which has been included with this distribution in
 * the LICENSE.txt file.
 * 
 * Created on 20. September 2007 by Joerg Schaible
 */
package com.feilong.lib.xstream.core.util;

import java.beans.PropertyEditor;

import com.feilong.lib.xstream.converters.ConversionException;
import com.feilong.lib.xstream.converters.ErrorWritingException;
import com.feilong.lib.xstream.converters.reflection.ObjectAccessException;

/**
 * Wrapper around {@link PropertyEditor} that can be called by multiple threads concurrently.
 * 
 * A PropertyEditor is not thread safe. To make best use of resources, the PropertyEditor
 * provides a dynamically sizing pool of instances, each of which will only be called by a
 * single thread at a time.
 * 
 * 
 * The pool has a maximum capacity, to limit overhead. If all instances in the pool are in use
 * and another is required, it shall block until one becomes available.
 * 
 * 
 * @author Jörg Schaible
 * @since 1.3
 */
public class ThreadSafePropertyEditor{

    private final Class editorType;

    private final Pool  pool;

    public ThreadSafePropertyEditor(Class type, int initialPoolSize, int maxPoolSize){
        if (!PropertyEditor.class.isAssignableFrom(type)){
            throw new IllegalArgumentException(type.getName() + " is not a " + PropertyEditor.class.getName());
        }
        editorType = type;
        pool = new Pool(initialPoolSize, maxPoolSize, () -> {
            ErrorWritingException ex = null;
            try{
                return editorType.newInstance();
            }catch (InstantiationException e1){
                ex = new ConversionException("Faild to call default constructor", e1);
            }catch (IllegalAccessException e2){
                ex = new ObjectAccessException("Cannot call default constructor", e2);
            }
            ex.add("construction-type", editorType.getName());
            throw ex;
        });
    }

    public String getAsText(Object object){
        PropertyEditor editor = fetchFromPool();
        try{
            editor.setValue(object);
            return editor.getAsText();
        }finally{
            pool.putInPool(editor);
        }
    }

    public Object setAsText(String str){
        PropertyEditor editor = fetchFromPool();
        try{
            editor.setAsText(str);
            return editor.getValue();
        }finally{
            pool.putInPool(editor);
        }
    }

    private PropertyEditor fetchFromPool(){
        PropertyEditor editor = (PropertyEditor) pool.fetchFromPool();
        return editor;
    }
}