Example usage for com.google.gson.reflect TypeToken get

Introduction

In this page you can find the example usage for com.google.gson.reflect TypeToken get.

Prototype

public static <T> TypeToken<T> get(Class<T> type) 

Source Link

Document

Gets type literal for the given Class instance.

Usage

From source file:com.flipkart.batching.gson.RuntimeTypeAdapterFactory.java

License:Open Source License

public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) {
    if (type.getRawType() != baseType) {
        return null;
    }/*from   w  w w . j a va 2s  . c om*/

    final Map<String, TypeAdapter<?>> labelToDelegate = new LinkedHashMap<>();
    final Map<Class<?>, TypeAdapter<?>> subtypeToDelegate = new LinkedHashMap<>();

    for (Map.Entry<String, Class<?>> entry : labelToSubtype.entrySet()) {
        TypeAdapter<?> delegate = labelToTypeAdapter.get(entry.getKey());
        if (delegate == null) {
            delegate = gson.getDelegateAdapter(this, TypeToken.get(entry.getValue()));
        }
        labelToDelegate.put(entry.getKey(), delegate);
        subtypeToDelegate.put(entry.getValue(), delegate);
    }

    return new TypeAdapter<R>() {
        @Override
        public R read(JsonReader reader) throws IOException {

            if (reader.peek() == com.google.gson.stream.JsonToken.NULL) {
                reader.nextNull();
                return null;
            }
            if (reader.peek() != com.google.gson.stream.JsonToken.BEGIN_OBJECT) {
                reader.skipValue();
                return null;
            }
            reader.beginObject();

            String label = null;
            R result = null;
            while (reader.hasNext()) {
                String name = reader.nextName();
                com.google.gson.stream.JsonToken jsonToken = reader.peek();
                if (jsonToken == com.google.gson.stream.JsonToken.NULL) {
                    reader.skipValue();
                    continue;
                }
                switch (name) {
                case "type":
                    label = TypeAdapters.STRING.read(reader);
                    break;
                case "value":
                    @SuppressWarnings("unchecked") // registration requires that subtype extends T
                    TypeAdapter<R> delegate = label == null ? null
                            : (TypeAdapter<R>) labelToDelegate.get(label);
                    if (delegate == null) {
                        throw new JsonParseException("cannot deserialize " + baseType + " subtype named "
                                + label + "; did you forget to register a subtype?");
                    }
                    result = delegate.read(reader);
                    break;
                default:
                    reader.skipValue();
                    break;
                }
            }

            reader.endObject();
            return result;
        }

        @Override
        public void write(JsonWriter out, R value) throws IOException {
            Class<?> srcType = value.getClass();
            @SuppressWarnings("unchecked") // registration requires that subtype extends T
            TypeAdapter<R> delegate = (TypeAdapter<R>) subtypeToDelegate.get(srcType);
            if (delegate == null) {
                throw new JsonParseException(
                        "cannot serialize " + srcType.getName() + "; did you forget to register a subtype?");
            }
            String label = subtypeToLabel.get(srcType);
            out.beginObject();

            out.name("type");
            out.value(label);

            out.name("value");
            delegate.write(out, value);

            out.endObject();
        }
    }.nullSafe();
}

---

From source file:com.gilecode.yagson.adapters.AdapterUtils.java

License:Apache License

@SuppressWarnings("unchecked")
public static <T> void writeByReflectiveAdapter(JsonWriter out, T obj, WriteContext ctx, Gson gson,
        Type formalType) throws IOException {
    TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(TypeUtils.mergeTypes(obj.getClass(), formalType));
    TypeAdapter<T> adapter = gson.getAdapter(typeToken);
    if (!(adapter instanceof ReflectiveTypeAdapterFactory.Adapter)) {
        adapter = gson.getReflectiveTypeAdapterFactory().create(gson, typeToken);
    }//w  ww  .  ja v  a2  s .  c  o  m
    adapter.write(out, obj, ctx);
}

---

