Java Examples for com.google.gson.reflect.TypeToken

@Test(timeout = 1000)
public void testSerializeComplexMapWithTypeAdapter_add1210() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(), this, "testSerializeComplexMapWithTypeAdapter_add1210");
    Type type = new TypeToken<java.util.Map<Point, java.lang.String>>() {
    }.getType();
    Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create();
    Map<Point, java.lang.String> original = new LinkedHashMap<Point, java.lang.String>();
    original.put(new Point(5, 5), "a");
    original.put(new Point(8, 8), "b");
    String json = gson.toJson(original, type);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1731, json);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1732, original);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1734, gson, 1733, gson.<java.util.Map<com.google.gson.functional.MapAsArrayTypeAdapterTest.Point, java.lang.String>>fromJson(json, type));
    Map<java.lang.String, java.lang.Boolean> otherMap = new LinkedHashMap<java.lang.String, java.lang.Boolean>();
    otherMap.put("t", true);
    otherMap.put("f", false);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1736, gson, 1735, gson.toJson(otherMap, java.util.Map.class));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1738, gson, 1737, gson.toJson(otherMap, new com.google.gson.reflect.TypeToken<java.util.Map<java.lang.String, java.lang.Boolean>>() {
    }.getType()));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1739, otherMap);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1741, gson, 1740, gson.<java.lang.Object>fromJson("{\"t\":true,\"f\":false}", new com.google.gson.reflect.TypeToken<java.util.Map<java.lang.String, java.lang.Boolean>>() {
    }.getType()));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<T> rawType = (Class<T>) type.getRawType();
    AutoGson annotation = rawType.getAnnotation(AutoGson.class);
    // Only deserialize classes decorated with @AutoGson.
    if (annotation == null) {
        return null;
    }
    return (TypeAdapter<T>) gson.getAdapter(annotation.autoValueClass());
}

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    if (alreadyResolvedTypeTokensRegistry.contains(type)) {
        return null;
    }
    if (classConfig.getConfiguredClass().isAssignableFrom(type.getRawType())) {
        TypeAdapter<T> fireTypeAdapter = new NullableTypeAdapter<T>(new TypeSelectorTypeAdapter<T>(type.getRawType(), classConfig.getTypeSelector(), gson));
        return fireTypeAdapter;
    } else {
        return null;
    }
}

