• Home
• com.arangodb
• arangodb-java-driver
• 2.7.5
• source code
• EntityDeserializers.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.arangodb.entity.EntityDeserializers Maven / Gradle / Ivy

/*
 * Copyright (C) 2012 tamtam180
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.arangodb.entity;

import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.arangodb.entity.CollectionEntity.Figures;
import com.arangodb.entity.EntityDeserializers.DeserializeSingleEntry;
import com.arangodb.entity.ReplicationApplierState.LastError;
import com.arangodb.entity.ReplicationApplierState.Progress;
import com.arangodb.entity.ReplicationInventoryEntity.Collection;
import com.arangodb.entity.ReplicationInventoryEntity.CollectionParameter;
import com.arangodb.entity.ReplicationLoggerStateEntity.Client;
import com.arangodb.entity.StatisticsDescriptionEntity.Figure;
import com.arangodb.entity.StatisticsDescriptionEntity.Group;
import com.arangodb.entity.StatisticsEntity.FigureValue;
import com.arangodb.entity.marker.VertexEntity;
import com.arangodb.util.DateUtils;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.google.gson.reflect.TypeToken;

/**
 * Entity deserializer , internally used.
 *
 * @author tamtam180 - kirscheless at gmail.com
 * 
 */
public class EntityDeserializers {

	private static final String ADAPTIVE_POLLING = "adaptivePolling";

	private static final String AUTO_START = "autoStart";

	private static final String CHUNK_SIZE = "chunkSize";

	private static final String REQUEST_TIMEOUT = "requestTimeout";

	private static final String CONNECT_TIMEOUT = "connectTimeout";

	private static final String MAX_CONNECT_RETRIES = "maxConnectRetries";

	private static final String PASSWORD = "password";

	private static final String USERNAME = "username";

	private static final String DATABASE = "database";

	private static final String ENDPOINT = "endpoint";

	private static final String SERVER = "server";

	private static final String ETAG = "etag";

	private static final String ERROR_MESSAGE = "errorMessage";

	private static final String ERROR_NUM = "errorNum";

	private static final String CODE = "code";

	private static final String ERROR = "error";

	private static final String RESULT = "result";

	private static final String VERSION = "version";

	private static final String PATHS = "paths";

	private static final String VERTICES = "vertices";

	private static final String SIZE = "size";

	private static final String COUNT = "count";

	private static final String ALIVE = "alive";

	private static final String WARNINGS = "warnings";

	private static final String ALT_DATE_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";

	private static final String DO_COMPACT = "doCompact";

	private static final String CHECKSUM = "checksum";

	private static final String KEY_OPTIONS = "keyOptions";

	private static final String TYPE = "type";

	private static final String FIGURES = "figures";

	private static final String REVISION = "revision";

	private static final String JOURNAL_SIZE = "journalSize";

	private static final String IS_VOLATILE = "isVolatile";

	private static final String IS_SYSTEM = "isSystem";

	private static final String WAIT_FOR_SYNC = "waitForSync";

	private static final String STATUS = "status";

	private static final String ID = "id";

	private static final String NAME = "name";

	private static final String EXTRA = "extra";

	private static final String ACTIVE = "active";

	private static final String COLLECTIONS = "collections";

	private static final String LAST_ERROR = "lastError";

	private static final String LAST_AVAILABLE_CONTINUOUS_TICK = "lastAvailableContinuousTick";

	private static final String LAST_PROCESSED_CONTINUOUS_TICK = "lastProcessedContinuousTick";

	private static final String LAST_APPLIED_CONTINUOUS_TICK = "lastAppliedContinuousTick";

	private static final String INDEXES = "indexes";

	private static final String EDGES = "edges";

	private static final String STATE = "state";

	private static final String FILE_SIZE = "fileSize";

	private static final String UPDATED = "updated";

	private static final String REPLACED = "replaced";

	private static final String DELETED = "deleted";

	private static final String MESSAGE = "message";

	private static Logger logger = LoggerFactory.getLogger(EntityDeserializers.class);

	private static class ClassHolder {
		private Class[] clazz;
		private int idx;

		ClassHolder(Class... clazz) {
			this.clazz = clazz;
			this.idx = 0;
		}

		public boolean isEmpty() {
			return clazz == null || clazz.length == 0;
		}

		public Class get() {
			if (isEmpty()) {
				return null;
			}
			return clazz[idx];
		}