From source file:com.gilecode.yagson.adapters.DefaultTypeAdapterRuntimeWrapper.java

License:Apache License

private TypeAdapter<T> getTypeAdapterFor(Class<? extends T> rawType) {
    Type type = TypeUtils.mergeTypes(rawType, formalType);
    return (TypeAdapter<T>) gson.getAdapter(TypeToken.get(type));
}

---

From source file:com.gilecode.yagson.adapters.ThreadTypesAdapterFactory.java

License:Apache License

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    Class<? super T> rawType = typeToken.getRawType();
    if (ThreadGroup.class.isAssignableFrom(rawType)) {
        @SuppressWarnings({ "unchecked", "rawtypes" })
        TypeAdapter<T> result = (TypeAdapter) new ThreadGroupAdapter();
        return result;
    } else if (Thread.class.isAssignableFrom(rawType)) {
        @SuppressWarnings({ "unchecked", "rawtypes" })
        TypeAdapter<T> result = (TypeAdapter) new ThreadAdapter();
        return result;
    } else if (ThreadLocal.class.isAssignableFrom(rawType)) {
        TypeToken<?> fieldType = TypeToken.get($Gson$Types.getSingleParameterType(typeToken.getType(),
                typeToken.getRawType(), ThreadLocal.class));

        ReflectiveTypeAdapterFactory.BoundField valueField = new ReflectiveTypeAdapterFactory.DefaultBoundField(
                "@.value", null, true, true, gson, fieldType) {
            @Override//from  ww  w .  j  a v a2s  .  c o  m
            protected boolean writeField(Object value, WriteContext ctx)
                    throws IOException, IllegalAccessException {
                if (value == null) {
                    return false;
                }
                Object threadLocalMap = getCurrentThreadMap(value);
                return threadLocalMap != null && getThreadLocalEntry(threadLocalMap, value) != null;
            }

            @Override
            @SuppressWarnings("unchecked")
            protected void applyReadFieldValue(Object value, Object fieldValue) throws IllegalAccessException {
                if (fieldValue != null) {
                    ((ThreadLocal) value).set(fieldValue);
                }
            }

            @Override
            protected Object getFieldValue(Object value) throws IllegalAccessException {
                Object threadLocalMap = getCurrentThreadMap(value);
                if (threadLocalMap != null) {
                    Object threadLocalEntry = getThreadLocalEntry(threadLocalMap, value);
                    if (threadLocalEntry != null) {
                        return threadLocalEntryValueField.get(threadLocalEntry);
                    }
                }
                return null;
            }

            @SuppressWarnings("unchecked")
            protected void applyReadPlaceholder(final Object value,
                    Map<Field, ReferencePlaceholder> fieldPlaceholders,
                    ReferencePlaceholder fieldValuePlaceholder) {
                // the thread local's "value" is not a real field, so do not add it to 'fieldPlaceholders' map
                fieldValuePlaceholder.registerUse(new PlaceholderUse() {
                    @Override
                    public void applyActualObject(Object actualObject) throws IOException {
                        try {
                            applyReadFieldValue(value, actualObject);
                        } catch (IllegalAccessException e) {
                            throw new IOException(e);
                        }
                    }
                });
            }
        };
        return gson.getReflectiveTypeAdapterFactory().createSpecial(gson, typeToken,
                Collections.singletonList(valueField), null);
    }
    return null;
}

---

From source file:com.gilecode.yagson.types.ConstructingObjectProvider.java

License:Apache License

@SuppressWarnings("unchecked")
public static <E> ObjectProvider<E> defaultOf(E instance, ConstructorConstructor cc) {
    TypeToken<E> typeToken = (TypeToken<E>) TypeToken.get(instance.getClass());
    return new ConstructingObjectProvider<E>(cc.get(typeToken));
}

---

From source file:com.gilecode.yagson.types.TypeUtils.java

License:Apache License

