private SegmentItem deserializeItem(JsonObject json, JsonDeserializationContext context) { if (!json.has("actions")) { throw new ProtectionParseException("Missing actions identifier"); } SegmentItem segment = new SegmentItem(); segment.types.addAll( deserializeAsArray( json.get("actions"), context, new TypeToken<ItemType>() {}, new TypeToken<List<ItemType>>() {}.getType())); json.remove("actions"); if (json.has("isAdjacent")) { segment.isAdjacent = json.get("isAdjacent").getAsBoolean(); json.remove("isAdjacent"); } if (json.has("clientUpdate")) { JsonObject jsonClientUpdate = json.get("clientUpdate").getAsJsonObject(); segment.clientUpdate = new ClientBlockUpdate( (Volume) context.deserialize(jsonClientUpdate.get("coords"), Volume.class)); if (jsonClientUpdate.has("directional")) { segment.directionalClientUpdate = jsonClientUpdate.get("directional").getAsBoolean(); } json.remove("clientUpdate"); } return segment; }
private SegmentBlock deserializeBlock(JsonObject json, JsonDeserializationContext context) { if (!json.has("actions")) { throw new ProtectionParseException("Missing actions identifier"); } SegmentBlock segment = new SegmentBlock(); segment.types.addAll( deserializeAsArray( json.get("actions"), context, new TypeToken<BlockType>() {}, new TypeToken<List<BlockType>>() {}.getType())); json.remove("actions"); if (json.has("meta")) { segment.meta = json.get("meta").getAsInt(); json.remove("meta"); } if (json.has("clientUpdate")) { segment.clientUpdate = new ClientBlockUpdate( (Volume) context.deserialize( json.get("clientUpdate").getAsJsonObject().get("coords"), Volume.class)); json.remove("clientUpdate"); } return segment; }
@Override public JsonObject upgrade(JsonObject unitGroup, Map<File, JsonObject> dbSnapshot) throws CouldNotPerformException { String newUnitType = unitTypeMap.get(unitGroup.get(UNIT_TYPE_FIELD).getAsString()); unitGroup.remove(UNIT_TYPE_FIELD); unitGroup.addProperty(UNIT_TYPE_FIELD, newUnitType); JsonArray serviceTemplates = unitGroup.getAsJsonArray(SERVICE_TEMPLATE_FIELD); if (serviceTemplates != null) { JsonArray newServiceTemplates = new JsonArray(); for (JsonElement serviceTemplateElem : serviceTemplates) { JsonObject serviceTemplate = serviceTemplateElem.getAsJsonObject(); String oldServiceType = serviceTemplate.get(SERVICE_TYPE_FIELD).getAsString(); String newServiceType = serviceTypeMap.get(oldServiceType); serviceTemplate.remove(SERVICE_TYPE_FIELD); serviceTemplate.addProperty(TYPE_FIELD, newServiceType); serviceTemplate.addProperty(PATTERN_FIELD, PROVIDER_PATTERN); newServiceTemplates.add(serviceTemplate); if (oldServiceType.endsWith("SERVICE")) { JsonObject operationServiceTemplate = new JsonObject(); operationServiceTemplate.addProperty(TYPE_FIELD, newServiceType); operationServiceTemplate.addProperty(PATTERN_FIELD, OPERATION_PATTERN); operationServiceTemplate.add(META_CONFIG_FIELD, serviceTemplate.get(META_CONFIG_FIELD)); newServiceTemplates.add(operationServiceTemplate); } } unitGroup.remove(SERVICE_TEMPLATE_FIELD); unitGroup.add(SERVICE_TEMPLATE_FIELD, newServiceTemplates); } return unitGroup; }
/** * Create a configuration file based on the internally stored configuration. * * @return The StringBuffer object associated with the internal JSON configuration file. */ private static StringBuffer create() { Logger.log("Creating default configuration file 'config.json'...", Logger.CRITICAL); StringBuffer fileData = getLocalConfig(); try { JsonObject json = (JsonObject) new JsonParser().parse(fileData.toString()); // # Remove config version from the output // # This config string will be used internally for // # tracking versions of cingif files when writing new ones // # or receiving new ones. json.remove("config-version"); // # Write configuration file. FileOutputStream out = new FileOutputStream("config.json"); out.write(json.toString().getBytes()); out.close(); } catch (JsonParseException e) { // # Should never get here because the config file is packaged internaly... // # If it fails, probably a developer not formatting the config file properly. Logger.log( "Compiling and creating the config file failed. Ensure you have properly formatted JSON data before recompiling your extension.", Logger.CRITICAL); } catch (IOException e) { Logger.log("Failed to write the configuration file: " + e.getMessage(), Logger.CRITICAL); } return fileData; }
private SegmentSpecialBlock deserializeSpecialBlock( JsonObject json, JsonDeserializationContext context) { SegmentSpecialBlock segment = new SegmentSpecialBlock(); if (json.has("meta")) { segment.meta = json.get("meta").getAsInt(); json.remove("meta"); } if (json.has("isAlwaysBreakable")) { segment.isAlwaysBreakable = json.get("isAlwaysBreakable").getAsBoolean(); json.remove("isAlwaysBreakable"); } return segment; }
public boolean changeCartProductCount(Product product, int count) { try { Log.d(TAG, "changeCartProductCount: " + product.getArticle() + " || " + count); if (count <= 0) { if (cartJson.has(product.getArticle() + "")) { cartJson.remove(product.getArticle() + ""); if (setCartJson()) { return true; } else { return false; } } return true; } ProductCart productCart = getProductCart(product); if (productCart.setCount(count)) { cartJson.addProperty(productCart.getArticle() + "", productCart.getCount()); if (setCartJson()) { return true; } } } catch (Exception e) { Log.e(TAG, "cart" + cartJson.toString() + "\n" + e.toString()); } return false; }
/** * Builds the start message. * * @param options the options * @return the request */ private String buildStartMessage(RecognizeOptions options) { JsonObject startMessage = new JsonParser().parse(new Gson().toJson(options)).getAsJsonObject(); startMessage.remove(MODEL); startMessage.addProperty(ACTION, START); return startMessage.toString(); }
@Override public void write(JsonWriter out, Patch<Data> value) throws IOException { JsonTreeWriter treeWriter = new JsonTreeWriter(); treeWriter.setSerializeNulls(true); _dataAdapter.write(treeWriter, value.data()); JsonObject tree = treeWriter.get().getAsJsonObject(); Set<String> presentJsonProperties = new HashSet<>(); for (Field field : value.changedFields()) { SerializedName nameSpecifier = field.getAnnotation(SerializedName.class); String jsonPropertyName = (nameSpecifier != null ? nameSpecifier.value() : field.getName()); presentJsonProperties.add(jsonPropertyName); } for (Map.Entry<String, JsonElement> entry : new ArrayList<>(tree.entrySet())) { if (!presentJsonProperties.contains(entry.getKey())) { tree.remove(entry.getKey()); } } // If a data field changed to null the null should be serialized. // This is the whole point of this adapter. ObjectTargetedJsonWriter patchWriter = new ObjectTargetedJsonWriter(out); patchWriter.setTargetedSerializeNulls(true); _gson.getAdapter(JsonObject.class).write(patchWriter, tree); }
// AmbientColorAgents MetaConfig entries with pattern UNIT_(number) private void updateAmbientColorAgentMetaConfig( JsonArray metaConfigEntries, Map<File, DatabaseEntryDescriptor> dalUnitDB) throws CouldNotPerformException { JsonObject metaConfigEntry; String key, unitScope; for (JsonElement metaConfigEntryElem : metaConfigEntries) { metaConfigEntry = metaConfigEntryElem.getAsJsonObject(); if (!metaConfigEntry.has(KEY_FIELD) || !metaConfigEntry.has(VALUE_FIELD)) { continue; } key = metaConfigEntry.get(KEY_FIELD).getAsString(); if (key.matches("UNIT_[0123456789]+")) { unitScope = updateScopeToNewUnitTypes(metaConfigEntry.get(VALUE_FIELD).getAsString()); if (!unitScopeIdMap.containsKey(unitScope)) { throw new CouldNotPerformException( "Could not replace scope [" + unitScope + "] with unit id in metaConfigEntry with key [" + key + "] of PowerStateSynchroniser"); } metaConfigEntry.remove(VALUE_FIELD); metaConfigEntry.addProperty(VALUE_FIELD, unitScopeIdMap.get(unitScope)); } } }
private SegmentTileEntity deserializeTileEntity( JsonObject json, JsonDeserializationContext context) { SegmentTileEntity segment = new SegmentTileEntity(); segment.retainsOwner = json.getAsJsonObject().get("retainsOwner").getAsBoolean(); json.remove("retainsOwner"); return segment; }
@Override public BlockDefinition getBlockDefinitionForSection(JsonObject json, String sectionName) { if (json.has(sectionName) && json.get(sectionName).isJsonObject()) { JsonObject sectionJson = json.getAsJsonObject(sectionName); json.remove(sectionName); JsonMergeUtil.mergeOnto(json, sectionJson); return createBlockDefinition(sectionJson); } return null; }
private JsonObject getResponse(HttpServletRequest request) throws IOException { JsonObject requestJSON = null; if (request.getInputStream() != null) { BufferedReader rd = new BufferedReader(new InputStreamReader(request.getInputStream())); StringBuilder s = new StringBuilder(); String line; while ((line = rd.readLine()) != null) { s.append(line); } rd.close(); String json = s.toString(); if (!"".equals(json)) { requestJSON = new JsonParser().parse(json).getAsJsonObject(); } } JsonObject res = new JsonObject(); res.addProperty("success", false); // the id can be specified via a param, or in the json request. String session; if (requestJSON == null) { session = request.getParameter("session"); } else { if (!requestJSON.has("session")) { res.addProperty( "msg", "you need to specify at least a session or internalKey when call the test slot status service."); return res; } session = requestJSON.get("session").getAsString(); } TestSession testSession = getRegistry().getSession(ExternalSessionKey.fromString(session)); if (testSession == null) { res.addProperty( "msg", "Cannot find test slot running session " + session + " in the registry."); return res; } res.addProperty("msg", "slot found !"); res.remove("success"); res.addProperty("success", true); res.addProperty("session", testSession.getExternalKey().getKey()); res.addProperty("internalKey", testSession.getInternalKey()); res.addProperty("inactivityTime", testSession.getInactivityTime()); RemoteProxy p = testSession.getSlot().getProxy(); res.addProperty("proxyId", p.getId()); return res; }
/** * do a PUT request on the StackMob platform, treating some of the fields as counters to be * incremented rather than as values to set * * @param path the path to put * @param id the id of the object to put * @param requestObject the object to serialize and send in the PUT body. this object will be * serialized with Gson * @param counterFields a list of the fields in the object to be treated as counters being * incremented * @param callback callback to be called when the server returns. may execute in a separate thread */ public void putAndUpdateAtomicCounters( String path, String id, Object requestObject, List<String> counterFields, StackMobRawCallback callback) { JsonObject obj = new Gson().toJsonTree(requestObject).getAsJsonObject(); for (Map.Entry<String, JsonElement> field : new HashSet<Map.Entry<String, JsonElement>>(obj.entrySet())) { if (counterFields.contains(field.getKey())) { obj.remove(field.getKey()); obj.add(field.getKey() + "[inc]", field.getValue()); } } put(path, id, obj.toString(), callback); }
private static JsonObject removeSystemProperties(JsonObject instance) { boolean haveCloned = false; for (Entry<String, JsonElement> property : instance.entrySet()) { if (property.getKey().startsWith("__")) { if (!haveCloned) { instance = (JsonObject) new JsonParser().parse(instance.toString()); haveCloned = true; } instance.remove(property.getKey()); } } return instance; }
private SegmentEntity deserializeEntity(JsonObject json, JsonDeserializationContext context) { if (!json.has("actions")) { throw new ProtectionParseException("Missing actions identifier"); } SegmentEntity segment = new SegmentEntity(); segment.types.addAll( deserializeAsArray( json.get("actions"), context, new TypeToken<EntityType>() {}, new TypeToken<List<EntityType>>() {}.getType())); json.remove("actions"); return segment; }
public String getCartPrice(Context context) { float price = 0; for (Map.Entry<String, JsonElement> item : cartJson.entrySet()) { try { ProductCart product = getProductCart(dataWorker.getProduct(Integer.valueOf(item.getKey()))); price += product.getPrice() * product.getCount(); } catch (Exception e) { Log.e(TAG, e.toString()); cartJson.remove(item.getKey()); setCartJson(); } } price = price / 100 * (100 - SharedPreferencesHelper.getDiscount(context)); int mod = Math.round(price * 100) % 100; return (int) price + "." + (mod > 9 ? mod : "0" + mod); }
public ArrayList<Product> getCartList() { ArrayList<Product> products = new ArrayList<>(); for (Map.Entry<String, JsonElement> item : cartJson.entrySet()) { try { products.add(dataWorker.getProduct(Integer.valueOf(item.getKey()))); } catch (Exception e) { Log.e(TAG, e.toString()); cartJson.remove(item.getKey()); setCartJson(); } } Collections.sort( products, new Comparator<Product>() { @Override public int compare(Product product1, Product product2) { return product1.getTitle().compareTo(product2.getTitle()); } }); return products; }
/** * Validate put request Json for Set Password API. * * @param requestBody the request Json object * @return true, if successful */ private boolean validatePut(final JsonObject requestBody) { LOG.trace("Start UserResourceValidator#validatePut()"); boolean isValid = false; // validation for password setInvalidParameter(VtnServiceJsonConsts.PASSWORD); if (requestBody.has(VtnServiceJsonConsts.PASSWORD) && requestBody.get(VtnServiceJsonConsts.PASSWORD) instanceof JsonObject && requestBody .get(VtnServiceJsonConsts.PASSWORD) .getAsJsonObject() .getAsJsonPrimitive(VtnServiceJsonConsts.PASSWORD) .getAsString() != null) { final String password = requestBody .get(VtnServiceJsonConsts.PASSWORD) .getAsJsonObject() .get(VtnServiceJsonConsts.PASSWORD) .getAsString(); requestBody.remove(VtnServiceJsonConsts.PASSWORD); requestBody.addProperty(VtnServiceJsonConsts.PASSWORD, password); } if (requestBody.has(VtnServiceJsonConsts.PASSWORD) && requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.PASSWORD).getAsString() != null && !requestBody .getAsJsonPrimitive(VtnServiceJsonConsts.PASSWORD) .getAsString() .trim() .isEmpty()) { isValid = validator.isValidMaxLength( requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.PASSWORD).getAsString().trim(), VtnServiceJsonConsts.LEN_72); } else { isValid = false; } LOG.trace("Complete UserResourceValidator#validatePut()"); return isValid; }
@Override public Image deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext context) throws JsonParseException { JsonObject json = jsonElement.getAsJsonObject(); Map<String, String> metadata = null; List<BlockDeviceMapping> blockDeviceMapping = null; JsonElement meta = json.get(METADATA); if (meta != null && meta.isJsonObject()) { metadata = Maps.newTreeMap(); for (Map.Entry<String, JsonElement> e : meta.getAsJsonObject().entrySet()) { Object value; if (e.getValue().isJsonArray()) { value = context.deserialize(e.getValue().getAsJsonArray(), ArrayList.class); } else if (e.getValue().isJsonObject()) { value = context.deserialize(e.getValue().getAsJsonObject(), TreeMap.class); } else if (e.getValue().isJsonPrimitive()) { value = e.getValue().getAsJsonPrimitive().getAsString(); } else { continue; } // keep non-string members out of normal metadata if (value instanceof String) { metadata.put(e.getKey(), (String) value); } else if (value instanceof List && BLOCK_DEVICE_MAPPING.equals(e.getKey())) { blockDeviceMapping = context.deserialize( e.getValue(), new TypeToken<List<BlockDeviceMapping>>() {}.getType()); } } json.remove(METADATA); } return apply( context.<ImageInternal>deserialize(json, ImageInternal.class), metadata, blockDeviceMapping); }
@Override public T read(JsonReader in) throws IOException { JsonObject el = Streams.parse(in).getAsJsonObject(); // Strip existing json schedules JsonObject directSchedules = el.has(SCHEDULES_FIELD_NAME) ? el.remove(SCHEDULES_FIELD_NAME).getAsJsonObject() : new JsonObject(); // Strip off @schedule annotations to update schedules attribute // Load annotated schedules JsonObject annotatedSchedules = new JsonObject(); // TODO: make this recursive to have nested schedules with dot notation for (Map.Entry<String, JsonElement> entry : el.entrySet()) { JsonElement entryEl = entry.getValue(); if (entryEl.isJsonObject()) { JsonObject subConfig = entryEl.getAsJsonObject(); if (subConfig.has(SCHEDULE)) { JsonElement scheduleConfig = subConfig.remove(SCHEDULE); annotatedSchedules.add(entry.getKey(), scheduleConfig); } } } T result = delegateAdapter.read(new JsonTreeReader(el)); // If there is a 'schedules' field, inject schedules Field schedulesField = AnnotationUtil.getField(SCHEDULES_FIELD_NAME, result.getClass()); if (schedulesField != null) { ///// Default schedules for every schedulable top level object JsonObject defaultSchedules = new JsonObject(); List<Field> fields = new ArrayList<Field>(); for (Field field : AnnotationUtil.getAllFields(fields, result.getClass())) { DefaultSchedule defaultSchedule = field.getAnnotation(DefaultSchedule.class); if (defaultSchedule == null) { boolean currentAccessibility = field.isAccessible(); try { field.setAccessible(true); Object fieldValue = field.get(result); if (fieldValue != null) { Class<?> fieldRuntimeClass = field.get(result).getClass(); defaultSchedule = fieldRuntimeClass.getAnnotation(DefaultSchedule.class); } } catch (IllegalArgumentException e) { Log.e(LogUtil.TAG, "Bad access of configurable fields!!", e); } catch (IllegalAccessException e) { Log.e(LogUtil.TAG, "Bad access of configurable fields!!", e); } finally { field.setAccessible(currentAccessibility); } } if (defaultSchedule != null) { defaultSchedules.add( field.getName(), gson.toJsonTree(defaultSchedule, DefaultSchedule.class)); } } JsonObject schedulesJson = directSchedules; JsonUtils.deepCopyOnto( defaultSchedules, schedulesJson, false); // Copy in default schedules, but do not replace JsonUtils.deepCopyOnto( annotatedSchedules, schedulesJson, true); // Override with annotations // For each schedule find default schedule, fill in remainder Map<String, Schedule> schedules = gson.fromJson(schedulesJson, new TypeToken<Map<String, Schedule>>() {}.getType()); boolean currentAccessibility = schedulesField.isAccessible(); try { schedulesField.setAccessible(true); schedulesField.set(result, schedules); } catch (IllegalArgumentException e) { Log.e(LogUtil.TAG, "Bad access of configurable fields!!", e); } catch (IllegalAccessException e) { Log.e(LogUtil.TAG, "Bad access of configurable fields!!", e); } finally { schedulesField.setAccessible(currentAccessibility); } } return result; }
/** * method used to clear the changes object. * * <p>It should be used after the changes have been saved to the database * * @private */ private void clearChanges() { for (Entry<String, JsonElement> pairs : this.changes.entrySet()) { changes.remove(pairs.getKey()); } }
/** * @param requestBody , for request * @param opFlag , for getting option1 type * @return true , if parameter are in correct format values */ public final boolean isValidGetForMappingIdIndex( final JsonObject requestBody, final boolean opFlag) { LOG.trace("Start CommonValidator#isValidGetForMappingIdIndex"); boolean isValid = true; // validation for key: targetdb setInvalidParameter(VtnServiceJsonConsts.TARGETDB); isValid = validator.isValidRequestDBState(requestBody); /* * Remove unwanted parameters from request body for Show APIs */ if (!opFlag) { if (requestBody.has(VtnServiceJsonConsts.OP)) { requestBody.remove(VtnServiceJsonConsts.OP); } else { LOG.debug("No need to remove"); } if (requestBody.has(VtnServiceJsonConsts.INDEX)) { requestBody.remove(VtnServiceJsonConsts.INDEX); } else { LOG.debug("No need to remove"); } if (requestBody.has(VtnServiceJsonConsts.MAX)) { requestBody.remove(VtnServiceJsonConsts.MAX); } else { LOG.debug("No need to remove"); } } else { // validation for key: op if (isValid) { setInvalidParameter(VtnServiceJsonConsts.OP); isValid = validator.isValidOperationForDetail(requestBody); } // validation for key: index where index is combination of // controller id and domain id if (isValid) { setInvalidParameter(VtnServiceJsonConsts.INDEX); if (requestBody.has(VtnServiceJsonConsts.INDEX) && requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.INDEX).getAsString() != null) { final String[] mappingId = requestBody .getAsJsonPrimitive(VtnServiceJsonConsts.INDEX) .getAsString() .split(VtnServiceJsonConsts.HYPHEN); isValid = validator.isValidMappingId(mappingId); } } // validation for key: max_repitition if (isValid) { setInvalidParameter(VtnServiceJsonConsts.MAX); isValid = validator.isValidMaxRepetition(requestBody); } // validation for key: vnode_type if (isValid) { setInvalidParameter(VtnServiceJsonConsts.VNODETYPE); if (requestBody.has(VtnServiceJsonConsts.VNODETYPE) && requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.VNODETYPE).getAsString() != null) { final String vnodeType = requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.VNODETYPE).getAsString(); isValid = validator.isValidVnodeType(vnodeType); } } // validation for key: vnode_name if (isValid) { setInvalidParameter(VtnServiceJsonConsts.VNODENAME); if (requestBody.has(VtnServiceJsonConsts.VNODENAME) && requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.VNODENAME).getAsString() != null) { final String vnodeName = requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.VNODENAME).getAsString(); isValid = validator.isValidMaxLengthAlphaNum(vnodeName, VtnServiceJsonConsts.LEN_31); } } // validation for key: if_name if (isValid) { setInvalidParameter(VtnServiceJsonConsts.VIFNAME); if (requestBody.has(VtnServiceJsonConsts.VIFNAME) && requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.VIFNAME).getAsString() != null) { final String ifName = requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.VIFNAME).getAsString(); isValid = validator.isValidMaxLengthAlphaNum(ifName, VtnServiceJsonConsts.LEN_31); } } } LOG.trace("Complete CommonValidator#isValidGetForMappingIdIndex"); return isValid; }
@Override public Segment deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { if (!json.getAsJsonObject().has("class")) { throw new ProtectionParseException("One of the segments is missing a class identifier"); } JsonObject jsonObject = json.getAsJsonObject(); String classString = jsonObject.get("class").getAsString(); if (!json.getAsJsonObject().has("type")) { throw new ProtectionParseException("Segment for " + classString + " is missing a type"); } String type = jsonObject.get("type").getAsString(); jsonObject.remove("type"); Segment segment = null; if ("specialBlock".equals(type)) { segment = deserializeSpecialBlock(jsonObject, context); } else if ("block".equals(type)) { segment = deserializeBlock(jsonObject, context); } else if ("entity".equals(type)) { segment = deserializeEntity(jsonObject, context); } else if ("item".equals(type)) { segment = deserializeItem(jsonObject, context); } else if ("tileEntity".equals(type)) { segment = deserializeTileEntity(jsonObject, context); } if (segment == null) { throw new ProtectionParseException("Identifier type is invalid"); } try { segment.checkClass = Class.forName(classString); } catch (ClassNotFoundException ex) { // throw new ProtectionParseException("Invalid class identifier: " + classString); MyTown.instance.LOG.error( "Invalid class identifier {" + classString + "}: >>> Segment Rejected <<<"); return null; } jsonObject.remove("class"); if (!(segment instanceof SegmentSpecialBlock)) { if (!json.getAsJsonObject().has("flags")) { throw new ProtectionParseException("Segment for " + classString + " is missing flags"); } segment.flags.addAll( deserializeAsArray( jsonObject.get("flags"), context, new TypeToken<FlagType<Boolean>>() {}, new TypeToken<List<FlagType<Boolean>>>() {}.getType())); jsonObject.remove("flags"); if (jsonObject.has("condition")) { segment.condition = new Condition(jsonObject.get("condition").getAsString()); jsonObject.remove("condition"); } if (jsonObject.has("priority")) { segment.priority = Priority.valueOf(jsonObject.get("priority").getAsString()); jsonObject.remove("priority"); } for (Map.Entry<String, JsonElement> entry : jsonObject.entrySet()) { Getter getter = context.deserialize(entry.getValue(), Getter.class); getter.setName(entry.getKey()); segment.getters.add(getter); } } return segment; }