		public Class next() {
			if (isEmpty()) {
				return null;
			}
			if (idx + 1 >= clazz.length) {
				throw new IllegalStateException("idx max-over!! idx=" + (idx + 1));
			}
			return clazz[++idx];
		}

		public boolean hasNext() {
			if (isEmpty()) {
				return false;
			}
			if (idx + 1 >= clazz.length) {
				return false;
			}
			return true;
		}

		public Class back() {
			if (isEmpty()) {
				return null;
			}
			if (idx - 1 < 0) {
				throw new IllegalStateException("idx min-over!! idx=" + (idx - 1));
			}
			return clazz[--idx];
		}
	}

	private static ThreadLocal parameterizedBridger = new ThreadLocal();

	private EntityDeserializers() {
		// this is a helper class
	}

	public static void setParameterized(Class... clazz) {
		parameterizedBridger.set(new ClassHolder(clazz));
	}

	public static void removeParameterized() {
		parameterizedBridger.remove();
	}

	private static Class getParameterized() {
		ClassHolder holder = parameterizedBridger.get();
		if (holder == null) {
			return null;
		}
		return holder.get();
	}

	private static boolean hasNextParameterized() {
		ClassHolder holder = parameterizedBridger.get();
		if (holder == null) {
			return false;
		}
		return holder.hasNext();
	}

	private static Class nextParameterized() {
		ClassHolder holder = parameterizedBridger.get();
		if (holder == null) {
			return null;
		}
		return holder.next();
	}

	private static  T deserializeBaseParameter(JsonObject obj, T entity) {
		if (obj.has(ERROR) && obj.getAsJsonPrimitive(ERROR).isBoolean()) {
			entity.error = obj.getAsJsonPrimitive(ERROR).getAsBoolean();
		}
		if (obj.has(CODE) && obj.getAsJsonPrimitive(CODE).isNumber()) {
			entity.code = obj.getAsJsonPrimitive(CODE).getAsInt();
		}
		if (obj.has(ERROR_NUM) && obj.getAsJsonPrimitive(ERROR_NUM).isNumber()) {
			entity.errorNumber = obj.getAsJsonPrimitive(ERROR_NUM).getAsInt();
		}
		if (obj.has(ERROR_MESSAGE)) {
			entity.errorMessage = obj.getAsJsonPrimitive(ERROR_MESSAGE).getAsString();
		}
		if (obj.has(ETAG) && obj.getAsJsonPrimitive(ERROR_NUM).isNumber()) {
			entity.etag = obj.getAsJsonPrimitive(ETAG).getAsLong();
		}

		return entity;
	}

	private static  T deserializeDocumentParameter(JsonObject obj, T entity) {

		if (obj.has("_rev")) {
			entity.setDocumentRevision(obj.getAsJsonPrimitive("_rev").getAsLong());
		}
		if (obj.has("_id")) {
			entity.setDocumentHandle(obj.getAsJsonPrimitive("_id").getAsString());
		}
		if (obj.has("_key")) {
			entity.setDocumentKey(obj.getAsJsonPrimitive("_key").getAsString());
		}

		return entity;
	}

	public static class DefaultEntityDeserializer implements JsonDeserializer {
		@Override
		public DefaultEntity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {
			if (json.isJsonNull()) {
				return null;
			}
			return deserializeBaseParameter(json.getAsJsonObject(), new DefaultEntity());
		}
	}

	public static class VersionDeserializer implements JsonDeserializer {

		@Override
		public ArangoVersion deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonObject obj = json.getAsJsonObject();
			ArangoVersion entity = deserializeBaseParameter(obj, new ArangoVersion());

			if (obj.has(SERVER)) {
				entity.server = obj.getAsJsonPrimitive(SERVER).getAsString();
			}

			if (obj.has(VERSION)) {
				entity.version = obj.getAsJsonPrimitive(VERSION).getAsString();
			}

