public class Value<T> {

    private T value;

    public Value(T ponylevel) {
        this.value = ponylevel;
    }

    public T get() {
        return value;
    }

    public void set(T val) {
        this.value = val;
    }

    public static class TypeFactory implements TypeAdapterFactory {

        @SuppressWarnings({ "rawtypes", "unchecked" })
        @Override
        public <T> TypeAdapter<T> create(final Gson gson, TypeToken<T> typeToken) {
            final Type type = typeToken.getType();
            System.out.println(type);
            if (!(typeToken.getRawType().isAssignableFrom(Value.class))) {
                return null;
            }
            System.out.println(type);

            Type componentType = ((ParameterizedType)type).getActualTypeArguments()[0];
            TypeAdapter<?> componentTypeAdapter = gson.getAdapter(TypeToken.get(componentType));

            return new TypeTypeAdapter(componentTypeAdapter);
        }

    }

    private static class TypeTypeAdapter<T> extends TypeAdapter<Value<T>> {

        private TypeAdapter<T> adapter;

        public TypeTypeAdapter(TypeAdapter<T> adapter) {
            this.adapter = adapter;
        }

        @Override
        public void write(JsonWriter out, Value<T> value) throws IOException {
            adapter.write(out, value.get());
        }

        @Override
        public Value<T> read(JsonReader in) throws IOException {
            return new Value<T>(adapter.read(in));
        }
    }
}