@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<? super T> rawType = type.getRawType();
    AutoGson annotation = rawType.getAnnotation(AutoGson.class);
    // Only deserialize classes decorated with @AutoGson.
    if (annotation == null) {
        return null;
    }
    return (TypeAdapter<T>) gson.getAdapter(annotation.autoValueClass());
}

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> type) {
    TypeAdapter<T> typeAdapter = null;
    try {
        if (type.getRawType() == List.class) {
            typeAdapter = new ArrayAdapter((Class) ((ParameterizedType) type.getType()).getActualTypeArguments()[0], contentValuesAdapter);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return typeAdapter;
}

public static void main(final String... args) throws IOException {
    // Register the AutoMatterTypeAdapterFactory to handle deserialization
    Gson gson = new GsonBuilder().registerTypeAdapterFactory(new AutoMatterTypeAdapterFactory()).create();
    GenericFoobar<Integer> foobar = new GenericFoobarBuilder<Integer>().foo(17).bar(1, 2, 3).putBaz("hello world", 4711).build();
    String json = gson.toJson(foobar);
    out.println("json: " + json);
    GenericFoobar<Integer> parsed = gson.fromJson(json, new TypeToken<GenericFoobar<Integer>>() {
    }.getType());
    out.println("parsed: " + parsed);
    out.println("equals: " + foobar.equals(parsed));
}

public <T extends ModelBase> List<T> convertPageResults(Class<T> clazz) {
    List<T> result = new ArrayList<T>();
    Gson gson = JsonEnvelopeDeserializer.makeGsonDeserializer();
    Type ty = TypeToken.get(clazz).getType();
    for (JsonObject jObj : pageResults) {
        T currentObj = gson.fromJson(jObj, ty);
        currentObj.setJsonObject(jObj);
        result.add(currentObj);
    }
    return result;
}

public static List<FindMoreEntity> parseFromJson(String jsonData) {
    List<FindMoreEntity> entities = new ArrayList<>();
    Type listType = new TypeToken<LinkedList<FindMoreEntity>>() {
    }.getType();
    Gson gson = new Gson();
    LinkedList<FindMoreEntity> findMoreEntities = gson.fromJson(jsonData, listType);
    for (Iterator iterator = findMoreEntities.iterator(); iterator.hasNext(); ) {
        FindMoreEntity findMoreEntity = (FindMoreEntity) iterator.next();
        entities.add(findMoreEntity);
    }
    return entities;
}

@Test
public void testGetAvailableDownloads() throws PhrescoException {
    PhrescoServerFactory.initialize();
    RepositoryManager repoMgr = PhrescoServerFactory.getRepositoryManager();
    String downloadInfoJSON = repoMgr.getArtifactAsString(SOFTWARE_REPO_PATH);
    Type type = new TypeToken<List<DownloadInfo>>() {
    }.getType();
    Gson gson = new Gson();
    List<DownloadInfo> downloadInfoList = gson.fromJson(downloadInfoJSON, type);
    assertNotNull(downloadInfoList);
}

@Test
public void testContData() {
    ContDataComparator cdc = new ContDataComparator();
    IData<ContValue> data = cdc.getContData();
    JSONUtils ju = new JSONUtils();
    Gson gson = JSONUtils.getFilledDefaultGsonBuilder().create();
    String s = gson.toJson(data);
    System.out.println(s);
    InMemoryData<ContValue> d = gson.fromJson(s, new TypeToken<InMemoryData<ContValue>>() {
    }.getType());
    String s2 = gson.toJson(d);
    assertEquals(s, s2);
    cdc.assertEqual(d);
}

@Override
public void run() {
    try {
        String response = HttpRequest.get(Constant.SERVER_URL + "/api/event").body();
        Log.w("GETEVENTS:" + response);
        Gson gson = new Gson();
        Type collectionType = new TypeToken<ArrayList<Event>>() {
        }.getType();
        ArrayList<Event> events = gson.fromJson(response, collectionType);
        mHandler.sendMessage(Message.obtain(mHandler, CODE_OK, events));
    } catch (Exception e) {
        Log.e("other exception, maybe encrypt: " + e.getMessage());
        sendMessage(CODE_ERROR);
    }
}

@Override
protected void loadDataByGson() {
    RequestQueue requestQueue = VolleyHelper.getInstance(getContext().getApplicationContext()).getAPIRequestQueue();
    GsonRequest<GenericSubjectItem<DisplayItem>> gsonRequest = new GsonRequest<GenericSubjectItem<DisplayItem>>(calledURL, new TypeToken<GenericSubjectItem<DisplayItem>>() {
    }.getType(), null, listener, errorListener);
    gsonRequest.setCacheNeed(getContext().getCacheDir() + "/" + cacheFileName);
    requestQueue.add(gsonRequest);
}

@Override
public List<Comic> deserialize(JsonElement je, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    Type listType = new TypeToken<List<Comic>>() {
    }.getType();
    JsonElement data = je.getAsJsonObject().get("data");
    JsonElement results = je.getAsJsonObject().get("results");
    JsonArray resultsArray = results.getAsJsonArray();
    JsonElement comicsObject = resultsArray.get(0);
    JsonElement items = comicsObject.getAsJsonObject().get("items");
    return new Gson().fromJson(items, listType);
}

@Test
public void test1() {
    Gson gson = CanvasRestAdapter.getGSONParser();
    List<Attachment> list = gson.fromJson(JSON, new TypeToken<List<Attachment>>() {
    }.getType());
    assertNotNull(list);
    Attachment attachment = list.get(0);
    assertTrue(attachment.getId() > 0);
    assertNotNull(attachment.getDisplayName());
    assertNotNull(attachment.getFilename());
    assertNotNull(attachment.getUrl());
    assertNotNull(attachment.getThumbnailUrl());
    assertNotNull(attachment.getMimeType());
}

@Override
public ModifiableStructure build(String structure) {
    MapStringStringStructure mapStringStringStructure = new MapStringStringStructure();
    if (StringUtils.isNotBlank(structure)) {
        TypeToken<MapStringStringStructure> listTypeToken = new TypeToken<MapStringStringStructure>() {
        };
        mapStringStringStructure = gson.fromJson(structure, listTypeToken.getType());
        mapStringStringStructure.dirty = false;
    }
    return mapStringStringStructure;
}

@Override
protected Response<List<String>> parseNetworkResponse(NetworkResponse response) {
    Gson gson = new Gson();
    String body = new String(response.data);
    Type type = new TypeToken<List<Repo>>() {
    }.getType();
    List<Repo> repos = gson.fromJson(body, type);
    List<String> repoNames = new ArrayList<>(repos.size());
    for (Repo repo : repos) {
        repoNames.add(repo.name);
    }
    return Response.success(repoNames, HttpHeaderParser.parseCacheHeaders(response));
}

@Test
public void test() {
    Map<String, String> colours = new HashMap<String, String>();
    colours.put("BLACK", "#000000");
    colours.put("RED", "#FF0000");
    colours.put("GREEN", "#008000");
    colours.put("BLUE", "#0000FF");
    colours.put("YELLOW", "#FFFF00");
    colours.put("WHITE", "#FFFFFF");
    //
    // Convert a Map into JSON string.
    //
    Gson gson = new Gson();
    String json = gson.toJson(colours);
    System.out.println("json = " + json);
    //
    // Convert JSON string back to Map.
    //
    Type type = new TypeToken<Map<String, String>>() {
    }.getType();
    Map<String, String> map = gson.fromJson(json, type);
    for (String key : map.keySet()) {
        System.out.println("map.get = " + map.get(key));
    }
}

@Override
public ReportDefinition load() throws Exception {
    try {
        return (ReportDefinition) new MotechJsonReader().readFromFile(reportDefinitionFileName, new TypeToken<ReportDefinition>() {
        }.getType());
    } catch (Exception e) {
        logger.error("Currently Running on: " + System.getProperty("user.dir"));
        logger.error(MessageFormat.format("Error loading report definition. Message: {0}", e.getMessage()));
        logger.error(getFullStackTrace(e));
        throw e;
    }
}

public void testWrapList() throws Exception {
    List<ConferenceSession> sessions = new ArrayList<ConferenceSession>();
    for (int i = 0; i < 10; i++) {
        ConferenceSession session = new ConferenceSession();
        session.setTrackName("test track" + i);
        session.setSessionTitle("title" + i);
        session.setSpeakerName("tester" + i);
        sessions.add(session);
    }
    Parcelable parcelable = GsonParcer.wrap(sessions);
    List<ConferenceSession> objects = GsonParcer.unwrap(parcelable, new TypeToken<Collection<ConferenceSession>>() {
    });
    for (int i = 0; i < 10; i++) {
        ConferenceSession object = objects.get(i);
        assertEquals("test track" + i, object.getTrackName());
        assertEquals("title" + i, object.getSessionTitle());
        assertEquals("tester" + i, object.getSpeakerName());
    }
}

@Override
public List<JATETerm> read(String file) throws IOException {
    //        JSONObject jo=gson.fromJson(file, JSONObject.class);
    Type listType = new TypeToken<ArrayList<JATETerm>>() {
    }.getType();
    List<JATETerm> terms = gson.fromJson(new InputStreamReader(new FileInputStream(file), "UTF8"), listType);
    Collections.sort(terms);
    return terms;
}

@Override
public ArrayList<Video> getCacheByPage(int page) {
    QueryBuilder<com.socks.greendao.VideoCache> query = mVideoCacheDao.queryBuilder().where(VideoCacheDao.Properties.Page.eq("" + page));
    if (query.list().size() > 0) {
        return (ArrayList<Video>) JSONParser.toObject(query.list().get(0).getResult(), new TypeToken<ArrayList<Video>>() {
        }.getType());
    } else {
        return new ArrayList<>();
    }
}

public void updateUserMeta(SqlSession sqlSession, long userId, String metaKey, Map<String, Object> metaValue) throws Exception {
    metaKey = metaKey.replaceAll("(?)[^a-z0-9_]", "");
    Gson gson = new Gson();
    Type listType = new TypeToken<Map<String, Object>>() {
    }.getType();
    String json = gson.toJson(metaValue, listType);
    // Deserialize : gson.fromJson(json, listType);
    logger.debug("--- json: " + json);
    userMetaMapper = sqlSession.getMapper(UserMetaMapper.class);
    UserMeta userMeta = userMetaMapper.selectUserMeta(userId, metaKey);
    if (null == userMeta)
        userMetaMapper.insertUserMeta(userId, metaKey, json);
    else
        userMetaMapper.updateUserMeta(userMeta.getUmetaId(), metaKey, json);
}

@Override
public Result deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    // Name
    String name = json.getAsJsonObject().get("name").getAsString();
    checkState(name != null, "Missing name");
    // Tags
    JsonElement tagsElement = json.getAsJsonObject().get("tags");
    Map<String, List<String>> tags = context.deserialize(tagsElement, new TypeToken<Map<String, List<String>>>() {
    }.getType());
    // Group_By
    JsonElement group_by = json.getAsJsonObject().get("group_by");
    List<GroupResult> groupResults = context.deserialize(group_by, new TypeToken<List<GroupResult>>() {
    }.getType());
    List<DataPoint> dataPoints = new ArrayList<DataPoint>();
    if (group_by != null) {
        String type = null;
        for (GroupResult groupResult : groupResults) {
            if (groupResult.getName().equals("type")) {
                type = ((DefaultGroupResult) groupResult).getType();
            }
        }
        checkState(type != null, "Missing type");
        // Data points
        final Class dataPointValueClass = typeRegistry.getDataPointValueClass(type);
        checkState(dataPointValueClass != null, "type: " + type + " is not registered to a custom data type.");
        JsonArray array = (JsonArray) json.getAsJsonObject().get("values");
        for (JsonElement element : array) {
            JsonArray pair = element.getAsJsonArray();
            dataPoints.add(new DataPoint(pair.get(0).getAsLong(), context.<DataPoint>deserialize(pair.get(1), dataPointValueClass)));
        }
    }
    return new Result(name, tags, dataPoints, groupResults);
}

public static Object performQuery(String query, QueryType qt) {
    StringBuffer response = new StringBuffer();
    try {
        URL obj = new URL("http://rgai.inf.u-szeged.hu/kpe_rest/wiki/" + qt.toString().toLowerCase() + "?query=" + URLEncoder.encode(query, "UTF-8"));
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        // optional default is GET
        con.setRequestMethod("GET");
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String responseLine;
        while ((responseLine = in.readLine()) != null) {
            response.append(responseLine);
        }
        in.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    Gson g = new Gson();
    return g.fromJson(response.toString(), new TypeToken<Collection<Object>>() {
    }.getType());
}

public void write(JsonWriter out, T value) throws IOException {
    TypeAdapter chosen = this.delegate;
    Type runtimeType = getRuntimeTypeIfMoreSpecific(this.type, value);
    if (runtimeType != this.type) {
        TypeAdapter runtimeTypeAdapter = this.context.getAdapter(TypeToken.get(runtimeType));
        if (!(runtimeTypeAdapter instanceof ReflectiveTypeAdapterFactory.Adapter)) {
            chosen = runtimeTypeAdapter;
        } else if (!(this.delegate instanceof ReflectiveTypeAdapterFactory.Adapter)) {
            chosen = this.delegate;
        } else {
            chosen = runtimeTypeAdapter;
        }
    }
    chosen.write(out, value);
}

public void getUserInfo(long userId, final RequestCallback<User> callback) {
    String request = URL_CENTER.replace("{userId}", userId + "");
    NetProxy.getInstance(getContext()).doGetRequest(request, new NetProxy.OnResponseListener() {

        @Override
        public void onResponse(String result, String requestId) {
            ReturnInfo<User> returnInfo = getGson().fromJson(result, new TypeToken<ReturnInfo<User>>() {
            }.getType());
            if (callback != null) {
                callback.callback(returnInfo, requestId);
            }
        }
    });
}

private RoutePath getRoutePath(int resource) {
    if (resource == 0) {
        return null;
    }
    RoutePath routePath;
    InputStream raw = mContext.getResources().openRawResource(resource);
    Reader reader = new BufferedReader(new InputStreamReader(raw));
    final Gson gson = new GsonBuilder().registerTypeAdapter(RouteDirection.class, new RouteDirectionDeserializer()).create();
    Type listType = new TypeToken<RoutePath>() {
    }.getType();
    routePath = gson.fromJson(reader, listType);
    return routePath;
}

@Override
protected void loadDataByGson() {
    RequestQueue requestQueue = VolleyHelper.getInstance(getContext().getApplicationContext()).getAPIRequestQueue();
    GsonRequest<GenericBlock<DisplayItem>> gsonRequest = new GsonRequest<GenericBlock<DisplayItem>>(calledURL, new TypeToken<GenericBlock<DisplayItem>>() {
    }.getType(), null, listener, errorListener);
    gsonRequest.setCacheNeed(getContext().getCacheDir() + "/" + cacheFileName);
    requestQueue.add(gsonRequest);
}

/*
     * (non-Javadoc) {@inheritDoc}
     */
@Override
public Navigation run() throws Exception {
    Validators v = new Validators(request);
    v.add("calendarId", v.required());
    v.add("keyword", v.maxlength(KEYWORD_MAX_LENGTH));
    v.add("notifyErrorMail", v.required());
    if (!v.validate()) {
        response.setStatus(HttpStatusConstants.FORBIDDEN);
        return null;
    }
    MyCalendar myCalendar = new MyCalendar();
    BeanUtil.copy(request, myCalendar);
    myCalendar.setDisabled(false);
    calendarService.putMyCalendar(myCalendar);
    Map<String, String> map = new HashMap<String, String>();
    map.put("status", "ok");
    JsonWriter writer = new JsonWriter(response.getWriter());
    TypeToken<Map<String, Object>> typeToken = new TypeToken<Map<String, Object>>() {
    };
    Type type = typeToken.getType();
    new Gson().toJson(map, type, writer);
    return null;
}

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<? super T> rawType = type.getRawType();
    if (Node.class.isAssignableFrom(rawType)) {
        TypeAdapter<List<Node>> collectionAdapter = gson.getAdapter(new TypeToken<List<Node>>() {
        });
        return (TypeAdapter<T>) new NodeAdapter(collectionAdapter);
    } else if (List.class.isAssignableFrom(rawType)) {
        Type type2 = type.getType();
        if (type2 instanceof ParameterizedType && ((ParameterizedType) type2).getActualTypeArguments().length == 1) {
            Type type3 = ((ParameterizedType) type2).getActualTypeArguments()[0];
            if (Node.class.isAssignableFrom($Gson$Types.getRawType(type3))) {
                TypeAdapter<Node> nodeAdapter = gson.getAdapter(Node.class);
                TypeAdapter<List<?>> collectionAdapter = gson.getAdapter(new TypeToken<List<?>>() {
                });
                return (TypeAdapter<T>) new NodeListAdapter(collectionAdapter, nodeAdapter);
            }
        }
    }
    return null;
}

/**
     * Utility method to create a standard {@link Gson} for the system. The standard GSon will register the
     * {@link AtomicStringTypeAdapter} and the various serializers (Presets, Banks, Favorites)
     *
     * @return a non-null {@link Gson}
     */
public static Gson createGson() {
    final GsonBuilder gs = new GsonBuilder();
    gs.registerTypeAdapter(new TypeToken<AtomicReference<String>>() {
    }.getType(), new AtomicStringTypeAdapter());
    gs.registerTypeAdapter(RioPreset.class, new RioPresetSerializer());
    gs.registerTypeAdapter(RioBank.class, new RioBankSerializer());
    gs.registerTypeAdapter(RioFavorite.class, new RioFavoriteSerializer());
    return gs.create();
}

public static List<String> nameHistoryFromUuid(UUID uuid) throws IOException {
    String url = "https://api.mojang.com/user/profiles/" + uuid.toString().replace("-", "") + "/names";
    Request request = new Request.Builder().url(url).get().build();
    ResponseBody body = httpClient.newCall(request).execute().body();
    String response = body.string();
    body.close();
    Type listType = new TypeToken<List<Name>>() {
    }.getType();
    List<Name> names = RedisBungee.getGson().fromJson(response, listType);
    List<String> humanNames = new ArrayList<>();
    for (Name name : names) {
        humanNames.add(name.name);
    }
    return humanNames;
}

public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) {
    final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
    final TypeAdapter<JsonElement> elementAdapter = gson.getAdapter(JsonElement.class);
    return new TypeAdapter<T>() {

        public void write(JsonWriter out, T value) throws IOException {
            delegate.write(out, value);
        }

        public T read(JsonReader in) throws IOException {
            JsonElement jsonElement = elementAdapter.read(in);
            if (jsonElement.isJsonObject()) {
                JsonObject jsonObject = jsonElement.getAsJsonObject();
                if (jsonObject.has("cod") && jsonObject.get("cod").getAsInt() == 404) {
                    throw new IllegalArgumentException(jsonObject.get("message").getAsString());
                }
            }
            return delegate.fromJsonTree(jsonElement);
        }
    }.nullSafe();
}

