~play-developers/play/zdb

package fr.zenexity.json;

 

import fr.zenexity.json.JSON.FieldWrapper;

import fr.zenexity.json.JSONTokenizer.Token;

import java.io.IOException;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.lang.reflect.Type;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

import static fr.zenexity.json.JSONTokenizer.Token.*;

 

class BeanBinder implements JSONBinder {

 

    private static final Logger log = Logger.getLogger("fr.zenexity.json");

    private Class forClass;

    private Map<String, FieldWrapper> fields = new HashMap<String, FieldWrapper>();

 

    public BeanBinder(Class forClass) {

        super();

        this.forClass = forClass;

        initialize();

    }

 

    /**

     * Introspect the bean class for properties and getters/setters

     * Field informations are cached in a {@link  FieldWrapper FieldWrapper} structure

     */

    private void initialize() {

        Set<Field> fieldset = new HashSet<Field>();

        findAllFields(forClass, fieldset);

        for (Field field : fieldset) {

            if (isSettable(field)) {

                FieldWrapper fw = new FieldWrapper(field, forClass);

                field.setAccessible(true);

                // todo there is a problem here if a superclass define a private field with same name

                fields.put(field.getName(), fw);

            }

        }

    }

 

    public static void findAllFields(Class clazz, Set<Field> found) {

        Field[] fields = clazz.getDeclaredFields();

        for (int i = 0; i < fields.length; i++) {

            found.add(fields[i]);

        }

        Class sClazz = clazz.getSuperclass();

        if (sClazz != null && sClazz != Object.class) {

            findAllFields(sClazz, found);

        }

    }

 

    public Object read(Class<?> clazz, Type type, JSONReader reader) {

        Token tok = reader.assertIs(START_MAP);

        try {

            Object instance = clazz.newInstance();

            tok = reader.nextToken();

            if (tok == END_MAP) {

                return instance;

            }

            for (;;) {

                String key = tok.value;

                tok = reader.nextToken();

                reader.assertIs(SEMICOLON);

                FieldWrapper wrapper = fields.get(key);

                if (wrapper == null) {

                    log.fine("no field " + key + " in bean " + clazz.getSimpleName() + " : skipping json data");

                    reader.skip();

                } else {

                    tok = reader.nextToken();

                    Object value = reader.readInternal(wrapper.field.getName(), wrapper.field.getType(), wrapper.field.getGenericType(), tok);

                    try {

                        wrapper.setValue(instance, value);

                    } catch (Exception e) {

                        log.log(Level.SEVERE, "unable to set field value for " + wrapper.field, e);

                    }

                }

                //

                tok = reader.nextToken();

                if (tok == END_MAP) {

                    break;

                }

                reader.assertIs(COMMA);

                tok = reader.nextToken();

            }

            return instance;

        } catch (JSONException pex) {

            throw pex;

        } catch (Exception ex) {

            throw JSONException.bindError("beanbinder failure", ex, reader.getParser());

        }

    }

 

    public boolean isSettable(Field field) {

        final int unmodifiable = Modifier.STATIC + Modifier.NATIVE + Modifier.FINAL + Modifier.TRANSIENT;

        return (field.getModifiers() & unmodifiable) == 0;

    }

 

    public void write(Object obj, JSONWriter jsonWriter) {

        Set<String> keys;

        try {

            int i = 0;

            jsonWriter.writeChar('{');

            keys = fields.keySet();

            for (String fieldname : keys) {

                if (i++ > 0) {

                    jsonWriter.writeChar(',');

                }

                FieldWrapper wrapper = fields.get(fieldname);

                jsonWriter.writeString(fieldname);

                jsonWriter.writeChar(':');

                log.fine("field:"+fieldname+" wrapper:"+wrapper);

                jsonWriter.write(wrapper.getValue(obj));

            }

            jsonWriter.writeChar('}');

 

        } catch (IOException ex) {

            log.log(Level.SEVERE, null, ex);

        }

    }

}