private static <T> T readTypeAdvisedValueAfterType(Gson gson, JsonReader in, ReadContext ctx, Type valueType)
        throws IOException {
    T result = null;//from  w w w.j av a  2  s  .co m
    if (consumeValueField(in)) {
        // use actual type adapter instead of delegate
        TypeAdapter<?> typeAdapter = gson.getAdapter(TypeToken.get(valueType));
        result = (T) typeAdapter.read(in, ctx);
    }

    in.endObject();
    return result;
}

---

From source file:com.gilecode.yagson.types.TypeUtils.java

License:Apache License

public static void writeTypeWrapperAndValue(JsonWriter out, Object value, TypeAdapter adapter, WriteContext ctx)
        throws IOException {
    Class<?> actualClass = value.getClass();
    String parameterTypes = "";
    if (EnumSet.class.isAssignableFrom(actualClass)) {
        Class<? extends Enum> enumClass = getField(enumSetElementTypeField, value);
        // change the written class to EnumSet (from RegularEnumSet/JumboEnumSet)
        actualClass = EnumSet.class;
        // write parameter for EnumSet type
        parameterTypes = "<" + enumClass.getName() + ">";
        // replace the used adapter for the one with known element type
        Type enumSetType = $Gson$Types.newParameterizedTypeWithOwner(null, actualClass, enumClass);
        adapter = ctx.getGson().getAdapter(TypeToken.get(enumSetType));
    } else if (EnumMap.class.isAssignableFrom(actualClass)) {
        Class<? extends Enum> enumClass = getField(enumMapKeyTypeField, value);
        int mapKeyTypeVarIdx;
        TypeVariable[] actualClassTypeVariables = actualClass.getTypeParameters();
        if (EnumMap.class.equals(actualClass)) {
            mapKeyTypeVarIdx = 0;/*from  w  ww. j  a v  a  2 s .c o m*/
            parameterTypes = "<" + enumClass.getName() + ",?>";
        } else {
            // the parameters may be overridden in subclasses
            // print the parameters, only if the enum (key) type is still present in the parameters lists of the actuall class
            TypeVariable mapKeyTypeVar = EnumMap.class.getTypeParameters()[0];
            mapKeyTypeVarIdx = indexOfInheritedTypeVariable(mapKeyTypeVar, EnumMap.class, actualClass);
            if (mapKeyTypeVarIdx >= 0) {
                StringBuilder sb = new StringBuilder();
                sb.append("<");
                for (int i = 0; i < actualClassTypeVariables.length; i++) {
                    if (i == mapKeyTypeVarIdx) {
                        sb.append(enumClass.getName());
                    } else {
                        sb.append('?');
                    }
                    sb.append(',');
                }
                sb.setCharAt(sb.length() - 1, '>'); // delete last ',' and add '>'
                parameterTypes = sb.toString();
            }
        }

        if (mapKeyTypeVarIdx >= 0) {
            TypeAdapter resolvedAdapter = AdapterUtils.resolve(adapter, value);
            if (resolvedAdapter instanceof MapTypeAdapterFactory.Adapter) {
                Type formalMapType = ((MapTypeAdapterFactory.Adapter) resolvedAdapter).getFormalMapType();
                Type[] typeArgsWithExactKeyType = new Type[actualClassTypeVariables.length];
                Arrays.fill(typeArgsWithExactKeyType, unknownType);
                typeArgsWithExactKeyType[mapKeyTypeVarIdx] = enumClass;

                Type mergedMapType = mergeTypes($Gson$Types.newParameterizedTypeWithOwner(
                        actualClass.getEnclosingClass(), actualClass, typeArgsWithExactKeyType), formalMapType);
                adapter = ctx.getGson().getAdapter(TypeToken.get(mergedMapType));
            }
        } // else key type is already fixed in subtypes, so do not print params and do not update adapter
    }

    // do not print type wrapper if the value is known to be skipped

    boolean isValueSkipped = AdapterUtils.isSkipSerializeTypeAdapter(adapter);
    if (!isValueSkipped) {
        out.beginObject();
        out.name("@type");
        out.value(actualClass.getName() + parameterTypes);
        out.name("@val");
    }

    adapter.write(out, value, ctx);
    if (!isValueSkipped) {
        out.endObject();
    }
}