			return entity;
		}
	}

	public static class ArangoUnixTimeDeserializer implements JsonDeserializer {
		@Override
		public ArangoUnixTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonObject obj = json.getAsJsonObject();
			ArangoUnixTime entity = deserializeBaseParameter(obj, new ArangoUnixTime());

			if (obj.has("time")) {
				entity.time = obj.getAsJsonPrimitive("time").getAsDouble();
				String time = obj.getAsJsonPrimitive("time").getAsString(); // 実際はdoubleだけど精度の問題が心配なので文字列で処理する。
				entity.second = (int) entity.time;

				int pos = time.indexOf('.');
				entity.microsecond = (pos >= 0 && pos + 1 != time.length()) ? Integer.parseInt(time.substring(pos + 1))
						: 0;
			}

			return entity;
		}
	}

	public static class FiguresDeserializer implements JsonDeserializer {

		@Override
		public Figures deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonObject obj = json.getAsJsonObject();
			Figures entity = new Figures();

			if (obj.has(ALIVE)) {
				JsonObject alive = obj.getAsJsonObject(ALIVE);
				entity.aliveCount = alive.getAsJsonPrimitive(COUNT).getAsLong();
				entity.aliveSize = alive.getAsJsonPrimitive(SIZE).getAsLong();
			}

			if (obj.has("dead")) {
				JsonObject dead = obj.getAsJsonObject("dead");
				entity.deadCount = dead.getAsJsonPrimitive(COUNT).getAsLong();
				entity.deadSize = dead.getAsJsonPrimitive(SIZE).getAsLong();
				entity.deadDeletion = dead.getAsJsonPrimitive("deletion").getAsLong();
			}

			if (obj.has("datafiles")) {
				JsonObject datafiles = obj.getAsJsonObject("datafiles");
				entity.datafileCount = datafiles.getAsJsonPrimitive(COUNT).getAsLong();
				entity.datafileFileSize = datafiles.getAsJsonPrimitive(FILE_SIZE).getAsLong();
			}

			if (obj.has("journals")) {
				JsonObject journals = obj.getAsJsonObject("journals");
				entity.journalsCount = journals.getAsJsonPrimitive(COUNT).getAsLong();
				entity.journalsFileSize = journals.getAsJsonPrimitive(FILE_SIZE).getAsLong();
			}

			if (obj.has("compactors")) {
				JsonObject compactors = obj.getAsJsonObject("compactors");
				entity.compactorsCount = compactors.getAsJsonPrimitive(COUNT).getAsLong();
				entity.compactorsFileSize = compactors.getAsJsonPrimitive(FILE_SIZE).getAsLong();
			}

			if (obj.has("shapefiles")) {
				JsonObject shapefiles = obj.getAsJsonObject("shapefiles");
				entity.shapefilesCount = shapefiles.getAsJsonPrimitive(COUNT).getAsLong();
				entity.shapefilesFileSize = shapefiles.getAsJsonPrimitive(FILE_SIZE).getAsLong();
			}

			if (obj.has("shapes")) {
				JsonObject shapes = obj.getAsJsonObject("shapes");
				entity.shapesCount = shapes.getAsJsonPrimitive(COUNT).getAsLong();
			}

			if (obj.has("attributes")) {
				JsonObject attributes = obj.getAsJsonObject("attributes");
				entity.attributesCount = attributes.getAsJsonPrimitive(COUNT).getAsLong();
			}

			if (obj.has(INDEXES)) {
				JsonObject indexes = obj.getAsJsonObject(INDEXES);
				entity.indexesCount = indexes.getAsJsonPrimitive(COUNT).getAsLong();
				entity.indexesSize = indexes.getAsJsonPrimitive(SIZE).getAsLong();
			}

			if (obj.has("lastTick")) {
				entity.lastTick = obj.getAsJsonPrimitive("lastTick").getAsLong();
			}

			if (obj.has("uncollectedLogfileEntries")) {
				entity.uncollectedLogfileEntries = obj.getAsJsonPrimitive("uncollectedLogfileEntries").getAsLong();
			}

			return entity;
		}
	}

	public static class CollectionKeyOptionDeserializer implements JsonDeserializer {
		@Override
		public CollectionKeyOption deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonObject obj = json.getAsJsonObject();
			CollectionKeyOption entity = new CollectionKeyOption();

			if (obj.has("type")) {
				entity.type = obj.getAsJsonPrimitive("type").getAsString();
			}

			if (obj.has("allowUserKeys")) {
				entity.allowUserKeys = obj.getAsJsonPrimitive("allowUserKeys").getAsBoolean();
			}

			if (obj.has("increment")) {
				entity.increment = obj.getAsJsonPrimitive("increment").getAsLong();
			}

			if (obj.has("offset")) {
				entity.offset = obj.getAsJsonPrimitive("offset").getAsLong();
			}

			return entity;
		}
	}

	public static class CollectionEntityDeserializer implements JsonDeserializer {

		@Override
		public CollectionEntity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonObject obj = json.getAsJsonObject();
			CollectionEntity entity = deserializeBaseParameter(obj, new CollectionEntity());

			if (obj.has(NAME)) {
				entity.name = obj.getAsJsonPrimitive(NAME).getAsString();
			}

			if (obj.has(ID)) {
				entity.id = obj.getAsJsonPrimitive(ID).getAsLong();
			}

			if (obj.has(STATUS)) {
				entity.status = context.deserialize(obj.get(STATUS), CollectionStatus.class);
			}

			if (obj.has(WAIT_FOR_SYNC)) {
				entity.waitForSync = obj.getAsJsonPrimitive(WAIT_FOR_SYNC).getAsBoolean();
			}

			if (obj.has(IS_SYSTEM)) {
				entity.isSystem = obj.getAsJsonPrimitive(IS_SYSTEM).getAsBoolean();
			}

			if (obj.has(IS_VOLATILE)) {
				entity.isVolatile = obj.getAsJsonPrimitive(IS_VOLATILE).getAsBoolean();
			}

			if (obj.has(JOURNAL_SIZE)) {
				entity.journalSize = obj.getAsJsonPrimitive(JOURNAL_SIZE).getAsLong();
			}

			if (obj.has(COUNT)) {
				entity.count = obj.getAsJsonPrimitive(COUNT).getAsLong();
			}

			if (obj.has(REVISION)) {
				entity.revision = obj.getAsJsonPrimitive(REVISION).getAsLong();
			}

			if (obj.has(FIGURES)) {
				entity.figures = context.deserialize(obj.get(FIGURES), Figures.class);
			}

			if (obj.has(TYPE)) {
				entity.type = CollectionType.valueOf(obj.getAsJsonPrimitive(TYPE).getAsInt());
			}

			if (obj.has(KEY_OPTIONS)) {
				entity.keyOptions = context.deserialize(obj.get(KEY_OPTIONS), CollectionKeyOption.class);
			}

			if (obj.has(CHECKSUM)) {
				entity.checksum = obj.getAsJsonPrimitive(CHECKSUM).getAsLong();
			}

			if (obj.has(DO_COMPACT)) {
				entity.doCompact = obj.getAsJsonPrimitive(DO_COMPACT).getAsBoolean();
			}

			return entity;
		}
	}

	public static class CollectionsEntityDeserializer implements JsonDeserializer {
		private Type collectionsType = new TypeToken>() {
		}.getType();
		private Type namesType = new TypeToken>() {
		}.getType();

		@Override
		public CollectionsEntity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonObject obj = json.getAsJsonObject();
			CollectionsEntity entity = deserializeBaseParameter(obj, new CollectionsEntity());

			if (obj.has(COLLECTIONS)) {
				entity.collections = context.deserialize(obj.get(COLLECTIONS), collectionsType);
			}
			if (obj.has("names")) {
				entity.names = context.deserialize(obj.get("names"), namesType);
			}

			return entity;
		}
	}

	public static class AqlfunctionsEntityDeserializer implements JsonDeserializer {

		@Override
		public AqlFunctionsEntity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonArray obj = json.getAsJsonArray();
			Iterator iterator = obj.iterator();
			Map functions = new HashMap();
			while (iterator.hasNext()) {
				JsonElement e = iterator.next();
				JsonObject o = e.getAsJsonObject();
				functions.put(o.get("name").getAsString(), o.get(CODE).getAsString());
			}
			return new AqlFunctionsEntity(functions);
		}
	}

	public static class JobsEntityDeserializer implements JsonDeserializer {

		@Override
		public JobsEntity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonArray obj = json.getAsJsonArray();
			Iterator iterator = obj.iterator();
			List jobs = new ArrayList();
			while (iterator.hasNext()) {
				JsonElement e = iterator.next();
				jobs.add(e.getAsString());
			}
			return new JobsEntity(jobs);
		}
	}

	public static class CursorEntityDeserializer implements JsonDeserializer> {

		private Type bindVarsType = new TypeToken>() {
		}.getType();

		private Type extraType = new TypeToken>() {
		}.getType();

		@Override
		public CursorEntity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {

			if (json.isJsonNull()) {
				return null;
			}

			JsonObject obj = json.getAsJsonObject();
			CursorEntity