source: geisa/common/implementation/com/ether/JSONHelperImpl.java @ 390

package com.ether;

import java.lang.reflect.TypeVariable;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;

import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonBeanProcessor;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.beans.factory.InitializingBean;

@SuppressWarnings("rawtypes")
public class JSONHelperImpl
        implements JSONHelper, InitializingBean
{
    public JSONHelperImpl()
    {
        _jsonConfig = new JsonConfig();
    }

        public void afterPropertiesSet()
            throws Exception
    {
        for( final Map.Entry<Class, JsonBeanProcessor> mapping : _mapping.entrySet() )
        {
            final Class key = mapping.getKey();
            final JsonBeanProcessor value = mapping.getValue();

            if( LOGGER.isDebugEnabled() )
                LOGGER.debug( key + " now uses custom JSON Serializer : " + value.getClass().getName() );

            _jsonConfig.registerJsonBeanProcessor( key, value );
        }
    }

    @NotNull
    public JSON toJSON( @NotNull final Object object )
    {
        if( object instanceof Throwable )
        {
            final Throwable throwable = (Throwable) object;
            final Throwable throwableWrapper = new Throwable( throwable );
            return JSONSerializer.toJSON( throwableWrapper, _jsonConfig );
        }
        return JSONSerializer.toJSON( object, _jsonConfig );
    }

    @NotNull
    public JSONObject toJSONObject( @NotNull final Object object )
    {
        return (JSONObject) toJSON( object );
    }

    @NotNull
    public JSONArray toJSON( @Nullable final Object[] collection )
    {
        return (JSONArray) JSONSerializer.toJSON( collection, _jsonConfig );
    }

    @NotNull
    public JSONArray toJSON( @Nullable final Collection collection )
    {
        return (JSONArray) JSONSerializer.toJSON( collection, _jsonConfig );
    }

    @SuppressWarnings({"unchecked"})
    @Nullable
    public <T> T fromJSON( @NotNull final JSON json, @NotNull final Class<T> beanClass )
    {
        if( json.isArray() )
        {
            final JSONArray jsonArray = JSONArray.fromObject( json, _jsonConfig );
            if( beanClass.isArray() )
            {
                final Class<?> componentType = beanClass.getComponentType();
                //json.sf.net does not support Long[] or long[]
                if( Long.class.equals( componentType ) || Long.TYPE.equals( componentType ) )
                {
                    final Integer[] integers = (Integer[]) JSONArray.toArray( jsonArray, Integer.class );
                    if( Long.class.equals( componentType ) )
                    {
                        final Long[] resultArray = new Long[integers.length];
                        for( int i = 0; i < integers.length; ++i )
                            resultArray[i] = integers[i].longValue();
                        return (T) resultArray;
                    }
                    if( Long.TYPE.equals( componentType ) )
                    {
                        final long[] resultArray = new long[integers.length];
                        for( int i = 0; i < integers.length; ++i )
                            resultArray[i] = integers[i].longValue();
                        return (T) resultArray;
                    }
                }
                return (T) JSONArray.toArray( jsonArray, componentType );
            }
            if( beanClass.isAssignableFrom( Collection.class ) )
            {
                final TypeVariable<Class<T>>[] typeParameters = beanClass.getTypeParameters();
                if( null == typeParameters || typeParameters.length != 1 || null == typeParameters[0] )
                    return (T) JSONArray.toCollection( jsonArray );
                return (T) JSONArray.toCollection( jsonArray, typeParameters[0].getGenericDeclaration() );
            }
        }
        final JSONObject jsonObject = JSONObject.fromObject( json, _jsonConfig );
        return (T) JSONObject.toBean( jsonObject, beanClass, _mapClassesForDeserialization.get( beanClass ) );
    }

    public Map<Class, JsonBeanProcessor> getMapping()
    {
        return _mapping;
    }

    public void setMapping( final Map<Class, JsonBeanProcessor> mapping )
    {
        _mapping = mapping;
    }

    public Map<Class, Map<String, Class>> getMapClassesForDeserialization()
    {
        return _mapClassesForDeserialization;
    }

    public void setMapClassesForDeserialization( final Map<Class, Map<String, Class>> mapClassesForDeserialization )
    {
        _mapClassesForDeserialization = mapClassesForDeserialization;
    }

    public void setJsonConfig( final JsonConfig jsonConfig )
    {
        _jsonConfig = jsonConfig;
    }

    private static final Log LOGGER = LogFactory.getLog(JSONHelperImpl.class);    

    private Map<Class, JsonBeanProcessor> _mapping = Collections.emptyMap();
    private JsonConfig _jsonConfig;
    private Map<Class, Map<String, Class>> _mapClassesForDeserialization;
}