---

From source file:com.github.easyjsonapi.adapters.EasyJsonApiMachine.java

License:Apache License

/**
 * Set classes need to use when create the json api structure
 * /*from   w  w  w.j  a  va2 s. c  o  m*/
 * @param clazz
 *            the class or classes need to use
 */
public final void setClassesUsed(Class<?>... clazz) {

    this.tokenTypesToUse.clear();

    if (this.classesUsedInJson.isEmpty()) {
        this.classesUsedInJson.addAll(Arrays.asList(clazz));
    } else {
        if (this.classesUsedInJson.isEmpty()) {
            this.classesUsedInJson.addAll(Arrays.asList(clazz));
        } else {
            this.classesUsedInJson.addAll(Arrays.asList(clazz));
            this.classesUsedInJson.retainAll(Arrays.asList(clazz));
        }
    }

    if (this.config.getClassesParsed().isEmpty()) {
        // Use Map structure to support the default configuration
        Type mapType = TypeToken.get(Map.class).getType();
        this.tokenTypesToUse.put(EasyJsonApiTypeToken.TOKEN_DEFAULT, mapType);
    } else {
        for (Map.Entry<EasyJsonApiTypeToken, List<Class<?>>> clazzMapping : this.config.getClassesParsed()
                .entrySet()) {
            List<Class<?>> classes = clazzMapping.getValue();

            for (Class<?> cla : classes) {
                if (this.classesUsedInJson.contains(cla)) {
                    Type classType = TypeToken.get(cla).getType();
                    this.tokenTypesToUse.put(clazzMapping.getKey(), classType);
                }
            }
        }
    }
}

---

From source file:com.github.kyriosdata.regras.infraestrutura.CustomRegraTypeAdapterFactory.java

License:Creative Commons License

@Override
public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> type) {
    if (type.getRawType() != Regra.class)
        return null;

    final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);

    return new TypeAdapter<T>() {
        @Override//from  w  w w. j a v  a 2s.  c o  m
        public void write(final JsonWriter jsonWriter, final T t) throws IOException {
            jsonWriter.beginObject();
            jsonWriter.name("tipo");
            jsonWriter.value(getTipo(t.getClass().getName()));
            jsonWriter.name("obj");
            delegate.write(jsonWriter, t);
            jsonWriter.endObject();
        }

        @Override
        public T read(final JsonReader jsonReader) throws IOException, JsonParseException {
            JsonElement tree = Streams.parse(jsonReader);
            JsonObject object = tree.getAsJsonObject();

            String clazz = object.get("tipo").getAsString();
            JsonElement obj = object.get("obj").getAsJsonObject();

            if ("expressao".equals(clazz)) {
                return (T) gson.getDelegateAdapter(CustomRegraTypeAdapterFactory.this,
                        TypeToken.get(RegraExpressao.class)).fromJsonTree(obj);
            }

            if ("pontosPorRelato".equals(clazz)) {
                return (T) gson.getDelegateAdapter(CustomRegraTypeAdapterFactory.this,
                        TypeToken.get(RegraPontosPorRelato.class)).fromJsonTree(obj);
            }

            throw new JsonParseException("Erro ao desserializar " + type + ". No  uma regra?");
        }
    };
}

---

From source file:com.github.ljtfreitas.restify.http.client.message.converter.json.GsonMessageConverter.java

License:Open Source License

@Override
public T read(HttpResponseMessage httpResponseMessage, Type expectedType)
        throws RestifyHttpMessageReadException {
    try {/*ww w  .  j a  va  2s . c o m*/
        TypeToken<?> token = TypeToken.get(expectedType);

        Reader json = new InputStreamReader(httpResponseMessage.body());

        return this.gson.fromJson(json, token.getType());
    } catch (JsonIOException | JsonSyntaxException e) {
        throw new RestifyHttpMessageReadException(e);
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• »