public <T extends SoundcloudEntity> SoundcloudApiQuery<T> create(final URLWrapper url, final HttpMethod method, final TypeToken<T> typeToken) {
    // Using very ugly, manual injection here, because I couldn't figure out
    // how to dynamically resolve the generic type using TypeLiterals.
    final SoundcloudApiQuery<T> instance;
    if (mPreferences.getSSLEnabled()) {
        instance = new SecureSoundcloudApiQueryImpl<T>(url, method, typeToken);
    } else {
        instance = new SoundcloudApiQueryImpl<T>(url, method, typeToken);
    }
    mInjector.injectMembers(instance);
    return instance;
}

public void analyse(String requestJsonFile, String jsonFile, AbstractNodeRefResSumAnalysis analysis, MetricDataAnswer answer) throws Exception {
    SegmentMock segmentMock = new SegmentMock();
    String requestJsonStr = segmentMock.loadJsonFile(requestJsonFile);
    Gson gson = new Gson();
    List<AbstractNodeRefResSumAnalysis.NodeRefResRecord> resRecordList = gson.fromJson(requestJsonStr, new TypeToken<List<AbstractNodeRefResSumAnalysis.NodeRefResRecord>>() {
    }.getType());
    for (AbstractNodeRefResSumAnalysis.NodeRefResRecord resRecord : resRecordList) {
        analysis.analyse(resRecord);
    }
    analysis.onWork(new EndOfBatchCommand());
    List<MetricData> metricDataList = answer.getMetricDataList();
    MetricDataMergeJson.INSTANCE.merge(jsonFile, metricDataList);
}

public ChargeRefundCollection deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).create();
    // API versions 2014-05-19 and earlier render charge refunds as an array instead of an object
    if (json.isJsonArray()) {
        Type refundListType = new TypeToken<List<Refund>>() {
        }.getType();
        List<Refund> refunds = gson.fromJson(json, refundListType);
        ChargeRefundCollection collection = new ChargeRefundCollection();
        collection.setData(refunds);
        collection.setHasMore(false);
        collection.setTotalCount(refunds.size());
        return collection;
    }
    return gson.fromJson(json, typeOfT);
}

@Override
public List<WorkoutHolderModel> deserialize(JsonElement je, Type type, JsonDeserializationContext jdc) throws JsonParseException {
    JsonElement workoutHolder = je.getAsJsonObject().get("data");
    Type listType = new TypeToken<List<WorkoutHolderModel>>() {
    }.getType();
    List<WorkoutHolderModel> workoutHolders = new Gson().fromJson(workoutHolder, listType);
    JsonArray workouts = workoutHolder.getAsJsonArray();
    int index = 0;
    for (JsonElement workout : workouts) {
        List<WorkoutsExercisesModel> workoutExercises = new ArrayList<WorkoutsExercisesModel>();
        JsonElement exercises = workout.getAsJsonObject().get("exercises");
        for (JsonElement exercise : exercises.getAsJsonArray()) {
            WorkoutsExercisesModel exe = new Gson().fromJson(exercise.getAsJsonObject().get("exercise"), WorkoutsExercisesModel.class);
            workoutExercises.add(exe);
        }
        workoutHolders.get(index).setExercises(workoutExercises);
        index++;
    }
    return workoutHolders;
}

private static <K, V> TypeToken<Map<K, List<V>>> getMapOfListsToken(TypeToken<ListMultimap<K, V>> from) {
    ParameterizedType rawType = (ParameterizedType) from.getSupertype(ListMultimap.class).getType();
    // key type is K
    @SuppressWarnings("unchecked") TypeToken<K> keyType = (TypeToken<K>) TypeToken.of(rawType.getActualTypeArguments()[0]);
    // value type is V
    @SuppressWarnings("unchecked") TypeToken<V> valueType = (TypeToken<V>) TypeToken.of(rawType.getActualTypeArguments()[1]);
    return new TypeToken<Map<K, List<V>>>() {
    }.where(new TypeParameter<K>() {
    }, keyType).where(new TypeParameter<V>() {
    }, valueType);
}

