How to use com.google.gson.internal.bind

 @Override
 public JsonReader create() {
  return new JsonTreeReader(element);
 }
}

  public static Gson getInstance() {
    if (gson == null) {
      gson = new GsonBuilder()
          .setPrettyPrinting()
          .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
          .registerTypeAdapter(Date.class, new DateTypeAdapter())
          .create();
    }
    return gson;
  }
}

public Adapter(Gson context, Type keyType, TypeAdapter<K> keyTypeAdapter,
  Type valueType, TypeAdapter<V> valueTypeAdapter,
  ObjectConstructor<? extends Map<K, V>> constructor) {
 this.keyTypeAdapter =
  new TypeAdapterRuntimeTypeWrapper<K>(context, keyTypeAdapter, keyType);
 this.valueTypeAdapter =
  new TypeAdapterRuntimeTypeWrapper<V>(context, valueTypeAdapter, valueType);
 this.constructor = constructor;
}

@Override public void nextNull() throws IOException {
 expect(JsonToken.NULL);
 popStack();
 if (stackSize > 0) {
  pathIndices[stackSize - 1]++;
 }
}

@Override public void skipValue() throws IOException {
 if (peek() == JsonToken.NAME) {
  nextName();
  pathNames[stackSize - 2] = "null";
 } else {
  popStack();
  if (stackSize > 0) {
   pathNames[stackSize - 1] = "null";
  }
 }
 if (stackSize > 0) {
  pathIndices[stackSize - 1]++;
 }
}

@Override public JsonWriter value(Boolean value) throws IOException {
 if (value == null) {
  return nullValue();
 }
 put(new JsonPrimitive(value));
 return this;
}

public boolean excludeField(Field f, boolean serialize) {
 return excludeField(f, serialize, excluder);
}

 @SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal
 @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
  return typeToken.getRawType() == java.sql.Date.class
    ? (TypeAdapter<T>) new SqlDateTypeAdapter() : null;
 }
};

@Override public JsonWriter nullValue() throws IOException {
 put(JsonNull.INSTANCE);
 return this;
}

@Override public boolean hasNext() throws IOException {
 JsonToken token = peek();
 return token != JsonToken.END_OBJECT && token != JsonToken.END_ARRAY;
}

/**
 * Returns a new factory that will match each type's raw type for assignability
 * to {@code hierarchyType}.
 */
public static TypeAdapterFactory newTypeHierarchyFactory(
  Class<?> hierarchyType, Object typeAdapter) {
 return new SingleTypeFactory(typeAdapter, null, false, hierarchyType);
}

public JsonTreeReader(JsonElement element) {
 super(UNREADABLE_READER);
 push(element);
}

 private String locationString() {
  return " at path " + getPath();
 }
}

@Override public void endObject() throws IOException {
 expect(JsonToken.END_OBJECT);
 popStack(); // empty iterator
 popStack(); // object
 if (stackSize > 0) {
  pathIndices[stackSize - 1]++;
 }
}

 @SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal
 @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
  return typeToken.getRawType() == Date.class ? (TypeAdapter<T>) new DateTypeAdapter() : null;
 }
};

public Adapter(Gson context, Type elementType,
  TypeAdapter<E> elementTypeAdapter,
  ObjectConstructor<? extends Collection<E>> constructor) {
 this.elementTypeAdapter =
   new TypeAdapterRuntimeTypeWrapper<E>(context, elementTypeAdapter, elementType);
 this.constructor = constructor;
}

/**
 * Returns a new factory that will match each type against {@code exactType}.
 */
public static TypeAdapterFactory newFactory(TypeToken<?> exactType, Object typeAdapter) {
 return new SingleTypeFactory(typeAdapter, exactType, false, null);
}

@Override public void endArray() throws IOException {
 expect(JsonToken.END_ARRAY);
 popStack(); // empty iterator
 popStack(); // array
 if (stackSize > 0) {
  pathIndices[stackSize - 1]++;
 }
}

public ArrayTypeAdapter(Gson context, TypeAdapter<E> componentTypeAdapter, Class<E> componentType) {
 this.componentTypeAdapter =
  new TypeAdapterRuntimeTypeWrapper<E>(context, componentTypeAdapter, componentType);
 this.componentType = componentType;
}

@Override public boolean nextBoolean() throws IOException {
 expect(JsonToken.BOOLEAN);
 boolean result = ((JsonPrimitive) popStack()).getAsBoolean();
 if (stackSize > 0) {
  pathIndices[stackSize - 1]++;
 }
 return result;
}