source: tapas/common/implementation/com/ether/JSONHelperImpl.java @ 399

package com.ether;

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;

import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;

@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 );
            final Class<? super T> superclass = beanClass.getSuperclass();
            if( superclass.isAssignableFrom( AbstractCollection.class ) )
            {
                final Tapas tapas = new Tapas();
                final List<Request> requests = new ArrayList<Request>();
                for( final Object jsonElement : jsonArray )
                {
                    final Request request = fromJSON( (JSON) jsonElement, Request.class );
                    requests.add( request );
                }
                tapas.setRequests( requests );
                return (T) tapas;
            }
//
//            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 );
//        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;
}