How to use

registerTypeHierarchyAdapter

method

in

com.google.gson.GsonBuilder

/**
 * Obtain a {@link GsonBuilder} which Base64-encodes {@code byte[]}
 * properties when reading and writing JSON.
 * <p>A custom {@link com.google.gson.TypeAdapter} will be registered via
 * {@link GsonBuilder#registerTypeHierarchyAdapter(Class, Object)} which
 * serializes a {@code byte[]} property to and from a Base64-encoded String
 * instead of a JSON array.
 */
public static GsonBuilder gsonBuilderWithBase64EncodedByteArrays() {
  GsonBuilder builder = new GsonBuilder();
  builder.registerTypeHierarchyAdapter(byte[].class, new Base64TypeAdapter());
  return builder;
}

/**
 * Obtain a {@link GsonBuilder} which Base64-encodes {@code byte[]}
 * properties when reading and writing JSON.
 * <p>A custom {@link com.google.gson.TypeAdapter} will be registered via
 * {@link GsonBuilder#registerTypeHierarchyAdapter(Class, Object)} which
 * serializes a {@code byte[]} property to and from a Base64-encoded String
 * instead of a JSON array.
 */
public static GsonBuilder gsonBuilderWithBase64EncodedByteArrays() {
  GsonBuilder builder = new GsonBuilder();
  builder.registerTypeHierarchyAdapter(byte[].class, new Base64TypeAdapter());
  return builder;
}

private void initGson() {
  if (gson == null) {
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeHierarchyAdapter(BehaviorNode.class, this);
    gsonBuilder.registerTypeAdapterFactory(new UriTypeAdapterFactory());
    gsonBuilder.registerTypeAdapter(BehaviorTree.class, new TypeAdapter<BehaviorTree>() {
      @Override
      public void write(JsonWriter out, BehaviorTree value) throws IOException {
        if (value != null) {
          // TODO doublecheck URN
          out.value(value.getUrn().toString());
        } else {
          out.value("");
        }
      }
      @Override
      public BehaviorTree read(JsonReader in) throws IOException {
        String uri = in.nextString();
        AssetManager assetManager = CoreRegistry.get(AssetManager.class);
        return assetManager.getAsset(new ResourceUrn(uri), BehaviorTree.class)
            .orElse(assetManager.getAsset(new ResourceUrn("Behaviors:fallback"), BehaviorTree.class).get());
      }
    });
    gson = gsonBuilder.create();
  }
}

  private static Gson gsonBuilder(final GoRequestContext requestContext) {
    GsonBuilder builder = new GsonBuilder();
    builder.registerTypeAdapter(JsonUrl.class, (JsonSerializer<JsonUrl>) (src, typeOfSrc, context) -> {
      if (requestContext == null) {
        return new JsonPrimitive(src.getUrl());
      } else {
        return new JsonPrimitive(requestContext.getFullRequestPath() + src.getUrl());
      }
    });

    builder.registerTypeHierarchyAdapter(MessageSourceResolvable.class, (JsonSerializer<MessageSourceResolvable>) (src, typeOfSrc, context) -> {
      if (requestContext == null) {
        return new JsonPrimitive(src.getDefaultMessage());
      } else {
        return new JsonPrimitive(requestContext.getMessage(src));
      }
    });

    builder.serializeNulls();
    return builder.create();
  }
}

public UIData load(JsonElement element, Locale otherLocale) throws IOException {
  NUIManager nuiManager = CoreRegistry.get(NUIManager.class);
  TranslationSystem translationSystem = CoreRegistry.get(TranslationSystem.class);
  TypeSerializationLibrary library = new TypeSerializationLibrary(CoreRegistry.get(TypeSerializationLibrary.class));
  library.add(UISkin.class, new AssetTypeHandler<>(UISkin.class));
  library.add(Border.class, new BorderTypeHandler());
  GsonBuilder gsonBuilder = new GsonBuilder()
      .registerTypeAdapterFactory(new GsonTypeSerializationLibraryAdapterFactory(library))
      .registerTypeAdapterFactory(new CaseInsensitiveEnumTypeAdapterFactory())
      .registerTypeAdapter(UIData.class, new UIDataTypeAdapter())
      .registerTypeHierarchyAdapter(UIWidget.class, new UIWidgetTypeAdapter(nuiManager));
  // override the String TypeAdapter from the serialization library
  gsonBuilder.registerTypeAdapter(String.class, new I18nStringTypeAdapter(translationSystem, otherLocale));
  Gson gson = gsonBuilder.create();
  return gson.fromJson(element, UIData.class);
}

static Gson prettyInit() {
  GsonBuilder builder = new GsonBuilder();
  builder.registerTypeHierarchyAdapter(Metadata.class, new SortedJsonMetadataSerializer());
  builder.registerTypeHierarchyAdapter(Metadata.class, new JsonMetadataDeserializer());
  builder.setPrettyPrinting();
  return builder.create();
}

static Gson defaultInit() {
  GsonBuilder builder = new GsonBuilder();
  builder.registerTypeHierarchyAdapter(Metadata.class, new JsonMetadataSerializer());
  builder.registerTypeHierarchyAdapter(Metadata.class, new JsonMetadataDeserializer());
  return builder.create();
}

static Gson createGson() {
 return new GsonBuilder()
   .registerTypeHierarchyAdapter(byte[].class, new ByteArrayToBase64TypeAdapter()).create();
}