@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(@NonNull final Gson gson, @NonNull final TypeToken<T> type) {
    final Class<? super T> rawType = type.getRawType();
    if (!rawType.isAnnotationPresent(AutoGson.class)) {
        return null;
    }
    final String packageName = rawType.getPackage().getName();
    final String className = rawType.getName().substring(packageName.length() + 1).replace('$', '_');
    final String autoParcelName = packageName + ".AutoParcel_" + className;
    try {
        final Class<?> autoParcelType = Class.forName(autoParcelName);
        return (TypeAdapter<T>) gson.getAdapter(autoParcelType);
    } catch (final ClassNotFoundException e) {
        throw new RuntimeException("Could not load AutoParcel type " + autoParcelName, e);
    }
}

/**
	 * 查询版本信�
	 * @return
	 */
public static APKBean checkVersion() {
    APKBean bean = null;
    List<NameValuePair> params = new ArrayList<NameValuePair>();
    String s = new HttpManager(Const.APKURL).submitRequest(params);
    //String s = "{"result":"true","url":"http://www.yeezhao.com/mobilefile/update/v1.apk","version":"1.0"}";
    Log.d(Const.TAG, "AppAction.checkVersion|jsonStr=" + s);
    if (s != null && !"".equals(s)) {
        Gson gson = new Gson();
        try {
            bean = gson.fromJson(s, new TypeToken<APKBean>() {
            }.getType());
        } catch (JsonParseException e) {
            Log.e(Const.TAG, "AppAction.checkVersion|JsonParseException", e);
        }
    }
    return bean;
}

public Response<AuthenticationContext> authenticate(String userIdentifier, String userSecret) throws SmartlingApiException {
    final HttpPost httpPost = createJsonPostRequest(getApiUrl(AUTH_API_V2_AUTHENTICATE, baseUrl), new AuthenticationCommand(userIdentifier, userSecret));
    final StringResponse response = executeRequest(httpPost);
    return getApiV2Response(response.getContents(), new TypeToken<ApiV2ResponseWrapper<AuthenticationContext>>() {
    });
}

/**
     * Parses the JSON file into data models
     * @return List of DrawerCategory Models
     */
public List<DrawerCategoryModel> serializeJson() {
    try {
        Reader reader = new InputStreamReader(context.getResources().openRawResource(resId));
        Gson gson = new GsonBuilder().create();
        Type listType = new TypeToken<List<DrawerCategoryModel>>() {
        }.getType();
        List<DrawerCategoryModel> list = gson.fromJson(reader, listType);
        reader.close();
        return list;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

public PaymentMethod create() throws AuthenticationException, InvalidRequestException, APIConnectionException, CardException, APIException {
    BillForwardClient client = BillForwardClient.getClient();
    String fullRoute = "tokenization/auth-capture";
    APIResponse<PaymentMethod> apiResponse = client.requestUntyped(BillForwardClient.RequestMethod.POST, fullRoute, this, new TypeToken<APIResponse<PaymentMethod>>() {
    }.getType());
    if (apiResponse.getResults() != null && apiResponse.getResults().length > 0) {
        return apiResponse.getResults()[0];
    } else {
        String message = "Error in capturing token";
        if (apiResponse.getErrorMessage() != null) {
            message = apiResponse.getErrorMessage();
        }
        throw new CardException(message, null, null, null);
    }
}

public static SearchEngineUtil getInstance() {
    if (searchEngineUtil == null) {
        searchEngineUtil = new SearchEngineUtil();
        if (searchEngineUtil.searchEngines == null) {
            String s = SPHelper.getString(SEARCH_ENGINES, ENGINES);
            searchEngineUtil.searchEngines = new Gson().fromJson(s, new TypeToken<ArrayList<SearchEngine>>() {
            }.getType());
        }
    }
    return searchEngineUtil;
}

private void loadSiteURL() {
    if (mBlog == null)
        return;
    String siteURL = null;
    Gson gson = new Gson();
    Type type = new TypeToken<Map<?, ?>>() {
    }.getType();
    Map<?, ?> blogOptions = gson.fromJson(mBlog.getBlogOptions(), type);
    if (blogOptions != null) {
        Map<?, ?> homeURLMap = (Map<?, ?>) blogOptions.get("home_url");
        if (homeURLMap != null)
            siteURL = homeURLMap.get("value").toString();
    }
    // Try to guess the URL of the site if blogOptions is null (blog not added to the app)
    if (siteURL == null) {
        siteURL = mBlog.getUrl().replace("/xmlrpc.php", "");
    }
    loadAuthenticatedUrl(siteURL);
}

/**
	 * Gets the popular stories.
	 * 
	 * @param tag the tag
	 * @param count the count
	 * 
	 * @return the popular stories
	 */
public List<Story> getPopularStories(String tag, int count) {
    GatewayApiUrlBuilder builder = createApiUrlBuilder(ApplicationConstants.DIGG_SEARCH_URL);
    String apiUrl = builder.withParameter("query", tag).withParameter("count", String.valueOf(count)).buildUrl();
    JsonObject json = parseJson(callApiGet(apiUrl)).getAsJsonObject();
    return unmarshall(new TypeToken<List<Story>>() {
    }, json.get("stories"));
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void write(JsonWriter out, HibernateProxy value) throws IOException {
    if (value == null) {
        out.nullValue();
        return;
    }
    LazyInitializer initializer = value.getHibernateLazyInitializer();
    if (initializer.isUninitialized()) {
        out.nullValue();
        return;
    } else {
        // Retrieve the original (not proxy) class
        Class<?> baseType = Hibernate.getClass(value);
        // Get the TypeAdapter of the original class, to delegate the serialization
        TypeAdapter delegate = context.getAdapter(TypeToken.get(baseType));
        // Get a filled instance of the original class
        Object unproxiedValue = initializer.getImplementation();
        // Serialize the value
        delegate.write(out, unproxiedValue);
    }
}

/**
	 * Get JSON string and convert to T (Object) you need
	 * 
	 * @param json
	 * @return Object filled with JSON string data
	 */
public static <T> T fromJson(String json, Class<T> cls) {
    if (json == null || json.equals("")) {
        return null;
    }
    Gson gson = create();
    JsonParser parser = new JsonParser();
    JsonElement element = parser.parse(json);
    // check if the Class type is array but the Json is an object
    if (cls != null && cls.isArray() && element instanceof JsonArray == false) {
        JsonArray jsonArray = new JsonArray();
        jsonArray.add(element);
        Type listType = new TypeToken<T>() {
        }.getType();
        return gson.fromJson(jsonArray, listType);
    }
    try {
        return gson.fromJson(json, cls);
    } catch (Exception e) {
        return null;
    }
}

public ArrayList<Movie> getFavorites() {
    ArrayList<Movie> favorites = new ArrayList<>();
    String favs = preferences.getString("favorites", "");
    Type listType = new TypeToken<ArrayList<Movie>>() {
    }.getType();
    ArrayList<Movie> list = new Gson().fromJson(favs, listType);
    if (list != null) {
        favorites = list;
    }
    Collections.sort(favorites);
    return favorites;
}

@Override
public <T> TypeAdapter<T> create(final Gson gson, TypeToken<T> token) {
    if (!World.class.isAssignableFrom(token.getRawType())) {
        return null;
    }
    return new TypeAdapter<T>() {

        @Override
        public T read(JsonReader reader) throws IOException {
            UUID uuid = gson.fromJson(reader, UUID.class);
            World world = Bukkit.getWorld(uuid);
            if (world == null && throwsException) {
                throw new GsonLoadRuntimeException("Unable to load world for uuid :" + uuid);
            }
            return (T) world;
        }

        @Override
        public void write(JsonWriter writer, T obj) throws IOException {
            World world = (World) obj;
            gson.toJson(world.getUID(), UUID.class, writer);
        }
    };
}

public String saveOrUpdate() throws Exception {
    String json = request.getParameter("cfgs");
    Type type = new TypeToken<List<BThersholdCfg>>() {
    }.getType();
    Gson gson = new Gson();
    List<BThersholdCfg> list = gson.fromJson(json, type);
    try {
        thersholdCfgComponent.saveOrUpdate(list.toArray(new BThersholdCfg[list.size()]));
    } catch (Exception e) {
        throw new ActionException(e.getMessage());
    }
    return JSON_SUCCESS;
}

private void fillViews(String photoString) {
    Type type = new TypeToken<RoverItem>() {
    }.getType();
    RoverItem item = new Gson().fromJson(photoString, type);
    Picasso.with(this).load(item.getImg_src()).into(marsImage);
    sol.setText("Sol : " + item.getSol());
    earthDate.setText("EarthDate : " + item.getEarth_date());
    roverInfoObject.setText("Rover info object : " + new Gson().toJson(item.getRover()).toString());
}

public void testListCall() {
    CloudStackClient client = new CloudStackClient("192.168.130.22", 8080, false);
    CloudStackCommand command = new CloudStackCommand("listVirtualMachines");
    command.setParam("domainid", "1");
    command.setParam("account", "admin");
    command.setParam("page", "1");
    command.setParam("pagesize", "20");
    try {
        List<CloudStackUserVm> vms = client.listCall(command, API_KEY, SECRET_KEY, "listvirtualmachinesresponse", "virtualmachine", new TypeToken<List<CloudStackUserVm>>() {
        }.getType());
        for (CloudStackUserVm vm : vms) {
            logger.info("id: " + vm.getId() + ", name: " + vm.getName());
        }
    } catch (Exception e) {
        logger.error("Unexpected exception ", e);
    }
}

public void testListCall() {
    CloudStackClient client = new CloudStackClient("192.168.130.22", 8080, false);
    CloudStackCommand command = new CloudStackCommand("listVirtualMachines");
    command.setParam("domainid", "1");
    command.setParam("account", "admin");
    command.setParam("page", "1");
    command.setParam("pagesize", "20");
    try {
        List<CloudStackUserVm> vms = client.listCall(command, API_KEY, SECRET_KEY, "listvirtualmachinesresponse", "virtualmachine", new TypeToken<List<CloudStackUserVm>>() {
        }.getType());
        for (CloudStackUserVm vm : vms) {
            logger.info("id: " + vm.getId() + ", name: " + vm.getName());
        }
    } catch (Exception e) {
        logger.error("Unexpected exception ", e);
    }
}

@Test
public void testInsertJsonInRecord() {
    long record = TestData.getLong();
    JsonObject json = new JsonObject();
    json.addProperty("boolean", true);
    json.addProperty("number", TestData.getScaleCount());
    json.addProperty("string", TestData.getSimpleString());
    Response resp = post("/{0}", json.toString(), record);
    boolean body = bodyAsJava(resp, TypeToken.get(Boolean.class));
    Assert.assertTrue(body);
    Assert.assertEquals(200, resp.code());
    Assert.assertEquals(json.get("boolean").getAsBoolean(), client.get("boolean", record));
    Assert.assertEquals(json.get("number").getAsNumber(), client.get("number", record));
    Assert.assertEquals(json.get("string").getAsString(), client.get("string", record));
}

@Override
public Response<List<String>> getStatusPeers() {
    RawResponse rawResponse = rawClient.makeGetRequest("/v1/status/peers");
    if (rawResponse.getStatusCode() == 200) {
        List<String> value = GsonFactory.getGson().fromJson(rawResponse.getContent(), new TypeToken<List<String>>() {
        }.getType());
        return new Response<List<String>>(value, rawResponse);
    } else {
        throw new OperationException(rawResponse);
    }
}

private void load() {
    try {
        Gson gson = new GsonBuilder().create();
        InputStream is = new FileInputStream(config);
        timers = gson.fromJson(Utils.stream2str(is), new TypeToken<List<Timer>>() {
        }.getType());
    } catch (Exception ignored) {
    }
    if (timers == null) {
        timers = new LinkedList<Timer>();
    }
}

public static List<AccessToken> arrayAccessTokenFromData(String str, String key) {
    try {
        JSONObject jsonObject = new JSONObject(str);
        Type listType = new TypeToken<ArrayList<AccessToken>>() {
        }.getType();
        return new Gson().fromJson(jsonObject.getString(str), listType);
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return new ArrayList();
}

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    if (!JsonStringWrapper.class.isAssignableFrom(type.getRawType())) {
        return null;
    }
    /**
         * Cast is checked since we check if JsonStringWrapper is assignable from type T
         */
    @SuppressWarnings("unchecked") TypeAdapter<T> result = (TypeAdapter<T>) new JsonStringWrapperAdapter();
    return result;
}

public void loadFromFile() {
    int ch;
    StringBuffer fileContent = new StringBuffer("");
    FileInputStream fis;
    try {
        fis = context.openFileInput(FILENAME);
        while ((ch = fis.read()) != -1) fileContent.append((char) ch);
    } catch (FileNotFoundException e) {
        Log.e(TAG, "FileNotFoundException while readingFromFile");
    } catch (IOException e) {
        Log.e(TAG, "IOException while readingFromFile");
    }
    Gson gson = new Gson();
    String json = new String(fileContent);
    Type listType = new TypeToken<ArrayList<GameCharacter>>() {
    }.getType();
    List<GameCharacter> characters = gson.fromJson(json, listType);
    GameCharacterManager.setCharactersFromStore(characters);
}

public static void put(Account account, List<Broadcast> broadcastList, Context context) {
    if (broadcastList.size() > MAX_LIST_SIZE) {
        broadcastList = broadcastList.subList(0, MAX_LIST_SIZE);
    }
    // NOTE: Defend against ConcurrentModificationException.
    DiskCacheHelper.putGson(getKeyForAccount(account), new ArrayList<>(broadcastList), new TypeToken<List<Broadcast>>() {
    }, context);
}

@Override
protected void disposeResult(String apiName, String content) {
    super.disposeResult(apiName, content);
    if (!apiName.equals(Method.QUERY_ANNOUNCEMENT))
        return;
    list.clear();
    try {
        Type collectionType = new TypeToken<List<Information>>() {
        }.getType();
        List<Information> newList = fromJson(content, collectionType);
        list.addAll(newList);
    } catch (Exception e) {
        e.printStackTrace();
        showToast(R.string.error_data);
    }
    if (list.size() > 0) {
        setAdatper();
    } else {
        showToast(R.string.no_information);
    }
}

public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<T> rawType = (Class<T>) type.getRawType();
    if (!rawType.isEnum()) {
        return null;
    }
    final Map<String, T> lowercaseToConstant = new HashMap<String, T>();
    for (T constant : rawType.getEnumConstants()) {
        lowercaseToConstant.put(toLowercase(constant), constant);
    }
    return new TypeAdapter<T>() {

        public void write(JsonWriter out, T value) throws IOException {
            if (value == null) {
                out.nullValue();
            } else {
                out.value(toLowercase(value));
            }
        }

        public T read(JsonReader reader) throws IOException {
            if (reader.peek() == JsonToken.NULL) {
                reader.nextNull();
                return null;
            } else {
                return lowercaseToConstant.get(reader.nextString().toLowerCase());
            }
        }
    };
}

/**
   * Registers type adapters by implicit type. Adds one to read numbers in a {@code Map<String,
   * Object>} as Integers.
   */
static Gson create(Iterable<TypeAdapter<?>> adapters) {
    GsonBuilder builder = new GsonBuilder().setPrettyPrinting();
    builder.registerTypeAdapter(new TypeToken<Map<String, Object>>() {
    }.getType(), new DoubleToIntMapTypeAdapter());
    for (TypeAdapter<?> adapter : adapters) {
        Type type = resolveLastTypeParameter(adapter.getClass(), TypeAdapter.class);
        builder.registerTypeAdapter(type, adapter);
    }
    return builder.create();
}

@Override
public FGVersionWrapper deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    FGVersionWrapper wrapper = new FGVersionWrapper();
    List<FGVersion> versions = context.deserialize(json, new TypeToken<List<FGVersion>>() {
    }.getType());
    for (int i = 0; i < versions.size(); i++) {
        FGVersion v = versions.get(i);
        v.index = i;
        wrapper.versions.add(v.version);
        wrapper.versionObjects.put(v.version, v);
    }
    return wrapper;
}

@Override
public List<LogCatMessage> retrieveLogCat(String poolName, String safeSerial, TestIdentifier testIdentifier) {
    File logcatJsonFile = fileManager.getFile(FileType.JSON_LOG, poolName, safeSerial, testIdentifier);
    try {
        FileReader fileReader = new FileReader(logcatJsonFile);
        return gson.fromJson(fileReader, new TypeToken<List<LogCatMessage>>() {
        }.getType());
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void onCompleted(String result) {
    assertNotNull(result);
    Gson gson = new Gson();
    Type type = new TypeToken<Review>() {
    }.getType();
    Review review = gson.fromJson(result, type);
    assertEquals(review.getId(), 1);
    Log.d(TAG, "Id: " + review.getId());
    Log.d(TAG, "Star: " + review.getStar());
    Log.d(TAG, "Comment: " + review.getComment());
    signal.countDown();
}

@Test
public void listTasks() throws Exception {
    RestResponse r = adminRestSession.get("/config/server/tasks/");
    r.assertOK();
    List<TaskInfo> result = newGson().fromJson(r.getReader(), new TypeToken<List<TaskInfo>>() {
    }.getType());
    assertThat(result).isNotEmpty();
    boolean foundLogFileCompressorTask = false;
    for (TaskInfo info : result) {
        if ("Log File Compressor".equals(info.command)) {
            foundLogFileCompressorTask = true;
        }
        assertThat(info.id).isNotNull();
        Long.parseLong(info.id, 16);
        assertThat(info.command).isNotNull();
        assertThat(info.startTime).isNotNull();
    }
    assertThat(foundLogFileCompressorTask).isTrue();
}

@Test
public void testSerialization() {
    Map<String, String> map = new HashMap<String, String>();
    map.put("a", "alligator");
    map.put("b", "bear");
    map.put("c", "caterpillar");
    map.put("d", "dingo");
    map.put("e", "eagle");
    String json = JsonUtils.toJsonString(map);
    assertEquals("{\"d\":\"dingo\",\"e\":\"eagle\",\"b\":\"bear\",\"c\":\"caterpillar\",\"a\":\"alligator\"}", json);
    Map<String, String> map2 = JsonUtils.fromJsonString(json, new TypeToken<Map<String, String>>() {
    }.getType());
    assertEquals(map, map2);
    SomeJsonObject someJson = new SomeJsonObject();
    json = JsonUtils.toJsonString(someJson);
    SomeJsonObject someJson2 = JsonUtils.fromJsonString(json, SomeJsonObject.class);
    assertEquals(someJson.name, someJson2.name);
    SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd HHmmss");
    assertEquals(df.format(someJson.date), df.format(someJson2.date));
}

public static <T> T getObj4String(String gsonStr, TypeToken<T> typeToken, FieldNamingStrategy fieldNamingStrategy) {
    GsonBuilder gsonBuilder = new GsonBuilder();
    if (null != fieldNamingStrategy) {
        gsonBuilder.setFieldNamingStrategy(fieldNamingStrategy);
    }
    Gson gson = gsonBuilder.create();
    T response = null;
    try {
        response = gson.fromJson(gsonStr, typeToken.getType());
    } catch (JsonSyntaxException exception) {
    }
    return response;
}

public static <T> T getObj4String(String gsonStr, TypeToken<T> typeToken, FieldNamingStrategy fieldNamingStrategy) {
    GsonBuilder gsonBuilder = new GsonBuilder();
    if (null != fieldNamingStrategy) {
        gsonBuilder.setFieldNamingStrategy(fieldNamingStrategy);
    }
    Gson gson = gsonBuilder.create();
    T response = null;
    try {
        response = gson.fromJson(gsonStr, typeToken.getType());
    } catch (JsonSyntaxException exception) {
    }
    return response;
}

public void testOurTypeFunctionality() throws Exception {
    Type parameterizedType = new TypeToken<List<String>>() {
    }.getType();
    assertNull(ourType.getOwnerType());
    assertEquals(String.class, ourType.getActualTypeArguments()[0]);
    assertEquals(List.class, ourType.getRawType());
    assertEquals(parameterizedType, ourType);
    assertEquals(parameterizedType.hashCode(), ourType.hashCode());
}

private void loadSiteURL() {
    String siteURL = null;
    Gson gson = new Gson();
    Type type = new TypeToken<Map<?, ?>>() {
    }.getType();
    Map<?, ?> blogOptions = gson.fromJson(mBlog.getBlogOptions(), type);
    if (blogOptions != null) {
        Map<?, ?> homeURLMap = (Map<?, ?>) blogOptions.get("home_url");
        if (homeURLMap != null)
            siteURL = homeURLMap.get("value").toString();
    }
    // Try to guess the URL of the site if blogOptions is null (blog not added to the app)
    if (siteURL == null) {
        siteURL = mBlog.getUrl().replace("/xmlrpc.php", "");
    }
    loadAuthenticatedUrl(siteURL);
}

@Override
public boolean handle(final WebView view, String url) {
    if (TextUtils.isEmpty(url)) {
        return false;
    }
    final Uri uri = Uri.parse(url);
    if (TextUtils.equals(uri.getPath(), getPath())) {
        TaskBuilder.create(new Callable<ArrayList<MenuItem>>() {

            @Override
            public ArrayList<MenuItem> call() throws Exception {
                String data = uri.getQueryParameter(KEY_DATA);
                if (TextUtils.isEmpty(data)) {
                    return null;
                }
                // get the menus
                return GsonHelper.getInstance().fromJson(data, new TypeToken<ArrayList<MenuItem>>() {
                }.getType());
            }
        }, new SimpleTaskCallback<ArrayList<MenuItem>>() {

            @Override
            public void onTaskSuccess(ArrayList<MenuItem> menuItems, Bundle extras) {
                if (null != menuItems && !menuItems.isEmpty()) {
                    // show the menus and tilte
                    if (null != view && view.getContext() instanceof RexxarActivity) {
                        ((RexxarActivity) view.getContext()).setMenuItems(menuItems);
                    } else {
                        Toast.makeText(view.getContext(), R.string.error_partial_rexxar_menu, Toast.LENGTH_SHORT).show();
                    }
                }
            }
        }, TAG).start();
        return true;
    }
    return false;
}

@Override
public Observable<HotSpot> getHotSpots(Location location) {
    TypeToken<List<HotSpot>> hotSpotsToken = new TypeToken<List<HotSpot>>() {
    };
    return CafeJava.invokeProcedure(new JavaProcedureInvoker.Builder("CloudantGeoAdapter", "users/{user_id}/wifi").pathParam("user_id", "user1").queryParam("lat", Double.toString(location.getLatitude())).queryParam("lon", Double.toString(location.getLongitude())).build()).compose(CafeJava.serializeTo(hotSpotsToken)).flatMap(new Func1<List<HotSpot>, Observable<HotSpot>>() {

        @Override
        public Observable<HotSpot> call(List<HotSpot> hotSpots) {
            return Observable.from(hotSpots);
        }
    });
}

@Test
public void adaptersProvided() {
    check(adapterFactory.create(gson, TypeToken.get(A.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(B.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(B.C.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(D.E.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(D.F.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(G.H.class))).notNull();
}

@Test
public void adaptersProvided() {
    check(adapterFactory.create(gson, TypeToken.get(A.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(B.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(B.C.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(D.E.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(D.F.class))).notNull();
    check(adapterFactory.create(gson, TypeToken.get(G.H.class))).notNull();
}

@Override
public void doFilter(ServletRequest req, ServletResponse arg1, FilterChain arg2) throws IOException, ServletException {
    if (roles.isEmpty()) {
        Gson g = new Gson();
        HttpServletRequest request = (HttpServletRequest) req;
        final BufferedReader userData = new BufferedReader(new InputStreamReader(request.getServletContext().getResourceAsStream(Utils.PATH_TO_PROVIDERS + USER_ROLES_JSON)));
        List<UserInRole> tempRead = g.fromJson(userData, new TypeToken<List<UserInRole>>() {
        }.getType());
        roles.addAll(tempRead);
    }
}

@Override
protected void initTypes() {
    Type stringMapListType = new TypeToken<List<StringMap>>() {
    }.getType();
    super.userClass = StringMap.class;
    super.userList = stringMapListType;
    super.subjectClass = StringMap.class;
    super.subjectList = stringMapListType;
    super.enrollmentClass = StringMap.class;
    super.enrollmentList = stringMapListType;
    super.courseClass = StringMap.class;
    super.courseList = stringMapListType;
    super.spaceClass = StringMap.class;
    super.spaceList = stringMapListType;
    super.statusClass = StringMap.class;
    super.statusList = stringMapListType;
    super.environmentClass = StringMap.class;
    super.chatMessageClass = StringMap.class;
    super.chatMessageList = stringMapListType;
    super.chatClass = StringMap.class;
    super.chatList = stringMapListType;
    super.lectureClass = StringMap.class;
    super.lectureList = stringMapListType;
}

@SuppressWarnings("unused")
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String fileSetString = req.getParameter("fileSet");
    Collection<FileInfo> newFiles = gson.fromJson(fileSetString, new TypeToken<Collection<FileInfo>>() {
    }.getType());
    resp.getWriter().write(gson.toJson(strategy.createExpiredFileSet(newFiles, currentFiles)));
    // updates the currentFiles, as FileInfo hashes by name.
    for (FileInfo fileInfo : newFiles) {
        currentFiles.remove(fileInfo);
        currentFiles.add(fileInfo);
    }
}

public void stream(Response response) {
    if (response.getError().equals("PANIC")) {
        System.err.println(response.getResponse());
        System.exit(1);
    }
    Collection<TestResult> results = gson.fromJson(response.getResponse(), new TypeToken<Collection<TestResult>>() {
    }.getType());
    for (TestResult result : results) {
        BrowserInfo browserInfo = response.getBrowser();
        result.setBrowserInfo(browserInfo);
        printer.print(result);
    }
}

@GET
@Path("node")
@Produces(MediaType.APPLICATION_JSON)
public Response monitorNode(@Context ServletContext context) {
    PrestoUtil prestoUtil = new PrestoUtil();
    String json = prestoUtil.getNode(0, null);
    Type stringStringMap = new TypeToken<Map<String, String>>() {
    }.getType();
    Map<String, String> map = gson.fromJson(json, stringStringMap);
    return Response.ok(gson.toJson(prestoUtil.getNode(0, null))).build();
}

@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<? super T> rawType = type.getRawType();
    if (!rawType.isEnum()) {
        return null;
    }
    final Map<String, Object> lowercaseToConstant = new HashMap<String, Object>();
    for (Object constant : rawType.getEnumConstants()) {
        lowercaseToConstant.put(toLowercase(constant), constant);
    }
    return new TypeAdapter() {

        @Override
        public void write(JsonWriter out, Object value) throws IOException {
            if (value == null) {
                out.nullValue();
            } else {
                out.value(LowerCaseEnumTypeAdapterFactory.this.toLowercase(value));
            }
        }

        @Override
        public T read(JsonReader reader) throws IOException {
            if (reader.peek() == JsonToken.NULL) {
                reader.nextNull();
                return null;
            }
            return (T) lowercaseToConstant.get(reader.nextString());
        }
    };
}

@Override
public void onNext(JSONObject obj) {
    super.onNext(obj);
    Gson mGson = new Gson();
    JSONArray appfocusArray = obj.optJSONArray("app-focus");
    Type type = new TypeToken<List<Banner>>() {
    }.getType();
    if (appfocusArray != null) {
        List<Banner> banners = mGson.fromJson(appfocusArray.toString(), type);
        mPresenterView.onGetBanners(banners);
    }
}

public static GsonGetRequest<HttpObject> createGetRequest(final String url, final List<BasicNameValuePair> params, Response.Listener<HttpObject> listener, Response.ErrorListener errorListener) {
    String formatUrl = Utils.attachHttpGetParams(url, params);
    final Gson gson = new GsonBuilder().registerTypeAdapter(HttpObject.class, new HttpObjectDeserializer()).create();
    return new GsonGetRequest<>(formatUrl, new TypeToken<HttpObject>() {
    }.getType(), gson, listener, errorListener);
}

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<? super T> rawType = type.getRawType();
    if (!rawType.isEnum()) {
        return null;
    }
    final Map<Object, Object> lowercaseToConstant = new HashMap<Object, Object>();
    for (Object constant : rawType.getEnumConstants()) {
        lowercaseToConstant.put(toLowercase(constant), constant);
    }
    return new TypeAdapter<T>() {

        public void write(JsonWriter out, Object value) throws IOException {
            if (value == null)
                out.nullValue();
            else
                out.value((String) LowerCaseEnumTypeAdapterFactory.this.toLowercase(value));
        }

        @SuppressWarnings("unchecked")
        public T read(JsonReader reader) throws IOException {
            if (reader.peek() == JsonToken.NULL) {
                reader.nextNull();
                return null;
            }
            return (T) lowercaseToConstant.get(reader.nextString());
        }
    };
}

public static void main(String[] args) throws IOException {
    Gson gson = new Gson();
    InputStream rules = MDMLanguageMain.class.getResourceAsStream("/mdmlang-rules.txt");
    InputStream json = MDMLanguageMain.class.getResourceAsStream("/source-data.json");
    MDMProcessorContext ctx = MDMProcessorContext.buildContext(rules);
    Type type = new TypeToken<Map<String, Object>>() {
    }.getType();
    Map<String, Object> values = gson.fromJson(new InputStreamReader(json), type);
    Map<String, Object> golden = ctx.process(values);
    System.out.println(gson.toJson(golden));
}

/**
	 * Retrieve users registered in a course
	 * 
	 * @param courseid
	 *            Moodle courseid of the course
	 * 
	 * @return list of MoodleUser
	 */
public List<MoodleUser> getUsers(int courseid) {
    // So that we know about network
    List<MoodleUser> mUsers = null;
    // failures
    String format = MoodleRestOption.RESPONSE_FORMAT;
    String function = MoodleRestOption.FUNCTION_GET_USERS_FROM_COURSE;
    try {
        // Adding all parameters.
        String params = "&courseid=" + URLEncoder.encode(courseid + "", "UTF-8");
        // Build a REST call url to make a call.
        String restUrl = mUrl + "/webservice/rest/server.php" + "?wstoken=" + token + "&wsfunction=" + function + "&moodlewsrestformat=" + format;
        // Fetch content now.
        MoodleRestCall mrc = new MoodleRestCall();
        Reader reader = mrc.fetchContent(restUrl, params);
        GsonExclude ex = new GsonExclude();
        Gson gson = new GsonBuilder().addDeserializationExclusionStrategy(ex).addSerializationExclusionStrategy(ex).create();
        mUsers = gson.fromJson(reader, new TypeToken<List<MoodleUser>>() {
        }.getType());
        reader.close();
    } catch (Exception e) {
        Log.d(DEBUG_TAG, "URL encoding failed");
        e.printStackTrace();
    }
    return mUsers;
}

@Override
public PermissionsCommand commandFromApiJson(final String json) {
    if (StringUtils.isBlank(json)) {
        throw new InvalidJsonException();
    }
    final Type typeOfMap = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, json, this.supportedParameters);
    return this.fromApiJsonHelper.fromJson(json, PermissionsCommand.class);
}

/**
	 * Populates the list with all the current users playlists 
	 */
public void populate(String JSONString) {
    //Parse JSON and populate arraylist with new Playlist objects
    Gson gson = new Gson();
    Type listType = new TypeToken<ArrayList<String>>() {
    }.getType();
    ArrayList<String> playlistNames = gson.fromJson(JSONString, listType);
    for (String playlistName : playlistNames) {
        playlists.add(new Playlist(playlistName));
    }
    runOnUiThread(returnRes);
}

@Override
public void getBannerData() {
    mRxManager.add(mModel.getBannerData().subscribe( data -> {
        List<FirstBannerBean> banners = null;
        JSONArray jsonArray = new JSONObject((Map) data).optJSONArray("app-focus");
        Gson mGson = new Gson();
        Type type = new TypeToken<List<FirstBannerBean>>() {
        }.getType();
        if (jsonArray != null) {
            banners = mGson.fromJson(jsonArray.toString(), type);
        }
        mView.showBannerContent(banners);
        topCount = banners.size();
    },  e -> mView.showError("数�加载失败ヽ(≧Д≦)ノ")));
}

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
    final TypeAdapter<JsonElement> elementTypeAdapter = gson.getAdapter(JsonElement.class);
    return new TypeAdapter<T>() {

        @Override
        public void write(JsonWriter out, T value) throws IOException {
            delegate.write(out, value);
        }

        @Override
        public T read(JsonReader in) throws IOException {
            JsonElement jsonElement = elementTypeAdapter.read(in);
            if (jsonElement.isJsonObject()) {
                JsonObject jsonObject = jsonElement.getAsJsonObject();
                if (jsonObject.has("status")) {
                    int status = jsonObject.get("status").getAsInt();
                    String message = jsonObject.get("message").getAsString();
                    if (status == 0) {
                    //do nothing
                    } else {
                        throw new ApiException(status, message);
                    }
                }
                if (jsonObject.has(dataElementName)) {
                    jsonElement = jsonObject.get(dataElementName);
                }
            }
            return delegate.fromJsonTree(jsonElement);
        }
    }.nullSafe();
}

private void setupCustom(Set<SerializerConfig> set, int avaliableIdIndex) {
    Type snapshotInventoryItemType = new TypeToken<Snapshot<InventoryItemAggregateRoot>>() {
    }.getType();
    // so just one Snapshot serializer cfg in hazelcast ? TODO
    set.add(new SerializerConfig().setImplementation(new HzGsonTypedSerializer(gson, avaliableIdIndex += 1, snapshotInventoryItemType)).setTypeClass(Snapshot.class));
}

public VideoMetadataInfoEntity transformVideoMetadataInfoEntity(Reader videoMetadataInfoJsonResponse) throws JsonSyntaxException {
    Type videoMetadataInfoWrapperEntityType = new TypeToken<VideoMetadataInfoWrapperEntity>() {
    }.getType();
    VideoMetadataInfoWrapperEntity videoMetadataInfoWrapperEntity = this.gson.fromJson(videoMetadataInfoJsonResponse, videoMetadataInfoWrapperEntityType);
    return videoMetadataInfoWrapperEntity.getVideoMetadataInfo();
}

public static void main(String[] args) {
    TopologyModuleParams params;
    params = new TopologyModuleParams("/home/jaume/Desktop/TopologyModuleNoONE.xml");
    params.initialize();
    log.warning("Initializing TED from WLAN Controller");
    SimpleTEDB ted = new SimpleTEDB();
    //Thread thread = new TEDUpdaterFloodlight(params.getControllerIP(), params.getControllerPORT(), params.getTopologyPath(), params.getTopologyNodesPath(), ted, log);
    //thread.start();	
    Gson gson = new Gson();
    //String json = gson.toJson(ted); 
    Collection<IntraDomainEdge> links = ted.getIntraDomainLinks();
    Collection<Object> nodes = ted.getNetworkGraph().vertexSet();
    //TE_Information te = new TE_Information(((IntraDomainEdge)(edge.toArray()[0])));
    //String json = gson.toJson(((IntraDomainEdge)(links.toArray()[0])));
    /*
		String json = gson.toJson(nodes); 
		
		Type collectionType = new TypeToken<Collection<RouterInfoPM>>(){}.getType();
		
		Collection<RouterInfoPM> recoveredNodes = gson.fromJson(json, collectionType);
		*/
    GsonTEDB gsonTed = new GsonTEDB(ted);
    String json = gson.toJson(gsonTed);
    Type collectionType = new TypeToken<Collection<RouterInfoPM>>() {
    }.getType();
    class auxGsonClass {

        Collection<IntraDomainEdge> links;

        Collection<RouterInfoPM> nodes;

        public String toString() {
            return links + "|" + nodes;
        }
    }
    //auxGsonClass recoveredNodes = gson.fromJson(json, auxGsonClass.class);
    json = gson.toJson(nodes);
    Collection<RouterInfoPM> recoveredNodes = gson.fromJson(json, collectionType);
    collectionType = new TypeToken<Collection<IntraDomainEdge>>() {
    }.getType();
    String jsonLinks = gson.toJson(links);
    //Collection<IntraDomainEdge> recoverdLinks = gson.fromJson(jsonLinks, collectionType);
    log.info(json.toString());
    log.info("As JSON:::" + recoveredNodes);
//log.info("Recoverd nodes::"+recoverdLinks.toString());
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    super.onCreateView(inflater, container, savedInstanceState);
    Bundle bundle = getArguments();
    this.jour = bundle.getString(JOUR);
    Gson gSon = new Gson();
    this.horaires = gSon.fromJson(bundle.getString(HORAIRES), new TypeToken<List<Horaires>>() {
    }.getType());
    view = inflater.inflate(R.layout.fragment_theater_detail_movie_content_page_horaires, null);
    charger();
    remplir();
    ajouterListener();
    return view;
}

public static List<CloudConfiguration> get() {
    File file = getFile();
    if (!file.exists())
        return new ArrayList<>();
    try {
        String data = new String(Files.readAllBytes(file.toPath()));
        return new Gson().fromJson(data, new TypeToken<List<CloudConfiguration>>() {
        }.getType());
    } catch (IOException e) {
        log.error("Error loading cloud configurations", e);
        return new ArrayList<>();
    }
}

/**
	 * Retrieves data sets descriptors of all changed data sets and for
	 * requested locally changed data sets
	 * 
	 * @return A list of data set descriptors for those data sets that have been
	 *         changed since the last fetch and for additionally requested data
	 *         sets
	 * @throws WebRequestException
	 *             If user has no access to the specified repository
	 */
Set<FetchRequestData> execute() throws WebRequestException {
    Valid.checkNotEmpty(baseUrl, "base url");
    Valid.checkNotEmpty(sessionId, "session id");
    Valid.checkNotEmpty(repositoryId, "repository id");
    if (untilCommitId == null || untilCommitId.isEmpty())
        untilCommitId = "null";
    String url = baseUrl + PATH + repositoryId + "/" + untilCommitId;
    ClientResponse response = WebRequests.call(Type.GET, url, sessionId);
    if (response.getStatus() == Status.NO_CONTENT.getStatusCode())
        return Collections.emptySet();
    return new Gson().fromJson(response.getEntity(String.class), new TypeToken<Set<FetchRequestData>>() {
    }.getType());
}

public void loadPacks(OpenLauncherGui form) throws IOException {
    Launch.form.packsComponent.packs.clear();
    JsonObject object = this.parser.parse(FileUtils.readFileToString(this.jsonFile)).getAsJsonObject();
    Object packs = new HashMap<String, ModPack>();
    Type stringStringMap = new TypeToken<Map<String, ModPack>>() {
    }.getType();
    packs = gson.fromJson(object.get("packs"), stringStringMap);
    Launch.packMap.putAll((Map) packs);
    System.out.println(((Map) packs).keySet());
    Iterator it = Launch.packMap.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry pair = (Map.Entry) it.next();
        //LauncherForm.packListString.addElement(pair.getKey());
        Launch.modPacks.add((ModPack) pair.getValue());
        // avoids a ConcurrentModificationException
        it.remove();
        Launch.form.packsComponent.packs.add((ModPack) pair.getValue());
    }
//		form.packList.repaint();
}

@Test
public void testUploadBatch() throws DataSinkException, IOException {
    TestUtils.pause(50);
    for (int i = 0; i < 25; i++) {
        sink.receive(message);
    }
    TestUtils.pause(1000);
    assertTrue(FakeHttp.httpRequestWasMade());
    Type listType = new TypeToken<List<SimpleVehicleMessage>>() {
    }.getType();
    ArrayList<SimpleVehicleMessage> messages = new ArrayList<>();
    HttpPost request;
    while ((request = (HttpPost) FakeHttp.getNextSentHttpRequest()) != null) {
        InputStream payload = request.getEntity().getContent();
        int length = payload.available();
        byte[] buffer = new byte[length];
        payload.read(buffer);
        messages.addAll((List<SimpleVehicleMessage>) gson.fromJson(new String(buffer), listType));
    }
    assertThat(messages, hasSize(25));
    for (SimpleVehicleMessage deserializedMessage : messages) {
        assertThat(message, equalTo((VehicleMessage) deserializedMessage));
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setTitle("Restaurant Past Orders");
    getActionBar().setDisplayHomeAsUpEnabled(true);
    setContentView(R.layout.activity_my_order_history);
    ApplicationState applicationContext = (ApplicationState) getApplicationContext();
    if (applicationContext.getMyOrderHistoryList() == null) {
        String url = new URLBuilder().addPath(URLBuilder.Path.serveTable).addAction(URLBuilder.URLAction.custHistory).addParam(URLBuilder.URLParam.customerId, //TODO: Add param for Rest Id
        ParseInstallation.getCurrentInstallation().getObjectId().toString()).build();
        Utilities.info("URL: " + url);
        try {
            String myOrderHistoryJson = new AsyncNetwork().execute(url).get();
            Utilities.info("myOrderHistoryJson: " + myOrderHistoryJson);
            Gson gs = new Gson();
            Type type = new TypeToken<ArrayList<RestaurantOrder>>() {
            }.getType();
            myOrderHistoryList = gs.fromJson(myOrderHistoryJson, type);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        ApplicationState.setMyOrderHistoryList(applicationContext, myOrderHistoryList);
    } else {
        myOrderHistoryList = ApplicationState.getMyOrderHistoryList(applicationContext);
    }
    ListView myOrderHistoryListView = (ListView) findViewById(R.id.orderHistoryList);
    MyOrderHistoryAdapter myOrderHistoryAdapter = new MyOrderHistoryAdapter(this, myOrderHistoryList);
    myOrderHistoryListView.setAdapter(myOrderHistoryAdapter);
}