public static AnalyzerManager newInstance(int maxTokens) throws IOException {
  InputStream is = AnalyzerManager.class.getClassLoader().getResourceAsStream("lucene-analyzers.json");
  Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8);
  GsonBuilder builder = new GsonBuilder();
  builder.registerTypeHierarchyAdapter(Map.class, new AnalyzerDeserializer(maxTokens));
  Gson gson = builder.create();
  Map<String, Analyzer> map = gson.fromJson(reader, Map.class);
  Analyzer general = map.get(GENERAL);
  Analyzer alphaIdeo = map.get(ALPHA_IDEOGRAPH);
  Analyzer common = map.get(COMMON_TOKENS);
  if (general == null) {
    throw new JsonParseException("Must specify "+GENERAL + " analyzer");
  }
  if (common == null) {
    throw new JsonParseException("Must specify "+ COMMON_TOKENS + " analyzer");
  }
  return new AnalyzerManager(general, common);
}

  /**
   * To object map map.
   *
   * @param json the json
   * @return the map
   */
  public Map<String, Object> toObjectMap(final String json) {
    TypeToken typeToken = new TypeToken<Map<String, Object>>() {
    };
    Gson gson = new GsonBuilder().serializeNulls().registerTypeHierarchyAdapter(typeToken.getRawType(), new MapDeserializer<String, Object>()).create();
    return gson.fromJson(json, typeToken.getType());
  }
}

/**
 * @since 3.1
 * @see JsonSerializer
 */
public JsonConverterBuilder registerNativeGsonHierarchySerializer(Class targetType, JsonSerializer<?> jsonSerializer) {
  Validate.argumentsAreNotNull(targetType, jsonSerializer);
  gsonBuilder.registerTypeHierarchyAdapter(targetType, jsonSerializer);
  return this;
}

protected Gson getGson() {
  GsonBuilder builder = new GsonBuilder();
  for (JsonDeserializer<?> adapter : adapters) {
    builder.registerTypeHierarchyAdapter(getAdapterType(adapter), adapter);
  }
  return builder.create();
}

protected Gson createGsonForDeserialization(@Nullable MetaClass metaClass, EntitySerializationOption... options) {
  return new GsonBuilder()
      .registerTypeHierarchyAdapter(Entity.class, new EntityDeserializer(metaClass, options))
      .registerTypeHierarchyAdapter(Date.class, new DateDeserializer())
      .create();
}

private MapSettings loadSettings(File file) throws IOException {
 Gson gson = new GsonBuilder().
   registerTypeHierarchyAdapter(Class.class, new MapSettings.ClassNameSerializer()).create();
 Reader br = new BufferedReader(new FileReader(file));
 return gson.fromJson(br, MapSettings.class);
}

private void saveSettings(MapSettings settings, File file) throws IOException {
 Gson gson = new GsonBuilder().
   registerTypeHierarchyAdapter(Class.class, new MapSettings.ClassNameSerializer()).create();
 Writer writer = new FileWriter(file);
 gson.toJson(settings, writer);
 writer.close();
}

public GsonUtil() {
  gsonBuilder = new GsonBuilder().enableComplexMapKeySerialization();
  gsonBuilder.registerTypeHierarchyAdapter(Pack.class, new PackDeserializer());
  gsonBuilder.registerTypeHierarchyAdapter(UiElementSelector.class, new UiElementSelectorDeserializer());
  gsonBuilder.registerTypeHierarchyAdapter(RequestMessage.class, new RequestMessageSerializer());
  gsonBuilder.registerTypeHierarchyAdapter(RequestMessage.class, new RequestMessageDeserializer());
  gsonBuilder.registerTypeHierarchyAdapter(ResponseMessage.class, new ResponseMessageSerializer());
  gsonBuilder.registerTypeHierarchyAdapter(ResponseMessage.class, new ResponseMessageDeserializer());
  g = gsonBuilder.create();
}

public static com.google.gson.Gson get() {
  if (mGson == null) {
    mGson = new GsonBuilder()
        .registerTypeHierarchyAdapter(Collection.class, new CollectionAdapter())
        .registerTypeAdapter(Date.class, new ISO8601DateFormat())
        .create();
  }
  return mGson;
}

public FileSystemRequirementsStore(File outputDirectory, String storeName) {
  this.outputDirectory = outputDirectory;
  this.storeName = storeName;
  this.gson = new GsonBuilder()
      .registerTypeAdapterFactory(OptionalTypeAdapter.FACTORY)
      .registerTypeHierarchyAdapter(Collection.class, new CollectionAdapter()).create();
}

public Gson create() {
  for (JsonSerializer<?> adapter : serializers) {
    builder.registerTypeHierarchyAdapter(getAdapterType(adapter), adapter);
  }
  for (ExclusionStrategy exclusion : exclusions) {
    builder.addSerializationExclusionStrategy(exclusion);
  }
  return builder.create();
}

protected void registerAdapter(Class<?> adapterType, Object adapter) {
  RegisterStrategy registerStrategy = adapter.getClass().getAnnotation(RegisterStrategy.class);
  if ((registerStrategy != null) && (registerStrategy.value().equals(RegisterType.SINGLE))) {
    getGsonBuilder().registerTypeAdapter(adapterType, adapter);
  } else {
    getGsonBuilder().registerTypeHierarchyAdapter(adapterType, adapter);
  }    
}