From 2df869d7e124af471b00b0775fc7c0a7bba819a0 Mon Sep 17 00:00:00 2001 From: Cervator Date: Sat, 22 Sep 2018 17:02:04 -0400 Subject: [PATCH 001/141] Revert "Revert "Merge PRs #3449 and #3446 by @eviltak - serialization improvements"" This reverts commit 22ed4da69dc1087389829be128bea112d8fdd9ad. --- .../org/terasology/HeadlessEnvironment.java | 6 +- .../entitySystem/PojoPrefabManagerTest.java | 4 +- .../persistence/ComponentSerializerTest.java | 4 +- .../TypeSerializationLibraryTest.java | 94 ++++++ .../coreTypes/CollectionTypeHandlerTest.java | 106 +++++++ .../CollectionTypeHandlerFactoryTest.java | 82 +++++ .../factories/EnumTypeHandlerFactoryTest.java | 52 ++++ ...MappedContainerTypeHandlerFactoryTest.java | 62 ++++ .../StringMapTypeHandlerFactoryTest.java | 59 ++++ .../terasology/reflection/TypeInfoTest.java | 74 +++++ .../utilities/ReflectionUtilsTest.java | 5 +- .../bootstrap/EntitySystemSetupUtil.java | 2 +- .../bootstrap/EnvironmentSwitchHandler.java | 10 +- .../modes/loadProcesses/RegisterBlocks.java | 4 +- .../network/internal/NetworkSystemImpl.java | 2 +- .../NetEntityRefTypeHandler.java | 33 --- .../typeHandling/DeserializationContext.java | 14 - .../typeHandling/InstanceCreator.java | 35 +++ .../typeHandling/SerializationContext.java | 10 - .../typeHandling/SimpleTypeHandler.java | 52 ---- .../StringRepresentationTypeHandler.java | 31 -- .../persistence/typeHandling/TypeHandler.java | 17 -- .../typeHandling/TypeHandlerFactory.java | 44 +++ .../TypeSerializationLibrary.java | 280 ++++++++---------- .../coreTypes/BooleanTypeHandler.java | 27 -- .../coreTypes/ByteArrayTypeHandler.java | 3 +- .../coreTypes/ByteTypeHandler.java | 17 -- .../coreTypes/CollectionTypeHandler.java | 58 ++++ .../coreTypes/DoubleTypeHandler.java | 28 -- .../coreTypes/EnumTypeHandler.java | 24 -- .../coreTypes/FloatTypeHandler.java | 27 -- .../coreTypes/IntTypeHandler.java | 27 -- .../coreTypes/ListTypeHandler.java | 48 --- .../coreTypes/LongTypeHandler.java | 27 -- .../coreTypes/MappedContainerTypeHandler.java | 3 +- .../coreTypes/NumberTypeHandler.java | 18 -- .../coreTypes/QueueTypeHandler.java | 52 ---- .../coreTypes/SetTypeHandler.java | 50 ---- .../coreTypes/StringMapTypeHandler.java | 3 +- .../coreTypes/StringTypeHandler.java | 16 - .../CollectionTypeHandlerFactory.java | 69 +++++ .../factories/EnumTypeHandlerFactory.java | 44 +++ .../MappedContainerTypeHandlerFactory.java | 89 ++++++ .../StringMapTypeHandlerFactory.java | 57 ++++ .../extensionTypes/ColorTypeHandler.java | 3 +- .../extensionTypes/EntityRefTypeHandler.java | 29 -- .../TextureRegionAssetTypeHandler.java | 48 +++ .../TextureRegionAssetTypeHandlerFactory.java | 37 +++ .../gson/GsonDeserializationContext.java | 14 - .../gson/GsonSerializationContext.java | 10 - ...ypeSerializationLibraryAdapterFactory.java | 2 +- .../mathTypes/BorderTypeHandler.java | 3 +- .../mathTypes/Quat4fTypeHandler.java | 3 +- .../mathTypes/Rect2fTypeHandler.java | 4 +- .../mathTypes/Rect2iTypeHandler.java | 3 +- .../mathTypes/Region3iTypeHandler.java | 3 +- .../mathTypes/Vector2fTypeHandler.java | 3 +- .../mathTypes/Vector2iTypeHandler.java | 3 +- .../mathTypes/Vector3fTypeHandler.java | 3 +- .../mathTypes/Vector3iTypeHandler.java | 3 +- .../mathTypes/Vector4fTypeHandler.java | 3 +- .../ProtobufDeserializationContext.java | 17 +- .../ProtobufSerializationContext.java | 10 +- .../recording/RecordedEventSerializer.java | 58 ++-- .../org/terasology/reflection/TypeInfo.java | 105 +++++++ .../reflect/ConstructorLibrary.java | 196 ++++++++++++ .../rendering/nui/asset/UIFormat.java | 4 +- .../terasology/utilities/ReflectionUtil.java | 96 +++++- 68 files changed, 1577 insertions(+), 852 deletions(-) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactoryTest.java create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java create mode 100644 engine-tests/src/test/java/org/terasology/reflection/TypeInfoTest.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/InstanceCreator.java delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/SimpleTypeHandler.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ListTypeHandler.java delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/QueueTypeHandler.java delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/SetTypeHandler.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactory.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/TextureRegionAssetTypeHandler.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java create mode 100644 engine/src/main/java/org/terasology/reflection/TypeInfo.java create mode 100644 engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java diff --git a/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java b/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java index 79db54b429f..0c3fdfc8a5c 100644 --- a/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java +++ b/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java @@ -164,7 +164,7 @@ protected void setupEntitySystem() { protected void setupCollisionManager() { CollisionGroupManager collisionGroupManager = new CollisionGroupManager(); context.put(CollisionGroupManager.class, collisionGroupManager); - context.get(TypeSerializationLibrary.class).add(CollisionGroup.class, new CollisionGroupTypeHandler(collisionGroupManager)); + context.get(TypeSerializationLibrary.class).addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(collisionGroupManager)); } @Override @@ -173,8 +173,8 @@ protected void setupBlockManager(AssetManager assetManager) { BlockManagerImpl blockManager = new BlockManagerImpl(worldAtlas, assetManager); context.put(BlockManager.class, blockManager); TypeSerializationLibrary typeSerializationLibrary = context.get(TypeSerializationLibrary.class); - typeSerializationLibrary.add(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); - typeSerializationLibrary.add(Block.class, new BlockTypeHandler(blockManager)); + typeSerializationLibrary.addTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); + typeSerializationLibrary.addTypeHandler(Block.class, new BlockTypeHandler(blockManager)); } @Override diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java index 2201735cc2c..d804f5ff428 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java @@ -63,8 +63,8 @@ public void setup() throws Exception { ReflectFactory reflectFactory = new ReflectionReflectFactory(); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); TypeSerializationLibrary lib = new TypeSerializationLibrary(reflectFactory, copyStrategyLibrary); - lib.add(Vector3f.class, new Vector3fTypeHandler()); - lib.add(Quat4f.class, new Quat4fTypeHandler()); + lib.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); + lib.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); entitySystemLibrary = new EntitySystemLibrary(context, lib); componentLibrary = entitySystemLibrary.getComponentLibrary(); diff --git a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java index e929280a744..74bf8978b4f 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java @@ -72,8 +72,8 @@ public void setup() { CoreRegistry.setContext(context); TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(reflectFactory, copyStrategyLibrary); - serializationLibrary.add(Vector3f.class, new Vector3fTypeHandler()); - serializationLibrary.add(Quat4f.class, new Quat4fTypeHandler()); + serializationLibrary.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); + serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); NetworkSystem networkSystem = mock(NetworkSystem.class); context.put(NetworkSystem.class, networkSystem); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java new file mode 100644 index 00000000000..e08426d5e93 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java @@ -0,0 +1,94 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + +import org.junit.Test; +import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.MappedContainerTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; +import org.terasology.reflection.MappedContainer; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.copy.CopyStrategyLibrary; +import org.terasology.reflection.reflect.ReflectionReflectFactory; + +import java.util.List; +import java.util.Map; +import java.util.Queue; +import java.util.Set; + +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +public class TypeSerializationLibraryTest { + private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); + private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); + private final TypeSerializationLibrary typeSerializationLibrary = + new TypeSerializationLibrary(reflectFactory, copyStrategyLibrary); + + private enum AnEnum {} + + @MappedContainer + private static class AMappedContainer {} + + @Test + public void testEnumHandler() { + TypeHandler handler = typeSerializationLibrary.getTypeHandler(AnEnum.class); + + assertTrue(handler instanceof EnumTypeHandler); + } + + @Test + public void testMappedContainerHandler() { + TypeHandler handler = typeSerializationLibrary.getTypeHandler(AMappedContainer.class); + + assertTrue(handler instanceof MappedContainerTypeHandler); + } + + @Test + public void testCollectionHandler() { + TypeHandler> setHandler = + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + + assertTrue(setHandler instanceof CollectionTypeHandler); + + TypeHandler> listHandler = + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + + assertTrue(listHandler instanceof CollectionTypeHandler); + + TypeHandler> queueHandler = + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + + assertTrue(queueHandler instanceof CollectionTypeHandler); + } + + @Test + public void testStringMapHandler() { + TypeHandler> handler = + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + + assertTrue(handler instanceof StringMapTypeHandler); + } + + @Test + public void testInvalidTypeHandler() { + TypeHandler> handler = + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + + assertNull(handler); + } +} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java new file mode 100644 index 00000000000..9082ba9f565 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java @@ -0,0 +1,106 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import com.google.common.collect.Queues; +import com.google.common.collect.Sets; +import com.google.gson.JsonArray; +import gnu.trove.list.TDoubleList; +import gnu.trove.list.TFloatList; +import gnu.trove.list.TIntList; +import gnu.trove.list.TLongList; +import org.junit.Test; +import org.mockito.ArgumentMatcher; +import org.mockito.ArgumentMatchers; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.terasology.persistence.typeHandling.DeserializationContext; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataArray; +import org.terasology.persistence.typeHandling.PersistedDataMap; +import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.gson.GsonPersistedDataArray; +import org.terasology.reflection.reflect.ObjectConstructor; + +import java.nio.ByteBuffer; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.Mockito.*; + +public class CollectionTypeHandlerTest { + @Test + public void testSerialize() { + IntTypeHandler elementTypeHandler = mock(IntTypeHandler.class); + + ObjectConstructor> constructor = Queues::newArrayDeque; + + CollectionTypeHandler typeHandler = new CollectionTypeHandler<>( + elementTypeHandler, + constructor + ); + + Collection collection = constructor.construct(); + collection.addAll(Collections.nCopies(500, -1)); + + SerializationContext context = mock(SerializationContext.class); + + typeHandler.serialize(collection, context); + + verify(elementTypeHandler, times(collection.size())).serialize(any(), any()); + + verify(context).create(argThat(new ArgumentMatcher>() { + @Override + public boolean matches(Iterable argument) { + return argument instanceof Collection && ((Collection) argument).size() == collection.size(); + } + })); + } + + @Test + public void testDeserialize() { + IntTypeHandler elementTypeHandler = mock(IntTypeHandler.class); + + ObjectConstructor> constructor = mock(ObjectConstructor.class); + when(constructor.construct()).then((Answer>) invocation -> Queues.newArrayDeque()); + + CollectionTypeHandler typeHandler = new CollectionTypeHandler<>( + elementTypeHandler, + constructor + ); + + JsonArray jsonArray = new JsonArray(); + + for (Integer i : Collections.nCopies(500, -1)) { + jsonArray.add(i); + } + + DeserializationContext context = mock(DeserializationContext.class); + + typeHandler.deserialize(new GsonPersistedDataArray(jsonArray), context); + + verify(constructor).construct(); + + verify(elementTypeHandler, times(jsonArray.size())).deserialize(any(), any()); + + verifyZeroInteractions(context); + } +} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java new file mode 100644 index 00000000000..8e847aa6273 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -0,0 +1,82 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import com.google.common.collect.Maps; +import org.junit.Test; +import org.mockito.ArgumentMatchers; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.reflect.ConstructorLibrary; +import org.terasology.reflection.reflect.ReflectionReflectFactory; + +import java.util.List; +import java.util.Optional; +import java.util.Queue; +import java.util.Set; + +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public class CollectionTypeHandlerFactoryTest { + private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap(), new ReflectionReflectFactory())); + + @Test + public void testList() { + TypeInfo> listTypeInfo = new TypeInfo>() {}; + + Optional>> typeHandler = + typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof CollectionTypeHandler); + + // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + } + + @Test + public void testSet() { + TypeInfo> listTypeInfo = new TypeInfo>() {}; + + Optional>> typeHandler = + typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof CollectionTypeHandler); + + // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + } + + @Test + public void testQueue() { + TypeInfo> listTypeInfo = new TypeInfo>() {}; + + Optional>> typeHandler = + typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof CollectionTypeHandler); + + // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + } +} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java new file mode 100644 index 00000000000..c1bb965b641 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java @@ -0,0 +1,52 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.junit.Test; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +import static org.junit.Assert.*; + +public class EnumTypeHandlerFactoryTest { + private enum SomeEnum { + A, B + } + + @Test + public void testEnum() { + EnumTypeHandlerFactory typeHandlerFactory = new EnumTypeHandlerFactory(); + // EnumTypeHandlerFactory does not require a TypeSerializationLibrary + Optional> typeHandler = typeHandlerFactory.create(TypeInfo.of(SomeEnum.class), null); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof EnumTypeHandler); + } + + @Test + public void testNonEnum() { + EnumTypeHandlerFactory typeHandlerFactory = new EnumTypeHandlerFactory(); + + // EnumTypeHandlerFactory does not require a TypeSerializationLibrary + Optional> typeHandler = typeHandlerFactory.create(TypeInfo.of(Integer.class), null); + + assertFalse(typeHandler.isPresent()); + } +} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactoryTest.java new file mode 100644 index 00000000000..b917cc5af33 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactoryTest.java @@ -0,0 +1,62 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.junit.Test; +import org.mockito.ArgumentMatchers; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.MappedContainerTypeHandler; +import org.terasology.reflection.MappedContainer; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.copy.CopyStrategyLibrary; +import org.terasology.reflection.reflect.ReflectionReflectFactory; + +import java.util.Optional; + +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public class MappedContainerTypeHandlerFactoryTest { + private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + + private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); + private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); + private final MappedContainerTypeHandlerFactory typeHandlerFactory = new MappedContainerTypeHandlerFactory( + reflectFactory, copyStrategyLibrary + ); + + @MappedContainer + public static class AMappedContainer { + public int someInt; + public String someString; + } + + @Test + public void testMappedContainer() { + Optional> typeHandler = + typeHandlerFactory.create(TypeInfo.of(AMappedContainer.class), typeSerializationLibrary); + + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof MappedContainerTypeHandler); + + // Verify that the Integer and String TypeHandlers were loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.TYPE).getType())); + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(String.class).getType())); + } +} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java new file mode 100644 index 00000000000..bfe2ff9e861 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -0,0 +1,59 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.junit.Test; +import org.mockito.ArgumentMatchers; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.Map; +import java.util.Optional; +import java.util.Set; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public class StringMapTypeHandlerFactoryTest { + private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final StringMapTypeHandlerFactory typeHandlerFactory = new StringMapTypeHandlerFactory(); + + @Test + public void testStringMap() { + TypeInfo> listTypeInfo = new TypeInfo>() {}; + + Optional>> typeHandler = + typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof StringMapTypeHandler); + + // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + } + + @Test + public void testNonStringMap() { + TypeInfo> listTypeInfo = new TypeInfo>() {}; + + Optional>> typeHandler = + typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + + assertFalse(typeHandler.isPresent()); + }} diff --git a/engine-tests/src/test/java/org/terasology/reflection/TypeInfoTest.java b/engine-tests/src/test/java/org/terasology/reflection/TypeInfoTest.java new file mode 100644 index 00000000000..248415382b1 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/reflection/TypeInfoTest.java @@ -0,0 +1,74 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.reflection; + +import org.junit.Test; + +import java.lang.reflect.GenericArrayType; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.lang.reflect.WildcardType; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class TypeInfoTest { + @Test + public void testSimpleTypeInfo() { + TypeInfo typeInfo = TypeInfo.of(String.class); + + assertEquals(String.class, typeInfo.getRawType()); + assertTrue(typeInfo.getType() instanceof Class); + assertEquals(typeInfo.getRawType(), typeInfo.getType()); + } + + @Test + public void testListTypeInfo() { + TypeInfo> typeInfo = new TypeInfo>() { + }; + + assertEquals(List.class, typeInfo.getRawType()); + assertTrue(typeInfo.getType() instanceof ParameterizedType); + assertEquals(Integer.class, ((ParameterizedType) typeInfo.getType()).getActualTypeArguments()[0]); + } + + @Test + public void testArrayTypeInfo() { + TypeInfo[]> typeInfo = new TypeInfo[]>() { + }; + + assertEquals(List[].class, typeInfo.getRawType()); + assertTrue(typeInfo.getType() instanceof GenericArrayType); + assertEquals( + new TypeInfo>() { + } + .getType(), + ((GenericArrayType) typeInfo.getType()).getGenericComponentType() + ); + } + + @Test + public void testWildcardGenericTypeInfo() { + TypeInfo> typeInfo = new TypeInfo>() { + }; + + assertEquals(List.class, typeInfo.getRawType()); + assertTrue(typeInfo.getType() instanceof ParameterizedType); + Type genericType = ((ParameterizedType) typeInfo.getType()).getActualTypeArguments()[0]; + assertTrue(genericType instanceof WildcardType); + } +} diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index 511939232ae..697d3a133eb 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -20,7 +20,10 @@ import org.terasology.logic.location.LocationComponent; import org.terasology.reflection.copy.CopyStrategy; +import java.lang.reflect.TypeVariable; + import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; /** */ @@ -43,7 +46,7 @@ public void testGetParameterForBuriedGenericInterface() throws Exception { @Test public void testGetParameterForUnboundGenericInterface() throws Exception { - assertEquals(null, ReflectionUtil.getTypeParameterForSuper(UnboundInterfaceImplementor.class, CopyStrategy.class, 0)); + assertTrue(ReflectionUtil.getTypeParameterForSuper(UnboundInterfaceImplementor.class, CopyStrategy.class, 0) instanceof TypeVariable); } public static class ParameterisedInterfaceImplementor implements CopyStrategy { diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java index c53f072ea7c..cf4177f0b3b 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java @@ -113,7 +113,7 @@ public static void addEntityManagementRelatedClasses(Context context) { // Standard serialization library TypeSerializationLibrary typeSerializationLibrary = context.get(TypeSerializationLibrary.class); - typeSerializationLibrary.add(EntityRef.class, new EntityRefTypeHandler(entityManager)); + typeSerializationLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler(entityManager)); entityManager.setTypeSerializerLibrary(typeSerializationLibrary); // Prefab Manager diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java index 7ff5624666e..4e905991c9c 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java @@ -70,9 +70,9 @@ public void handleSwitchToGameEnvironment(Context context) { if (copyStrategy.getAnnotation(RegisterCopyStrategy.class) == null) { continue; } - Class targetType = ReflectionUtil.getTypeParameterForSuper(copyStrategy, CopyStrategy.class, 0); - if (targetType != null) { - registerCopyStrategy(copyStrategyLibrary, targetType, copyStrategy); + Type targetType = ReflectionUtil.getTypeParameterForSuper(copyStrategy, CopyStrategy.class, 0); + if (targetType instanceof Class) { + registerCopyStrategy(copyStrategyLibrary, (Class) targetType, copyStrategy); } else { logger.error("Cannot register CopyStrategy '{}' - unable to determine target type", copyStrategy); } @@ -80,7 +80,7 @@ public void handleSwitchToGameEnvironment(Context context) { ReflectFactory reflectFactory = context.get(ReflectFactory.class); TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); - typeSerializationLibrary.add(CollisionGroup.class, new CollisionGroupTypeHandler(context.get(CollisionGroupManager.class))); + typeSerializationLibrary.addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(context.get(CollisionGroupManager.class))); context.put(TypeSerializationLibrary.class, typeSerializationLibrary); // Entity System Library @@ -186,7 +186,7 @@ private static void registerTypeHandlers(Context context, TypeSerializationLibra if (opt.isPresent()) { TypeHandler instance = InjectionHelper.createWithConstructorInjection(handler, context); InjectionHelper.inject(instance, context); - library.add((Class) opt.get(), instance); + library.addTypeHandler((Class) opt.get(), instance); } } } diff --git a/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java b/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java index 4d1a2c045f7..369e5ecf070 100644 --- a/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java +++ b/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java @@ -68,8 +68,8 @@ public boolean step() { blockManager = new BlockManagerImpl(atlas, context.get(AssetManager.class), false); } context.put(BlockManager.class, blockManager); - context.get(TypeSerializationLibrary.class).add(Block.class, new BlockTypeHandler(blockManager)); - context.get(TypeSerializationLibrary.class).add(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); + context.get(TypeSerializationLibrary.class).addTypeHandler(Block.class, new BlockTypeHandler(blockManager)); + context.get(TypeSerializationLibrary.class).addTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); blockManager.initialise(gameManifest.getRegisteredBlockFamilies(), gameManifest.getBlockIdMap()); diff --git a/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java b/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java index 40e57b4e6e5..6169491b6e9 100644 --- a/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java +++ b/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java @@ -535,7 +535,7 @@ public void connectToEntitySystem(EngineEntityManager newEntityManager, EventLib context.get(ComponentSystemManager.class).register(new NetworkEntitySystem(this), "engine:networkEntitySystem"); TypeSerializationLibrary typeSerializationLibrary = new TypeSerializationLibrary(entityManager.getTypeSerializerLibrary()); - typeSerializationLibrary.add(EntityRef.class, new NetEntityRefTypeHandler(this, blockEntityRegistry)); + typeSerializationLibrary.addTypeHandler(EntityRef.class, new NetEntityRefTypeHandler(this, blockEntityRegistry)); // TODO: Add network override types here (that use id lookup tables) eventSerializer = new EventSerializer(eventLibrary, typeSerializationLibrary); diff --git a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java index 48efac0e620..b88969d1327 100644 --- a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java @@ -16,7 +16,6 @@ package org.terasology.network.serialization; -import com.google.common.collect.Lists; import gnu.trove.list.TIntList; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.math.geom.Vector3i; @@ -30,9 +29,6 @@ import org.terasology.world.BlockEntityRegistry; import org.terasology.world.block.BlockComponent; -import java.util.Collection; -import java.util.List; - /** * This type handler encodes EntityRef for network transferals. For normal entities, the Network Id of the entity is used. * For block entities the block position is used instead (this allows overriding simulated block entities). @@ -76,33 +72,4 @@ public EntityRef deserialize(PersistedData data, DeserializationContext context) return EntityRef.NULL; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - List items = Lists.newArrayList(); - for (EntityRef ref : value) { - BlockComponent blockComponent = ref.getComponent(BlockComponent.class); - if (blockComponent != null) { - Vector3i blockPos = blockComponent.getPosition(); - items.add(context.create(blockPos.x, blockPos.y, blockPos.z)); - } else { - NetworkComponent netComponent = ref.getComponent(NetworkComponent.class); - if (netComponent != null) { - items.add(context.create(netComponent.getNetworkId())); - } else { - items.add(context.createNull()); - } - } - } - return context.create(items); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - List result = Lists.newArrayListWithCapacity(data.getAsArray().size()); - for (PersistedData item : data.getAsArray()) { - result.add(deserialize(item, context)); - } - return result; - } - } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java index 054d9f8750f..d54d2d5b471 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java @@ -32,18 +32,4 @@ public interface DeserializationContext { * @throws org.terasology.persistence.typeHandling.DeserializationException if the data cannot be deserialized as type. */ T deserializeAs(PersistedData data, Class type); - - /** - * Atempts to deserialize the given persisted data as a List of the specified type. Type handlers should take care not to invoke this on the type they handle - * or otherwise in a recursive manner. - * - * @param data The persisted data to deserialize - should be an array - * @param type The type of the objects in the collection to deserialize as - * @param - * @return A list of objects of type - * @throws org.terasology.persistence.typeHandling.DeserializationException if the data cannot be deserialized as type - * @throws java.lang.IllegalStateException if the data is not an array. - */ - List deserializeCollection(PersistedData data, Class type); - } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/InstanceCreator.java b/engine/src/main/java/org/terasology/persistence/typeHandling/InstanceCreator.java new file mode 100644 index 00000000000..28fde996d09 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/InstanceCreator.java @@ -0,0 +1,35 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + +import java.lang.reflect.Type; + +/** + * Creates new instances of the type {@link T} to be used during deserialization. + * @param The type of which new instances are to be created. + */ +public interface InstanceCreator { + /** + * This method is called during deserialization to create an instance of the + * specified type. The fields of the returned instance are overwritten with the deserialized data. + * Since the prior contents of the object are destroyed and overwritten, always return different instances. In particular, do not return a common instance, + * always use {@code new} to create a new instance. + * + * @param type the parameterized type {@link T} represented as a {@link Type}. + * @return a default object instance of type {@link T}. + */ + T createInstance(Type type); +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java index 45b04b5f96d..d213aa4198f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java @@ -193,16 +193,6 @@ public interface SerializationContext { */ PersistedData create(T data, Class type); - /** - * Attempts to serialize the given data using registered an appropriate type handler. Type handlers should take care not to invoke this on the type they - * handle or otherwise in a recursive manner. - * @param data - * @param type - * @param - * @return The serialized data - */ - PersistedData create(Collection data, Class type); - /** * @return A 'null' PersistedData */ diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/SimpleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/SimpleTypeHandler.java deleted file mode 100644 index c465a3fa45a..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/SimpleTypeHandler.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling; - -import com.google.common.collect.Lists; - -import java.util.Collection; -import java.util.List; - -/** - * Abstract class for type handlers where collections of the type are simply handled by nesting individually serialized values into another value - that is there is - * no special manner in which they are handled. - * - */ -public abstract class SimpleTypeHandler implements TypeHandler { - - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - List rawList = Lists.newArrayList(); - for (T item : value) { - rawList.add(serialize(item, context)); - } - return context.create(rawList); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - for (PersistedData value : array) { - result.add(deserialize(value, context)); - } - return result; - } - return Lists.newArrayList(); - } - -} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index f9ef1b61f96..e4cd72d7023 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -15,11 +15,6 @@ */ package org.terasology.persistence.typeHandling; -import com.google.common.collect.Lists; - -import java.util.Collection; -import java.util.List; - /** */ public abstract class StringRepresentationTypeHandler implements TypeHandler { @@ -46,30 +41,4 @@ public T deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - String[] result = new String[value.size()]; - int index = 0; - for (T item : value) { - if (item != null) { - result[index++] = getAsString(item); - } else { - result[index++] = ""; - } - } - return context.create(result); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - List result = Lists.newArrayList(); - for (String item : data.getAsArray().getAsStringArray()) { - if (item == null || item.isEmpty()) { - result.add(null); - } else { - result.add(getFromString(item)); - } - } - return result; - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index 8a35aaf1b88..e8a06f7b20c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -40,21 +40,4 @@ public interface TypeHandler { * @throws org.terasology.persistence.typeHandling.DeserializationException if there was an error deserializing the data */ T deserialize(PersistedData data, DeserializationContext context); - - /** - * Serializes a collection of this type. This allows for efficiency for types that can be serialized more efficiently in this way, such as primitives - * - * @param value The values to serialize - * @return The serialized values. - */ - PersistedData serializeCollection(Collection value, SerializationContext context); - - /** - * Deserializes a collection of this type. - * - * @param data The persisted data to deserialize from - * @return A list of the resultant values. - * @throws org.terasology.persistence.typeHandling.DeserializationException if there was an error deserializing the data - */ - List deserializeCollection(PersistedData data, DeserializationContext context); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java new file mode 100644 index 00000000000..3b8c19ebb5b --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java @@ -0,0 +1,44 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +/** + * Creates type handlers for a set of types. Type handler factories are generally used when a set of types + * are similar in serialization structure. + */ +public interface TypeHandlerFactory { + /** + * Creates a {@link TypeHandler} for the given type {@link T}. If the type is not supported by + * this {@link TypeHandlerFactory}, {@link Optional#empty()} is returned. + * + * This method is usually called only once for a type, so all expensive pre-computations and reflection + * operations can be performed here so that the generated + * {@link TypeHandler#serialize(Object, SerializationContext)} and + * {@link TypeHandler#deserialize(PersistedData, DeserializationContext)} implementations are fast. + * + * @param typeInfo The {@link TypeInfo} of the type for which a {@link TypeHandler} must be generated. + * @param typeSerializationLibrary The {@link TypeSerializationLibrary} for which the {@link TypeHandler} + * is being created. + * @param The type for which a {@link TypeHandler} must be generated. + * @return An {@link Optional} wrapping the created {@link TypeHandler}, or {@link Optional#empty()} + * if the type is not supported by this {@link TypeHandlerFactory}. + */ + Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary); +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 7cad2f96d5b..65330c7c53b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -16,24 +16,21 @@ package org.terasology.persistence.typeHandling; -import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Lists; import com.google.common.collect.Maps; -import com.google.common.collect.Sets; - import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.audio.StaticSound; import org.terasology.audio.StreamingSound; -import org.terasology.engine.SimpleUri; import org.terasology.entitySystem.prefab.Prefab; import org.terasology.logic.behavior.asset.BehaviorTree; import org.terasology.math.IntegerRange; -import org.terasology.math.geom.Rect2f; -import org.terasology.math.geom.Rect2i; import org.terasology.math.Region3i; -import org.terasology.math.geom.Vector2i; import org.terasology.math.geom.Quat4f; +import org.terasology.math.geom.Rect2f; +import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector2f; +import org.terasology.math.geom.Vector2i; import org.terasology.math.geom.Vector3f; import org.terasology.math.geom.Vector3i; import org.terasology.math.geom.Vector4f; @@ -42,22 +39,21 @@ import org.terasology.persistence.typeHandling.coreTypes.ByteArrayTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ByteTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.DoubleTypeHandler; -import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.FloatTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.IntTypeHandler; -import org.terasology.persistence.typeHandling.coreTypes.ListTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.LongTypeHandler; -import org.terasology.persistence.typeHandling.coreTypes.MappedContainerTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.NumberTypeHandler; -import org.terasology.persistence.typeHandling.coreTypes.QueueTypeHandler; -import org.terasology.persistence.typeHandling.coreTypes.SetTypeHandler; -import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; +import org.terasology.persistence.typeHandling.coreTypes.factories.EnumTypeHandlerFactory; +import org.terasology.persistence.typeHandling.coreTypes.factories.MappedContainerTypeHandlerFactory; +import org.terasology.persistence.typeHandling.coreTypes.factories.StringMapTypeHandlerFactory; import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.ColorTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.NameTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.PrefabTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.TextureRegionTypeHandler; +import org.terasology.persistence.typeHandling.extensionTypes.factories.TextureRegionAssetTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.IntegerRangeHandler; import org.terasology.persistence.typeHandling.mathTypes.Quat4fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Rect2fTypeHandler; @@ -68,11 +64,11 @@ import org.terasology.persistence.typeHandling.mathTypes.Vector3fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector3iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector4fTypeHandler; -import org.terasology.reflection.MappedContainer; +import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.metadata.ClassMetadata; -import org.terasology.reflection.metadata.DefaultClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; +import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.reflection.reflect.ReflectFactory; import org.terasology.rendering.assets.animation.MeshAnimation; import org.terasology.rendering.assets.material.Material; @@ -80,28 +76,29 @@ import org.terasology.rendering.assets.skeletalmesh.SkeletalMesh; import org.terasology.rendering.assets.texture.Texture; import org.terasology.rendering.assets.texture.TextureRegion; -import org.terasology.rendering.assets.texture.TextureRegionAsset; import org.terasology.rendering.nui.Color; import org.terasology.rendering.nui.asset.UIElement; -import org.terasology.utilities.ReflectionUtil; -import java.lang.reflect.Modifier; + import java.lang.reflect.Type; import java.util.List; import java.util.Map; -import java.util.Queue; -import java.util.Set; +import java.util.Optional; /** * A library of type handlers. This is used for the construction of class metadata. * This library should be initialised by adding a number of base type handlers, describing how to serialize each supported type. * It will then produce serializers for classes (through their ClassMetadata) on request. - * */ public class TypeSerializationLibrary { private static final Logger logger = LoggerFactory.getLogger(TypeSerializationLibrary.class); - private Map, TypeHandler> typeHandlers = Maps.newHashMap(); - private Set> coreTypeHandlers = Sets.newHashSet(); + private List typeHandlerFactories = Lists.newArrayList(); + + private Map, TypeHandler> typeHandlerCache = Maps.newHashMap(); + + private Map> instanceCreators = Maps.newHashMap(); + private ConstructorLibrary constructorLibrary; + private ReflectFactory reflectFactory; private CopyStrategyLibrary copyStrategies; @@ -114,21 +111,29 @@ public class TypeSerializationLibrary { public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copyStrategies) { this.reflectFactory = factory; this.copyStrategies = copyStrategies; - add(Boolean.class, new BooleanTypeHandler()); - add(Boolean.TYPE, new BooleanTypeHandler()); - add(Byte.class, new ByteTypeHandler()); - add(Byte.TYPE, new ByteTypeHandler()); - add(Double.class, new DoubleTypeHandler()); - add(Double.TYPE, new DoubleTypeHandler()); - add(Float.class, new FloatTypeHandler()); - add(Float.TYPE, new FloatTypeHandler()); - add(Integer.class, new IntTypeHandler()); - add(Integer.TYPE, new IntTypeHandler()); - add(Long.class, new LongTypeHandler()); - add(Long.TYPE, new LongTypeHandler()); - add(String.class, new StringTypeHandler()); - add(Number.class, new NumberTypeHandler()); - add(byte[].class, new ByteArrayTypeHandler()); + + constructorLibrary = new ConstructorLibrary(instanceCreators, reflectFactory); + + addTypeHandler(Boolean.class, new BooleanTypeHandler()); + addTypeHandler(Boolean.TYPE, new BooleanTypeHandler()); + addTypeHandler(Byte.class, new ByteTypeHandler()); + addTypeHandler(Byte.TYPE, new ByteTypeHandler()); + addTypeHandler(Double.class, new DoubleTypeHandler()); + addTypeHandler(Double.TYPE, new DoubleTypeHandler()); + addTypeHandler(Float.class, new FloatTypeHandler()); + addTypeHandler(Float.TYPE, new FloatTypeHandler()); + addTypeHandler(Integer.class, new IntTypeHandler()); + addTypeHandler(Integer.TYPE, new IntTypeHandler()); + addTypeHandler(Long.class, new LongTypeHandler()); + addTypeHandler(Long.TYPE, new LongTypeHandler()); + addTypeHandler(String.class, new StringTypeHandler()); + addTypeHandler(Number.class, new NumberTypeHandler()); + addTypeHandler(byte[].class, new ByteArrayTypeHandler()); + + addTypeHandlerFactory(new EnumTypeHandlerFactory()); + addTypeHandlerFactory(new CollectionTypeHandlerFactory(constructorLibrary)); + addTypeHandlerFactory(new StringMapTypeHandlerFactory()); + addTypeHandlerFactory(new MappedContainerTypeHandlerFactory(reflectFactory, this.copyStrategies)); } /** @@ -140,39 +145,41 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy public TypeSerializationLibrary(TypeSerializationLibrary original) { this.reflectFactory = original.reflectFactory; this.copyStrategies = original.copyStrategies; - for (Class type : original.coreTypeHandlers) { - typeHandlers.put(type, original.typeHandlers.get(type)); - coreTypeHandlers.add(type); - } + this.typeHandlerFactories.addAll(original.typeHandlerFactories); } public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory factory, CopyStrategyLibrary copyStrategies) { TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(factory, copyStrategies); - serializationLibrary.add(Color.class, new ColorTypeHandler()); - serializationLibrary.add(Quat4f.class, new Quat4fTypeHandler()); - serializationLibrary.add(Texture.class, new AssetTypeHandler<>(Texture.class)); - serializationLibrary.add(UIElement.class, new AssetTypeHandler<>(UIElement.class)); - serializationLibrary.add(Mesh.class, new AssetTypeHandler<>(Mesh.class)); - serializationLibrary.add(StaticSound.class, new AssetTypeHandler<>(StaticSound.class)); - serializationLibrary.add(StreamingSound.class, new AssetTypeHandler<>(StreamingSound.class)); - serializationLibrary.add(Material.class, new AssetTypeHandler<>(Material.class)); - serializationLibrary.add(Name.class, new NameTypeHandler()); - serializationLibrary.add(SkeletalMesh.class, new AssetTypeHandler<>(SkeletalMesh.class)); - serializationLibrary.add(MeshAnimation.class, new AssetTypeHandler<>(MeshAnimation.class)); - serializationLibrary.add(TextureRegion.class, new TextureRegionTypeHandler()); - serializationLibrary.add(TextureRegionAsset.class, new TextureRegionTypeHandler()); - serializationLibrary.add(Vector4f.class, new Vector4fTypeHandler()); - serializationLibrary.add(Vector3f.class, new Vector3fTypeHandler()); - serializationLibrary.add(Vector2f.class, new Vector2fTypeHandler()); - serializationLibrary.add(Vector3i.class, new Vector3iTypeHandler()); - serializationLibrary.add(Vector2i.class, new Vector2iTypeHandler()); - serializationLibrary.add(Rect2i.class, new Rect2iTypeHandler()); - serializationLibrary.add(Rect2f.class, new Rect2fTypeHandler()); - serializationLibrary.add(Region3i.class, new Region3iTypeHandler()); - serializationLibrary.add(Prefab.class, new PrefabTypeHandler()); - serializationLibrary.add(BehaviorTree.class, new AssetTypeHandler<>(BehaviorTree.class)); - serializationLibrary.add(IntegerRange.class, new IntegerRangeHandler()); + + serializationLibrary.addTypeHandler(Color.class, new ColorTypeHandler()); + serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); + // TODO: Add AssetTypeHandlerFactory + serializationLibrary.addTypeHandler(Texture.class, new AssetTypeHandler<>(Texture.class)); + serializationLibrary.addTypeHandler(UIElement.class, new AssetTypeHandler<>(UIElement.class)); + serializationLibrary.addTypeHandler(Mesh.class, new AssetTypeHandler<>(Mesh.class)); + serializationLibrary.addTypeHandler(StaticSound.class, new AssetTypeHandler<>(StaticSound.class)); + serializationLibrary.addTypeHandler(StreamingSound.class, new AssetTypeHandler<>(StreamingSound.class)); + serializationLibrary.addTypeHandler(Material.class, new AssetTypeHandler<>(Material.class)); + serializationLibrary.addTypeHandler(Name.class, new NameTypeHandler()); + serializationLibrary.addTypeHandler(SkeletalMesh.class, new AssetTypeHandler<>(SkeletalMesh.class)); + serializationLibrary.addTypeHandler(MeshAnimation.class, new AssetTypeHandler<>(MeshAnimation.class)); + serializationLibrary.addTypeHandler(TextureRegion.class, new TextureRegionTypeHandler()); + + serializationLibrary.addTypeHandlerFactory(new TextureRegionAssetTypeHandlerFactory()); + + serializationLibrary.addTypeHandler(Vector4f.class, new Vector4fTypeHandler()); + serializationLibrary.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); + serializationLibrary.addTypeHandler(Vector2f.class, new Vector2fTypeHandler()); + serializationLibrary.addTypeHandler(Vector3i.class, new Vector3iTypeHandler()); + serializationLibrary.addTypeHandler(Vector2i.class, new Vector2iTypeHandler()); + serializationLibrary.addTypeHandler(Rect2i.class, new Rect2iTypeHandler()); + serializationLibrary.addTypeHandler(Rect2f.class, new Rect2fTypeHandler()); + serializationLibrary.addTypeHandler(Region3i.class, new Region3iTypeHandler()); + serializationLibrary.addTypeHandler(Prefab.class, new PrefabTypeHandler()); + serializationLibrary.addTypeHandler(BehaviorTree.class, new AssetTypeHandler<>(BehaviorTree.class)); + serializationLibrary.addTypeHandler(IntegerRange.class, new IntegerRangeHandler()); + return serializationLibrary; } @@ -192,117 +199,68 @@ public Serializer getSerializerFor(ClassMetadata type) { return serializer; } - /** - * Adds a type handler that will be to serialize a specified type. - * If a type handler was previously registered for that type, it will be replaced with the new type handler. - * Existing serializers will not be updated. - * - * @param type The type to handle. - * @param handler The TypeHandler - * @param The type to handle. - */ - public void add(Class type, TypeHandler handler) { - typeHandlers.put(type, handler); - coreTypeHandlers.add(type); + public void addTypeHandlerFactory(TypeHandlerFactory typeHandlerFactory) { + typeHandlerFactories.add(typeHandlerFactory); + } + + public void addTypeHandler(Class typeClass, TypeHandler typeHandler) { + addTypeHandler(TypeInfo.of(typeClass), typeHandler); + } + + public void addTypeHandler(TypeInfo type, TypeHandler typeHandler) { + TypeHandlerFactory factory = new TypeHandlerFactory() { + @SuppressWarnings("unchecked") + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + return typeInfo.equals(type) ? Optional.of((TypeHandler) typeHandler) : Optional.empty(); + } + }; + + addTypeHandlerFactory(factory); + } + + public void addInstanceCreator(Class typeClass, InstanceCreator instanceCreator) { + addInstanceCreator(TypeInfo.of(typeClass), instanceCreator); + } + + public void addInstanceCreator(TypeInfo typeInfo, InstanceCreator instanceCreator) { + instanceCreators.put(typeInfo.getType(), instanceCreator); } - public ImmutableSet> getCoreTypes() { - return ImmutableSet.copyOf(coreTypeHandlers); + public TypeHandler getTypeHandler(Type type) { + return getTypeHandler(TypeInfo.of(type)); } - public void clear() { - typeHandlers.clear(); - coreTypeHandlers.clear(); + public TypeHandler getTypeHandler(Class typeClass) { + return getTypeHandler(TypeInfo.of(typeClass)); } - // TODO: Refactor @SuppressWarnings("unchecked") - public TypeHandler getHandlerFor(Type genericType) { - Class typeClass = ReflectionUtil.getClassOfType(genericType); - if (typeClass == null) { - logger.error("Unabled to get class from type {}", genericType); - return null; + public TypeHandler getTypeHandler(TypeInfo type) { + if (typeHandlerCache.containsKey(type)) { + return (TypeHandler) typeHandlerCache.get(type); } - if (Enum.class.isAssignableFrom(typeClass)) { - return new EnumTypeHandler(typeClass); - } else if (List.class.isAssignableFrom(typeClass)) { - // For lists, createEntityRef the handler for the contained type and wrap in a list type handler - Type parameter = ReflectionUtil.getTypeParameter(genericType, 0); - if (parameter != null) { - TypeHandler innerHandler = getHandlerFor(parameter); - if (innerHandler != null) { - return new ListTypeHandler<>(innerHandler); - } - } - logger.error("List field is not parametrized, or holds unsupported type"); - return null; - - } else if (Set.class.isAssignableFrom(typeClass)) { - // For sets: - Type parameter = ReflectionUtil.getTypeParameter(genericType, 0); - if (parameter != null) { - TypeHandler innerHandler = getHandlerFor(parameter); - if (innerHandler != null) { - return new SetTypeHandler<>(innerHandler); - } - } - logger.error("Set field is not parametrized, or holds unsupported type"); - return null; - - } else if (Queue.class.isAssignableFrom(typeClass)) { - // For queues: - Type parameter = ReflectionUtil.getTypeParameter(genericType, 0); - if (parameter != null) { - TypeHandler innerHandler = getHandlerFor(parameter); - if (innerHandler != null) { - return new QueueTypeHandler<>(innerHandler); - } - } - logger.error("Queue field is not parametrized, or holds unsupported type"); - return null; - - } else if (Map.class.isAssignableFrom(typeClass)) { - // For Maps, createEntityRef the handler for the value type (and maybe key too?) - Type keyParameter = ReflectionUtil.getTypeParameter(genericType, 0); - Type contentsParameter = ReflectionUtil.getTypeParameter(genericType, 1); - if (keyParameter != null && contentsParameter != null && String.class == keyParameter) { - TypeHandler valueHandler = getHandlerFor(contentsParameter); - if (valueHandler != null) { - return new StringMapTypeHandler<>(valueHandler); - } - } - logger.error("Map field is not parametrized, does not have a String key, or holds unsupported values"); - - } else if (typeHandlers.containsKey(typeClass)) { - // For known types, just use the handler - return typeHandlers.get(typeClass); - - } else if (typeClass.getAnnotation(MappedContainer.class) != null - && !Modifier.isAbstract(typeClass.getModifiers()) - && !typeClass.isLocalClass() - && !(typeClass.isMemberClass() - && !Modifier.isStatic(typeClass.getModifiers()))) { - try { - ClassMetadata metadata = new DefaultClassMetadata<>(new SimpleUri(), typeClass, reflectFactory, copyStrategies); - MappedContainerTypeHandler mappedHandler = new MappedContainerTypeHandler(typeClass, getFieldHandlerMap(metadata)); - typeHandlers.put(typeClass, mappedHandler); - return mappedHandler; - } catch (NoSuchMethodException e) { - logger.error("Unable to register field of type {}: no publicly accessible default constructor", typeClass.getSimpleName()); - return null; + // TODO: Explore reversing typeHandlerFactories itself before building object + for (int i = typeHandlerFactories.size() - 1; i >= 0; i--) { + TypeHandlerFactory typeHandlerFactory = typeHandlerFactories.get(i); + Optional> typeHandler = typeHandlerFactory.create(type, this); + + if (typeHandler.isPresent()) { + TypeHandler handler = typeHandler.get(); + typeHandlerCache.put(type, handler); + return handler; } - } else { - logger.error("Unable to register field of type {}: not a supported type or MappedContainer", typeClass.getSimpleName()); } + // TODO: Log error and/or return Optional.empty() return null; } private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type) { Map, TypeHandler> handlerMap = Maps.newHashMap(); for (FieldMetadata field : type.getFields()) { - TypeHandler handler = getHandlerFor(field.getField().getGenericType()); + TypeHandler handler = getTypeHandler(field.getField().getGenericType()); if (handler != null) { handlerMap.put(field, handler); } else { @@ -311,8 +269,4 @@ public TypeHandler getHandlerFor(Type genericType) { } return handlerMap; } - - public TypeHandler getTypeHandlerFromClass(Class c) { - return this.typeHandlers.get(c); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index d194a63d543..16a5bfad4a9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -15,17 +15,11 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; -import com.google.common.primitives.Booleans; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class BooleanTypeHandler implements TypeHandler { @@ -46,25 +40,4 @@ public Boolean deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.create(Booleans.toArray(value)); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - for (PersistedData item : array) { - if (item.isBoolean()) { - result.add(item.getAsBoolean()); - } else { - result.add(null); - } - } - return result; - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index 7dbb3a648d7..657d68912b9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -18,9 +18,8 @@ import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; -public class ByteArrayTypeHandler extends SimpleTypeHandler { +public class ByteArrayTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(byte[] value, SerializationContext context) { if (value == null) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index c09a95e3a80..375c5a09e18 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -15,16 +15,11 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; -import com.google.common.primitives.Bytes; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class ByteTypeHandler implements TypeHandler { @@ -48,16 +43,4 @@ public Byte deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.create(Bytes.toArray(value)); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isBytes()) { - return Lists.newArrayList(Bytes.asList(data.getAsBytes())); - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java new file mode 100644 index 00000000000..f33aa057f97 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -0,0 +1,58 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import com.google.common.collect.Lists; +import org.terasology.persistence.typeHandling.DeserializationContext; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.reflection.reflect.ObjectConstructor; + +import java.util.Collection; +import java.util.List; + +public class CollectionTypeHandler implements TypeHandler> { + private TypeHandler elementTypeHandler; + private ObjectConstructor> constructor; + + public CollectionTypeHandler(TypeHandler elementTypeHandler, ObjectConstructor> constructor) { + this.elementTypeHandler = elementTypeHandler; + this.constructor = constructor; + } + + @Override + public PersistedData serialize(Collection value, SerializationContext context) { + List items = Lists.newArrayList(); + + for (E element : value) { + items.add(elementTypeHandler.serialize(element, context)); + } + + return context.create(items); + } + + @Override + public Collection deserialize(PersistedData data, DeserializationContext context) { + Collection collection = constructor.construct(); + + for (PersistedData item : data.getAsArray()) { + collection.add(elementTypeHandler.deserialize(item, context)); + } + + return collection; + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index 28d89d95598..978e0a90d0a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -15,17 +15,11 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; -import com.google.common.primitives.Doubles; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class DoubleTypeHandler implements TypeHandler { @@ -46,26 +40,4 @@ public Double deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.create(Doubles.toArray(value)); - - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - for (PersistedData item : array) { - if (item.isNumber()) { - result.add(item.getAsDouble()); - } else { - result.add(null); - } - } - return result; - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index 1ba6a6cf73a..ffc44507f6e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -15,22 +15,16 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; import java.util.Locale; import java.util.Map; -import java.util.stream.Collectors; /** */ @@ -67,22 +61,4 @@ public T deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - List values = value.stream().map(T::toString).collect(Collectors.toCollection(ArrayList::new)); - return context.createStrings(values); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - for (PersistedData item : array) { - result.add(deserialize(item, context)); - } - return result; - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index 9831be9d6a7..7913a8d2cc8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -15,17 +15,11 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; -import com.google.common.primitives.Floats; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class FloatTypeHandler implements TypeHandler { @@ -46,25 +40,4 @@ public Float deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.create(Floats.toArray(value)); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - for (PersistedData item : array) { - if (item.isNumber()) { - result.add(item.getAsFloat()); - } else { - result.add(null); - } - } - return result; - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index 3aa9d259a1d..2362bbb259e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -15,17 +15,11 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; -import com.google.common.primitives.Ints; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class IntTypeHandler implements TypeHandler { @@ -46,25 +40,4 @@ public Integer deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.create(Ints.toArray(value)); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - for (PersistedData item : array) { - if (item.isNumber()) { - result.add(item.getAsInteger()); - } else { - result.add(null); - } - } - return result; - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ListTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ListTypeHandler.java deleted file mode 100644 index 4e43378d396..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ListTypeHandler.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.coreTypes; - -import org.terasology.persistence.typeHandling.DeserializationContext; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; -import org.terasology.persistence.typeHandling.TypeHandler; - -import java.util.List; - -/** - */ -public class ListTypeHandler extends SimpleTypeHandler> { - private TypeHandler contentsType; - - public ListTypeHandler(TypeHandler contentsType) { - this.contentsType = contentsType; - } - - - @Override - public PersistedData serialize(List value, SerializationContext context) { - if (value.size() > 0) { - return contentsType.serializeCollection(value, context); - } - return context.createNull(); - } - - @Override - public List deserialize(PersistedData data, DeserializationContext context) { - return contentsType.deserializeCollection(data, context); - } -} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index de5abbcf043..a316c916c77 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -15,17 +15,11 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; -import com.google.common.primitives.Longs; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class LongTypeHandler implements TypeHandler { @@ -46,25 +40,4 @@ public Long deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.create(Longs.toArray(value)); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - for (PersistedData item : array) { - if (item.isNumber()) { - result.add(item.getAsLong()); - } else { - result.add(null); - } - } - return result; - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/MappedContainerTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/MappedContainerTypeHandler.java index 360d3fc1ed1..28b1278d993 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/MappedContainerTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/MappedContainerTypeHandler.java @@ -23,14 +23,13 @@ import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; /** */ -public class MappedContainerTypeHandler extends SimpleTypeHandler { +public class MappedContainerTypeHandler implements TypeHandler { private static final Logger logger = LoggerFactory.getLogger(MappedContainerTypeHandler.class); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index 99056c76ae1..d12088df67a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -16,16 +16,11 @@ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; -import com.google.common.primitives.Doubles; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class NumberTypeHandler implements TypeHandler { @@ -46,17 +41,4 @@ public Number deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.create(Doubles.toArray(value)); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - List result = Lists.newArrayList(); - for (PersistedData item : data.getAsArray()) { - result.add(item.getAsDouble()); - } - return result; - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/QueueTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/QueueTypeHandler.java deleted file mode 100644 index 476c8381c00..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/QueueTypeHandler.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright 2018 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.coreTypes; - - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.terasology.persistence.typeHandling.DeserializationContext; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; -import org.terasology.persistence.typeHandling.TypeHandler; - -import java.util.LinkedList; -import java.util.List; -import java.util.Queue; - -public class QueueTypeHandler extends SimpleTypeHandler> { - private TypeHandler contentsType; - - public QueueTypeHandler(TypeHandler type) { - this.contentsType = type; - } - - @Override - public PersistedData serialize(Queue value, SerializationContext context) { - if (value.size() > 0) { - return contentsType.serializeCollection(value, context); - } - return context.createNull(); - } - - @Override - public Queue deserialize(PersistedData data, DeserializationContext context) { - List list = contentsType.deserializeCollection(data, context); - return new LinkedList<>(list); - } - -} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/SetTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/SetTypeHandler.java deleted file mode 100644 index ca2f0a1e1df..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/SetTypeHandler.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.coreTypes; - -import com.google.common.collect.Sets; -import org.terasology.persistence.typeHandling.DeserializationContext; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; -import org.terasology.persistence.typeHandling.TypeHandler; - -import java.util.Set; - -/** - */ -public class SetTypeHandler extends SimpleTypeHandler> { - private TypeHandler contentsHandler; - - public SetTypeHandler(TypeHandler contentsHandler) { - this.contentsHandler = contentsHandler; - } - - public TypeHandler getContentsHandler() { - return contentsHandler; - } - - @Override - public PersistedData serialize(Set value, SerializationContext context) { - return contentsHandler.serializeCollection(value, context); - } - - @Override - public Set deserialize(PersistedData data, DeserializationContext context) { - return Sets.newLinkedHashSet(contentsHandler.deserializeCollection(data, context)); - } -} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java index 02e2a319048..262d1f34322 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java @@ -19,14 +19,13 @@ import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; /** */ -public class StringMapTypeHandler extends SimpleTypeHandler> { +public class StringMapTypeHandler implements TypeHandler> { private TypeHandler contentsHandler; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index 89dd68c94d1..2d901bb6843 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -15,15 +15,11 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import com.google.common.collect.Lists; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; -import java.util.List; - /** */ public class StringTypeHandler implements TypeHandler { @@ -45,16 +41,4 @@ public String deserialize(PersistedData data, DeserializationContext context) { return null; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - return context.createStrings(value); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - if (data.isArray()) { - return Lists.newArrayList(data.getAsArray().getAsStringArray()); - } - return Lists.newArrayList(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java new file mode 100644 index 00000000000..c5702dd1552 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -0,0 +1,69 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.reflect.ConstructorLibrary; +import org.terasology.reflection.reflect.ObjectConstructor; +import org.terasology.utilities.ReflectionUtil; + +import java.lang.reflect.Type; +import java.util.Collection; +import java.util.Optional; + +/** + * Creates type handlers for {@link Collection} types. + */ +public class CollectionTypeHandlerFactory implements TypeHandlerFactory { + private static final Logger LOGGER = LoggerFactory.getLogger(CollectionTypeHandlerFactory.class); + + private ConstructorLibrary constructorLibrary; + + public CollectionTypeHandlerFactory(ConstructorLibrary constructorLibrary) { + this.constructorLibrary = constructorLibrary; + } + + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + Class rawType = typeInfo.getRawType(); + + if (!Collection.class.isAssignableFrom(rawType)) { + return Optional.empty(); + } + + Type elementType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 0); + + if (elementType == null) { + LOGGER.error("Collection is not parameterized and cannot be serialized"); + return Optional.empty(); + } + + TypeHandler elementTypeHandler = typeSerializationLibrary.getTypeHandler(elementType); + + ObjectConstructor collectionConstructor = constructorLibrary.get(typeInfo); + + @SuppressWarnings({"unchecked"}) + TypeHandler typeHandler = new CollectionTypeHandler(elementTypeHandler, collectionConstructor); + + return Optional.of(typeHandler); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java new file mode 100644 index 00000000000..67602dcb73c --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java @@ -0,0 +1,44 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +/** + * A {@link TypeHandlerFactory} that generates an {@link EnumTypeHandler} for enum types. + */ +public class EnumTypeHandlerFactory implements TypeHandlerFactory { + @SuppressWarnings("unchecked") + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + Class enumClass = typeInfo.getRawType(); + if (!Enum.class.isAssignableFrom(enumClass) || Enum.class.equals(enumClass)) { + return Optional.empty(); + } + + while (!enumClass.isEnum()) { + enumClass = enumClass.getSuperclass(); + } + + return Optional.of((TypeHandler) new EnumTypeHandler(enumClass)); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactory.java new file mode 100644 index 00000000000..edae702afd9 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactory.java @@ -0,0 +1,89 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import com.google.common.collect.Maps; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.terasology.engine.SimpleUri; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.MappedContainerTypeHandler; +import org.terasology.reflection.MappedContainer; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.copy.CopyStrategyLibrary; +import org.terasology.reflection.metadata.ClassMetadata; +import org.terasology.reflection.metadata.DefaultClassMetadata; +import org.terasology.reflection.metadata.FieldMetadata; +import org.terasology.reflection.reflect.ReflectFactory; + +import java.lang.reflect.Modifier; +import java.util.Map; +import java.util.Optional; + +public class MappedContainerTypeHandlerFactory implements TypeHandlerFactory { + private static final Logger LOGGER = LoggerFactory.getLogger(MappedContainerTypeHandlerFactory.class); + + private ReflectFactory reflectFactory; + private CopyStrategyLibrary copyStrategies; + + public MappedContainerTypeHandlerFactory(ReflectFactory reflectFactory, CopyStrategyLibrary copyStrategies) { + this.reflectFactory = reflectFactory; + this.copyStrategies = copyStrategies; + } + + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + Class typeClass = typeInfo.getRawType(); + + if (typeClass.getAnnotation(MappedContainer.class) != null + && !Modifier.isAbstract(typeClass.getModifiers()) + && !typeClass.isLocalClass() + && !(typeClass.isMemberClass() + && !Modifier.isStatic(typeClass.getModifiers()))) { + try { + ClassMetadata metadata = new DefaultClassMetadata<>(new SimpleUri(), typeClass, + reflectFactory, copyStrategies); + + @SuppressWarnings({"unchecked"}) + MappedContainerTypeHandler mappedHandler = new MappedContainerTypeHandler(typeClass, + getFieldHandlerMap(metadata, typeSerializationLibrary)); + + return Optional.of(mappedHandler); + } catch (NoSuchMethodException e) { + LOGGER.error("Unable to register field of type {}: no publicly accessible default constructor", + typeClass.getSimpleName()); + return Optional.empty(); + } + } + + return Optional.empty(); + } + + private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type, TypeSerializationLibrary typeSerializationLibrary) { + Map, TypeHandler> handlerMap = Maps.newHashMap(); + for (FieldMetadata field : type.getFields()) { + TypeHandler handler = typeSerializationLibrary.getTypeHandler(field.getField().getGenericType()); + if (handler != null) { + handlerMap.put(field, handler); + } else { + LOGGER.info("Unsupported field: '{}.{}'", type.getUri(), field.getName()); + } + } + return handlerMap; + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java new file mode 100644 index 00000000000..d4890c9eba7 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -0,0 +1,57 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; +import org.terasology.reflection.TypeInfo; +import org.terasology.utilities.ReflectionUtil; + +import java.lang.reflect.Type; +import java.util.Map; +import java.util.Optional; + +public class StringMapTypeHandlerFactory implements TypeHandlerFactory { + private static final Logger LOGGER = LoggerFactory.getLogger(StringMapTypeHandler.class); + + @SuppressWarnings("unchecked") + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + if (!Map.class.isAssignableFrom(typeInfo.getRawType())) { + return Optional.empty(); + } + + Type keyType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 0); + Type valueType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 1); + + if (!String.class.equals(keyType)) { + return Optional.empty(); + } + + if (valueType == null) { + LOGGER.error("Map is not parameterized and cannot be serialized"); + return Optional.empty(); + } + + TypeHandler valueTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(valueType); + + return Optional.of((TypeHandler) new StringMapTypeHandler<>(valueTypeHandler)); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 105fd4cbc2a..1c71cf2db45 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -21,14 +21,13 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; import org.terasology.rendering.nui.Color; /** * Serializes {@link Color} instances to an int array [r, g, b, a]. * De-serializing also supports hexadecimal strings such as "AAAAAAFF". */ -public class ColorTypeHandler extends SimpleTypeHandler { +public class ColorTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Color value, SerializationContext context) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java index d61bcf6469d..0c5a468aad7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java @@ -15,10 +15,7 @@ */ package org.terasology.persistence.typeHandling.extensionTypes; -import com.google.common.collect.Lists; import gnu.trove.iterator.TLongIterator; -import gnu.trove.list.TLongList; -import gnu.trove.list.array.TLongArrayList; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.EngineEntityManager; import org.terasology.persistence.typeHandling.DeserializationContext; @@ -27,7 +24,6 @@ import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; -import java.util.Collection; import java.util.List; /** @@ -56,31 +52,6 @@ public EntityRef deserialize(PersistedData data, DeserializationContext context) return EntityRef.NULL; } - @Override - public PersistedData serializeCollection(Collection value, SerializationContext context) { - TLongList items = new TLongArrayList(); - for (EntityRef ref : value) { - if (!ref.exists()) { - items.add(0L); - } else { - if (ref.isPersistent()) { - items.add((ref).getId()); - } else { - items.add(0L); - } - } - } - return context.create(items.iterator()); - } - - @Override - public List deserializeCollection(PersistedData data, DeserializationContext context) { - PersistedDataArray array = data.getAsArray(); - List result = Lists.newArrayListWithCapacity(array.size()); - addEntitiesFromLongArray(result, array); - return result; - } - private void addEntitiesFromLongArray(List result, PersistedDataArray array) { TLongIterator iterator = array.getAsLongArray().iterator(); while (iterator.hasNext()) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/TextureRegionAssetTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/TextureRegionAssetTypeHandler.java new file mode 100644 index 00000000000..bf16867eabf --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/TextureRegionAssetTypeHandler.java @@ -0,0 +1,48 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.extensionTypes; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.terasology.persistence.typeHandling.StringRepresentationTypeHandler; +import org.terasology.rendering.assets.texture.TextureRegionAsset; +import org.terasology.utilities.Assets; + +import java.util.Optional; + +public class TextureRegionAssetTypeHandler extends StringRepresentationTypeHandler { + private static final Logger logger = LoggerFactory.getLogger(TextureRegionTypeHandler.class); + + @Override + public String getAsString(TextureRegionAsset item) { + if (item != null) { + return item.getUrn().toString(); + } + return ""; + } + + @Override + public TextureRegionAsset getFromString(String representation) { + Optional region = Assets.getTextureRegion(representation); + if (region.isPresent()) { + return region.get(); + } else { + logger.error("Failed to resolve texture region '" + representation + "'"); + return Assets.getTextureRegion("engine:default").get(); + } + } + +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java new file mode 100644 index 00000000000..0785db3cce0 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java @@ -0,0 +1,37 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.extensionTypes.factories; + +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.extensionTypes.TextureRegionAssetTypeHandler; +import org.terasology.reflection.TypeInfo; +import org.terasology.rendering.assets.texture.TextureRegionAsset; + +import java.util.Optional; + +public class TextureRegionAssetTypeHandlerFactory implements TypeHandlerFactory { + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + if (!TextureRegionAsset.class.equals(typeInfo.getRawType())) { + return Optional.empty(); + } + + TypeHandler handler = (TypeHandler) new TextureRegionAssetTypeHandler(); + return Optional.of(handler); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java index bb3f4a90709..0e241f0760b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java @@ -15,15 +15,12 @@ */ package org.terasology.persistence.typeHandling.gson; -import com.google.common.collect.Lists; import com.google.gson.JsonDeserializationContext; import com.google.gson.JsonParseException; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.DeserializationException; import org.terasology.persistence.typeHandling.PersistedData; -import java.util.List; - /** */ public class GsonDeserializationContext implements DeserializationContext { @@ -44,15 +41,4 @@ public T deserializeAs(PersistedData data, Class type) { } } - @Override - public List deserializeCollection(PersistedData data, Class type) { - if (!data.isArray()) { - throw new IllegalStateException("Data is not an array"); - } - List result = Lists.newArrayList(); - for (PersistedData item : data.getAsArray()) { - result.add(deserializeAs(item, type)); - } - return result; - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java index ab652bb3fe6..d23626a3ce0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java @@ -30,7 +30,6 @@ import java.nio.ByteBuffer; import java.util.Arrays; -import java.util.Collection; import java.util.Map; /** @@ -212,15 +211,6 @@ public PersistedData create(T data, Class type) { return new GsonPersistedData(context.serialize(data, type)); } - @Override - public PersistedData create(Collection data, Class type) { - JsonArray array = new JsonArray(); - for (T item : data) { - array.add(context.serialize(item, type)); - } - return new GsonPersistedData(array); - } - @Override public PersistedData createNull() { return NULL_INSTANCE; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java index 9443b02a92c..7efb14fd7a0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java @@ -41,7 +41,7 @@ public GsonTypeSerializationLibraryAdapterFactory(TypeSerializationLibrary typeS public TypeAdapter create(Gson gson, TypeToken type) { Type rawType = type.getType(); - TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getHandlerFor(rawType); + TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType); if (typeHandler == null) { return null; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java index 83dd337ef60..6c452140211 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java @@ -21,13 +21,12 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; import java.util.Map; /** */ -public class BorderTypeHandler extends SimpleTypeHandler { +public class BorderTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { private static final String LEFT_FIELD = "left"; private static final String RIGHT_FIELD = "right"; private static final String TOP_FIELD = "top"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index b656e65ac21..496cc71d903 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -21,11 +21,10 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; /** */ -public class Quat4fTypeHandler extends SimpleTypeHandler { +public class Quat4fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Quat4f value, SerializationContext context) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index e7061570fc7..8b47331eef0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -23,13 +23,13 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; +import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; /** */ -public class Rect2fTypeHandler extends SimpleTypeHandler { +public class Rect2fTypeHandler implements TypeHandler { private static final String MIN_FIELD = "min"; private static final String SIZE_FIELD = "size"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index 0cf8701759f..67d4d60880e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -24,13 +24,12 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; import java.util.Map; /** */ -public class Rect2iTypeHandler extends SimpleTypeHandler { +public class Rect2iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { private static final String MIN_FIELD = "min"; private static final String SIZE_FIELD = "size"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java index 95949922fc5..9d5da708698 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java @@ -24,13 +24,12 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; import java.util.Map; /** */ -public class Region3iTypeHandler extends SimpleTypeHandler { +public class Region3iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { private static final String MIN_FIELD = UriUtil.normalise("min"); private static final String SIZE_FIELD = UriUtil.normalise("size"); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index de6ddfe5f78..a098d8eb929 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -22,11 +22,10 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; /** */ -public class Vector2fTypeHandler extends SimpleTypeHandler { +public class Vector2fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector2f value, SerializationContext context) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index 28f23592042..f3f95338ddd 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -21,11 +21,10 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; /** */ -public class Vector2iTypeHandler extends SimpleTypeHandler { +public class Vector2iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector2i value, SerializationContext context) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index d1e699f520d..a5caaf4e045 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -21,11 +21,10 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; /** */ -public class Vector3fTypeHandler extends SimpleTypeHandler { +public class Vector3fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector3f value, SerializationContext context) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index 1235fc1fbc0..39da417c53c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -21,11 +21,10 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; /** */ -public class Vector3iTypeHandler extends SimpleTypeHandler { +public class Vector3iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector3i value, SerializationContext context) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index 89e5e24f8ae..32cae2c9f4c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -22,11 +22,10 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.SimpleTypeHandler; /** */ -public class Vector4fTypeHandler extends SimpleTypeHandler { +public class Vector4fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector4f value, SerializationContext context) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java index 2d461dfb741..303fd6e98ab 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java @@ -15,16 +15,12 @@ */ package org.terasology.persistence.typeHandling.protobuf; -import com.google.common.collect.Lists; - import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.DeserializationException; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import java.util.List; - /** */ public class ProtobufDeserializationContext implements DeserializationContext { @@ -37,22 +33,11 @@ public ProtobufDeserializationContext(TypeSerializationLibrary typeSerialization @Override public T deserializeAs(PersistedData data, Class type) { - TypeHandler handler = typeSerializationLibrary.getHandlerFor(type); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(type); if (handler == null) { throw new DeserializationException("No handler found for " + type); } return type.cast(handler.deserialize(data, this)); } - @Override - public List deserializeCollection(PersistedData data, Class type) { - if (!data.isArray()) { - throw new IllegalStateException("Data is not an array"); - } - List result = Lists.newArrayList(); - for (PersistedData item : data.getAsArray()) { - result.add(deserializeAs(item, type)); - } - return result; - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java index c7fd0084d79..2fea1cb71f6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java @@ -28,7 +28,6 @@ import java.nio.ByteBuffer; import java.util.Arrays; -import java.util.Collection; import java.util.Map; /** @@ -199,17 +198,10 @@ public PersistedData create(Map data) { @Override public PersistedData create(T data, Class type) { - TypeHandler handler = (TypeHandler) library.getHandlerFor(type); + TypeHandler handler = (TypeHandler) library.getTypeHandler(type); return handler.serialize(data, this); } - @Override - public PersistedData create(Collection data, Class type) { - TypeHandler handler = (TypeHandler) library.getHandlerFor(type); - return handler.serializeCollection(data, this); - - } - @Override public PersistedData createNull() { return new ProtobufPersistedData(EntityData.Value.newBuilder().build()); diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 7981f6dd066..d3695e8c35c 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -94,12 +94,12 @@ class RecordedEventSerializer { ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); this.typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); - typeSerializationLibrary.add(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); - typeSerializationLibrary.add(MouseAxisEvent.MouseAxis.class, new EnumTypeHandler<>(MouseAxisEvent.MouseAxis.class)); - typeSerializationLibrary.add(ButtonState.class, new EnumTypeHandler<>(ButtonState.class)); - typeSerializationLibrary.add(Keyboard.Key.class, new EnumTypeHandler<>(Keyboard.Key.class)); - typeSerializationLibrary.add(MouseInput.class, new EnumTypeHandler<>(MouseInput.class)); - typeSerializationLibrary.add(MovementMode.class, new EnumTypeHandler<>(MovementMode.class)); + typeSerializationLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); + typeSerializationLibrary.addTypeHandler(MouseAxisEvent.MouseAxis.class, new EnumTypeHandler<>(MouseAxisEvent.MouseAxis.class)); + typeSerializationLibrary.addTypeHandler(ButtonState.class, new EnumTypeHandler<>(ButtonState.class)); + typeSerializationLibrary.addTypeHandler(Keyboard.Key.class, new EnumTypeHandler<>(Keyboard.Key.class)); + typeSerializationLibrary.addTypeHandler(MouseInput.class, new EnumTypeHandler<>(MouseInput.class)); + typeSerializationLibrary.addTypeHandler(MovementMode.class, new EnumTypeHandler<>(MovementMode.class)); this.entityManager = entityManager; this.moduleEnvironment = moduleEnvironment; } @@ -153,7 +153,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { } else if (event instanceof PlaySoundEvent) { PlaySoundEvent e = (PlaySoundEvent) event; writer.name("volume").value(e.getVolume()); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(StaticSound.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); PersistedData data = handler.serialize(e.getSound(), serializationContext); writer.name("sound").value(data.getAsString()); @@ -167,7 +167,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { writer.name("jumpRequested").value(e.isJumpRequested()); writer.name("sequeceNumber").value(e.getSequenceNumber()); writer.name("firstRun").value(e.isFirstRun()); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(Vector3f.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementDirection(), serializationContext); writer.name("movementDirection"); writer.beginObject(); @@ -180,7 +180,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { } else if (event instanceof GetMaxSpeedEvent) { GetMaxSpeedEvent e = (GetMaxSpeedEvent) event; writer.name("baseValue").value(e.getBaseValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(MovementMode.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementMode(), serializationContext); writer.name("movementMode").value(data.getAsString()); writer.name("modifiers"); @@ -210,7 +210,7 @@ private void writeVector3fData(JsonWriter writer, GsonSerializationContext seria } private void writeRealVector3fData(JsonWriter writer, GsonSerializationContext serializationContext, InputEvent e) throws IOException { - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(Vector3f.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getHitNormal(), serializationContext); writer.name("hitNormal"); writer.beginObject(); @@ -229,7 +229,7 @@ private void writeRealVector3fData(JsonWriter writer, GsonSerializationContext s writer.name("z").value(array.get(2).getAsFloat()); writer.endObject(); - handler = typeSerializationLibrary.getTypeHandlerFromClass(Vector3i.class); + handler = typeSerializationLibrary.getTypeHandler(Vector3i.class); data = (GsonPersistedData) handler.serialize(e.getTargetBlockPosition(), serializationContext); writer.name("targetBlockPosition"); writer.beginObject(); @@ -267,7 +267,7 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonSer if (event instanceof MouseWheelEvent) { MouseWheelEvent e = (MouseWheelEvent) event; writer.name("wheelTurns").value(e.getWheelTurns()); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(Vector2i.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector2i.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); writer.name("mousePosition"); writer.beginObject(); @@ -278,7 +278,7 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonSer } else if (event instanceof MouseAxisEvent) { MouseAxisEvent e = (MouseAxisEvent) event; writer.name("value").value(e.getValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(MouseAxisEvent.MouseAxis.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMouseAxis(), serializationContext); writer.name("mouseAxis").value(data.getAsString()); } else if (event instanceof BindAxisEvent) { @@ -287,12 +287,12 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonSer writer.name("value").value(e.getValue()); } else if (event instanceof BindButtonEvent) { BindButtonEvent e = (BindButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(ButtonState.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); writer.name("id"); writer.beginObject(); - handler = typeSerializationLibrary.getTypeHandlerFromClass(Name.class); + handler = typeSerializationLibrary.getTypeHandler(Name.class); data = (GsonPersistedData) handler.serialize(e.getId().getModuleName(), serializationContext); writer.name("moduleName").value(data.getAsString()); data = (GsonPersistedData) handler.serialize(e.getId().getObjectName(), serializationContext); @@ -301,21 +301,21 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonSer } else if (event instanceof KeyEvent) { KeyEvent e = (KeyEvent) event; writer.name("keychar").value(e.getKeyCharacter()); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(ButtonState.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandlerFromClass(Keyboard.Key.class); // might need to add some things to key + handler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); // might need to add some things to key data = (GsonPersistedData) handler.serialize(e.getKey(), serializationContext); writer.name("input").value(data.getAsString()); } else if (event instanceof MouseButtonEvent) { MouseButtonEvent e = (MouseButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(ButtonState.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandlerFromClass(MouseInput.class); + handler = typeSerializationLibrary.getTypeHandler(MouseInput.class); data = (GsonPersistedData) handler.serialize(e.getButton(), serializationContext); writer.name("button").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandlerFromClass(Vector2i.class); + handler = typeSerializationLibrary.getTypeHandler(Vector2i.class); data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); writer.name("mousePosition"); writer.beginObject(); @@ -373,7 +373,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa } else if (className.equals(PlaySoundEvent.class.getName())) { float volume = jsonObject.get("volume").getAsFloat(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("sound")); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(StaticSound.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); StaticSound sound = (StaticSound) handler.deserialize(data, deserializationContext); result = new PlaySoundEvent(sound, volume); } else if (className.equals(CharacterMoveInputEvent.class.getName())) { @@ -392,7 +392,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa result = new CharacterMoveInputEvent(sequenceNumber, pitch, yaw, movementDirection, running, crouching, jumpRequested, delta); } else if (className.equals(GetMaxSpeedEvent.class.getName())) { float baseValue = jsonObject.get("baseValue").getAsFloat(); - TypeHandler handler = typeSerializationLibrary.getTypeHandlerFromClass(MovementMode.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); GsonPersistedData data = new GsonPersistedData(jsonObject.get("movementMode")); MovementMode movementMode = (MovementMode) handler.deserialize(data, deserializationContext); TFloatList modifiers = gson.fromJson(jsonObject.get("modifiers"), TFloatArrayList.class); @@ -422,10 +422,10 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = (InputEvent) clazz.getConstructor().newInstance(); } else if (clazz.equals(KeyDownEvent.class) || clazz.equals(KeyRepeatEvent.class) || clazz.equals(KeyUpEvent.class)) { //KeyEvent GsonPersistedData data = new GsonPersistedData(jsonObject.get("input")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandlerFromClass(Keyboard.Key.class); + TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); Keyboard.Key input = (Keyboard.Key) typeHandler.deserialize(data, deserializationContext); data = new GsonPersistedData(jsonObject.get("state")); - typeHandler = typeSerializationLibrary.getTypeHandlerFromClass(ButtonState.class); + typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); ButtonState state = (ButtonState) typeHandler.deserialize(data, deserializationContext); char keychar = jsonObject.get("keychar").getAsCharacter(); float delta = jsonObject.get("delta").getAsFloat(); @@ -443,10 +443,10 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = aux; } else if (clazz.equals(MouseButtonEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("button")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandlerFromClass(MouseInput.class); + TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(MouseInput.class); MouseInput button = (MouseInput) typeHandler.deserialize(data, deserializationContext); data = new GsonPersistedData(jsonObject.get("state")); - typeHandler = typeSerializationLibrary.getTypeHandlerFromClass(ButtonState.class); + typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); ButtonState state = (ButtonState) typeHandler.deserialize(data, deserializationContext); JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); @@ -456,7 +456,7 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = event; } else if (clazz.equals(MouseAxisEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("mouseAxis")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandlerFromClass(MouseAxisEvent.MouseAxis.class); + TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); MouseAxisEvent.MouseAxis mouseAxis = (MouseAxisEvent.MouseAxis) typeHandler.deserialize(data, deserializationContext); float value = jsonObject.get("value").getAsFloat(); float delta = jsonObject.get("delta").getAsFloat(); @@ -488,10 +488,10 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject, GsonDeserializationContext deserializationContext) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandlerFromClass(ButtonState.class); + TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); ButtonState state = (ButtonState) typeHandler.deserialize(data, deserializationContext); float delta = jsonObject.get("delta").getAsFloat(); - typeHandler = typeSerializationLibrary.getTypeHandlerFromClass(Name.class); + typeHandler = typeSerializationLibrary.getTypeHandler(Name.class); JsonObject aux = jsonObject.get("id").getAsJsonObject(); data = new GsonPersistedData(aux.get("moduleName")); Name moduleName = (Name) typeHandler.deserialize(data, deserializationContext); diff --git a/engine/src/main/java/org/terasology/reflection/TypeInfo.java b/engine/src/main/java/org/terasology/reflection/TypeInfo.java new file mode 100644 index 00000000000..7d06a130b77 --- /dev/null +++ b/engine/src/main/java/org/terasology/reflection/TypeInfo.java @@ -0,0 +1,105 @@ +/* + * Copyright 2017 MovingBlocks + * + * 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 org.terasology.reflection; + +import org.terasology.utilities.ReflectionUtil; + +import java.lang.reflect.Type; + +/** + * Represents the type {@link T}. The type information generated is more comprehensive than {@link Class}, + * and {@link #type} correctly represents {@link T} whether it is generic or a wildcard type. + * + *

+ * Clients must create a subclass so that the proper {@link Type} can be retrieved at run-time: + * + *

+ * {@code TypeInfo> list = new TypeInfo>() {}; } + * + *

+ * However, if the {@link Type} for the given type is already available, {@link TypeInfo#of(Type)} + * can be used: + * + *

+ * {@code TypeInfo fieldType = TypeInfo.of(field.getGenericType()); } + * + *

+ * Alternatively, if the type is a simple class, {@link TypeInfo#of(Class)} will suffice: + * + *

+ * {@code TypeInfo string = TypeInfo.of(String.class); } + * + * @param The type for which type information is to be generated. + */ +public class TypeInfo { + private final Class rawType; + private final Type type; + private final int hashCode; + + /** + * Constructs a new {@link TypeInfo} where the represented type is derived from the type parameter. + */ + @SuppressWarnings("unchecked") + protected TypeInfo() { + this.type = ReflectionUtil.getTypeParameterForSuper(getClass(), TypeInfo.class, 0); + this.rawType = (Class) ReflectionUtil.getClassOfType(type); + this.hashCode = type.hashCode(); + } + + /** + * Constructs a new {@link TypeInfo} directly from the type. + */ + @SuppressWarnings("unchecked") + protected TypeInfo(Type type) { + this.type = type; + this.rawType = (Class) ReflectionUtil.getClassOfType(type); + this.hashCode = type.hashCode(); + } + + /** + * Creates a {@link TypeInfo} for the given type. + */ + public static TypeInfo of(Type type) { + return new TypeInfo(type); + } + + /** + * Creates a {@link TypeInfo} for the given {@link Class}. + */ + public static TypeInfo of(Class type) { + return new TypeInfo<>(type); + } + + public Class getRawType() { + return rawType; + } + + public Type getType() { + return type; + } + + @Override + public final int hashCode() { + return this.hashCode; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + return o instanceof TypeInfo + && ReflectionUtil.typeEquals(type, ((TypeInfo) o).type); + } +} diff --git a/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java new file mode 100644 index 00000000000..60e2424bc2a --- /dev/null +++ b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java @@ -0,0 +1,196 @@ +/* + * Copyright 2018 MovingBlocks + * Copyright (C) 2011 Google Inc. + * + * 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. + * + * Based on Gson v2.6.2 com.google.gson.internal.ConstructorConstructor + */ +package org.terasology.reflection.reflect; + +import org.terasology.persistence.typeHandling.InstanceCreator; +import org.terasology.persistence.typeHandling.SerializationException; +import org.terasology.reflection.TypeInfo; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Collection; +import java.util.EnumSet; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.Map; +import java.util.Queue; +import java.util.Set; +import java.util.SortedMap; +import java.util.SortedSet; +import java.util.TreeMap; +import java.util.TreeSet; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class ConstructorLibrary { + private final Map> instanceCreators; + private final ReflectFactory reflectFactory; + + public ConstructorLibrary(Map> instanceCreators, ReflectFactory reflectFactory) { + this.instanceCreators = instanceCreators; + this.reflectFactory = reflectFactory; + } + + public ObjectConstructor get(TypeInfo typeInfo) { + final Type type = typeInfo.getType(); + final Class rawType = typeInfo.getRawType(); + + // first try an instance creator + + @SuppressWarnings("unchecked") // types must agree + final InstanceCreator typeCreator = (InstanceCreator) instanceCreators.get(type); + if (typeCreator != null) { + return () -> typeCreator.createInstance(type); + } + + // Next try raw type match for instance creators + @SuppressWarnings("unchecked") // types must agree + final InstanceCreator rawTypeCreator = + (InstanceCreator) instanceCreators.get(rawType); + if (rawTypeCreator != null) { + return () -> rawTypeCreator.createInstance(type); + } + + ObjectConstructor defaultConstructor = newDefaultConstructor(rawType); + if (defaultConstructor != null) { + return defaultConstructor; + } + + ObjectConstructor defaultImplementation = newDefaultImplementationConstructor(type, rawType); + if (defaultImplementation != null) { + return defaultImplementation; + } + + // We should never have to reach here + return null; + } + + @SuppressWarnings("unchecked") + private ObjectConstructor newDefaultConstructor(Class rawType) { + try { + return (ObjectConstructor) reflectFactory.createConstructor(rawType); + } catch (NoSuchMethodException e) { + return null; + } + } + + /** + * Constructors for common interface types like Map and List and their + * subtypes. + */ + @SuppressWarnings("unchecked") // use runtime checks to guarantee that 'T' is what it is + private ObjectConstructor newDefaultImplementationConstructor( + final Type type, Class rawType) { + if (Collection.class.isAssignableFrom(rawType)) { + if (SortedSet.class.isAssignableFrom(rawType)) { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new TreeSet(); + } + }; + } else if (EnumSet.class.isAssignableFrom(rawType)) { + return new ObjectConstructor() { + @SuppressWarnings("rawtypes") + @Override + public T construct() { + if (type instanceof ParameterizedType) { + Type elementType = ((ParameterizedType) type).getActualTypeArguments()[0]; + if (elementType instanceof Class) { + return (T) EnumSet.noneOf((Class) elementType); + } else { + throw new SerializationException("Invalid EnumSet type: " + type.toString()); + } + } else { + throw new SerializationException("Invalid EnumSet type: " + type.toString()); + } + } + }; + } else if (Set.class.isAssignableFrom(rawType)) { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new LinkedHashSet(); + } + }; + } else if (Queue.class.isAssignableFrom(rawType)) { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new LinkedList(); + } + }; + } else { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new ArrayList(); + } + }; + } + } + + if (Map.class.isAssignableFrom(rawType)) { + if (ConcurrentNavigableMap.class.isAssignableFrom(rawType)) { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new ConcurrentSkipListMap(); + } + }; + } else if (ConcurrentMap.class.isAssignableFrom(rawType)) { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new ConcurrentHashMap(); + } + }; + } else if (SortedMap.class.isAssignableFrom(rawType)) { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new TreeMap(); + } + }; + } else if (type instanceof ParameterizedType && !(String.class.isAssignableFrom( + TypeInfo.of(((ParameterizedType) type).getActualTypeArguments()[0]).getRawType()))) { + return new ObjectConstructor() { + @Override + public T construct() { + return (T) new LinkedHashMap(); + } + }; + } + } + + return null; + } + + @Override + public String toString() { + return instanceCreators.toString(); + } + +} diff --git a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java index 2062ac87155..1c96ca1fc34 100644 --- a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java +++ b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java @@ -97,8 +97,8 @@ 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()); + library.addTypeHandler(UISkin.class, new AssetTypeHandler<>(UISkin.class)); + library.addTypeHandler(Border.class, new BorderTypeHandler()); GsonBuilder gsonBuilder = new GsonBuilder() .registerTypeAdapterFactory(new GsonTypeSerializationLibraryAdapterFactory(library)) diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 896e42d29e6..02ef29f8e9f 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -21,10 +21,15 @@ import com.google.common.collect.Sets; import org.terasology.rendering.nui.UIWidget; +import java.lang.reflect.Array; import java.lang.reflect.Field; +import java.lang.reflect.GenericArrayType; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; +import java.lang.reflect.TypeVariable; +import java.lang.reflect.WildcardType; +import java.util.Arrays; import java.util.List; import java.util.Locale; import java.util.Set; @@ -36,6 +41,69 @@ public final class ReflectionUtil { private ReflectionUtil() { } + private static boolean equal(Object a, Object b) { + return a == b || (a != null && a.equals(b)); + } + + /** + * Returns true if {@link Type} {@code a} and {@code b} are equal. + */ + public static boolean typeEquals(Type a, Type b) { + if (a == b) { + // also handles (a == null && b == null) + return true; + + } else if (a instanceof Class) { + // Class already specifies equals(). + return a.equals(b); + + } else if (a instanceof ParameterizedType) { + if (!(b instanceof ParameterizedType)) { + return false; + } + + // TODO: save a .clone() call + ParameterizedType pa = (ParameterizedType) a; + ParameterizedType pb = (ParameterizedType) b; + return equal(pa.getOwnerType(), pb.getOwnerType()) + && pa.getRawType().equals(pb.getRawType()) + && Arrays.equals(pa.getActualTypeArguments(), pb.getActualTypeArguments()); + + } else if (a instanceof GenericArrayType) { + if (!(b instanceof GenericArrayType)) { + return false; + } + + GenericArrayType ga = (GenericArrayType) a; + GenericArrayType gb = (GenericArrayType) b; + return typeEquals(ga.getGenericComponentType(), gb.getGenericComponentType()); + + } else if (a instanceof WildcardType) { + if (!(b instanceof WildcardType)) { + return false; + } + + WildcardType wa = (WildcardType) a; + WildcardType wb = (WildcardType) b; + return Arrays.equals(wa.getUpperBounds(), wb.getUpperBounds()) + && Arrays.equals(wa.getLowerBounds(), wb.getLowerBounds()); + + } else if (a instanceof TypeVariable) { + if (!(b instanceof TypeVariable)) { + return false; + } + TypeVariable va = (TypeVariable) a; + TypeVariable vb = (TypeVariable) b; + return va.getGenericDeclaration() == vb.getGenericDeclaration() + && va.getName().equals(vb.getName()); + + } else { + // This isn't a type we support. Could be a generic array type, wildcard type, etc. + return false; + } + } + + /** * Attempts to return the type of a parameter of a parameterised field. This uses compile-time information only - the * type should be obtained from a field with a the generic types bound. @@ -61,8 +129,14 @@ public static Class getClassOfType(Type type) { return (Class) type; } else if (type instanceof ParameterizedType) { return (Class) ((ParameterizedType) type).getRawType(); + } else if (type instanceof GenericArrayType) { + GenericArrayType genericArrayType = (GenericArrayType) type; + return Array.newInstance(getClassOfType(genericArrayType.getGenericComponentType()), 0).getClass(); + } else if (type instanceof WildcardType) { + WildcardType wildcardType = (WildcardType) type; + return getClassOfType(wildcardType.getUpperBounds()[0]); } - return null; + return Object.class; } public static Method findGetter(Field field) { @@ -153,7 +227,7 @@ private static void addInterfaceToInheritanceTree(Class interfa result.add(interfaceType); } - public static Class getTypeParameterForSuper(Type target, Class superClass, int index) { + public static Type getTypeParameterForSuper(Type target, Class superClass, int index) { Class targetClass = getClassOfType(target); Preconditions.checkArgument(superClass.isAssignableFrom(targetClass), "Target must be a child of superClass"); @@ -164,35 +238,25 @@ public static Class getTypeParameterForSuper(Type target, Class superC } } - private static Class getTypeParameterForSuperClass(Type target, Class superClass, int index) { + private static Type getTypeParameterForSuperClass(Type target, Class superClass, int index) { Class targetClass = getClassOfType(target); if (superClass.equals(getClassOfType(targetClass.getGenericSuperclass()))) { Type superType = targetClass.getGenericSuperclass(); if (superType instanceof ParameterizedType) { if (((ParameterizedType) superType).getRawType().equals(superClass)) { - Type boundType = ((ParameterizedType) superType).getActualTypeArguments()[index]; - if (boundType instanceof Class) { - return (Class) boundType; - } else { - return null; - } + return ((ParameterizedType) superType).getActualTypeArguments()[index]; } } } return getTypeParameterForSuperClass(targetClass.getGenericSuperclass(), superClass, index); } - private static Class getTypeParameterForSuperInterface(Type target, Class superClass, int index) { + private static Type getTypeParameterForSuperInterface(Type target, Class superClass, int index) { Class targetClass = getClassOfType(target); for (Type superType : targetClass.getGenericInterfaces()) { if (superType instanceof ParameterizedType) { if (((ParameterizedType) superType).getRawType().equals(superClass)) { - Type boundType = ((ParameterizedType) superType).getActualTypeArguments()[index]; - if (boundType instanceof Class) { - return (Class) boundType; - } else { - return null; - } + return ((ParameterizedType) superType).getActualTypeArguments()[index]; } } } From 61db3e193d3f6906fd1249eacc12451eb6e80d7c Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 10:45:12 +0530 Subject: [PATCH 002/141] Rename MappedContainerTypeHandler to ObjectFieldMapTypeHandler --- .../typeHandling/TypeSerializationLibraryTest.java | 4 ++-- ....java => ObjectFieldMapTypeHandlerFactoryTest.java} | 8 ++++---- .../typeHandling/TypeSerializationLibrary.java | 4 ++-- ...TypeHandler.java => ObjectFieldMapTypeHandler.java} | 6 +++--- ...tory.java => ObjectFieldMapTypeHandlerFactory.java} | 10 +++++----- 5 files changed, 16 insertions(+), 16 deletions(-) rename engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/{MappedContainerTypeHandlerFactoryTest.java => ObjectFieldMapTypeHandlerFactoryTest.java} (87%) rename engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/{MappedContainerTypeHandler.java => ObjectFieldMapTypeHandler.java} (93%) rename engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/{MappedContainerTypeHandlerFactory.java => ObjectFieldMapTypeHandlerFactory.java} (89%) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java index e08426d5e93..de84cefe0d9 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java @@ -18,7 +18,7 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; -import org.terasology.persistence.typeHandling.coreTypes.MappedContainerTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.MappedContainer; import org.terasology.reflection.TypeInfo; @@ -55,7 +55,7 @@ public void testEnumHandler() { public void testMappedContainerHandler() { TypeHandler handler = typeSerializationLibrary.getTypeHandler(AMappedContainer.class); - assertTrue(handler instanceof MappedContainerTypeHandler); + assertTrue(handler instanceof ObjectFieldMapTypeHandler); } @Test diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java similarity index 87% rename from engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactoryTest.java rename to engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index b917cc5af33..ed0a5c9e51a 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -19,7 +19,7 @@ import org.mockito.ArgumentMatchers; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.coreTypes.MappedContainerTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.reflection.MappedContainer; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; @@ -31,12 +31,12 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; -public class MappedContainerTypeHandlerFactoryTest { +public class ObjectFieldMapTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - private final MappedContainerTypeHandlerFactory typeHandlerFactory = new MappedContainerTypeHandlerFactory( + private final ObjectFieldMapTypeHandlerFactory typeHandlerFactory = new ObjectFieldMapTypeHandlerFactory( reflectFactory, copyStrategyLibrary ); @@ -53,7 +53,7 @@ public void testMappedContainer() { assertTrue(typeHandler.isPresent()); - assertTrue(typeHandler.get() instanceof MappedContainerTypeHandler); + assertTrue(typeHandler.get() instanceof ObjectFieldMapTypeHandler); // Verify that the Integer and String TypeHandlers were loaded from the TypeSerializationLibrary verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.TYPE).getType())); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 65330c7c53b..d95f304a0f6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -46,7 +46,7 @@ import org.terasology.persistence.typeHandling.coreTypes.StringTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.EnumTypeHandlerFactory; -import org.terasology.persistence.typeHandling.coreTypes.factories.MappedContainerTypeHandlerFactory; +import org.terasology.persistence.typeHandling.coreTypes.factories.ObjectFieldMapTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.StringMapTypeHandlerFactory; import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.ColorTypeHandler; @@ -133,7 +133,7 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy addTypeHandlerFactory(new EnumTypeHandlerFactory()); addTypeHandlerFactory(new CollectionTypeHandlerFactory(constructorLibrary)); addTypeHandlerFactory(new StringMapTypeHandlerFactory()); - addTypeHandlerFactory(new MappedContainerTypeHandlerFactory(reflectFactory, this.copyStrategies)); + addTypeHandlerFactory(new ObjectFieldMapTypeHandlerFactory(reflectFactory, this.copyStrategies)); } /** diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/MappedContainerTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java similarity index 93% rename from engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/MappedContainerTypeHandler.java rename to engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 28b1278d993..e30c87cb044 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/MappedContainerTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -29,15 +29,15 @@ /** */ -public class MappedContainerTypeHandler implements TypeHandler { +public class ObjectFieldMapTypeHandler implements TypeHandler { - private static final Logger logger = LoggerFactory.getLogger(MappedContainerTypeHandler.class); + private static final Logger logger = LoggerFactory.getLogger(ObjectFieldMapTypeHandler.class); private Map> fieldByName = Maps.newHashMap(); private Map, TypeHandler> mappedFields; private Class clazz; - public MappedContainerTypeHandler(Class clazz, Map, TypeHandler> mappedFields) { + public ObjectFieldMapTypeHandler(Class clazz, Map, TypeHandler> mappedFields) { this.clazz = clazz; this.mappedFields = mappedFields; for (FieldMetadata field : mappedFields.keySet()) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java similarity index 89% rename from engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactory.java rename to engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index edae702afd9..7b731874aed 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/MappedContainerTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -22,7 +22,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.coreTypes.MappedContainerTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.reflection.MappedContainer; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; @@ -35,13 +35,13 @@ import java.util.Map; import java.util.Optional; -public class MappedContainerTypeHandlerFactory implements TypeHandlerFactory { - private static final Logger LOGGER = LoggerFactory.getLogger(MappedContainerTypeHandlerFactory.class); +public class ObjectFieldMapTypeHandlerFactory implements TypeHandlerFactory { + private static final Logger LOGGER = LoggerFactory.getLogger(ObjectFieldMapTypeHandlerFactory.class); private ReflectFactory reflectFactory; private CopyStrategyLibrary copyStrategies; - public MappedContainerTypeHandlerFactory(ReflectFactory reflectFactory, CopyStrategyLibrary copyStrategies) { + public ObjectFieldMapTypeHandlerFactory(ReflectFactory reflectFactory, CopyStrategyLibrary copyStrategies) { this.reflectFactory = reflectFactory; this.copyStrategies = copyStrategies; } @@ -60,7 +60,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati reflectFactory, copyStrategies); @SuppressWarnings({"unchecked"}) - MappedContainerTypeHandler mappedHandler = new MappedContainerTypeHandler(typeClass, + ObjectFieldMapTypeHandler mappedHandler = new ObjectFieldMapTypeHandler(typeClass, getFieldHandlerMap(metadata, typeSerializationLibrary)); return Optional.of(mappedHandler); From 3c84a1010325a50531ad01a7798e7d982334fb4f Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 10:47:30 +0530 Subject: [PATCH 003/141] Remove field name normalization in ObjectFieldMapTypeHandler --- .../typeHandling/coreTypes/ObjectFieldMapTypeHandler.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index e30c87cb044..0a513287580 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -41,7 +41,7 @@ public ObjectFieldMapTypeHandler(Class clazz, Map, TypeHa this.clazz = clazz; this.mappedFields = mappedFields; for (FieldMetadata field : mappedFields.keySet()) { - this.fieldByName.put(UriUtil.normalise(field.getName()), field); + this.fieldByName.put(field.getName(), field); } } @@ -69,7 +69,7 @@ public T deserialize(PersistedData data, DeserializationContext context) { try { T result = clazz.newInstance(); for (Map.Entry entry : data.getAsValueMap().entrySet()) { - FieldMetadata fieldInfo = fieldByName.get(UriUtil.normalise(entry.getKey())); + FieldMetadata fieldInfo = fieldByName.get(entry.getKey()); if (fieldInfo != null) { TypeHandler handler = mappedFields.get(fieldInfo); Object val = handler.deserialize(entry.getValue(), context); From 27d3efd0520120b3c749b8b560690b2e3431f054 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 15:26:46 +0530 Subject: [PATCH 004/141] Remove MappedContainer check in ObjectFieldMapTypeHandlerFactory --- .../ObjectFieldMapTypeHandlerFactoryTest.java | 10 ++++------ .../factories/ObjectFieldMapTypeHandlerFactory.java | 7 ++----- 2 files changed, 6 insertions(+), 11 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index ed0a5c9e51a..8e94765ee4d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -20,7 +20,6 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; -import org.terasology.reflection.MappedContainer; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; @@ -40,16 +39,15 @@ public class ObjectFieldMapTypeHandlerFactoryTest { reflectFactory, copyStrategyLibrary ); - @MappedContainer - public static class AMappedContainer { + public static class SomeClass { public int someInt; public String someString; } @Test - public void testMappedContainer() { - Optional> typeHandler = - typeHandlerFactory.create(TypeInfo.of(AMappedContainer.class), typeSerializationLibrary); + public void testObject() { + Optional> typeHandler = + typeHandlerFactory.create(TypeInfo.of(SomeClass.class), typeSerializationLibrary); assertTrue(typeHandler.isPresent()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 7b731874aed..24d7e1ea4ba 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -23,7 +23,6 @@ import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; -import org.terasology.reflection.MappedContainer; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.metadata.ClassMetadata; @@ -50,11 +49,9 @@ public ObjectFieldMapTypeHandlerFactory(ReflectFactory reflectFactory, CopyStrat public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { Class typeClass = typeInfo.getRawType(); - if (typeClass.getAnnotation(MappedContainer.class) != null - && !Modifier.isAbstract(typeClass.getModifiers()) + if (!Modifier.isAbstract(typeClass.getModifiers()) && !typeClass.isLocalClass() - && !(typeClass.isMemberClass() - && !Modifier.isStatic(typeClass.getModifiers()))) { + && !(typeClass.isMemberClass() && !Modifier.isStatic(typeClass.getModifiers()))) { try { ClassMetadata metadata = new DefaultClassMetadata<>(new SimpleUri(), typeClass, reflectFactory, copyStrategies); From 6a064a955696bde95c993a8a980887af7dd5159e Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 18:20:28 +0530 Subject: [PATCH 005/141] Make getTypeHandlerForSuper methods consider target type itself --- .../terasology/utilities/ReflectionUtil.java | 43 +++++++++++++------ 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 02ef29f8e9f..7fdff64ef50 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -239,28 +239,43 @@ public static Type getTypeParameterForSuper(Type target, Class superClass } private static Type getTypeParameterForSuperClass(Type target, Class superClass, int index) { - Class targetClass = getClassOfType(target); - if (superClass.equals(getClassOfType(targetClass.getGenericSuperclass()))) { - Type superType = targetClass.getGenericSuperclass(); - if (superType instanceof ParameterizedType) { - if (((ParameterizedType) superType).getRawType().equals(superClass)) { - return ((ParameterizedType) superType).getActualTypeArguments()[index]; - } + for (Class targetClass = getClassOfType(target); + !Object.class.equals(targetClass); + target = targetClass.getGenericSuperclass(), targetClass = getClassOfType(target)) { + if (superClass.equals(targetClass)) { + return getTypeParameter(target, index); } } - return getTypeParameterForSuperClass(targetClass.getGenericSuperclass(), superClass, index); + + return null; } private static Type getTypeParameterForSuperInterface(Type target, Class superClass, int index) { Class targetClass = getClassOfType(target); - for (Type superType : targetClass.getGenericInterfaces()) { - if (superType instanceof ParameterizedType) { - if (((ParameterizedType) superType).getRawType().equals(superClass)) { - return ((ParameterizedType) superType).getActualTypeArguments()[index]; - } + + if (Object.class.equals(targetClass)) { + return null; + } + + if (targetClass.equals(superClass)) { + return getTypeParameter(target, index); + } + + Type genericSuperclass = targetClass.getGenericSuperclass(); + + if (!Object.class.equals(genericSuperclass) && genericSuperclass != null) { + return getTypeParameterForSuperInterface(genericSuperclass, superClass, index); + } + + for (Type genericInterface : targetClass.getGenericInterfaces()) { + Type typeParameter = getTypeParameterForSuperInterface(genericInterface, superClass, index); + + if (typeParameter != null) { + return typeParameter; } } - return getTypeParameterForSuperInterface(targetClass.getGenericSuperclass(), superClass, index); + + return null; } public static Object readField(Object object, String fieldName) { From 18b0591d1122e494df4225bebabcdbdd63e12a81 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 18:21:50 +0530 Subject: [PATCH 006/141] Add incomplete ReflectionUtil.resolveFieldType --- .../utilities/ReflectionUtilsTest.java | 35 ++++++++++++++++++- .../terasology/utilities/ReflectionUtil.java | 28 +++++++++++++++ 2 files changed, 62 insertions(+), 1 deletion(-) diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index 697d3a133eb..362e5da5b49 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -18,9 +18,12 @@ import org.junit.Test; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.logic.location.LocationComponent; +import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategy; +import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; +import java.util.Arrays; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -36,7 +39,7 @@ public void testGetParameterForField() throws Exception { @Test public void testGetParameterForGenericInterface() throws Exception { - assertEquals(Integer.class, ReflectionUtil.getTypeParameterForSuper(ParameterisedInterfaceImplementor.class, CopyStrategy.class, 0)); + assertEquals(Integer.class, ReflectionUtil.getTypeParameterForSuper(SubInterfaceImplementor.class, CopyStrategy.class, 0)); } @Test @@ -49,6 +52,36 @@ public void testGetParameterForUnboundGenericInterface() throws Exception { assertTrue(ReflectionUtil.getTypeParameterForSuper(UnboundInterfaceImplementor.class, CopyStrategy.class, 0) instanceof TypeVariable); } + @Test + public void testResolveFieldType() { + class SomeClass { + private T t; + + SomeClass(T t) { + this.t = t; + } + } + + TypeInfo> typeInfo = new TypeInfo>() { + }; + + Type resolvedFieldType = ReflectionUtil.resolveFieldType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[0].getGenericType() + ); + + assertEquals(Float.class, resolvedFieldType); + } + + interface GenericInterfaceSubInterface extends CopyStrategy {} + + class SubInterfaceImplementor implements GenericInterfaceSubInterface { + @Override + public Integer copy(Integer value) { + return null; + } + } + public static class ParameterisedInterfaceImplementor implements CopyStrategy { @Override diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 7fdff64ef50..fd724b9981a 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -278,6 +278,34 @@ private static Type getTypeParameterForSuperInterface(Type target, Class return null; } + public static Type resolveFieldType(Type classType, Type fieldType) { + Class classClass = getClassOfType(classType); + + if (fieldType instanceof TypeVariable) { + TypeVariable typeVariable = (TypeVariable) fieldType; + + Preconditions.checkArgument(typeVariable.getGenericDeclaration() instanceof Class, + "fieldType has not been declared in a class and cannot be a field's type"); + + Class declaringClass = (Class) typeVariable.getGenericDeclaration(); + + Preconditions.checkArgument(declaringClass.isAssignableFrom(classClass), + "Field was not declared in class " + classClass); + + List> typeParameters = + Arrays.asList(declaringClass.getTypeParameters()); + + int typeParameterIndex = typeParameters.indexOf(typeVariable); + + if (!classClass.equals(declaringClass)) { + return getTypeParameterForSuper(classType, declaringClass, typeParameterIndex); + } + return getTypeParameter(classType, typeParameterIndex); + } + + return fieldType; + } + public static Object readField(Object object, String fieldName) { Class cls = object.getClass(); for (Class c = cls; c != null; c = c.getSuperclass()) { From ea34be39b08ea302effef8a971448ad220ea6b08 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 18:46:36 +0530 Subject: [PATCH 007/141] Handle GenericArrayType in resolveFieldType --- .../terasology/utilities/ReflectionUtil.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index fd724b9981a..ed20fb2ffea 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -281,6 +281,7 @@ private static Type getTypeParameterForSuperInterface(Type target, Class public static Type resolveFieldType(Type classType, Type fieldType) { Class classClass = getClassOfType(classType); + // T field; if (fieldType instanceof TypeVariable) { TypeVariable typeVariable = (TypeVariable) fieldType; @@ -303,6 +304,26 @@ public static Type resolveFieldType(Type classType, Type fieldType) { return getTypeParameter(classType, typeParameterIndex); } + // T[] field || List[] field; + if (fieldType instanceof GenericArrayType) { + GenericArrayType arrayType = (GenericArrayType) fieldType; + + Type componentType = arrayType.getGenericComponentType(); + Type resolvedComponentType = resolveFieldType(classType, componentType); + + if (resolvedComponentType == componentType) { + return fieldType; + } else { + return new GenericArrayType() { + final Type genericComponentType = resolvedComponentType; + @Override + public Type getGenericComponentType() { + return genericComponentType; + } + }; + } + } + return fieldType; } From 37b69f04aac09c0d537996a58d4b71705938fe49 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 18:54:20 +0530 Subject: [PATCH 008/141] Rename resolveFieldType to resolveType --- .../utilities/ReflectionUtilsTest.java | 5 +- .../terasology/utilities/ReflectionUtil.java | 61 +++++++++++-------- 2 files changed, 39 insertions(+), 27 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index 362e5da5b49..b69725d8a9d 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -23,7 +23,6 @@ import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; -import java.util.Arrays; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -53,7 +52,7 @@ public void testGetParameterForUnboundGenericInterface() throws Exception { } @Test - public void testResolveFieldType() { + public void testResolveType() { class SomeClass { private T t; @@ -65,7 +64,7 @@ class SomeClass { TypeInfo> typeInfo = new TypeInfo>() { }; - Type resolvedFieldType = ReflectionUtil.resolveFieldType( + Type resolvedFieldType = ReflectionUtil.resolveType( typeInfo.getType(), typeInfo.getRawType().getDeclaredFields()[0].getGenericType() ); diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index ed20fb2ffea..f67beb998b1 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -278,41 +278,31 @@ private static Type getTypeParameterForSuperInterface(Type target, Class return null; } - public static Type resolveFieldType(Type classType, Type fieldType) { - Class classClass = getClassOfType(classType); + public static Type resolveType(Type contextType, Type type) { + Class contextClass = getClassOfType(contextType); // T field; - if (fieldType instanceof TypeVariable) { - TypeVariable typeVariable = (TypeVariable) fieldType; + if (type instanceof TypeVariable) { + TypeVariable typeVariable = (TypeVariable) type; - Preconditions.checkArgument(typeVariable.getGenericDeclaration() instanceof Class, - "fieldType has not been declared in a class and cannot be a field's type"); + Type resolvedType = resolveTypeVariable(contextType, typeVariable, contextClass); - Class declaringClass = (Class) typeVariable.getGenericDeclaration(); - - Preconditions.checkArgument(declaringClass.isAssignableFrom(classClass), - "Field was not declared in class " + classClass); - - List> typeParameters = - Arrays.asList(declaringClass.getTypeParameters()); - - int typeParameterIndex = typeParameters.indexOf(typeVariable); - - if (!classClass.equals(declaringClass)) { - return getTypeParameterForSuper(classType, declaringClass, typeParameterIndex); + if (resolvedType == null) { + return typeVariable; } - return getTypeParameter(classType, typeParameterIndex); + + return resolvedType; } // T[] field || List[] field; - if (fieldType instanceof GenericArrayType) { - GenericArrayType arrayType = (GenericArrayType) fieldType; + if (type instanceof GenericArrayType) { + GenericArrayType arrayType = (GenericArrayType) type; Type componentType = arrayType.getGenericComponentType(); - Type resolvedComponentType = resolveFieldType(classType, componentType); + Type resolvedComponentType = resolveType(contextType, componentType); if (resolvedComponentType == componentType) { - return fieldType; + return type; } else { return new GenericArrayType() { final Type genericComponentType = resolvedComponentType; @@ -324,7 +314,30 @@ public Type getGenericComponentType() { } } - return fieldType; + return type; + } + + private static Type resolveTypeVariable(Type contextType, TypeVariable typeVariable, Class contextClass) { + if (!(typeVariable.getGenericDeclaration() instanceof Class)) { + // We cannot resolve type variables declared by a method, quit + return typeVariable; + } + + Class declaringClass = (Class) typeVariable.getGenericDeclaration(); + + Preconditions.checkArgument(declaringClass.isAssignableFrom(contextClass), + "Type variable was not declared in context class " + contextClass); + + List> typeParameters = + Arrays.asList(declaringClass.getTypeParameters()); + + int typeParameterIndex = typeParameters.indexOf(typeVariable); + + if (!contextClass.equals(declaringClass)) { + return getTypeParameterForSuper(contextType, declaringClass, typeParameterIndex); + } + + return getTypeParameter(contextType, typeParameterIndex); } public static Object readField(Object object, String fieldName) { From 0111d27601530840810117497c96fac122b40651 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 19:24:06 +0530 Subject: [PATCH 009/141] Handle ParameterizedType in resolveType, Add more resolveType tests --- .../utilities/ReflectionUtilsTest.java | 41 ++++++++++++-- .../terasology/utilities/ReflectionUtil.java | 56 ++++++++++++++++++- 2 files changed, 89 insertions(+), 8 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index b69725d8a9d..b2333eb9673 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -21,6 +21,7 @@ import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategy; +import java.lang.reflect.GenericArrayType; import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; @@ -52,13 +53,9 @@ public void testGetParameterForUnboundGenericInterface() throws Exception { } @Test - public void testResolveType() { + public void testResolveTypeVariable() { class SomeClass { private T t; - - SomeClass(T t) { - this.t = t; - } } TypeInfo> typeInfo = new TypeInfo>() { @@ -72,6 +69,40 @@ class SomeClass { assertEquals(Float.class, resolvedFieldType); } + @Test + public void testResolveParameterizedType() { + class SomeClass { + private CopyStrategy t; + } + + TypeInfo> typeInfo = new TypeInfo>() { + }; + + Type resolvedFieldType = ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[0].getGenericType() + ); + + assertEquals(new TypeInfo>() {}.getType(), resolvedFieldType); + } + + @Test + public void testResolveGenericArray() { + class SomeClass { + private T[] t; + } + + TypeInfo> typeInfo = new TypeInfo>() { + }; + + GenericArrayType resolvedFieldType = (GenericArrayType) ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[0].getGenericType() + ); + + assertEquals(Float[].class.getComponentType(), resolvedFieldType.getGenericComponentType()); + } + interface GenericInterfaceSubInterface extends CopyStrategy {} class SubInterfaceImplementor implements GenericInterfaceSubInterface { diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index f67beb998b1..67a4f8b8ae2 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -285,13 +285,63 @@ public static Type resolveType(Type contextType, Type type) { if (type instanceof TypeVariable) { TypeVariable typeVariable = (TypeVariable) type; - Type resolvedType = resolveTypeVariable(contextType, typeVariable, contextClass); + Type resolvedTypeVariable = resolveTypeVariable(contextType, typeVariable, contextClass); - if (resolvedType == null) { + if (resolvedTypeVariable == null || resolvedTypeVariable == typeVariable) { return typeVariable; } - return resolvedType; + return resolveType(contextType, resolvedTypeVariable); + } + + // List field; + if (type instanceof ParameterizedType) { + ParameterizedType parameterizedType = (ParameterizedType) type; + + Type ownerType = parameterizedType.getOwnerType(); + Type resolvedOwnerType = resolveType(contextType, ownerType); + + boolean changed = resolvedOwnerType != ownerType; + + Type[] typeArguments = parameterizedType.getActualTypeArguments(); + + for (int i = 0; i < typeArguments.length; i++) { + Type resolvedTypeArgument = resolveType(contextType, typeArguments[i]); + + if (resolvedTypeArgument != typeArguments[i]) { + if (!changed) { + typeArguments = typeArguments.clone(); + changed = true; + } + + typeArguments[i] = resolvedTypeArgument; + } + } + + if (!changed) { + return parameterizedType; + } + + Type[] resolvedTypeArguments = typeArguments; + + return new ParameterizedType() { + final Type rawType = parameterizedType.getRawType(); + + @Override + public Type[] getActualTypeArguments() { + return resolvedTypeArguments; + } + + @Override + public Type getRawType() { + return rawType; + } + + @Override + public Type getOwnerType() { + return resolvedOwnerType; + } + }; } // T[] field || List[] field; From 90035587e080d2a4ba2eadfd98a982ec805b3344 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 19:42:07 +0530 Subject: [PATCH 010/141] Handle WildcardType in resolveType --- .../utilities/ReflectionUtilsTest.java | 31 +++++++++ .../terasology/utilities/ReflectionUtil.java | 65 +++++++++++++++---- 2 files changed, 83 insertions(+), 13 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index b2333eb9673..9e349f9ac4e 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -22,8 +22,10 @@ import org.terasology.reflection.copy.CopyStrategy; import java.lang.reflect.GenericArrayType; +import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; +import java.lang.reflect.WildcardType; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -103,6 +105,35 @@ class SomeClass { assertEquals(Float[].class.getComponentType(), resolvedFieldType.getGenericComponentType()); } + @Test + public void testResolveWildcardType() { + class SomeClass { + private CopyStrategy t; + private CopyStrategy u; + } + + TypeInfo> typeInfo = new TypeInfo>() { + }; + + ParameterizedType resolvedFieldType = (ParameterizedType) ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[0].getGenericType() + ); + + WildcardType resolvedWildcardType = (WildcardType) resolvedFieldType.getActualTypeArguments()[0]; + + assertEquals(Float.class, resolvedWildcardType.getUpperBounds()[0]); + + resolvedFieldType = (ParameterizedType) ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[1].getGenericType() + ); + + resolvedWildcardType = (WildcardType) resolvedFieldType.getActualTypeArguments()[0]; + + assertEquals(Integer.class, resolvedWildcardType.getLowerBounds()[0]); + } + interface GenericInterfaceSubInterface extends CopyStrategy {} class SubInterfaceImplementor implements GenericInterfaceSubInterface { diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 67a4f8b8ae2..e66ac124302 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -305,25 +305,14 @@ public static Type resolveType(Type contextType, Type type) { Type[] typeArguments = parameterizedType.getActualTypeArguments(); - for (int i = 0; i < typeArguments.length; i++) { - Type resolvedTypeArgument = resolveType(contextType, typeArguments[i]); + Type[] resolvedTypeArguments = resolveTypes(contextType, typeArguments); - if (resolvedTypeArgument != typeArguments[i]) { - if (!changed) { - typeArguments = typeArguments.clone(); - changed = true; - } - - typeArguments[i] = resolvedTypeArgument; - } - } + changed |= resolvedTypeArguments != typeArguments; if (!changed) { return parameterizedType; } - Type[] resolvedTypeArguments = typeArguments; - return new ParameterizedType() { final Type rawType = parameterizedType.getRawType(); @@ -364,9 +353,59 @@ public Type getGenericComponentType() { } } + // List field; + if (type instanceof WildcardType) { + WildcardType wildcardType = (WildcardType) type; + Type[] lowerBounds = wildcardType.getLowerBounds(); + Type[] upperBounds = wildcardType.getUpperBounds(); + + boolean changed = false; + + // Technically not required as language supports only one bound, but generalizing + Type[] resolvedLowerBounds = resolveTypes(contextType, lowerBounds); + changed |= resolvedLowerBounds != lowerBounds; + + Type[] resolvedUpperBounds = resolveTypes(contextType, upperBounds); + changed |= resolvedUpperBounds != upperBounds; + + if (!changed) { + return wildcardType; + } + + return new WildcardType() { + @Override + public Type[] getUpperBounds() { + return resolvedUpperBounds; + } + + @Override + public Type[] getLowerBounds() { + return resolvedLowerBounds; + } + }; + } + return type; } + private static Type[] resolveTypes(Type contextType, Type[] types) { + boolean changed = false; + + for (int i = 0; i < types.length; i++) { + Type resolvedTypeArgument = resolveType(contextType, types[i]); + + if (resolvedTypeArgument != types[i]) { + if (!changed) { + types = types.clone(); + } + + types[i] = resolvedTypeArgument; + } + } + + return types; + } + private static Type resolveTypeVariable(Type contextType, TypeVariable typeVariable, Class contextClass) { if (!(typeVariable.getGenericDeclaration() instanceof Class)) { // We cannot resolve type variables declared by a method, quit From cba3745ea031076ea498e6586c0f897760f14c1f Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 21:15:12 +0530 Subject: [PATCH 011/141] Complete ObjectFieldMapTypeHandler + Factory definition --- .../ObjectFieldMapTypeHandlerFactoryTest.java | 31 ++++---- .../TypeSerializationLibrary.java | 3 +- .../coreTypes/ObjectFieldMapTypeHandler.java | 44 +++++++----- .../ObjectFieldMapTypeHandlerFactory.java | 70 ++++++++++--------- 4 files changed, 83 insertions(+), 65 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index 8e94765ee4d..b91113e5f46 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -15,6 +15,7 @@ */ package org.terasology.persistence.typeHandling.coreTypes.factories; +import com.google.common.collect.Maps; import org.junit.Test; import org.mockito.ArgumentMatchers; import org.terasology.persistence.typeHandling.TypeHandler; @@ -22,8 +23,10 @@ import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; +import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; +import java.util.List; import java.util.Optional; import static org.junit.Assert.assertTrue; @@ -33,28 +36,30 @@ public class ObjectFieldMapTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); - private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); - private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); + private final ConstructorLibrary constructorLibrary = new ConstructorLibrary(Maps.newHashMap(), new ReflectionReflectFactory()); private final ObjectFieldMapTypeHandlerFactory typeHandlerFactory = new ObjectFieldMapTypeHandlerFactory( - reflectFactory, copyStrategyLibrary - ); + constructorLibrary); - public static class SomeClass { - public int someInt; - public String someString; + private static class SomeClass { + private T t; + private List list; } @Test public void testObject() { - Optional> typeHandler = - typeHandlerFactory.create(TypeInfo.of(SomeClass.class), typeSerializationLibrary); - + Optional>> typeHandler = + typeHandlerFactory.create(new TypeInfo>() {}, typeSerializationLibrary); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof ObjectFieldMapTypeHandler); - // Verify that the Integer and String TypeHandlers were loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.TYPE).getType())); - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(String.class).getType())); + // Verify that the Integer and List TypeHandlers were loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler( + ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()) + ); + + verify(typeSerializationLibrary).getTypeHandler( + ArgumentMatchers.eq(new TypeInfo>() {}.getType()) + ); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index d95f304a0f6..1e1a9107ca8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -114,6 +114,8 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy constructorLibrary = new ConstructorLibrary(instanceCreators, reflectFactory); + addTypeHandlerFactory(new ObjectFieldMapTypeHandlerFactory(constructorLibrary)); + addTypeHandler(Boolean.class, new BooleanTypeHandler()); addTypeHandler(Boolean.TYPE, new BooleanTypeHandler()); addTypeHandler(Byte.class, new ByteTypeHandler()); @@ -133,7 +135,6 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy addTypeHandlerFactory(new EnumTypeHandlerFactory()); addTypeHandlerFactory(new CollectionTypeHandlerFactory(constructorLibrary)); addTypeHandlerFactory(new StringMapTypeHandlerFactory()); - addTypeHandlerFactory(new ObjectFieldMapTypeHandlerFactory(reflectFactory, this.copyStrategies)); } /** diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 0a513287580..f8198b0ca27 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -18,13 +18,13 @@ import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.terasology.reflection.metadata.FieldMetadata; -import org.terasology.engine.module.UriUtil; import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.reflection.reflect.ObjectConstructor; +import java.lang.reflect.Field; import java.util.Map; /** @@ -33,14 +33,14 @@ public class ObjectFieldMapTypeHandler implements TypeHandler { private static final Logger logger = LoggerFactory.getLogger(ObjectFieldMapTypeHandler.class); - private Map> fieldByName = Maps.newHashMap(); - private Map, TypeHandler> mappedFields; - private Class clazz; + private Map fieldByName = Maps.newHashMap(); + private Map> mappedFields; + private ObjectConstructor constructor; - public ObjectFieldMapTypeHandler(Class clazz, Map, TypeHandler> mappedFields) { - this.clazz = clazz; - this.mappedFields = mappedFields; - for (FieldMetadata field : mappedFields.keySet()) { + public ObjectFieldMapTypeHandler(ObjectConstructor constructor, Map> fieldTypeHandlers) { + this.constructor = constructor; + this.mappedFields = fieldTypeHandlers; + for (Field field : fieldTypeHandlers.keySet()) { this.fieldByName.put(field.getName(), field); } } @@ -51,13 +51,23 @@ public PersistedData serialize(T value, SerializationContext context) { return context.createNull(); } Map mappedData = Maps.newLinkedHashMap(); - for (Map.Entry, TypeHandler> entry : mappedFields.entrySet()) { - Object val = entry.getKey().getValue(value); + for (Map.Entry> entry : mappedFields.entrySet()) { + Field field = entry.getKey(); + + Object val; + + try { + val = field.get(value); + } catch (IllegalAccessException e) { + logger.error("Field {} is inaccessible", field); + continue; + } + if (val != null) { TypeHandler handler = entry.getValue(); PersistedData fieldValue = handler.serialize(val, context); if (fieldValue != null) { - mappedData.put(entry.getKey().getName(), fieldValue); + mappedData.put(field.getName(), fieldValue); } } } @@ -67,13 +77,13 @@ public PersistedData serialize(T value, SerializationContext context) { @Override public T deserialize(PersistedData data, DeserializationContext context) { try { - T result = clazz.newInstance(); + T result = constructor.construct(); for (Map.Entry entry : data.getAsValueMap().entrySet()) { - FieldMetadata fieldInfo = fieldByName.get(entry.getKey()); - if (fieldInfo != null) { - TypeHandler handler = mappedFields.get(fieldInfo); + Field field = fieldByName.get(entry.getKey()); + if (field != null) { + TypeHandler handler = mappedFields.get(field); Object val = handler.deserialize(entry.getValue(), context); - fieldInfo.setValue(result, val); + field.set(result, val); } } return result; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 24d7e1ea4ba..349e7957ea7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -18,31 +18,29 @@ import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.terasology.engine.SimpleUri; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.reflection.TypeInfo; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.metadata.ClassMetadata; -import org.terasology.reflection.metadata.DefaultClassMetadata; -import org.terasology.reflection.metadata.FieldMetadata; -import org.terasology.reflection.reflect.ReflectFactory; +import org.terasology.reflection.reflect.ConstructorLibrary; +import org.terasology.utilities.ReflectionUtil; +import java.lang.reflect.Field; import java.lang.reflect.Modifier; +import java.lang.reflect.Type; +import java.util.HashMap; import java.util.Map; import java.util.Optional; +import java.util.stream.Collectors; public class ObjectFieldMapTypeHandlerFactory implements TypeHandlerFactory { private static final Logger LOGGER = LoggerFactory.getLogger(ObjectFieldMapTypeHandlerFactory.class); - private ReflectFactory reflectFactory; - private CopyStrategyLibrary copyStrategies; + private ConstructorLibrary constructorLibrary; - public ObjectFieldMapTypeHandlerFactory(ReflectFactory reflectFactory, CopyStrategyLibrary copyStrategies) { - this.reflectFactory = reflectFactory; - this.copyStrategies = copyStrategies; + public ObjectFieldMapTypeHandlerFactory(ConstructorLibrary constructorLibrary) { + this.constructorLibrary = constructorLibrary; } @Override @@ -52,35 +50,39 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati if (!Modifier.isAbstract(typeClass.getModifiers()) && !typeClass.isLocalClass() && !(typeClass.isMemberClass() && !Modifier.isStatic(typeClass.getModifiers()))) { - try { - ClassMetadata metadata = new DefaultClassMetadata<>(new SimpleUri(), typeClass, - reflectFactory, copyStrategies); - - @SuppressWarnings({"unchecked"}) - ObjectFieldMapTypeHandler mappedHandler = new ObjectFieldMapTypeHandler(typeClass, - getFieldHandlerMap(metadata, typeSerializationLibrary)); - - return Optional.of(mappedHandler); - } catch (NoSuchMethodException e) { - LOGGER.error("Unable to register field of type {}: no publicly accessible default constructor", - typeClass.getSimpleName()); - return Optional.empty(); - } + Map> fieldTypeHandlerMap = Maps.newHashMap(); + + getResolvedFields(typeInfo).forEach( + (field, type) -> { + fieldTypeHandlerMap.put(field, typeSerializationLibrary.getTypeHandler(type)); + } + ); + + ObjectFieldMapTypeHandler mappedHandler = + new ObjectFieldMapTypeHandler<>(constructorLibrary.get(typeInfo), fieldTypeHandlerMap); + + return Optional.of(mappedHandler); } return Optional.empty(); } - private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type, TypeSerializationLibrary typeSerializationLibrary) { - Map, TypeHandler> handlerMap = Maps.newHashMap(); - for (FieldMetadata field : type.getFields()) { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(field.getField().getGenericType()); - if (handler != null) { - handlerMap.put(field, handler); - } else { - LOGGER.info("Unsupported field: '{}.{}'", type.getUri(), field.getName()); + private Map getResolvedFields(TypeInfo typeInfo) { + Map fields = Maps.newLinkedHashMap(); + + Type type = typeInfo.getType(); + Class rawType = typeInfo.getRawType(); + + while (!Object.class.equals(rawType)) { + for (Field field : rawType.getDeclaredFields()) { + field.setAccessible(true); + Type fieldType = ReflectionUtil.resolveType(type, field.getGenericType()); + fields.put(field, fieldType); } + + rawType = rawType.getSuperclass(); } - return handlerMap; + + return fields; } } From 9561007a0f49e6209029f1e3ee9bed2f41a17c5b Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 21:45:25 +0530 Subject: [PATCH 012/141] Resolve raw type TypeVariables as Object in resolveType --- .../utilities/ReflectionUtilsTest.java | 50 +++++++++++++++++++ .../terasology/utilities/ReflectionUtil.java | 18 ++++--- 2 files changed, 60 insertions(+), 8 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index 9e349f9ac4e..f7b02e51aa8 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -88,6 +88,56 @@ class SomeClass { assertEquals(new TypeInfo>() {}.getType(), resolvedFieldType); } + @Test + public void testResolveRawParameterizedType() { + class SomeClass { + private CopyStrategy t; + private T o; + } + + TypeInfo typeInfo = new TypeInfo() { + }; + + Type resolvedFieldType = ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[0].getGenericType() + ); + + assertEquals(new TypeInfo>() {}.getType(), resolvedFieldType); + + resolvedFieldType = ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[1].getGenericType() + ); + + assertEquals(TypeInfo.of(Object.class).getType(), resolvedFieldType); + } + + @Test + public void testResolveNothing() { + class SomeClass { + private CopyStrategy t; + private String o; + } + + TypeInfo typeInfo = new TypeInfo() { + }; + + Type resolvedFieldType = ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[0].getGenericType() + ); + + assertEquals(new TypeInfo>() {}.getType(), resolvedFieldType); + + resolvedFieldType = ReflectionUtil.resolveType( + typeInfo.getType(), + typeInfo.getRawType().getDeclaredFields()[1].getGenericType() + ); + + assertEquals(TypeInfo.of(String.class).getType(), resolvedFieldType); + } + @Test public void testResolveGenericArray() { class SomeClass { diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index e66ac124302..8a55abd967d 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -287,10 +287,15 @@ public static Type resolveType(Type contextType, Type type) { Type resolvedTypeVariable = resolveTypeVariable(contextType, typeVariable, contextClass); - if (resolvedTypeVariable == null || resolvedTypeVariable == typeVariable) { + if (resolvedTypeVariable == typeVariable) { return typeVariable; } + if (resolvedTypeVariable == null) { + // TypeVariable not specified (i.e. raw type), return Object + return Object.class; + } + return resolveType(contextType, resolvedTypeVariable); } @@ -313,9 +318,9 @@ public static Type resolveType(Type contextType, Type type) { return parameterizedType; } - return new ParameterizedType() { - final Type rawType = parameterizedType.getRawType(); + final Type rawType = parameterizedType.getRawType(); + return new ParameterizedType() { @Override public Type[] getActualTypeArguments() { return resolvedTypeArguments; @@ -397,6 +402,7 @@ private static Type[] resolveTypes(Type contextType, Type[] types) { if (resolvedTypeArgument != types[i]) { if (!changed) { types = types.clone(); + changed = true; } types[i] = resolvedTypeArgument; @@ -422,11 +428,7 @@ private static Type resolveTypeVariable(Type contextType, TypeVariable typeVa int typeParameterIndex = typeParameters.indexOf(typeVariable); - if (!contextClass.equals(declaringClass)) { - return getTypeParameterForSuper(contextType, declaringClass, typeParameterIndex); - } - - return getTypeParameter(contextType, typeParameterIndex); + return getTypeParameterForSuper(contextType, declaringClass, typeParameterIndex); } public static Object readField(Object object, String fieldName) { From a27cffa6b6739bc16cd073615ea4fb05479fa508 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 23:48:48 +0530 Subject: [PATCH 013/141] Ignore ObjectFieldMapTypeHandler in GsonTypeSerializationLibraryAdapterFactory --- .../gson/GsonTypeSerializationLibraryAdapterFactory.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java index 7efb14fd7a0..9d36d6ddfc8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java @@ -21,6 +21,7 @@ import com.google.gson.reflect.TypeToken; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import java.lang.reflect.Type; @@ -43,7 +44,7 @@ public TypeAdapter create(Gson gson, TypeToken type) { TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType); - if (typeHandler == null) { + if (typeHandler == null || typeHandler instanceof ObjectFieldMapTypeHandler) { return null; } From ba1b810b7fdf4e0d4a808496b8e4830eacef7b45 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 25 Jul 2018 23:49:38 +0530 Subject: [PATCH 014/141] Add AssetTypeHandlerFactory --- .../AssetTypeHandlerFactoryTest.java | 55 +++++++++++++++++++ .../TypeSerializationLibrary.java | 14 ++--- .../factories/AssetTypeHandlerFactory.java | 41 ++++++++++++++ 3 files changed, 100 insertions(+), 10 deletions(-) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactoryTest.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactoryTest.java new file mode 100644 index 00000000000..7df10a9526d --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactoryTest.java @@ -0,0 +1,55 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.extensionTypes.factories; + +import com.google.common.collect.Lists; +import org.junit.Test; +import org.terasology.assets.Asset; +import org.terasology.audio.StaticSound; +import org.terasology.audio.StreamingSound; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; +import org.terasology.reflection.TypeInfo; +import org.terasology.rendering.assets.texture.Texture; +import org.terasology.rendering.nui.asset.UIElement; + +import java.util.List; +import java.util.Optional; + +import static org.junit.Assert.assertTrue; + +public class AssetTypeHandlerFactoryTest { + @Test + public void testCreate() { + TypeHandlerFactory factory = new AssetTypeHandlerFactory(); + + List> typesToTest = Lists.newArrayList( + TypeInfo.of(Texture.class), + TypeInfo.of(UIElement.class), + TypeInfo.of(StaticSound.class), + TypeInfo.of(StreamingSound.class) + ); + + for (TypeInfo typeInfo : typesToTest) { + Optional> typeHandler = factory.create(typeInfo, null); + + assertTrue(typeHandler.isPresent()); + + assertTrue(typeHandler.get() instanceof AssetTypeHandler); + } + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 1e1a9107ca8..fb3327f5941 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -53,6 +53,7 @@ import org.terasology.persistence.typeHandling.extensionTypes.NameTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.PrefabTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.TextureRegionTypeHandler; +import org.terasology.persistence.typeHandling.extensionTypes.factories.AssetTypeHandlerFactory; import org.terasology.persistence.typeHandling.extensionTypes.factories.TextureRegionAssetTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.IntegerRangeHandler; import org.terasology.persistence.typeHandling.mathTypes.Quat4fTypeHandler; @@ -155,16 +156,10 @@ public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory facto serializationLibrary.addTypeHandler(Color.class, new ColorTypeHandler()); serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); - // TODO: Add AssetTypeHandlerFactory - serializationLibrary.addTypeHandler(Texture.class, new AssetTypeHandler<>(Texture.class)); - serializationLibrary.addTypeHandler(UIElement.class, new AssetTypeHandler<>(UIElement.class)); - serializationLibrary.addTypeHandler(Mesh.class, new AssetTypeHandler<>(Mesh.class)); - serializationLibrary.addTypeHandler(StaticSound.class, new AssetTypeHandler<>(StaticSound.class)); - serializationLibrary.addTypeHandler(StreamingSound.class, new AssetTypeHandler<>(StreamingSound.class)); - serializationLibrary.addTypeHandler(Material.class, new AssetTypeHandler<>(Material.class)); + + serializationLibrary.addTypeHandlerFactory(new AssetTypeHandlerFactory()); + serializationLibrary.addTypeHandler(Name.class, new NameTypeHandler()); - serializationLibrary.addTypeHandler(SkeletalMesh.class, new AssetTypeHandler<>(SkeletalMesh.class)); - serializationLibrary.addTypeHandler(MeshAnimation.class, new AssetTypeHandler<>(MeshAnimation.class)); serializationLibrary.addTypeHandler(TextureRegion.class, new TextureRegionTypeHandler()); serializationLibrary.addTypeHandlerFactory(new TextureRegionAssetTypeHandlerFactory()); @@ -178,7 +173,6 @@ public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory facto serializationLibrary.addTypeHandler(Rect2f.class, new Rect2fTypeHandler()); serializationLibrary.addTypeHandler(Region3i.class, new Region3iTypeHandler()); serializationLibrary.addTypeHandler(Prefab.class, new PrefabTypeHandler()); - serializationLibrary.addTypeHandler(BehaviorTree.class, new AssetTypeHandler<>(BehaviorTree.class)); serializationLibrary.addTypeHandler(IntegerRange.class, new IntegerRangeHandler()); return serializationLibrary; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java new file mode 100644 index 00000000000..51b162b4251 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java @@ -0,0 +1,41 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.extensionTypes.factories; + +import org.terasology.assets.Asset; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +public class AssetTypeHandlerFactory implements TypeHandlerFactory { + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + Class rawType = typeInfo.getRawType(); + + if (!Asset.class.isAssignableFrom(rawType)) { + return Optional.empty(); + } + + @SuppressWarnings({"unchecked"}) + TypeHandler typeHandler = new AssetTypeHandler(rawType); + + return Optional.of(typeHandler); + } +} From 6d8fe6f228f58e8e91c9388b09d30be0cbf90cd7 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 12:20:15 +0530 Subject: [PATCH 015/141] Add RuntimeDelegatingTypeHandler --- .../RuntimeDelegatingTypeHandlerTest.java | 83 ++++++++++++ .../RuntimeDelegatingTypeHandler.java | 118 ++++++++++++++++++ .../CollectionTypeHandlerFactory.java | 8 +- .../ObjectFieldMapTypeHandlerFactory.java | 15 ++- .../StringMapTypeHandlerFactory.java | 8 +- 5 files changed, 225 insertions(+), 7 deletions(-) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java new file mode 100644 index 00000000000..57cc089865e --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -0,0 +1,83 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import org.junit.Test; +import org.terasology.persistence.typeHandling.DeserializationContext; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.reflect.ConstructorLibrary; +import org.terasology.reflection.reflect.ReflectionReflectFactory; + +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.List; + +import static org.mockito.Mockito.*; + +public class RuntimeDelegatingTypeHandlerTest { + private final ConstructorLibrary constructorLibrary = + new ConstructorLibrary(Maps.newHashMap(), new ReflectionReflectFactory()); + + private final CollectionTypeHandlerFactory collectionHandlerFactory = + new CollectionTypeHandlerFactory(constructorLibrary); + + private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + + private static class Base { + int x; + } + + private static class Sub extends Base { + float y; + } + + @Test + public void testSerialize() { + SerializationContext context = mock(SerializationContext.class); + + Class subType = Sub.class; + Type baseType = TypeInfo.of(Base.class).getType(); + + TypeHandler baseTypeHandler = mock(TypeHandler.class); + TypeHandler subTypeHandler = mock(TypeHandler.class); + + when(typeSerializationLibrary.getTypeHandler(eq(baseType))).thenReturn(baseTypeHandler); + when(typeSerializationLibrary.getTypeHandler(eq(subType))).thenReturn(subTypeHandler); + + TypeHandler> listTypeHandler = collectionHandlerFactory.create(new TypeInfo>() { + }, typeSerializationLibrary).get(); + + ArrayList bases = Lists.newArrayList(new Sub(), new Base(), new Sub(), new Base(), new Sub()); + listTypeHandler.serialize(bases, context); + + verify(typeSerializationLibrary).getTypeHandler(baseType); + verify(typeSerializationLibrary, times(3)).getTypeHandler(subType); + + verify(baseTypeHandler, times(2)).serialize(any(), any()); + verify(subTypeHandler, times(3)).serialize(any(), any()); + } + + @Test + public void testDeserialize() { + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java new file mode 100644 index 00000000000..7f862aa841a --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -0,0 +1,118 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import com.google.common.collect.Maps; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.terasology.persistence.typeHandling.DeserializationContext; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataMap; +import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.reflection.TypeInfo; + +import java.util.Map; + +public class RuntimeDelegatingTypeHandler implements TypeHandler { + private static final String TYPE_FIELD = "@type"; + private static final String VALUE_FIELD = "@value"; + + private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeDelegatingTypeHandler.class); + + private TypeHandler delegateHandler; + private TypeInfo typeInfo; + private TypeSerializationLibrary typeSerializationLibrary; + + public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + this.delegateHandler = delegateHandler; + this.typeInfo = typeInfo; + this.typeSerializationLibrary = typeSerializationLibrary; + } + + @Override + public PersistedData serialize(T value, SerializationContext context) { + TypeHandler chosenHandler = delegateHandler; + Class runtimeClass = value.getClass(); + + if (!typeInfo.getRawType().equals(runtimeClass)) { + TypeHandler runtimeTypeHandler = + (TypeHandler) typeSerializationLibrary.getTypeHandler(runtimeClass); + + if (!(runtimeTypeHandler instanceof ObjectFieldMapTypeHandler)) { + // Custom handler for runtime type + chosenHandler = runtimeTypeHandler; + } else if (!(delegateHandler instanceof ObjectFieldMapTypeHandler)) { + // Custom handler for specified type + chosenHandler = delegateHandler; + } else { + chosenHandler = runtimeTypeHandler; + } + } + + if (chosenHandler == delegateHandler) { + return delegateHandler.serialize(value, context); + } + + Map typeValuePersistedDataMap = Maps.newHashMap(); + + typeValuePersistedDataMap.put( + TYPE_FIELD, + context.create(runtimeClass.getName()) + ); + + typeValuePersistedDataMap.put( + VALUE_FIELD, + chosenHandler.serialize(value, context) + ); + + return context.create(typeValuePersistedDataMap); + } + + @Override + public T deserialize(PersistedData data, DeserializationContext context) { + if (!data.isValueMap()) { + return delegateHandler.deserialize(data, context); + } + + PersistedDataMap valueMap = data.getAsValueMap(); + + if (!valueMap.has(TYPE_FIELD) || !valueMap.has(VALUE_FIELD)) { + return delegateHandler.deserialize(data, context); + } + + String typeName = valueMap.getAsString(TYPE_FIELD); + + // TODO: Use context class loaders + Class typeToDeserializeAs; + + try { + typeToDeserializeAs = Class.forName(typeName); + } catch (ClassNotFoundException e) { + LOGGER.error("Cannot find class {}", typeName); + return null; + } + + TypeHandler typeHandler = + (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs); + + PersistedData valueData = valueMap.get(VALUE_FIELD); + + return typeHandler.deserialize(data, context); + + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index c5702dd1552..b1cc5383fe1 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -21,6 +21,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.reflection.reflect.ObjectConstructor; @@ -50,6 +51,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } + // TODO: Use getTypeParameterFromSuper Type elementType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 0); if (elementType == null) { @@ -57,7 +59,11 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } - TypeHandler elementTypeHandler = typeSerializationLibrary.getTypeHandler(elementType); + TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( + typeSerializationLibrary.getTypeHandler(elementType), + TypeInfo.of(elementType), + typeSerializationLibrary + ); ObjectConstructor collectionConstructor = constructorLibrary.get(typeInfo); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 349e7957ea7..7f319f305bb 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -22,6 +22,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.utilities.ReflectionUtil; @@ -29,10 +30,8 @@ import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.lang.reflect.Type; -import java.util.HashMap; import java.util.Map; import java.util.Optional; -import java.util.stream.Collectors; public class ObjectFieldMapTypeHandlerFactory implements TypeHandlerFactory { private static final Logger LOGGER = LoggerFactory.getLogger(ObjectFieldMapTypeHandlerFactory.class); @@ -53,9 +52,15 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati Map> fieldTypeHandlerMap = Maps.newHashMap(); getResolvedFields(typeInfo).forEach( - (field, type) -> { - fieldTypeHandlerMap.put(field, typeSerializationLibrary.getTypeHandler(type)); - } + (field, fieldType) -> + fieldTypeHandlerMap.put( + field, + new RuntimeDelegatingTypeHandler( + typeSerializationLibrary.getTypeHandler(fieldType), + TypeInfo.of(fieldType), + typeSerializationLibrary + ) + ) ); ObjectFieldMapTypeHandler mappedHandler = diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index d4890c9eba7..fc3e23e5e5f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -20,6 +20,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.utilities.ReflectionUtil; @@ -38,6 +39,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } + // TODO: Replace with getTypeParameterFromSuper Type keyType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 0); Type valueType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 1); @@ -50,7 +52,11 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } - TypeHandler valueTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(valueType); + TypeHandler valueTypeHandler = new RuntimeDelegatingTypeHandler( + typeSerializationLibrary.getTypeHandler(valueType), + TypeInfo.of(valueType), + typeSerializationLibrary + ); return Optional.of((TypeHandler) new StringMapTypeHandler<>(valueTypeHandler)); } From f54143d8b95473b4900aa692bb90479106acbc45 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 13:02:09 +0530 Subject: [PATCH 016/141] Resolve types in getTypeParameterForSuper --- .../utilities/ReflectionUtilsTest.java | 35 ++++++++++++++++++- .../terasology/utilities/ReflectionUtil.java | 7 ++-- 2 files changed, 39 insertions(+), 3 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index f7b02e51aa8..3b5e8182887 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -33,6 +33,15 @@ /** */ public class ReflectionUtilsTest { + @Test + public void testGetClassOfTypeWildcard() { + class C {} + + ParameterizedType cType = (ParameterizedType) new TypeInfo>() {}.getType(); + Type wildcardType = cType.getActualTypeArguments()[0]; + + assertEquals(Object.class, ReflectionUtil.getClassOfType(wildcardType)); + } @Test public void testGetParameterForField() throws Exception { @@ -51,7 +60,31 @@ public void testGetParameterForBuriedGenericInterface() throws Exception { @Test public void testGetParameterForUnboundGenericInterface() throws Exception { - assertTrue(ReflectionUtil.getTypeParameterForSuper(UnboundInterfaceImplementor.class, CopyStrategy.class, 0) instanceof TypeVariable); + Type parameter = ReflectionUtil.getTypeParameterForSuper(new TypeInfo>() {}.getType(), CopyStrategy.class, 0); + + assertTrue(parameter instanceof WildcardType); + } + + @Test + public void testGetTypeParameterForGenericSupertypeInGenericSubclass() { + class SubInterface implements CopyStrategy { + @Override + public T copy(T value) { + return null; + } + } + + class SuperClass {} + + class SubClass extends SuperClass {} + + Type subInterfaceType = new TypeInfo>() {}.getType(); + + assertEquals(Integer.class, ReflectionUtil.getTypeParameterForSuper(subInterfaceType, CopyStrategy.class, 0)); + + Type subClassType = new TypeInfo>() {}.getType(); + + assertEquals(Integer.class, ReflectionUtil.getTypeParameterForSuper(subClassType, SuperClass.class, 0)); } @Test diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 8a55abd967d..9316b6f0469 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -241,7 +241,8 @@ public static Type getTypeParameterForSuper(Type target, Class superClass private static Type getTypeParameterForSuperClass(Type target, Class superClass, int index) { for (Class targetClass = getClassOfType(target); !Object.class.equals(targetClass); - target = targetClass.getGenericSuperclass(), targetClass = getClassOfType(target)) { + target = resolveType(target, targetClass.getGenericSuperclass()), + targetClass = getClassOfType(target)) { if (superClass.equals(targetClass)) { return getTypeParameter(target, index); } @@ -261,13 +262,15 @@ private static Type getTypeParameterForSuperInterface(Type target, Class return getTypeParameter(target, index); } - Type genericSuperclass = targetClass.getGenericSuperclass(); + Type genericSuperclass = resolveType(target, targetClass.getGenericSuperclass()); if (!Object.class.equals(genericSuperclass) && genericSuperclass != null) { return getTypeParameterForSuperInterface(genericSuperclass, superClass, index); } for (Type genericInterface : targetClass.getGenericInterfaces()) { + genericInterface = resolveType(target, genericInterface); + Type typeParameter = getTypeParameterForSuperInterface(genericInterface, superClass, index); if (typeParameter != null) { From 9b7eb997eb2e643e55d1a066a13941cbade4780f Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 13:07:45 +0530 Subject: [PATCH 017/141] Use getTypeParameterForSuper in Collection and StringMap handlers --- .../CollectionTypeHandlerFactoryTest.java | 15 +++++++++++++++ .../StringMapTypeHandlerFactoryTest.java | 18 +++++++++++++++++- .../CollectionTypeHandlerFactory.java | 3 +-- .../factories/StringMapTypeHandlerFactory.java | 5 ++--- 4 files changed, 35 insertions(+), 6 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index 8e847aa6273..b29656c5488 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -25,6 +25,7 @@ import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; +import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.Queue; @@ -79,4 +80,18 @@ public void testQueue() { // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); } + + @Test + public void testNonGenericCollection() { + class IntList extends ArrayList {} + + Optional> typeHandler = + typeHandlerFactory.create(TypeInfo.of(IntList.class), typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof CollectionTypeHandler); + + // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java index bfe2ff9e861..f5dc59294c6 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -22,6 +22,7 @@ import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.TypeInfo; +import java.util.HashMap; import java.util.Map; import java.util.Optional; import java.util.Set; @@ -56,4 +57,19 @@ public void testNonStringMap() { typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); assertFalse(typeHandler.isPresent()); - }} + } + + @Test + public void testNonGenericMap() { + class IntMap extends HashMap {} + + Optional> typeHandler = + typeHandlerFactory.create(TypeInfo.of(IntMap.class), typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof StringMapTypeHandler); + + // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index b1cc5383fe1..e1b3d643de2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -51,8 +51,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } - // TODO: Use getTypeParameterFromSuper - Type elementType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 0); + Type elementType = ReflectionUtil.getTypeParameterForSuper(typeInfo.getType(), Collection.class, 0); if (elementType == null) { LOGGER.error("Collection is not parameterized and cannot be serialized"); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index fc3e23e5e5f..738d5e9e796 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -39,9 +39,8 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } - // TODO: Replace with getTypeParameterFromSuper - Type keyType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 0); - Type valueType = ReflectionUtil.getTypeParameter(typeInfo.getType(), 1); + Type keyType = ReflectionUtil.getTypeParameterForSuper(typeInfo.getType(), Map.class, 0); + Type valueType = ReflectionUtil.getTypeParameterForSuper(typeInfo.getType(), Map.class, 1); if (!String.class.equals(keyType)) { return Optional.empty(); From 125d19cb7cdfe98371d61ccb9340d60ec951fd95 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 13:44:40 +0530 Subject: [PATCH 018/141] Document additions of #3453 --- .../coreTypes/ObjectFieldMapTypeHandler.java | 2 ++ .../coreTypes/RuntimeDelegatingTypeHandler.java | 8 ++++++++ .../factories/AssetTypeHandlerFactory.java | 4 ++++ .../java/org/terasology/utilities/ReflectionUtil.java | 10 ++++++++++ 4 files changed, 24 insertions(+) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index f8198b0ca27..5a9df8157c9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -28,6 +28,8 @@ import java.util.Map; /** + * Serializes objects as a fieldName -> fieldValue map. It is used as the last resort while serializing an + * object through a {@link org.terasology.persistence.typeHandling.TypeSerializationLibrary}. */ public class ObjectFieldMapTypeHandler implements TypeHandler { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 7f862aa841a..fadb53d2a80 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -28,6 +28,14 @@ import java.util.Map; +/** + * Delegates serialization of a value to a handler of its runtime type if needed. It is used in + * cases where a subclass instance can be referred to as its supertype. As such, it is meant + * for internal use in another {@link TypeHandler} only, and is never directly registered + * in a {@link TypeSerializationLibrary}. + * + * @param The base type whose instances may be delegated to a subtype's {@link TypeHandler} at runtime. + */ public class RuntimeDelegatingTypeHandler implements TypeHandler { private static final String TYPE_FIELD = "@type"; private static final String VALUE_FIELD = "@value"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java index 51b162b4251..e6ed7481155 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java @@ -24,6 +24,10 @@ import java.util.Optional; +/** + * Generates an {@link AssetTypeHandler} for each type extending {@link Asset} so that an + * {@link AssetTypeHandler} does not have to be manually registered for each subtype of {@link Asset}. + */ public class AssetTypeHandlerFactory implements TypeHandlerFactory { @Override public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 9316b6f0469..72d6c8bcf67 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -281,6 +281,16 @@ private static Type getTypeParameterForSuperInterface(Type target, Class return null; } + /** + * Resolves all {@link TypeVariable}s in {@code type} to concrete types as per the type + * parameter definitions in {@code contextType}. All {@link TypeVariable}s in {@code type} + * should have been declared in {@code contextType} or one of its supertypes, otherwise an error + * will be thrown. + * + * @param contextType The {@link Type} which contains all type parameter definitions used in {@code type}. + * @param type The {@link Type} whose {@link TypeVariable}s are to be resolved. + * @return A copy of {@code type} with all {@link TypeVariable}s resolved. + */ public static Type resolveType(Type contextType, Type type) { Class contextClass = getClassOfType(contextType); From b5f102265548a343eaa30236091b04a54518a2d4 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 16:39:05 +0530 Subject: [PATCH 019/141] Skip primitive types and static or transient fields during serialization --- .../coreTypes/ObjectFieldMapTypeHandler.java | 17 +++++++++++------ .../coreTypes/RuntimeDelegatingTypeHandler.java | 7 ++++++- .../ObjectFieldMapTypeHandlerFactory.java | 4 ++++ 3 files changed, 21 insertions(+), 7 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 5a9df8157c9..520c630e992 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -81,12 +81,18 @@ public T deserialize(PersistedData data, DeserializationContext context) { try { T result = constructor.construct(); for (Map.Entry entry : data.getAsValueMap().entrySet()) { - Field field = fieldByName.get(entry.getKey()); - if (field != null) { - TypeHandler handler = mappedFields.get(field); - Object val = handler.deserialize(entry.getValue(), context); - field.set(result, val); + String fieldName = entry.getKey(); + Field field = fieldByName.get(fieldName); + + if (field == null) { + logger.error("Cound not find field with name {}", fieldName); + continue; } + + TypeHandler handler = mappedFields.get(field); + Object fieldValue = handler.deserialize(entry.getValue(), context); + + field.set(result, fieldValue); } return result; } catch (Exception e) { @@ -94,5 +100,4 @@ public T deserialize(PersistedData data, DeserializationContext context) { } return null; } - } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index fadb53d2a80..7752974f25d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -54,6 +54,11 @@ public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo @Override public PersistedData serialize(T value, SerializationContext context) { + // If primitive, don't go looking for the runtime type, serialize as is + if (typeInfo.getRawType().isPrimitive()) { + return delegateHandler.serialize(value, context); + } + TypeHandler chosenHandler = delegateHandler; Class runtimeClass = value.getClass(); @@ -120,7 +125,7 @@ public T deserialize(PersistedData data, DeserializationContext context) { PersistedData valueData = valueMap.get(VALUE_FIELD); - return typeHandler.deserialize(data, context); + return typeHandler.deserialize(valueData, context); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 7f319f305bb..2a88f1d41df 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -80,6 +80,10 @@ private Map getResolvedFields(TypeInfo typeInfo) { while (!Object.class.equals(rawType)) { for (Field field : rawType.getDeclaredFields()) { + if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers())) { + continue; + } + field.setAccessible(true); Type fieldType = ReflectionUtil.resolveType(type, field.getGenericType()); fields.put(field, fieldType); From 980522b1056fca79eb1713138ae8c5a89d942749 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 17:17:02 +0530 Subject: [PATCH 020/141] Make Rect2fTypeHandler use a TypeHandler for serializing vectors --- .../TypeSerializationLibrary.java | 13 +----- .../mathTypes/Rect2fTypeHandler.java | 18 ++++++-- .../factories/Rect2fTypeHandlerFactory.java | 46 +++++++++++++++++++ 3 files changed, 62 insertions(+), 15 deletions(-) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index fb3327f5941..98a9d4d9dde 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -20,10 +20,7 @@ import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.terasology.audio.StaticSound; -import org.terasology.audio.StreamingSound; import org.terasology.entitySystem.prefab.Prefab; -import org.terasology.logic.behavior.asset.BehaviorTree; import org.terasology.math.IntegerRange; import org.terasology.math.Region3i; import org.terasology.math.geom.Quat4f; @@ -48,7 +45,6 @@ import org.terasology.persistence.typeHandling.coreTypes.factories.EnumTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.ObjectFieldMapTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.StringMapTypeHandlerFactory; -import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.ColorTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.NameTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.PrefabTypeHandler; @@ -65,20 +61,15 @@ import org.terasology.persistence.typeHandling.mathTypes.Vector3fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector3iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector4fTypeHandler; +import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2fTypeHandlerFactory; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.metadata.ClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.reflection.reflect.ReflectFactory; -import org.terasology.rendering.assets.animation.MeshAnimation; -import org.terasology.rendering.assets.material.Material; -import org.terasology.rendering.assets.mesh.Mesh; -import org.terasology.rendering.assets.skeletalmesh.SkeletalMesh; -import org.terasology.rendering.assets.texture.Texture; import org.terasology.rendering.assets.texture.TextureRegion; import org.terasology.rendering.nui.Color; -import org.terasology.rendering.nui.asset.UIElement; import java.lang.reflect.Type; import java.util.List; @@ -170,7 +161,7 @@ public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory facto serializationLibrary.addTypeHandler(Vector3i.class, new Vector3iTypeHandler()); serializationLibrary.addTypeHandler(Vector2i.class, new Vector2iTypeHandler()); serializationLibrary.addTypeHandler(Rect2i.class, new Rect2iTypeHandler()); - serializationLibrary.addTypeHandler(Rect2f.class, new Rect2fTypeHandler()); + serializationLibrary.addTypeHandlerFactory(new Rect2fTypeHandlerFactory()); serializationLibrary.addTypeHandler(Region3i.class, new Region3iTypeHandler()); serializationLibrary.addTypeHandler(Prefab.class, new PrefabTypeHandler()); serializationLibrary.addTypeHandler(IntegerRange.class, new IntegerRangeHandler()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index 8b47331eef0..e2541e2bf9b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -34,14 +34,22 @@ public class Rect2fTypeHandler implements TypeHandler { private static final String MIN_FIELD = "min"; private static final String SIZE_FIELD = "size"; + private TypeHandler vector2fTypeHandler; + + public Rect2fTypeHandler(TypeHandler vector2fTypeHandler) { + this.vector2fTypeHandler = vector2fTypeHandler; + } + @Override public PersistedData serialize(Rect2f value, SerializationContext context) { if (value == null) { return context.createNull(); } else { Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, context.create(value.min(), Vector2f.class)); - map.put(SIZE_FIELD, context.create(value.size(), Vector2f.class)); + + map.put(MIN_FIELD, vector2fTypeHandler.serialize(value.min(), context)); + map.put(SIZE_FIELD, vector2fTypeHandler.serialize(value.size(), context)); + return context.create(map); } } @@ -50,8 +58,10 @@ public PersistedData serialize(Rect2f value, SerializationContext context) { public Rect2f deserialize(PersistedData data, DeserializationContext context) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2f min = context.deserializeAs(map.get(MIN_FIELD), Vector2f.class); - Vector2f size = context.deserializeAs(map.get(SIZE_FIELD), Vector2f.class); + + Vector2f min = vector2fTypeHandler.deserialize(map.get(MIN_FIELD), context); + Vector2f size = vector2fTypeHandler.deserialize(map.get(SIZE_FIELD), context); + return Rect2f.createFromMinAndSize(min, size); } return null; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java new file mode 100644 index 00000000000..a193790f249 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java @@ -0,0 +1,46 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.mathTypes.factories; + +import com.google.common.base.Preconditions; +import org.terasology.math.geom.Rect2f; +import org.terasology.math.geom.Vector2f; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.mathTypes.Rect2fTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +public class Rect2fTypeHandlerFactory implements TypeHandlerFactory { + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + if (!typeInfo.equals(TypeInfo.of(Rect2f.class))) { + return Optional.empty(); + } + + TypeHandler vector2fTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2f.class); + + Preconditions.checkNotNull(vector2fTypeHandler, "No Vector2f type handler found"); + + Rect2fTypeHandler rect2fTypeHandler = + new Rect2fTypeHandler(vector2fTypeHandler); + + return Optional.of((TypeHandler) rect2fTypeHandler); + + } +} From 252d03615ee0dcb1afc7ece419d8b78f2bfc3c9a Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 17:22:29 +0530 Subject: [PATCH 021/141] Make Rect2iTypeHandler use a TypeHandler for serializing vectors --- .../TypeSerializationLibrary.java | 5 +- .../mathTypes/Rect2iTypeHandler.java | 19 ++++++-- .../factories/Rect2iTypeHandlerFactory.java | 48 +++++++++++++++++++ 3 files changed, 65 insertions(+), 7 deletions(-) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 98a9d4d9dde..5c105efc7fe 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -24,7 +24,6 @@ import org.terasology.math.IntegerRange; import org.terasology.math.Region3i; import org.terasology.math.geom.Quat4f; -import org.terasology.math.geom.Rect2f; import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector2f; import org.terasology.math.geom.Vector2i; @@ -53,7 +52,6 @@ import org.terasology.persistence.typeHandling.extensionTypes.factories.TextureRegionAssetTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.IntegerRangeHandler; import org.terasology.persistence.typeHandling.mathTypes.Quat4fTypeHandler; -import org.terasology.persistence.typeHandling.mathTypes.Rect2fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Rect2iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Region3iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector2fTypeHandler; @@ -62,6 +60,7 @@ import org.terasology.persistence.typeHandling.mathTypes.Vector3iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector4fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2fTypeHandlerFactory; +import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2iTypeHandlerFactory; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.metadata.ClassMetadata; @@ -160,7 +159,7 @@ public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory facto serializationLibrary.addTypeHandler(Vector2f.class, new Vector2fTypeHandler()); serializationLibrary.addTypeHandler(Vector3i.class, new Vector3iTypeHandler()); serializationLibrary.addTypeHandler(Vector2i.class, new Vector2iTypeHandler()); - serializationLibrary.addTypeHandler(Rect2i.class, new Rect2iTypeHandler()); + serializationLibrary.addTypeHandlerFactory(new Rect2iTypeHandlerFactory()); serializationLibrary.addTypeHandlerFactory(new Rect2fTypeHandlerFactory()); serializationLibrary.addTypeHandler(Region3i.class, new Region3iTypeHandler()); serializationLibrary.addTypeHandler(Prefab.class, new PrefabTypeHandler()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index 67d4d60880e..19425437f5b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -24,6 +24,7 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; @@ -34,14 +35,22 @@ public class Rect2iTypeHandler implements org.terasology.persistence.typeHandlin private static final String MIN_FIELD = "min"; private static final String SIZE_FIELD = "size"; + private TypeHandler vector2iTypeHandler; + + public Rect2iTypeHandler(TypeHandler vector2iTypeHandler) { + this.vector2iTypeHandler = vector2iTypeHandler; + } + @Override public PersistedData serialize(Rect2i value, SerializationContext context) { if (value == null) { return context.createNull(); } else { Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, context.create(value.min(), Vector2i.class)); - map.put(SIZE_FIELD, context.create(value.size(), Vector2i.class)); + + map.put(MIN_FIELD, vector2iTypeHandler.serialize(value.min(), context)); + map.put(SIZE_FIELD, vector2iTypeHandler.serialize(value.size(), context)); + return context.create(map); } } @@ -50,8 +59,10 @@ public PersistedData serialize(Rect2i value, SerializationContext context) { public Rect2i deserialize(PersistedData data, DeserializationContext context) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2i min = context.deserializeAs(map.get(MIN_FIELD), Vector2i.class); - Vector2i size = context.deserializeAs(map.get(SIZE_FIELD), Vector2i.class); + + Vector2i min = vector2iTypeHandler.deserialize(map.get(MIN_FIELD), context); + Vector2i size = vector2iTypeHandler.deserialize(map.get(SIZE_FIELD), context); + return Rect2i.createFromMinAndSize(min, size); } return null; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java new file mode 100644 index 00000000000..d139f63fde8 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java @@ -0,0 +1,48 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.mathTypes.factories; + +import com.google.common.base.Preconditions; +import org.terasology.math.geom.Rect2i; +import org.terasology.math.geom.Vector2f; +import org.terasology.math.geom.Vector2i; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.mathTypes.Rect2fTypeHandler; +import org.terasology.persistence.typeHandling.mathTypes.Rect2iTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +public class Rect2iTypeHandlerFactory implements TypeHandlerFactory { + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + if (!typeInfo.equals(TypeInfo.of(Rect2i.class))) { + return Optional.empty(); + } + + TypeHandler vector2iTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2i.class); + + Preconditions.checkNotNull(vector2iTypeHandler, "No Vector2f type handler found"); + + Rect2iTypeHandler rect2fTypeHandler = + new Rect2iTypeHandler(vector2iTypeHandler); + + return Optional.of((TypeHandler) rect2fTypeHandler); + + } +} From 57e087b51bf40ed8dc639c1a91f442c3bf31dbe5 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 17:26:29 +0530 Subject: [PATCH 022/141] Make Region3iTypeHandler use a TypeHandler for serializing vectors --- .../TypeSerializationLibrary.java | 5 +- .../mathTypes/Region3iTypeHandler.java | 19 ++++++-- .../factories/Region3iTypeHandlerFactory.java | 46 +++++++++++++++++++ 3 files changed, 63 insertions(+), 7 deletions(-) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 5c105efc7fe..d0a27a48452 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -24,7 +24,6 @@ import org.terasology.math.IntegerRange; import org.terasology.math.Region3i; import org.terasology.math.geom.Quat4f; -import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector2f; import org.terasology.math.geom.Vector2i; import org.terasology.math.geom.Vector3f; @@ -52,7 +51,6 @@ import org.terasology.persistence.typeHandling.extensionTypes.factories.TextureRegionAssetTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.IntegerRangeHandler; import org.terasology.persistence.typeHandling.mathTypes.Quat4fTypeHandler; -import org.terasology.persistence.typeHandling.mathTypes.Rect2iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Region3iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector2fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector2iTypeHandler; @@ -61,6 +59,7 @@ import org.terasology.persistence.typeHandling.mathTypes.Vector4fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2fTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2iTypeHandlerFactory; +import org.terasology.persistence.typeHandling.mathTypes.factories.Region3iTypeHandlerFactory; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.metadata.ClassMetadata; @@ -161,7 +160,7 @@ public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory facto serializationLibrary.addTypeHandler(Vector2i.class, new Vector2iTypeHandler()); serializationLibrary.addTypeHandlerFactory(new Rect2iTypeHandlerFactory()); serializationLibrary.addTypeHandlerFactory(new Rect2fTypeHandlerFactory()); - serializationLibrary.addTypeHandler(Region3i.class, new Region3iTypeHandler()); + serializationLibrary.addTypeHandlerFactory(new Region3iTypeHandlerFactory()); serializationLibrary.addTypeHandler(Prefab.class, new PrefabTypeHandler()); serializationLibrary.addTypeHandler(IntegerRange.class, new IntegerRangeHandler()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java index 9d5da708698..d8b981b0935 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java @@ -24,6 +24,7 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; @@ -34,14 +35,22 @@ public class Region3iTypeHandler implements org.terasology.persistence.typeHandl private static final String MIN_FIELD = UriUtil.normalise("min"); private static final String SIZE_FIELD = UriUtil.normalise("size"); + private TypeHandler vector3iTypeHandler; + + public Region3iTypeHandler(TypeHandler vector3iTypeHandler) { + this.vector3iTypeHandler = vector3iTypeHandler; + } + @Override public PersistedData serialize(Region3i value, SerializationContext context) { if (value == null) { return context.createNull(); } else { Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, context.create(value.min(), Vector3i.class)); - map.put(SIZE_FIELD, context.create(value.size(), Vector3i.class)); + + map.put(MIN_FIELD, vector3iTypeHandler.serialize(value.min(), context)); + map.put(SIZE_FIELD, vector3iTypeHandler.serialize(value.size(), context)); + return context.create(map); } } @@ -50,8 +59,10 @@ public PersistedData serialize(Region3i value, SerializationContext context) { public Region3i deserialize(PersistedData data, DeserializationContext context) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector3i min = context.deserializeAs(map.get(MIN_FIELD), Vector3i.class); - Vector3i size = context.deserializeAs(map.get(SIZE_FIELD), Vector3i.class); + + Vector3i min = vector3iTypeHandler.deserialize(map.get(MIN_FIELD), context); + Vector3i size = vector3iTypeHandler.deserialize(map.get(SIZE_FIELD), context); + return Region3i.createFromMinAndSize(min, size); } return null; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java new file mode 100644 index 00000000000..e7b2866e1ae --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java @@ -0,0 +1,46 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.mathTypes.factories; + +import com.google.common.base.Preconditions; +import org.terasology.math.Region3i; +import org.terasology.math.geom.Vector3i; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.mathTypes.Region3iTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +public class Region3iTypeHandlerFactory implements TypeHandlerFactory { + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + if (!typeInfo.equals(TypeInfo.of(Region3i.class))) { + return Optional.empty(); + } + + TypeHandler vector3iTypeHandler = typeSerializationLibrary.getTypeHandler(Vector3i.class); + + Preconditions.checkNotNull(vector3iTypeHandler, "No Vector2f type handler found"); + + Region3iTypeHandler region3iTypeHandler = + new Region3iTypeHandler(vector3iTypeHandler); + + return Optional.of((TypeHandler) region3iTypeHandler); + + } +} From e24a74e6d5965e39b6f531de3795e7c1553a85b0 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 17:27:32 +0530 Subject: [PATCH 023/141] Remove DeserializationContext.deserializeAs --- .../typeHandling/DeserializationContext.java | 11 ----------- .../gson/GsonDeserializationContext.java | 13 ------------- .../protobuf/ProtobufDeserializationContext.java | 12 ------------ 3 files changed, 36 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java index d54d2d5b471..a3f1e64ed6e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java @@ -21,15 +21,4 @@ */ public interface DeserializationContext { - /** - * Attempts to deserialize the given persisted data as the specified type. Type handlers should take care not to invoke this on the type they handle or otherwise in - * a recursive manner. - * - * @param data The persisted data to deserialize - * @param type The type of the deserialized object. - * @param The type of the deserialized object. - * @return An object of type - * @throws org.terasology.persistence.typeHandling.DeserializationException if the data cannot be deserialized as type. - */ - T deserializeAs(PersistedData data, Class type); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java index 0e241f0760b..f019fdcb450 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java @@ -16,10 +16,7 @@ package org.terasology.persistence.typeHandling.gson; import com.google.gson.JsonDeserializationContext; -import com.google.gson.JsonParseException; import org.terasology.persistence.typeHandling.DeserializationContext; -import org.terasology.persistence.typeHandling.DeserializationException; -import org.terasology.persistence.typeHandling.PersistedData; /** */ @@ -31,14 +28,4 @@ public GsonDeserializationContext(JsonDeserializationContext context) { this.context = context; } - @Override - public T deserializeAs(PersistedData data, Class type) { - GsonPersistedData gsonData = (GsonPersistedData) data; - try { - return context.deserialize(gsonData.getElement(), type); - } catch (JsonParseException jpe) { - throw new DeserializationException("Failed to deserialize data as " + type, jpe); - } - } - } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java index 303fd6e98ab..17843a9c9cf 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java @@ -16,9 +16,6 @@ package org.terasology.persistence.typeHandling.protobuf; import org.terasology.persistence.typeHandling.DeserializationContext; -import org.terasology.persistence.typeHandling.DeserializationException; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; /** @@ -31,13 +28,4 @@ public ProtobufDeserializationContext(TypeSerializationLibrary typeSerialization this.typeSerializationLibrary = typeSerializationLibrary; } - @Override - public T deserializeAs(PersistedData data, Class type) { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(type); - if (handler == null) { - throw new DeserializationException("No handler found for " + type); - } - return type.cast(handler.deserialize(data, this)); - } - } From 3cd0e2a27a33e0b8e58a194b970b0ced600c464b Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 17:56:52 +0530 Subject: [PATCH 024/141] Remove DeserializationContext usages --- .../coreTypes/CollectionTypeHandlerTest.java | 22 ++----------------- .../EnumTypeHandlerSerializerTest.java | 7 ++---- .../RuntimeDelegatingTypeHandlerTest.java | 2 -- .../extensionTypes/ColorTypeHandlerTest.java | 6 ++--- .../NetEntityRefTypeHandler.java | 3 +-- .../serializers/ComponentSerializer.java | 4 +--- .../serializers/EventSerializer.java | 6 +---- .../serializers/NetworkEntitySerializer.java | 2 +- .../persistence/typeHandling/Serializer.java | 22 +++++++++---------- .../StringRepresentationTypeHandler.java | 2 +- .../persistence/typeHandling/TypeHandler.java | 5 +---- .../typeHandling/TypeHandlerFactory.java | 2 +- .../coreTypes/BooleanTypeHandler.java | 3 +-- .../coreTypes/ByteArrayTypeHandler.java | 3 +-- .../coreTypes/ByteTypeHandler.java | 3 +-- .../coreTypes/CollectionTypeHandler.java | 5 ++--- .../coreTypes/DoubleTypeHandler.java | 3 +-- .../coreTypes/EnumTypeHandler.java | 3 +-- .../coreTypes/FloatTypeHandler.java | 3 +-- .../coreTypes/IntTypeHandler.java | 3 +-- .../coreTypes/LongTypeHandler.java | 3 +-- .../coreTypes/NumberTypeHandler.java | 3 +-- .../coreTypes/ObjectFieldMapTypeHandler.java | 5 ++--- .../RuntimeDelegatingTypeHandler.java | 9 ++++---- .../coreTypes/StringMapTypeHandler.java | 5 ++--- .../coreTypes/StringTypeHandler.java | 3 +-- .../extensionTypes/ColorTypeHandler.java | 3 +-- .../extensionTypes/EntityRefTypeHandler.java | 3 +-- .../gson/GsonTypeHandlerAdapter.java | 2 +- .../gson/LegacyGsonTypeHandlerAdapter.java | 2 +- .../mathTypes/BorderTypeHandler.java | 3 +-- .../mathTypes/Quat4fTypeHandler.java | 3 +-- .../mathTypes/Rect2fTypeHandler.java | 7 +++--- .../mathTypes/Rect2iTypeHandler.java | 7 +++--- .../mathTypes/Region3iTypeHandler.java | 7 +++--- .../mathTypes/Vector2fTypeHandler.java | 3 +-- .../mathTypes/Vector2iTypeHandler.java | 3 +-- .../mathTypes/Vector3fTypeHandler.java | 3 +-- .../mathTypes/Vector3iTypeHandler.java | 3 +-- .../mathTypes/Vector4fTypeHandler.java | 3 +-- .../recording/RecordedEventSerializer.java | 20 ++++++++--------- 41 files changed, 73 insertions(+), 136 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java index 9082ba9f565..f7e96537bce 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java @@ -16,31 +16,17 @@ package org.terasology.persistence.typeHandling.coreTypes; import com.google.common.collect.Queues; -import com.google.common.collect.Sets; import com.google.gson.JsonArray; -import gnu.trove.list.TDoubleList; -import gnu.trove.list.TFloatList; -import gnu.trove.list.TIntList; -import gnu.trove.list.TLongList; import org.junit.Test; import org.mockito.ArgumentMatcher; -import org.mockito.ArgumentMatchers; -import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.gson.GsonPersistedDataArray; import org.terasology.reflection.reflect.ObjectConstructor; -import java.nio.ByteBuffer; import java.util.Collection; import java.util.Collections; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.argThat; @@ -93,14 +79,10 @@ public void testDeserialize() { jsonArray.add(i); } - DeserializationContext context = mock(DeserializationContext.class); - - typeHandler.deserialize(new GsonPersistedDataArray(jsonArray), context); + typeHandler.deserialize(new GsonPersistedDataArray(jsonArray)); verify(constructor).construct(); - verify(elementTypeHandler, times(jsonArray.size())).deserialize(any(), any()); - - verifyZeroInteractions(context); + verify(elementTypeHandler, times(jsonArray.size())).deserialize(any()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java index 749b122910e..a6f3f6fe6d7 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.junit.Test; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; @@ -43,8 +42,7 @@ public void testNullValue() throws Exception { PersistedData serializedNull = handler.serialize(null, serializationContext); assertEquals(nullData, serializedNull); - DeserializationContext deserializationContext = mock(DeserializationContext.class); - TestEnum deserializedValue = handler.deserialize(nullData, deserializationContext); + TestEnum deserializedValue = handler.deserialize(nullData); assertEquals(null, deserializedValue); } @@ -60,8 +58,7 @@ public void testNonNullValue() throws Exception { PersistedData serializedNonNull = handler.serialize(TestEnum.NON_NULL, serializationContext); assertEquals(data, serializedNonNull); - DeserializationContext deserializationContext = mock(DeserializationContext.class); - TestEnum deserializedValue = handler.deserialize(data, deserializationContext); + TestEnum deserializedValue = handler.deserialize(data); assertEquals(TestEnum.NON_NULL, deserializedValue); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 57cc089865e..236b8acc0e7 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -18,8 +18,6 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.junit.Test; -import org.terasology.persistence.typeHandling.DeserializationContext; -import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java index 64452ebb7c5..9c0b18774f8 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java @@ -21,7 +21,6 @@ import org.junit.Assert; import org.junit.Test; import org.mockito.Mockito; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.gson.GsonPersistedDataArray; @@ -34,7 +33,6 @@ public class ColorTypeHandlerTest { private final ColorTypeHandler handler = new ColorTypeHandler(); - private final DeserializationContext deserializationContext = Mockito.mock(DeserializationContext.class); @Test public void testSerialize() { @@ -46,7 +44,7 @@ public void testSerialize() { @Test public void testDeserializeHex() { PersistedData data = new PersistedString("DEADBEEF"); - Color color = handler.deserialize(data, deserializationContext); + Color color = handler.deserialize(data); Assert.assertEquals(0xDEADBEEF, color.rgba()); } @@ -54,7 +52,7 @@ public void testDeserializeHex() { public void testDeserializeArray() { JsonArray array = new Gson().fromJson("[12, 34, 56, 78]", JsonArray.class); PersistedData data = new GsonPersistedDataArray(array); - Color color = handler.deserialize(data, deserializationContext); + Color color = handler.deserialize(data); Assert.assertEquals(12, color.r()); Assert.assertEquals(34, color.g()); Assert.assertEquals(56, color.b()); diff --git a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java index b88969d1327..d12fec16597 100644 --- a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java @@ -21,7 +21,6 @@ import org.terasology.math.geom.Vector3i; import org.terasology.network.NetworkComponent; import org.terasology.network.internal.NetworkSystemImpl; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -57,7 +56,7 @@ public PersistedData serialize(EntityRef value, SerializationContext context) { } @Override - public EntityRef deserialize(PersistedData data, DeserializationContext context) { + public EntityRef deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray array = data.getAsArray(); if (array.isNumberArray() && array.size() == 3) { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java index e9dc391bb3b..ec76dd3010f 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java @@ -28,7 +28,6 @@ import org.terasology.entitySystem.metadata.ComponentMetadata; import org.terasology.entitySystem.metadata.ReplicatedFieldMetadata; import org.terasology.module.Module; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.Serializer; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; @@ -184,7 +183,6 @@ public Component deserializeOnto(Component target, EntityData.Component componen private Component deserializeOnto(Component targetComponent, EntityData.Component componentData, ComponentMetadata componentMetadata, FieldSerializeCheck fieldCheck) { Serializer serializer = typeSerializationLibrary.getSerializerFor(componentMetadata); - DeserializationContext context = new ProtobufDeserializationContext(typeSerializationLibrary); Map, PersistedData> dataMap = Maps.newHashMapWithExpectedSize(componentData.getFieldCount()); for (EntityData.NameValue field : componentData.getFieldList()) { FieldMetadata fieldInfo = null; @@ -199,7 +197,7 @@ private Component deserializeOnto(Component targetComponen logger.warn("Cannot deserialize unknown field '{}' onto '{}'", field.getName(), componentMetadata.getUri()); } } - serializer.deserializeOnto(targetComponent, dataMap, context, fieldCheck); + serializer.deserializeOnto(targetComponent, dataMap, fieldCheck); return targetComponent; } diff --git a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java index 0bd62154969..504643418f1 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java @@ -26,13 +26,11 @@ import org.terasology.entitySystem.metadata.EventLibrary; import org.terasology.entitySystem.metadata.EventMetadata; import org.terasology.entitySystem.metadata.ReplicatedFieldMetadata; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.DeserializationException; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.SerializationException; import org.terasology.persistence.typeHandling.Serializer; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.protobuf.ProtobufDeserializationContext; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; import org.terasology.persistence.typeHandling.protobuf.ProtobufSerializationContext; import org.terasology.protobuf.EntityData; @@ -48,7 +46,6 @@ public class EventSerializer { private TypeSerializationLibrary typeSerializationLibrary; private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); private SerializationContext serializationContext; - private DeserializationContext deserializationContext; /** * Creates the event serializer. @@ -58,7 +55,6 @@ public class EventSerializer { public EventSerializer(EventLibrary eventLibrary, TypeSerializationLibrary typeSerializationLibrary) { this.eventLibrary = eventLibrary; this.typeSerializationLibrary = typeSerializationLibrary; - this.deserializationContext = new ProtobufDeserializationContext(typeSerializationLibrary); this.serializationContext = new ProtobufSerializationContext(typeSerializationLibrary); } @@ -110,7 +106,7 @@ private Event deserializeOnto(Event targetEvent, EntityData.Event eventData, Eve continue; } if (fieldInfo.isReplicated()) { - serializer.deserializeOnto(targetEvent, fieldInfo, new ProtobufPersistedData(eventData.getFieldValue(i)), deserializationContext); + serializer.deserializeOnto(targetEvent, fieldInfo, new ProtobufPersistedData(eventData.getFieldValue(i))); } } return targetEvent; diff --git a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java index a0966a4554c..2d9833182f5 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java @@ -234,7 +234,7 @@ public void deserializeOnto(MutableComponentContainer entity, EntityData.PackedE ReplicatedFieldMetadata fieldMetadata = metadata.getField(fieldId); if (fieldMetadata != null && fieldCheck.shouldDeserialize(metadata, fieldMetadata)) { logger.trace("Deserializing field {} of component {} as value {}", fieldMetadata, metadata, entityData.getFieldValue(fieldPos)); - serializer.deserializeOnto(component, fieldMetadata, new ProtobufPersistedData(entityData.getFieldValue(fieldPos)), deserializationContext); + serializer.deserializeOnto(component, fieldMetadata, new ProtobufPersistedData(entityData.getFieldValue(fieldPos))); } fieldPos++; } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java index b1b235cce51..77f54647d78 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java @@ -86,15 +86,14 @@ public PersistedData serializeValue(FieldMetadata fieldMetadata, Object ra * @param target The object to deserialize the field onto * @param fieldMetadata The metadata of the field * @param data The serialized value of the field - * @param context The deserialization context */ - public void deserializeOnto(Object target, FieldMetadata fieldMetadata, PersistedData data, DeserializationContext context) { + public void deserializeOnto(Object target, FieldMetadata fieldMetadata, PersistedData data) { TypeHandler handler = getHandlerFor(fieldMetadata); if (handler == null) { logger.error("No type handler for type {} used by {}::{}", fieldMetadata.getType(), target.getClass(), fieldMetadata); } else { try { - Object deserializedValue = handler.deserialize(data, context); + Object deserializedValue = handler.deserialize(data); fieldMetadata.setValue(target, deserializedValue); } catch (DeserializationException e) { logger.error("Unable to deserialize field '{}' from '{}'", fieldMetadata.getName(), data.toString(), e); @@ -107,10 +106,9 @@ public void deserializeOnto(Object target, FieldMetadata fieldMetadata, Pe * * @param target The object to deserialize onto * @param values The collection of values to apply to the object - * @param context The deserialization context */ - public void deserializeOnto(Object target, PersistedDataMap values, DeserializationContext context) { - deserializeOnto(target, values, DeserializeFieldCheck.NullCheck.newInstance(), context); + public void deserializeOnto(Object target, PersistedDataMap values) { + deserializeOnto(target, values, DeserializeFieldCheck.NullCheck.newInstance()); } /** @@ -120,12 +118,12 @@ public void deserializeOnto(Object target, PersistedDataMap values, Deserializat * @param values The collection of values to apply to the object * @param check A check to filter which fields to deserialize */ - public void deserializeOnto(Object target, PersistedDataMap values, DeserializeFieldCheck check, DeserializationContext context) { + public void deserializeOnto(Object target, PersistedDataMap values, DeserializeFieldCheck check) { for (Map.Entry field : values.entrySet()) { FieldMetadata fieldInfo = classMetadata.getField(field.getKey()); if (fieldInfo != null && check.shouldDeserialize(classMetadata, fieldInfo)) { - deserializeOnto(target, fieldInfo, field.getValue(), context); + deserializeOnto(target, fieldInfo, field.getValue()); } else if (fieldInfo == null) { logger.warn("Cannot deserialize unknown field '{}' onto '{}'", field.getKey(), classMetadata.getUri()); } @@ -138,8 +136,8 @@ public void deserializeOnto(Object target, PersistedDataMap values, DeserializeF * @param target The object to deserialize onto * @param values The collection of values to apply to the object */ - public void deserializeOnto(Object target, Map, PersistedData> values, DeserializationContext context) { - deserializeOnto(target, values, context, DeserializeFieldCheck.NullCheck.newInstance()); + public void deserializeOnto(Object target, Map, PersistedData> values) { + deserializeOnto(target, values, DeserializeFieldCheck.NullCheck.newInstance()); } /** @@ -149,10 +147,10 @@ public void deserializeOnto(Object target, Map, PersistedDat * @param values The collection of values to apply to the object * @param check A check to filter which fields to deserialize */ - public void deserializeOnto(Object target, Map, PersistedData> values, DeserializationContext context, DeserializeFieldCheck check) { + public void deserializeOnto(Object target, Map, PersistedData> values, DeserializeFieldCheck check) { for (Map.Entry, PersistedData> field : values.entrySet()) { if (check.shouldDeserialize(classMetadata, field.getKey())) { - deserializeOnto(target, field.getKey(), field.getValue(), context); + deserializeOnto(target, field.getKey(), field.getValue()); } } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index e4cd72d7023..afea5155669 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -34,7 +34,7 @@ public PersistedData serialize(T value, SerializationContext context) { } @Override - public T deserialize(PersistedData data, DeserializationContext context) { + public T deserialize(PersistedData data) { if (data.isString()) { return getFromString(data.getAsString()); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index e8a06f7b20c..610f5e144e1 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -15,9 +15,6 @@ */ package org.terasology.persistence.typeHandling; -import java.util.Collection; -import java.util.List; - /** */ public interface TypeHandler { @@ -39,5 +36,5 @@ public interface TypeHandler { * @return The deserialized value. * @throws org.terasology.persistence.typeHandling.DeserializationException if there was an error deserializing the data */ - T deserialize(PersistedData data, DeserializationContext context); + T deserialize(PersistedData data); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java index 3b8c19ebb5b..33f77efa724 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java @@ -31,7 +31,7 @@ public interface TypeHandlerFactory { * This method is usually called only once for a type, so all expensive pre-computations and reflection * operations can be performed here so that the generated * {@link TypeHandler#serialize(Object, SerializationContext)} and - * {@link TypeHandler#deserialize(PersistedData, DeserializationContext)} implementations are fast. + * {@link TypeHandler#deserialize(PersistedData)} implementations are fast. * * @param typeInfo The {@link TypeInfo} of the type for which a {@link TypeHandler} must be generated. * @param typeSerializationLibrary The {@link TypeSerializationLibrary} for which the {@link TypeHandler} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index 16a5bfad4a9..f53d88e66e3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -33,7 +32,7 @@ public PersistedData serialize(Boolean value, SerializationContext context) { } @Override - public Boolean deserialize(PersistedData data, DeserializationContext context) { + public Boolean deserialize(PersistedData data) { if (data.isBoolean()) { return data.getAsBoolean(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index 657d68912b9..a35a46c7fb7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; @@ -30,7 +29,7 @@ public PersistedData serialize(byte[] value, SerializationContext context) { } @Override - public byte[] deserialize(PersistedData data, DeserializationContext context) { + public byte[] deserialize(PersistedData data) { if (data.isBytes()) { return data.getAsBytes(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index 375c5a09e18..5324462500d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -33,7 +32,7 @@ public PersistedData serialize(Byte value, SerializationContext context) { } @Override - public Byte deserialize(PersistedData data, DeserializationContext context) { + public Byte deserialize(PersistedData data) { if (data.isBytes()) { return data.getAsBytes()[0]; } else if (data.isNumber()) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java index f33aa057f97..4cc2efe933d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.coreTypes; import com.google.common.collect.Lists; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -46,11 +45,11 @@ public PersistedData serialize(Collection value, SerializationContext context } @Override - public Collection deserialize(PersistedData data, DeserializationContext context) { + public Collection deserialize(PersistedData data) { Collection collection = constructor.construct(); for (PersistedData item : data.getAsArray()) { - collection.add(elementTypeHandler.deserialize(item, context)); + collection.add(elementTypeHandler.deserialize(item)); } return collection; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index 978e0a90d0a..73d93c673d5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -33,7 +32,7 @@ public PersistedData serialize(Double value, SerializationContext context) { } @Override - public Double deserialize(PersistedData data, DeserializationContext context) { + public Double deserialize(PersistedData data) { if (data.isNumber()) { return data.getAsDouble(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index ffc44507f6e..0a68c4d9c5a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -18,7 +18,6 @@ import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -50,7 +49,7 @@ public PersistedData serialize(T value, SerializationContext context) { } @Override - public T deserialize(PersistedData data, DeserializationContext context) { + public T deserialize(PersistedData data) { if (data.isString()) { T result = caseInsensitiveLookup.get(data.getAsString().toLowerCase(Locale.ENGLISH)); if (result == null) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index 7913a8d2cc8..8018dedd18f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -33,7 +32,7 @@ public PersistedData serialize(Float value, SerializationContext context) { } @Override - public Float deserialize(PersistedData data, DeserializationContext context) { + public Float deserialize(PersistedData data) { if (data.isNumber()) { return data.getAsFloat(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index 2362bbb259e..2307f66bdf8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -33,7 +32,7 @@ public PersistedData serialize(Integer value, SerializationContext context) { } @Override - public Integer deserialize(PersistedData data, DeserializationContext context) { + public Integer deserialize(PersistedData data) { if (data.isNumber()) { return data.getAsInteger(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index a316c916c77..f0b9777861a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -33,7 +32,7 @@ public PersistedData serialize(Long value, SerializationContext context) { } @Override - public Long deserialize(PersistedData data, DeserializationContext context) { + public Long deserialize(PersistedData data) { if (data.isNumber()) { return data.getAsLong(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index d12088df67a..8b50b2186c0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -34,7 +33,7 @@ public PersistedData serialize(Number value, SerializationContext context) { } @Override - public Number deserialize(PersistedData data, DeserializationContext context) { + public Number deserialize(PersistedData data) { if (data.isNumber()) { return data.getAsDouble(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 520c630e992..0e688425cee 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -18,7 +18,6 @@ import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -77,7 +76,7 @@ public PersistedData serialize(T value, SerializationContext context) { } @Override - public T deserialize(PersistedData data, DeserializationContext context) { + public T deserialize(PersistedData data) { try { T result = constructor.construct(); for (Map.Entry entry : data.getAsValueMap().entrySet()) { @@ -90,7 +89,7 @@ public T deserialize(PersistedData data, DeserializationContext context) { } TypeHandler handler = mappedFields.get(field); - Object fieldValue = handler.deserialize(entry.getValue(), context); + Object fieldValue = handler.deserialize(entry.getValue()); field.set(result, fieldValue); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 7752974f25d..6766b274703 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -18,7 +18,6 @@ import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; @@ -97,15 +96,15 @@ public PersistedData serialize(T value, SerializationContext context) { } @Override - public T deserialize(PersistedData data, DeserializationContext context) { + public T deserialize(PersistedData data) { if (!data.isValueMap()) { - return delegateHandler.deserialize(data, context); + return delegateHandler.deserialize(data); } PersistedDataMap valueMap = data.getAsValueMap(); if (!valueMap.has(TYPE_FIELD) || !valueMap.has(VALUE_FIELD)) { - return delegateHandler.deserialize(data, context); + return delegateHandler.deserialize(data); } String typeName = valueMap.getAsString(TYPE_FIELD); @@ -125,7 +124,7 @@ public T deserialize(PersistedData data, DeserializationContext context) { PersistedData valueData = valueMap.get(VALUE_FIELD); - return typeHandler.deserialize(valueData, context); + return typeHandler.deserialize(valueData); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java index 262d1f34322..fccfbceeb05 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.coreTypes; import com.google.common.collect.Maps; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -46,11 +45,11 @@ public PersistedData serialize(Map value, SerializationContext contex } @Override - public Map deserialize(PersistedData data, DeserializationContext context) { + public Map deserialize(PersistedData data) { Map result = Maps.newLinkedHashMap(); if (data.isValueMap()) { for (Map.Entry item : data.getAsValueMap().entrySet()) { - result.put(item.getKey(), contentsHandler.deserialize(item.getValue(), context)); + result.put(item.getKey(), contentsHandler.deserialize(item.getValue())); } } return result; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index 2d901bb6843..e79640ca44e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -15,7 +15,6 @@ */ package org.terasology.persistence.typeHandling.coreTypes; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; import org.terasology.persistence.typeHandling.TypeHandler; @@ -34,7 +33,7 @@ public PersistedData serialize(String value, SerializationContext context) { } @Override - public String deserialize(PersistedData data, DeserializationContext context) { + public String deserialize(PersistedData data) { if (data.isString()) { return data.getAsString(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 1c71cf2db45..5c6232f7d9e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.extensionTypes; import gnu.trove.list.TIntList; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.DeserializationException; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; @@ -39,7 +38,7 @@ public PersistedData serialize(Color value, SerializationContext context) { } @Override - public Color deserialize(PersistedData data, DeserializationContext context) { + public Color deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 3) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java index 0c5a468aad7..786f5f52eb4 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java @@ -18,7 +18,6 @@ import gnu.trove.iterator.TLongIterator; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.EngineEntityManager; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -45,7 +44,7 @@ public PersistedData serialize(EntityRef value, SerializationContext context) { } @Override - public EntityRef deserialize(PersistedData data, DeserializationContext context) { + public EntityRef deserialize(PersistedData data) { if (data.isNumber()) { return entityManager.getEntity(data.getAsLong()); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java index 2ccf980cc4b..805c6e1977d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java @@ -62,7 +62,7 @@ public final class GsonTypeHandlerAdapter extends TypeAdapter { .getElement(); this.deserializer = (json, typeOfT, context) -> - typeHandler.deserialize(new GsonPersistedData(json), new GsonDeserializationContext(context)); + typeHandler.deserialize(new GsonPersistedData(json)); this.gson = gson; this.typeToken = typeToken; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java index 944e561d8cb..f45c322985f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java @@ -43,7 +43,7 @@ public LegacyGsonTypeHandlerAdapter(TypeHandler handler) { @Override public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { - return typeHandler.deserialize(new GsonPersistedData(json), new GsonDeserializationContext(context)); + return typeHandler.deserialize(new GsonPersistedData(json)); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java index 6c452140211..31feee3176c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java @@ -17,7 +17,6 @@ import com.google.common.collect.Maps; import org.terasology.math.Border; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; @@ -47,7 +46,7 @@ public PersistedData serialize(Border value, SerializationContext context) { } @Override - public Border deserialize(PersistedData data, DeserializationContext context) { + public Border deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); return new Border(map.getAsInteger(LEFT_FIELD), map.getAsInteger(RIGHT_FIELD), map.getAsInteger(TOP_FIELD), map.getAsInteger(BOTTOM_FIELD)); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index 496cc71d903..45912c2143b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -17,7 +17,6 @@ import gnu.trove.list.TFloatList; import org.terasology.math.geom.Quat4f; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -37,7 +36,7 @@ public PersistedData serialize(Quat4f value, SerializationContext context) { } @Override - public Quat4f deserialize(PersistedData data, DeserializationContext context) { + public Quat4f deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 3) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index e2541e2bf9b..c5280a2a1ff 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -19,7 +19,6 @@ import com.google.common.collect.Maps; import org.terasology.math.geom.Rect2f; import org.terasology.math.geom.Vector2f; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; @@ -55,12 +54,12 @@ public PersistedData serialize(Rect2f value, SerializationContext context) { } @Override - public Rect2f deserialize(PersistedData data, DeserializationContext context) { + public Rect2f deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2f min = vector2fTypeHandler.deserialize(map.get(MIN_FIELD), context); - Vector2f size = vector2fTypeHandler.deserialize(map.get(SIZE_FIELD), context); + Vector2f min = vector2fTypeHandler.deserialize(map.get(MIN_FIELD)); + Vector2f size = vector2fTypeHandler.deserialize(map.get(SIZE_FIELD)); return Rect2f.createFromMinAndSize(min, size); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index 19425437f5b..807b56e5165 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -20,7 +20,6 @@ import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector2i; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; @@ -56,12 +55,12 @@ public PersistedData serialize(Rect2i value, SerializationContext context) { } @Override - public Rect2i deserialize(PersistedData data, DeserializationContext context) { + public Rect2i deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2i min = vector2iTypeHandler.deserialize(map.get(MIN_FIELD), context); - Vector2i size = vector2iTypeHandler.deserialize(map.get(SIZE_FIELD), context); + Vector2i min = vector2iTypeHandler.deserialize(map.get(MIN_FIELD)); + Vector2i size = vector2iTypeHandler.deserialize(map.get(SIZE_FIELD)); return Rect2i.createFromMinAndSize(min, size); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java index d8b981b0935..8bcbc46f5d8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java @@ -20,7 +20,6 @@ import org.terasology.engine.module.UriUtil; import org.terasology.math.Region3i; import org.terasology.math.geom.Vector3i; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.SerializationContext; @@ -56,12 +55,12 @@ public PersistedData serialize(Region3i value, SerializationContext context) { } @Override - public Region3i deserialize(PersistedData data, DeserializationContext context) { + public Region3i deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector3i min = vector3iTypeHandler.deserialize(map.get(MIN_FIELD), context); - Vector3i size = vector3iTypeHandler.deserialize(map.get(SIZE_FIELD), context); + Vector3i min = vector3iTypeHandler.deserialize(map.get(MIN_FIELD)); + Vector3i size = vector3iTypeHandler.deserialize(map.get(SIZE_FIELD)); return Region3i.createFromMinAndSize(min, size); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index a098d8eb929..972f4ed93d7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -18,7 +18,6 @@ import gnu.trove.list.TFloatList; import org.terasology.math.geom.Vector2f; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -38,7 +37,7 @@ public PersistedData serialize(Vector2f value, SerializationContext context) { } @Override - public Vector2f deserialize(PersistedData data, DeserializationContext context) { + public Vector2f deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 1) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index f3f95338ddd..1d3b04f738c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -17,7 +17,6 @@ import gnu.trove.list.TIntList; import org.terasology.math.geom.Vector2i; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -36,7 +35,7 @@ public PersistedData serialize(Vector2i value, SerializationContext context) { } @Override - public Vector2i deserialize(PersistedData data, DeserializationContext context) { + public Vector2i deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 1) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index a5caaf4e045..08632150405 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -17,7 +17,6 @@ import gnu.trove.list.TFloatList; import org.terasology.math.geom.Vector3f; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -36,7 +35,7 @@ public PersistedData serialize(Vector3f value, SerializationContext context) { } @Override - public Vector3f deserialize(PersistedData data, DeserializationContext context) { + public Vector3f deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 2) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index 39da417c53c..d62d7438a93 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -17,7 +17,6 @@ import gnu.trove.list.TIntList; import org.terasology.math.geom.Vector3i; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -36,7 +35,7 @@ public PersistedData serialize(Vector3i value, SerializationContext context) { } @Override - public Vector3i deserialize(PersistedData data, DeserializationContext context) { + public Vector3i deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 2) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index 32cae2c9f4c..d8365ed8e4c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -18,7 +18,6 @@ import gnu.trove.list.TFloatList; import org.terasology.math.geom.Vector4f; -import org.terasology.persistence.typeHandling.DeserializationContext; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.SerializationContext; @@ -37,7 +36,7 @@ public PersistedData serialize(Vector4f value, SerializationContext context) { } @Override - public Vector4f deserialize(PersistedData data, DeserializationContext context) { + public Vector4f deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 3) { diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index d3695e8c35c..3bca58c50fd 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -374,7 +374,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa float volume = jsonObject.get("volume").getAsFloat(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("sound")); TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); - StaticSound sound = (StaticSound) handler.deserialize(data, deserializationContext); + StaticSound sound = (StaticSound) handler.deserialize(data); result = new PlaySoundEvent(sound, volume); } else if (className.equals(CharacterMoveInputEvent.class.getName())) { long delta = jsonObject.get("delta").getAsLong(); @@ -394,7 +394,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa float baseValue = jsonObject.get("baseValue").getAsFloat(); TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); GsonPersistedData data = new GsonPersistedData(jsonObject.get("movementMode")); - MovementMode movementMode = (MovementMode) handler.deserialize(data, deserializationContext); + MovementMode movementMode = (MovementMode) handler.deserialize(data); TFloatList modifiers = gson.fromJson(jsonObject.get("modifiers"), TFloatArrayList.class); TFloatList multipliers = gson.fromJson(jsonObject.get("multipliers"), TFloatArrayList.class); TFloatList postModifiers = gson.fromJson(jsonObject.get("postModifiers"), TFloatArrayList.class); @@ -423,10 +423,10 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(KeyDownEvent.class) || clazz.equals(KeyRepeatEvent.class) || clazz.equals(KeyUpEvent.class)) { //KeyEvent GsonPersistedData data = new GsonPersistedData(jsonObject.get("input")); TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); - Keyboard.Key input = (Keyboard.Key) typeHandler.deserialize(data, deserializationContext); + Keyboard.Key input = (Keyboard.Key) typeHandler.deserialize(data); data = new GsonPersistedData(jsonObject.get("state")); typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = (ButtonState) typeHandler.deserialize(data, deserializationContext); + ButtonState state = (ButtonState) typeHandler.deserialize(data); char keychar = jsonObject.get("keychar").getAsCharacter(); float delta = jsonObject.get("delta").getAsFloat(); KeyEvent aux; @@ -444,10 +444,10 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(MouseButtonEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("button")); TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(MouseInput.class); - MouseInput button = (MouseInput) typeHandler.deserialize(data, deserializationContext); + MouseInput button = (MouseInput) typeHandler.deserialize(data); data = new GsonPersistedData(jsonObject.get("state")); typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = (ButtonState) typeHandler.deserialize(data, deserializationContext); + ButtonState state = (ButtonState) typeHandler.deserialize(data); JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); float delta = jsonObject.get("delta").getAsFloat(); @@ -457,7 +457,7 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(MouseAxisEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("mouseAxis")); TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); - MouseAxisEvent.MouseAxis mouseAxis = (MouseAxisEvent.MouseAxis) typeHandler.deserialize(data, deserializationContext); + MouseAxisEvent.MouseAxis mouseAxis = (MouseAxisEvent.MouseAxis) typeHandler.deserialize(data); float value = jsonObject.get("value").getAsFloat(); float delta = jsonObject.get("delta").getAsFloat(); MouseAxisEvent aux = MouseAxisEvent.create(mouseAxis, value, delta); @@ -489,14 +489,14 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject, GsonDeserializationContext deserializationContext) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = (ButtonState) typeHandler.deserialize(data, deserializationContext); + ButtonState state = (ButtonState) typeHandler.deserialize(data); float delta = jsonObject.get("delta").getAsFloat(); typeHandler = typeSerializationLibrary.getTypeHandler(Name.class); JsonObject aux = jsonObject.get("id").getAsJsonObject(); data = new GsonPersistedData(aux.get("moduleName")); - Name moduleName = (Name) typeHandler.deserialize(data, deserializationContext); + Name moduleName = (Name) typeHandler.deserialize(data); data = new GsonPersistedData(aux.get("objectName")); - Name objectName = (Name) typeHandler.deserialize(data, deserializationContext); + Name objectName = (Name) typeHandler.deserialize(data); SimpleUri id = new SimpleUri(moduleName, objectName); event.prepare(id, state, delta); } From 8369839831af8a8f87751cf54dd2b60fcc161fb4 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 18:00:29 +0530 Subject: [PATCH 025/141] Remove DeserializationContext and implementations --- .../serializers/ComponentSerializer.java | 3 -- .../serializers/NetworkEntitySerializer.java | 3 -- .../typeHandling/DeserializationContext.java | 24 -------------- .../gson/GsonDeserializationContext.java | 31 ------------------- .../ProtobufDeserializationContext.java | 31 ------------------- .../recording/RecordedEventSerializer.java | 12 +++---- 6 files changed, 5 insertions(+), 99 deletions(-) delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java index ec76dd3010f..ef0091ccc3f 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java @@ -31,7 +31,6 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.Serializer; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.protobuf.ProtobufDeserializationContext; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; import org.terasology.persistence.typeHandling.protobuf.ProtobufSerializationContext; import org.terasology.protobuf.EntityData; @@ -58,7 +57,6 @@ public class ComponentSerializer { private boolean usingFieldIds; private TypeSerializationLibrary typeSerializationLibrary; private ProtobufSerializationContext serializationContext; - private ProtobufDeserializationContext deserializationContext; /** * Creates the component serializer. @@ -69,7 +67,6 @@ public ComponentSerializer(ComponentLibrary componentLibrary, TypeSerializationL this.componentLibrary = componentLibrary; this.typeSerializationLibrary = typeSerializationLibrary; this.serializationContext = new ProtobufSerializationContext(typeSerializationLibrary); - this.deserializationContext = new ProtobufDeserializationContext(typeSerializationLibrary); } public void setUsingFieldIds(boolean usingFieldIds) { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java index 2d9833182f5..3b23461f7da 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java @@ -37,7 +37,6 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.Serializer; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.protobuf.ProtobufDeserializationContext; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; import org.terasology.persistence.typeHandling.protobuf.ProtobufSerializationContext; import org.terasology.protobuf.EntityData; @@ -55,7 +54,6 @@ public class NetworkEntitySerializer { private ComponentLibrary componentLibrary; private TypeSerializationLibrary typeSerializationLibrary; private ProtobufSerializationContext serializationContext; - private ProtobufDeserializationContext deserializationContext; private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); public NetworkEntitySerializer(EngineEntityManager entityManager, ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { @@ -63,7 +61,6 @@ public NetworkEntitySerializer(EngineEntityManager entityManager, ComponentLibra this.componentLibrary = componentLibrary; this.typeSerializationLibrary = typeSerializationLibrary; this.serializationContext = new ProtobufSerializationContext(typeSerializationLibrary); - this.deserializationContext = new ProtobufDeserializationContext(typeSerializationLibrary); } public void setComponentSerializeCheck(ComponentSerializeCheck componentSerializeCheck) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java deleted file mode 100644 index a3f1e64ed6e..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/DeserializationContext.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling; - -import java.util.List; - -/** - */ -public interface DeserializationContext { - -} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java deleted file mode 100644 index f019fdcb450..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonDeserializationContext.java +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.gson; - -import com.google.gson.JsonDeserializationContext; -import org.terasology.persistence.typeHandling.DeserializationContext; - -/** - */ -public class GsonDeserializationContext implements DeserializationContext { - - private JsonDeserializationContext context; - - public GsonDeserializationContext(JsonDeserializationContext context) { - this.context = context; - } - -} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java deleted file mode 100644 index 17843a9c9cf..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufDeserializationContext.java +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.protobuf; - -import org.terasology.persistence.typeHandling.DeserializationContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; - -/** - */ -public class ProtobufDeserializationContext implements DeserializationContext { - - private TypeSerializationLibrary typeSerializationLibrary; - - public ProtobufDeserializationContext(TypeSerializationLibrary typeSerializationLibrary) { - this.typeSerializationLibrary = typeSerializationLibrary; - } - -} diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 3bca58c50fd..be06ac14c5c 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -48,7 +48,6 @@ import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; -import org.terasology.persistence.typeHandling.gson.GsonDeserializationContext; import org.terasology.persistence.typeHandling.gson.GsonPersistedData; import org.terasology.persistence.typeHandling.gson.GsonSerializationContext; import org.terasology.reflection.copy.CopyStrategyLibrary; @@ -365,7 +364,6 @@ private void createInputEventClassMap() { private Event deserializeSpecificEventData(JsonObject jsonObject, String className) { Event result = null; Gson gson = new GsonBuilder().create(); - GsonDeserializationContext deserializationContext = new GsonDeserializationContext(null); if (className.equals(CameraTargetChangedEvent.class.getName())) { EntityRef oldTarget = new RecordedEntityRef(jsonObject.get("OldTarget").getAsLong(), (LowLevelEntityManager) this.entityManager); EntityRef newTarget = new RecordedEntityRef(jsonObject.get("NewTarget").getAsLong(), (LowLevelEntityManager) this.entityManager); @@ -407,14 +405,14 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa EntityRef instigator = new RecordedEntityRef(jsonObject.get("instigator").getAsLong(), (LowLevelEntityManager) this.entityManager); EntityRef directCause = new RecordedEntityRef(jsonObject.get("directCause").getAsLong(), (LowLevelEntityManager) this.entityManager); result = new AttackEvent(instigator, directCause); - } else if (getInputEventSpecificType(jsonObject, className, deserializationContext) != null) { //input events - result = getInputEventSpecificType(jsonObject, className, deserializationContext); + } else if (getInputEventSpecificType(jsonObject, className) != null) { //input events + result = getInputEventSpecificType(jsonObject, className); } return result; } - private InputEvent getInputEventSpecificType(JsonObject jsonObject, String className, GsonDeserializationContext deserializationContext) { + private InputEvent getInputEventSpecificType(JsonObject jsonObject, String className) { InputEvent newEvent = null; try { Class clazz = this.inputEventClassMap.get(className); @@ -474,7 +472,7 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } if (newEvent instanceof BindButtonEvent) { - bindButtonEventSetup((BindButtonEvent) newEvent, jsonObject, deserializationContext); + bindButtonEventSetup((BindButtonEvent) newEvent, jsonObject); } else if (newEvent instanceof BindAxisEvent) { bindAxisEvent((BindAxisEvent) newEvent, jsonObject); } @@ -486,7 +484,7 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class return newEvent; } - private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject, GsonDeserializationContext deserializationContext) { + private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); ButtonState state = (ButtonState) typeHandler.deserialize(data); From b690c2163c708914282923072f131a904aeccf7f Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 18:09:27 +0530 Subject: [PATCH 026/141] Remove SerializationContext.create(T, Class) --- .../persistence/typeHandling/SerializationContext.java | 10 ---------- .../typeHandling/gson/GsonSerializationContext.java | 5 ----- .../protobuf/ProtobufSerializationContext.java | 7 ------- 3 files changed, 22 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java index d213aa4198f..9ace1a68991 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java @@ -183,16 +183,6 @@ public interface SerializationContext { */ PersistedData create(Map data); - /** - * Attempts to serialize the given data using registered an appropriate type handler. Type handlers should take care not to invoke this on the type they - * handle or otherwise in a recursive manner. - * @param data - * @param type - * @param - * @return The serialized data - */ - PersistedData create(T data, Class type); - /** * @return A 'null' PersistedData */ diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java index d23626a3ce0..0b1e911dc21 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java @@ -206,11 +206,6 @@ public PersistedData create(Map data) { return new GsonPersistedData(object); } - @Override - public PersistedData create(T data, Class type) { - return new GsonPersistedData(context.serialize(data, type)); - } - @Override public PersistedData createNull() { return NULL_INSTANCE; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java index 2fea1cb71f6..a8216db470d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java @@ -22,7 +22,6 @@ import gnu.trove.iterator.TLongIterator; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.protobuf.EntityData; @@ -196,12 +195,6 @@ public PersistedData create(Map data) { return new ProtobufPersistedData(builder.build()); } - @Override - public PersistedData create(T data, Class type) { - TypeHandler handler = (TypeHandler) library.getTypeHandler(type); - return handler.serialize(data, this); - } - @Override public PersistedData createNull() { return new ProtobufPersistedData(EntityData.Value.newBuilder().build()); From 838c493563bf55b56074de5593417bb342eb9e68 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 18:13:37 +0530 Subject: [PATCH 027/141] Remove GsonSerializationContext.context --- .../typeHandling/gson/GsonSerializationContext.java | 6 ------ .../typeHandling/gson/GsonTypeHandlerAdapter.java | 2 +- .../typeHandling/gson/LegacyGsonTypeHandlerAdapter.java | 2 +- .../org/terasology/recording/RecordedEventSerializer.java | 2 +- 4 files changed, 3 insertions(+), 9 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java index 0b1e911dc21..94bd9506aaf 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java @@ -38,12 +38,6 @@ public class GsonSerializationContext implements SerializationContext { private static final PersistedData NULL_INSTANCE = new GsonPersistedData(JsonNull.INSTANCE); - private JsonSerializationContext context; - - public GsonSerializationContext(JsonSerializationContext context) { - this.context = context; - } - @Override public PersistedData create(String value) { return new GsonPersistedData(new JsonPrimitive(value)); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java index 805c6e1977d..c08a1a501f2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java @@ -58,7 +58,7 @@ public final class GsonTypeHandlerAdapter extends TypeAdapter { this.typeHandler = typeHandler; this.serializer = (src, typeOfSrc, context) -> - ((GsonPersistedData) typeHandler.serialize(src, new GsonSerializationContext(context))) + ((GsonPersistedData) typeHandler.serialize(src, new GsonSerializationContext())) .getElement(); this.deserializer = (json, typeOfT, context) -> diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java index f45c322985f..7d735906258 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java @@ -48,6 +48,6 @@ public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext @Override public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context) { - return ((GsonPersistedData) typeHandler.serialize(src, new GsonSerializationContext(context))).getElement(); + return ((GsonPersistedData) typeHandler.serialize(src, new GsonSerializationContext())).getElement(); } } diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index be06ac14c5c..711748dbcec 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -133,7 +133,7 @@ void serializeRecordedEvents(List events, String filePath) { private void writeSpecificEventData(JsonWriter writer, Event event) { try { - GsonSerializationContext serializationContext = new GsonSerializationContext(null); + GsonSerializationContext serializationContext = new GsonSerializationContext(); Gson gson = new GsonBuilder().create(); if (event instanceof InputEvent) { InputEvent e = (InputEvent) event; From 326bd89768cff22ef131f73c15ff8024dd9a8464 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 18:14:58 +0530 Subject: [PATCH 028/141] Remove ProtobufSerializationContext.library --- .../persistence/serializers/ComponentSerializer.java | 2 +- .../persistence/serializers/EventSerializer.java | 2 +- .../persistence/serializers/NetworkEntitySerializer.java | 2 +- .../protobuf/ProtobufSerializationContext.java | 7 ------- 4 files changed, 3 insertions(+), 10 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java index ef0091ccc3f..2d832c9a389 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java @@ -66,7 +66,7 @@ public class ComponentSerializer { public ComponentSerializer(ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { this.componentLibrary = componentLibrary; this.typeSerializationLibrary = typeSerializationLibrary; - this.serializationContext = new ProtobufSerializationContext(typeSerializationLibrary); + this.serializationContext = new ProtobufSerializationContext(); } public void setUsingFieldIds(boolean usingFieldIds) { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java index 504643418f1..42a32db60cd 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java @@ -55,7 +55,7 @@ public class EventSerializer { public EventSerializer(EventLibrary eventLibrary, TypeSerializationLibrary typeSerializationLibrary) { this.eventLibrary = eventLibrary; this.typeSerializationLibrary = typeSerializationLibrary; - this.serializationContext = new ProtobufSerializationContext(typeSerializationLibrary); + this.serializationContext = new ProtobufSerializationContext(); } /** diff --git a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java index 3b23461f7da..bcc5e67f14e 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java @@ -60,7 +60,7 @@ public NetworkEntitySerializer(EngineEntityManager entityManager, ComponentLibra this.entityManager = entityManager; this.componentLibrary = componentLibrary; this.typeSerializationLibrary = typeSerializationLibrary; - this.serializationContext = new ProtobufSerializationContext(typeSerializationLibrary); + this.serializationContext = new ProtobufSerializationContext(); } public void setComponentSerializeCheck(ComponentSerializeCheck componentSerializeCheck) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java index a8216db470d..08a3d231141 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java @@ -22,7 +22,6 @@ import gnu.trove.iterator.TLongIterator; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.protobuf.EntityData; import java.nio.ByteBuffer; @@ -33,12 +32,6 @@ */ public class ProtobufSerializationContext implements SerializationContext { - private TypeSerializationLibrary library; - - public ProtobufSerializationContext(TypeSerializationLibrary library) { - this.library = library; - } - @Override public PersistedData create(String value) { return createStrings(Arrays.asList(value)); From 7421deb3b762852ba36912fc5ce4f9373fb040de Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 18:22:01 +0530 Subject: [PATCH 029/141] Rename SerializationContext to PersistedDataSerializer --- .../coreTypes/CollectionTypeHandlerTest.java | 4 ++-- .../coreTypes/EnumTypeHandlerSerializerTest.java | 14 +++++++------- .../RuntimeDelegatingTypeHandlerTest.java | 4 ++-- .../extensionTypes/ColorTypeHandlerTest.java | 8 ++++---- .../serialization/NetEntityRefTypeHandler.java | 11 ++++++----- .../serializers/ComponentSerializer.java | 6 +++--- .../persistence/serializers/EventSerializer.java | 10 +++++----- .../serializers/NetworkEntitySerializer.java | 6 +++--- ...Context.java => PersistedDataSerializer.java} | 2 +- .../persistence/typeHandling/Serializer.java | 4 ++-- .../StringRepresentationTypeHandler.java | 6 +++--- .../persistence/typeHandling/TypeHandler.java | 4 ++-- .../typeHandling/TypeHandlerFactory.java | 2 +- .../coreTypes/BooleanTypeHandler.java | 8 ++++---- .../coreTypes/ByteArrayTypeHandler.java | 8 ++++---- .../typeHandling/coreTypes/ByteTypeHandler.java | 8 ++++---- .../coreTypes/CollectionTypeHandler.java | 8 ++++---- .../coreTypes/DoubleTypeHandler.java | 8 ++++---- .../typeHandling/coreTypes/EnumTypeHandler.java | 8 ++++---- .../typeHandling/coreTypes/FloatTypeHandler.java | 8 ++++---- .../typeHandling/coreTypes/IntTypeHandler.java | 8 ++++---- .../typeHandling/coreTypes/LongTypeHandler.java | 8 ++++---- .../coreTypes/NumberTypeHandler.java | 8 ++++---- .../coreTypes/ObjectFieldMapTypeHandler.java | 10 +++++----- .../coreTypes/RuntimeDelegatingTypeHandler.java | 14 +++++++------- .../coreTypes/StringMapTypeHandler.java | 8 ++++---- .../coreTypes/StringTypeHandler.java | 8 ++++---- .../extensionTypes/ColorTypeHandler.java | 8 ++++---- .../extensionTypes/EntityRefTypeHandler.java | 8 ++++---- ...ext.java => GsonPersistedDataSerializer.java} | 5 ++--- .../gson/GsonTypeHandlerAdapter.java | 2 +- .../gson/LegacyGsonTypeHandlerAdapter.java | 2 +- .../mathTypes/BorderTypeHandler.java | 16 ++++++++-------- .../mathTypes/Quat4fTypeHandler.java | 8 ++++---- .../mathTypes/Rect2fTypeHandler.java | 12 ++++++------ .../mathTypes/Rect2iTypeHandler.java | 12 ++++++------ .../mathTypes/Region3iTypeHandler.java | 12 ++++++------ .../mathTypes/Vector2fTypeHandler.java | 8 ++++---- .../mathTypes/Vector2iTypeHandler.java | 8 ++++---- .../mathTypes/Vector3fTypeHandler.java | 8 ++++---- .../mathTypes/Vector3iTypeHandler.java | 8 ++++---- .../mathTypes/Vector4fTypeHandler.java | 8 ++++---- ...java => ProtobufPersistedDataSerializer.java} | 4 ++-- .../recording/RecordedEventSerializer.java | 10 +++++----- 44 files changed, 170 insertions(+), 170 deletions(-) rename engine/src/main/java/org/terasology/persistence/typeHandling/{SerializationContext.java => PersistedDataSerializer.java} (99%) rename engine/src/main/java/org/terasology/persistence/typeHandling/gson/{GsonSerializationContext.java => GsonPersistedDataSerializer.java} (96%) rename engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/{ProtobufSerializationContext.java => ProtobufPersistedDataSerializer.java} (97%) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java index f7e96537bce..b68e9bdb85b 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java @@ -21,7 +21,7 @@ import org.mockito.ArgumentMatcher; import org.mockito.stubbing.Answer; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.gson.GsonPersistedDataArray; import org.terasology.reflection.reflect.ObjectConstructor; @@ -47,7 +47,7 @@ public void testSerialize() { Collection collection = constructor.construct(); collection.addAll(Collections.nCopies(500, -1)); - SerializationContext context = mock(SerializationContext.class); + PersistedDataSerializer context = mock(PersistedDataSerializer.class); typeHandler.serialize(collection, context); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java index a6f3f6fe6d7..a859eedea90 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java @@ -17,7 +17,7 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.mock; @@ -36,10 +36,10 @@ public void testNullValue() throws Exception { PersistedData nullData = mock(PersistedData.class); when(nullData.isNull()).thenReturn(true); - SerializationContext serializationContext = mock(SerializationContext.class); - when(serializationContext.createNull()).thenReturn(nullData); + PersistedDataSerializer persistedDataSerializer = mock(PersistedDataSerializer.class); + when(persistedDataSerializer.createNull()).thenReturn(nullData); EnumTypeHandler handler = new EnumTypeHandler<>(TestEnum.class); - PersistedData serializedNull = handler.serialize(null, serializationContext); + PersistedData serializedNull = handler.serialize(null, persistedDataSerializer); assertEquals(nullData, serializedNull); TestEnum deserializedValue = handler.deserialize(nullData); @@ -52,10 +52,10 @@ public void testNonNullValue() throws Exception { when(data.getAsString()).thenReturn(TestEnum.NON_NULL.toString()); when(data.isString()).thenReturn(true); - SerializationContext serializationContext = mock(SerializationContext.class); - when(serializationContext.create(TestEnum.NON_NULL.toString())).thenReturn(data); + PersistedDataSerializer persistedDataSerializer = mock(PersistedDataSerializer.class); + when(persistedDataSerializer.create(TestEnum.NON_NULL.toString())).thenReturn(data); EnumTypeHandler handler = new EnumTypeHandler<>(TestEnum.class); - PersistedData serializedNonNull = handler.serialize(TestEnum.NON_NULL, serializationContext); + PersistedData serializedNonNull = handler.serialize(TestEnum.NON_NULL, persistedDataSerializer); assertEquals(data, serializedNonNull); TestEnum deserializedValue = handler.deserialize(data); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 236b8acc0e7..7f3d9e19a38 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -18,7 +18,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.junit.Test; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; @@ -51,7 +51,7 @@ private static class Sub extends Base { @Test public void testSerialize() { - SerializationContext context = mock(SerializationContext.class); + PersistedDataSerializer context = mock(PersistedDataSerializer.class); Class subType = Sub.class; Type baseType = TypeInfo.of(Base.class).getType(); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java index 9c0b18774f8..1562ca0962a 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java @@ -22,7 +22,7 @@ import org.junit.Test; import org.mockito.Mockito; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.gson.GsonPersistedDataArray; import org.terasology.persistence.typeHandling.inMemory.PersistedString; import org.terasology.rendering.nui.Color; @@ -36,9 +36,9 @@ public class ColorTypeHandlerTest { @Test public void testSerialize() { - SerializationContext serializationContext = Mockito.mock(SerializationContext.class); - handler.serialize(new Color(0x010380FF), serializationContext); - Mockito.verify(serializationContext).create(1, 3, 128, 255); + PersistedDataSerializer persistedDataSerializer = Mockito.mock(PersistedDataSerializer.class); + handler.serialize(new Color(0x010380FF), persistedDataSerializer); + Mockito.verify(persistedDataSerializer).create(1, 3, 128, 255); } @Test diff --git a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java index d12fec16597..5fa1721b14b 100644 --- a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java @@ -23,7 +23,7 @@ import org.terasology.network.internal.NetworkSystemImpl; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.world.BlockEntityRegistry; import org.terasology.world.block.BlockComponent; @@ -43,16 +43,17 @@ public NetEntityRefTypeHandler(NetworkSystemImpl networkSystem, BlockEntityRegis } @Override - public PersistedData serialize(EntityRef value, SerializationContext context) { + public PersistedData serialize(EntityRef value, PersistedDataSerializer serializer) { BlockComponent blockComponent = value.getComponent(BlockComponent.class); if (blockComponent != null) { - return context.create(blockComponent.position.x, blockComponent.position.y, blockComponent.position.z); + Vector3i pos = blockComponent.position; + return serializer.create(pos.x, pos.y, pos.z); } NetworkComponent netComponent = value.getComponent(NetworkComponent.class); if (netComponent != null) { - return context.create(netComponent.getNetworkId()); + return serializer.create(netComponent.getNetworkId()); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java index 2d832c9a389..0373373728c 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java @@ -32,7 +32,7 @@ import org.terasology.persistence.typeHandling.Serializer; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; -import org.terasology.persistence.typeHandling.protobuf.ProtobufSerializationContext; +import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; import org.terasology.protobuf.EntityData; import org.terasology.reflection.metadata.FieldMetadata; @@ -56,7 +56,7 @@ public class ComponentSerializer { private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); private boolean usingFieldIds; private TypeSerializationLibrary typeSerializationLibrary; - private ProtobufSerializationContext serializationContext; + private ProtobufPersistedDataSerializer serializationContext; /** * Creates the component serializer. @@ -66,7 +66,7 @@ public class ComponentSerializer { public ComponentSerializer(ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { this.componentLibrary = componentLibrary; this.typeSerializationLibrary = typeSerializationLibrary; - this.serializationContext = new ProtobufSerializationContext(); + this.serializationContext = new ProtobufPersistedDataSerializer(); } public void setUsingFieldIds(boolean usingFieldIds) { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java index 42a32db60cd..cdb4b9d400c 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java @@ -27,12 +27,12 @@ import org.terasology.entitySystem.metadata.EventMetadata; import org.terasology.entitySystem.metadata.ReplicatedFieldMetadata; import org.terasology.persistence.typeHandling.DeserializationException; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.SerializationException; import org.terasology.persistence.typeHandling.Serializer; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; -import org.terasology.persistence.typeHandling.protobuf.ProtobufSerializationContext; +import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; import org.terasology.protobuf.EntityData; import java.util.Map; @@ -45,7 +45,7 @@ public class EventSerializer { private EventLibrary eventLibrary; private TypeSerializationLibrary typeSerializationLibrary; private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); - private SerializationContext serializationContext; + private PersistedDataSerializer persistedDataSerializer; /** * Creates the event serializer. @@ -55,7 +55,7 @@ public class EventSerializer { public EventSerializer(EventLibrary eventLibrary, TypeSerializationLibrary typeSerializationLibrary) { this.eventLibrary = eventLibrary; this.typeSerializationLibrary = typeSerializationLibrary; - this.serializationContext = new ProtobufSerializationContext(); + this.persistedDataSerializer = new ProtobufPersistedDataSerializer(); } /** @@ -133,7 +133,7 @@ public EntityData.Event serialize(Event event) { ByteString.Output fieldIds = ByteString.newOutput(); for (ReplicatedFieldMetadata field : eventMetadata.getFields()) { if (field.isReplicated()) { - EntityData.Value serializedValue = ((ProtobufPersistedData) eventSerializer.serialize(field, event, serializationContext)).getValue(); + EntityData.Value serializedValue = ((ProtobufPersistedData) eventSerializer.serialize(field, event, persistedDataSerializer)).getValue(); if (serializedValue != null) { eventData.addFieldValue(serializedValue); fieldIds.write(field.getId()); diff --git a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java index bcc5e67f14e..55e6ead3454 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java @@ -38,7 +38,7 @@ import org.terasology.persistence.typeHandling.Serializer; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; -import org.terasology.persistence.typeHandling.protobuf.ProtobufSerializationContext; +import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; import org.terasology.protobuf.EntityData; import java.util.Map; @@ -53,14 +53,14 @@ public class NetworkEntitySerializer { private EngineEntityManager entityManager; private ComponentLibrary componentLibrary; private TypeSerializationLibrary typeSerializationLibrary; - private ProtobufSerializationContext serializationContext; + private ProtobufPersistedDataSerializer serializationContext; private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); public NetworkEntitySerializer(EngineEntityManager entityManager, ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { this.entityManager = entityManager; this.componentLibrary = componentLibrary; this.typeSerializationLibrary = typeSerializationLibrary; - this.serializationContext = new ProtobufSerializationContext(); + this.serializationContext = new ProtobufPersistedDataSerializer(); } public void setComponentSerializeCheck(ComponentSerializeCheck componentSerializeCheck) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataSerializer.java similarity index 99% rename from engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java rename to engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataSerializer.java index 9ace1a68991..4a9740d559f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/SerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataSerializer.java @@ -27,7 +27,7 @@ /** * */ -public interface SerializationContext { +public interface PersistedDataSerializer { /** * Serializes a single string diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java index 77f54647d78..44f198ef7b6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java @@ -56,7 +56,7 @@ public TypeHandler getHandlerFor(FieldMetadata field) { * @return The serialized value of the field */ @SuppressWarnings("unchecked") - public PersistedData serialize(FieldMetadata field, Object container, SerializationContext context) { + public PersistedData serialize(FieldMetadata field, Object container, PersistedDataSerializer context) { Object rawValue = field.getValue(container); if (rawValue != null) { TypeHandler handler = getHandlerFor(field); @@ -76,7 +76,7 @@ public PersistedData serialize(FieldMetadata field, Object container, Seri * @return The serialized value */ @SuppressWarnings("unchecked") - public PersistedData serializeValue(FieldMetadata fieldMetadata, Object rawValue, SerializationContext context) { + public PersistedData serializeValue(FieldMetadata fieldMetadata, Object rawValue, PersistedDataSerializer context) { return fieldHandlers.get(fieldMetadata).serialize(rawValue, context); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index afea5155669..e427b065e00 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -24,12 +24,12 @@ public abstract class StringRepresentationTypeHandler implements TypeHandler< public abstract T getFromString(String representation); @Override - public PersistedData serialize(T value, SerializationContext context) { + public PersistedData serialize(T value, PersistedDataSerializer serializer) { String stringValue = getAsString(value); if (stringValue == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(stringValue); + return serializer.create(stringValue); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index 610f5e144e1..5fc0e4e08d2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -24,10 +24,10 @@ public interface TypeHandler { * This method should return null if the value cannot or should not be serialized. An example would be if value itself is null. * * @param value The value to serialize - may be null - * @param context The persistence context to serialize into + * @param serializer The serializer used to serialize simple values * @return The serialized value. */ - PersistedData serialize(T value, SerializationContext context); + PersistedData serialize(T value, PersistedDataSerializer serializer); /** * Deserializes a single value. diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java index 33f77efa724..96846068fe0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java @@ -30,7 +30,7 @@ public interface TypeHandlerFactory { * * This method is usually called only once for a type, so all expensive pre-computations and reflection * operations can be performed here so that the generated - * {@link TypeHandler#serialize(Object, SerializationContext)} and + * {@link TypeHandler#serialize(Object, PersistedDataSerializer)} and * {@link TypeHandler#deserialize(PersistedData)} implementations are fast. * * @param typeInfo The {@link TypeInfo} of the type for which a {@link TypeHandler} must be generated. diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index f53d88e66e3..ba3cf111102 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -16,7 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -24,11 +24,11 @@ public class BooleanTypeHandler implements TypeHandler { @Override - public PersistedData serialize(Boolean value, SerializationContext context) { + public PersistedData serialize(Boolean value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(value); + return serializer.create(value); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index a35a46c7fb7..eceebd3abaa 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -16,15 +16,15 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; public class ByteArrayTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(byte[] value, SerializationContext context) { + public PersistedData serialize(byte[] value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value); + return serializer.create(value); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index 5324462500d..39f5855af4f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -16,7 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -24,11 +24,11 @@ public class ByteTypeHandler implements TypeHandler { @Override - public PersistedData serialize(Byte value, SerializationContext context) { + public PersistedData serialize(Byte value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(new byte[]{value}); + return serializer.create(new byte[]{value}); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java index 4cc2efe933d..c00c5864cc5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -17,7 +17,7 @@ import com.google.common.collect.Lists; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.reflection.reflect.ObjectConstructor; @@ -34,14 +34,14 @@ public CollectionTypeHandler(TypeHandler elementTypeHandler, ObjectConstructo } @Override - public PersistedData serialize(Collection value, SerializationContext context) { + public PersistedData serialize(Collection value, PersistedDataSerializer serializer) { List items = Lists.newArrayList(); for (E element : value) { - items.add(elementTypeHandler.serialize(element, context)); + items.add(elementTypeHandler.serialize(element, serializer)); } - return context.create(items); + return serializer.create(items); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index 73d93c673d5..8c8b527e4ff 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -16,7 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -24,11 +24,11 @@ public class DoubleTypeHandler implements TypeHandler { @Override - public PersistedData serialize(Double value, SerializationContext context) { + public PersistedData serialize(Double value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(value); + return serializer.create(value); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index 0a68c4d9c5a..d39b1ba0223 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -19,7 +19,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Locale; @@ -41,11 +41,11 @@ public EnumTypeHandler(Class enumType) { } @Override - public PersistedData serialize(T value, SerializationContext context) { + public PersistedData serialize(T value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(value.toString()); + return serializer.create(value.toString()); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index 8018dedd18f..1d91ca66c45 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -16,7 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -24,11 +24,11 @@ public class FloatTypeHandler implements TypeHandler { @Override - public PersistedData serialize(Float value, SerializationContext context) { + public PersistedData serialize(Float value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(value); + return serializer.create(value); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index 2307f66bdf8..0e8c5efe23d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -16,7 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -24,11 +24,11 @@ public class IntTypeHandler implements TypeHandler { @Override - public PersistedData serialize(Integer value, SerializationContext context) { + public PersistedData serialize(Integer value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(value); + return serializer.create(value); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index f0b9777861a..13004c6cbe4 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -16,7 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -24,11 +24,11 @@ public class LongTypeHandler implements TypeHandler { @Override - public PersistedData serialize(Long value, SerializationContext context) { + public PersistedData serialize(Long value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(value); + return serializer.create(value); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index 8b50b2186c0..b0f84ef0196 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -17,7 +17,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -25,11 +25,11 @@ public class NumberTypeHandler implements TypeHandler { @Override - public PersistedData serialize(Number value, SerializationContext context) { + public PersistedData serialize(Number value, PersistedDataSerializer serializer) { if (value != null) { - return context.create(value.doubleValue()); + return serializer.create(value.doubleValue()); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 0e688425cee..041b146cf30 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -19,7 +19,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.reflection.reflect.ObjectConstructor; @@ -47,9 +47,9 @@ public ObjectFieldMapTypeHandler(ObjectConstructor constructor, Map mappedData = Maps.newLinkedHashMap(); for (Map.Entry> entry : mappedFields.entrySet()) { @@ -66,13 +66,13 @@ public PersistedData serialize(T value, SerializationContext context) { if (val != null) { TypeHandler handler = entry.getValue(); - PersistedData fieldValue = handler.serialize(val, context); + PersistedData fieldValue = handler.serialize(val, serializer); if (fieldValue != null) { mappedData.put(field.getName(), fieldValue); } } } - return context.create(mappedData); + return serializer.create(mappedData); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 6766b274703..b2e699ff625 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -20,7 +20,7 @@ import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.reflection.TypeInfo; @@ -52,10 +52,10 @@ public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo } @Override - public PersistedData serialize(T value, SerializationContext context) { + public PersistedData serialize(T value, PersistedDataSerializer serializer) { // If primitive, don't go looking for the runtime type, serialize as is if (typeInfo.getRawType().isPrimitive()) { - return delegateHandler.serialize(value, context); + return delegateHandler.serialize(value, serializer); } TypeHandler chosenHandler = delegateHandler; @@ -77,22 +77,22 @@ public PersistedData serialize(T value, SerializationContext context) { } if (chosenHandler == delegateHandler) { - return delegateHandler.serialize(value, context); + return delegateHandler.serialize(value, serializer); } Map typeValuePersistedDataMap = Maps.newHashMap(); typeValuePersistedDataMap.put( TYPE_FIELD, - context.create(runtimeClass.getName()) + serializer.create(runtimeClass.getName()) ); typeValuePersistedDataMap.put( VALUE_FIELD, - chosenHandler.serialize(value, context) + chosenHandler.serialize(value, serializer) ); - return context.create(typeValuePersistedDataMap); + return serializer.create(typeValuePersistedDataMap); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java index fccfbceeb05..6c2fedb65cd 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java @@ -17,7 +17,7 @@ import com.google.common.collect.Maps; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; @@ -33,15 +33,15 @@ public StringMapTypeHandler(TypeHandler contentsHandler) { } @Override - public PersistedData serialize(Map value, SerializationContext context) { + public PersistedData serialize(Map value, PersistedDataSerializer serializer) { Map map = Maps.newLinkedHashMap(); for (Map.Entry entry : value.entrySet()) { - PersistedData item = contentsHandler.serialize(entry.getValue(), context); + PersistedData item = contentsHandler.serialize(entry.getValue(), serializer); if (!item.isNull()) { map.put(entry.getKey(), item); } } - return context.create(map); + return serializer.create(map); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index e79640ca44e..d81996773e5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -16,7 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; /** @@ -24,11 +24,11 @@ public class StringTypeHandler implements TypeHandler { @Override - public PersistedData serialize(String value, SerializationContext context) { + public PersistedData serialize(String value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value); + return serializer.create(value); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 5c6232f7d9e..5616f94494c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -19,7 +19,7 @@ import org.terasology.persistence.typeHandling.DeserializationException; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.rendering.nui.Color; /** @@ -29,11 +29,11 @@ public class ColorTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Color value, SerializationContext context) { + public PersistedData serialize(Color value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value.r(), value.g(), value.b(), value.a()); + return serializer.create(value.r(), value.g(), value.b(), value.a()); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java index 786f5f52eb4..b7a5d2980ee 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java @@ -20,7 +20,7 @@ import org.terasology.entitySystem.entity.internal.EngineEntityManager; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.List; @@ -36,11 +36,11 @@ public EntityRefTypeHandler(EngineEntityManager engineEntityManager) { } @Override - public PersistedData serialize(EntityRef value, SerializationContext context) { + public PersistedData serialize(EntityRef value, PersistedDataSerializer serializer) { if (value.exists() && value.isPersistent()) { - return context.create(value.getId()); + return serializer.create(value.getId()); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonPersistedDataSerializer.java similarity index 96% rename from engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java rename to engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonPersistedDataSerializer.java index 94bd9506aaf..56bb9278cd0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonPersistedDataSerializer.java @@ -20,13 +20,12 @@ import com.google.gson.JsonNull; import com.google.gson.JsonObject; import com.google.gson.JsonPrimitive; -import com.google.gson.JsonSerializationContext; import gnu.trove.iterator.TDoubleIterator; import gnu.trove.iterator.TFloatIterator; import gnu.trove.iterator.TIntIterator; import gnu.trove.iterator.TLongIterator; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import java.nio.ByteBuffer; import java.util.Arrays; @@ -34,7 +33,7 @@ /** */ -public class GsonSerializationContext implements SerializationContext { +public class GsonPersistedDataSerializer implements PersistedDataSerializer { private static final PersistedData NULL_INSTANCE = new GsonPersistedData(JsonNull.INSTANCE); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java index c08a1a501f2..b1d29c25b50 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java @@ -58,7 +58,7 @@ public final class GsonTypeHandlerAdapter extends TypeAdapter { this.typeHandler = typeHandler; this.serializer = (src, typeOfSrc, context) -> - ((GsonPersistedData) typeHandler.serialize(src, new GsonSerializationContext())) + ((GsonPersistedData) typeHandler.serialize(src, new GsonPersistedDataSerializer())) .getElement(); this.deserializer = (json, typeOfT, context) -> diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java index 7d735906258..6c9e5e18e21 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java @@ -48,6 +48,6 @@ public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext @Override public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context) { - return ((GsonPersistedData) typeHandler.serialize(src, new GsonSerializationContext())).getElement(); + return ((GsonPersistedData) typeHandler.serialize(src, new GsonPersistedDataSerializer())).getElement(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java index 31feee3176c..5681fe3b769 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java @@ -19,7 +19,7 @@ import org.terasology.math.Border; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import java.util.Map; @@ -32,17 +32,17 @@ public class BorderTypeHandler implements org.terasology.persistence.typeHandlin private static final String BOTTOM_FIELD = "bottom"; @Override - public PersistedData serialize(Border value, SerializationContext context) { + public PersistedData serialize(Border value, PersistedDataSerializer serializer) { if (value != null) { Map map = Maps.newLinkedHashMap(); - map.put(LEFT_FIELD, context.create(value.getLeft())); - map.put(RIGHT_FIELD, context.create(value.getRight())); - map.put(TOP_FIELD, context.create(value.getTop())); - map.put(BOTTOM_FIELD, context.create(value.getBottom())); - return context.create(map); + map.put(LEFT_FIELD, serializer.create(value.getLeft())); + map.put(RIGHT_FIELD, serializer.create(value.getRight())); + map.put(TOP_FIELD, serializer.create(value.getTop())); + map.put(BOTTOM_FIELD, serializer.create(value.getBottom())); + return serializer.create(map); } - return context.createNull(); + return serializer.createNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index 45912c2143b..ddb9170501c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -19,18 +19,18 @@ import org.terasology.math.geom.Quat4f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; /** */ public class Quat4fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Quat4f value, SerializationContext context) { + public PersistedData serialize(Quat4f value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value.x, value.y, value.z, value.w); + return serializer.create(value.x, value.y, value.z, value.w); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index c5280a2a1ff..471bc167d28 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -21,7 +21,7 @@ import org.terasology.math.geom.Vector2f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; @@ -40,16 +40,16 @@ public Rect2fTypeHandler(TypeHandler vector2fTypeHandler) { } @Override - public PersistedData serialize(Rect2f value, SerializationContext context) { + public PersistedData serialize(Rect2f value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, vector2fTypeHandler.serialize(value.min(), context)); - map.put(SIZE_FIELD, vector2fTypeHandler.serialize(value.size(), context)); + map.put(MIN_FIELD, vector2fTypeHandler.serialize(value.min(), serializer)); + map.put(SIZE_FIELD, vector2fTypeHandler.serialize(value.size(), serializer)); - return context.create(map); + return serializer.create(map); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index 807b56e5165..f277c2acd48 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -22,7 +22,7 @@ import org.terasology.math.geom.Vector2i; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; @@ -41,16 +41,16 @@ public Rect2iTypeHandler(TypeHandler vector2iTypeHandler) { } @Override - public PersistedData serialize(Rect2i value, SerializationContext context) { + public PersistedData serialize(Rect2i value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, vector2iTypeHandler.serialize(value.min(), context)); - map.put(SIZE_FIELD, vector2iTypeHandler.serialize(value.size(), context)); + map.put(MIN_FIELD, vector2iTypeHandler.serialize(value.min(), serializer)); + map.put(SIZE_FIELD, vector2iTypeHandler.serialize(value.size(), serializer)); - return context.create(map); + return serializer.create(map); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java index 8bcbc46f5d8..d377a5dad18 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java @@ -22,7 +22,7 @@ import org.terasology.math.geom.Vector3i; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; @@ -41,16 +41,16 @@ public Region3iTypeHandler(TypeHandler vector3iTypeHandler) { } @Override - public PersistedData serialize(Region3i value, SerializationContext context) { + public PersistedData serialize(Region3i value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, vector3iTypeHandler.serialize(value.min(), context)); - map.put(SIZE_FIELD, vector3iTypeHandler.serialize(value.size(), context)); + map.put(MIN_FIELD, vector3iTypeHandler.serialize(value.min(), serializer)); + map.put(SIZE_FIELD, vector3iTypeHandler.serialize(value.size(), serializer)); - return context.create(map); + return serializer.create(map); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index 972f4ed93d7..639dc1c1742 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -20,18 +20,18 @@ import org.terasology.math.geom.Vector2f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; /** */ public class Vector2fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector2f value, SerializationContext context) { + public PersistedData serialize(Vector2f value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value.x, value.y); + return serializer.create(value.x, value.y); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index 1d3b04f738c..2a92e83ba49 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -19,18 +19,18 @@ import org.terasology.math.geom.Vector2i; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; /** */ public class Vector2iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector2i value, SerializationContext context) { + public PersistedData serialize(Vector2i value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value.x, value.y); + return serializer.create(value.x, value.y); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index 08632150405..f596ebcd2e5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -19,18 +19,18 @@ import org.terasology.math.geom.Vector3f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; /** */ public class Vector3fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector3f value, SerializationContext context) { + public PersistedData serialize(Vector3f value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value.x, value.y, value.z); + return serializer.create(value.x, value.y, value.z); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index d62d7438a93..f9b2429b6e0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -19,18 +19,18 @@ import org.terasology.math.geom.Vector3i; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; /** */ public class Vector3iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector3i value, SerializationContext context) { + public PersistedData serialize(Vector3i value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value.x, value.y, value.z); + return serializer.create(value.x, value.y, value.z); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index d8365ed8e4c..b62e47bee94 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -20,18 +20,18 @@ import org.terasology.math.geom.Vector4f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; /** */ public class Vector4fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector4f value, SerializationContext context) { + public PersistedData serialize(Vector4f value, PersistedDataSerializer serializer) { if (value == null) { - return context.createNull(); + return serializer.createNull(); } else { - return context.create(value.x, value.y, value.z, value.w); + return serializer.create(value.x, value.y, value.z, value.w); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufPersistedDataSerializer.java similarity index 97% rename from engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java rename to engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufPersistedDataSerializer.java index 08a3d231141..cea428f70af 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufSerializationContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufPersistedDataSerializer.java @@ -21,7 +21,7 @@ import gnu.trove.iterator.TIntIterator; import gnu.trove.iterator.TLongIterator; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.SerializationContext; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.protobuf.EntityData; import java.nio.ByteBuffer; @@ -30,7 +30,7 @@ /** */ -public class ProtobufSerializationContext implements SerializationContext { +public class ProtobufPersistedDataSerializer implements PersistedDataSerializer { @Override public PersistedData create(String value) { diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 711748dbcec..a62440da288 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -49,7 +49,7 @@ import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; import org.terasology.persistence.typeHandling.gson.GsonPersistedData; -import org.terasology.persistence.typeHandling.gson.GsonSerializationContext; +import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.naming.Name; @@ -133,7 +133,7 @@ void serializeRecordedEvents(List events, String filePath) { private void writeSpecificEventData(JsonWriter writer, Event event) { try { - GsonSerializationContext serializationContext = new GsonSerializationContext(); + GsonPersistedDataSerializer serializationContext = new GsonPersistedDataSerializer(); Gson gson = new GsonBuilder().create(); if (event instanceof InputEvent) { InputEvent e = (InputEvent) event; @@ -200,7 +200,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { } } - private void writeVector3fData(JsonWriter writer, GsonSerializationContext serializationContext, InputEvent e) throws IOException { + private void writeVector3fData(JsonWriter writer, GsonPersistedDataSerializer serializationContext, InputEvent e) throws IOException { if (e.getHitNormal() == null) { writeDefaultVector3fData(writer); } else { @@ -208,7 +208,7 @@ private void writeVector3fData(JsonWriter writer, GsonSerializationContext seria } } - private void writeRealVector3fData(JsonWriter writer, GsonSerializationContext serializationContext, InputEvent e) throws IOException { + private void writeRealVector3fData(JsonWriter writer, GsonPersistedDataSerializer serializationContext, InputEvent e) throws IOException { TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getHitNormal(), serializationContext); writer.name("hitNormal"); @@ -262,7 +262,7 @@ private void writeDefaultVector3fData(JsonWriter writer) throws IOException { writer.endObject(); } - private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonSerializationContext serializationContext) throws Exception { + private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPersistedDataSerializer serializationContext) throws Exception { if (event instanceof MouseWheelEvent) { MouseWheelEvent e = (MouseWheelEvent) event; writer.name("wheelTurns").value(e.getWheelTurns()); From 1a54b9eb5494041d1a596ea77ebbb790cdd77a1a Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 18:36:42 +0530 Subject: [PATCH 030/141] Rename PersistedDataSerializer.createXYZ to serializeXYZ --- .../coreTypes/CollectionTypeHandlerTest.java | 2 +- .../EnumTypeHandlerSerializerTest.java | 4 +- .../extensionTypes/ColorTypeHandlerTest.java | 2 +- .../NetEntityRefTypeHandler.java | 6 +-- .../typeHandling/PersistedDataSerializer.java | 46 ++++++++-------- .../persistence/typeHandling/Serializer.java | 2 +- .../StringRepresentationTypeHandler.java | 4 +- .../coreTypes/BooleanTypeHandler.java | 4 +- .../coreTypes/ByteArrayTypeHandler.java | 4 +- .../coreTypes/ByteTypeHandler.java | 4 +- .../coreTypes/CollectionTypeHandler.java | 2 +- .../coreTypes/DoubleTypeHandler.java | 4 +- .../coreTypes/EnumTypeHandler.java | 4 +- .../coreTypes/FloatTypeHandler.java | 4 +- .../coreTypes/IntTypeHandler.java | 4 +- .../coreTypes/LongTypeHandler.java | 4 +- .../coreTypes/NumberTypeHandler.java | 4 +- .../coreTypes/ObjectFieldMapTypeHandler.java | 4 +- .../RuntimeDelegatingTypeHandler.java | 4 +- .../coreTypes/StringMapTypeHandler.java | 2 +- .../coreTypes/StringTypeHandler.java | 4 +- .../extensionTypes/ColorTypeHandler.java | 4 +- .../extensionTypes/EntityRefTypeHandler.java | 4 +- .../gson/GsonPersistedDataSerializer.java | 52 +++++++++---------- .../mathTypes/BorderTypeHandler.java | 12 ++--- .../mathTypes/Quat4fTypeHandler.java | 4 +- .../mathTypes/Rect2fTypeHandler.java | 4 +- .../mathTypes/Rect2iTypeHandler.java | 4 +- .../mathTypes/Region3iTypeHandler.java | 4 +- .../mathTypes/Vector2fTypeHandler.java | 4 +- .../mathTypes/Vector2iTypeHandler.java | 4 +- .../mathTypes/Vector3fTypeHandler.java | 4 +- .../mathTypes/Vector3iTypeHandler.java | 4 +- .../mathTypes/Vector4fTypeHandler.java | 4 +- .../ProtobufPersistedDataSerializer.java | 52 +++++++++---------- 35 files changed, 139 insertions(+), 139 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java index b68e9bdb85b..abd63f99a01 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandlerTest.java @@ -53,7 +53,7 @@ public void testSerialize() { verify(elementTypeHandler, times(collection.size())).serialize(any(), any()); - verify(context).create(argThat(new ArgumentMatcher>() { + verify(context).serialize(argThat(new ArgumentMatcher>() { @Override public boolean matches(Iterable argument) { return argument instanceof Collection && ((Collection) argument).size() == collection.size(); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java index a859eedea90..c72ad0f9670 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java @@ -37,7 +37,7 @@ public void testNullValue() throws Exception { when(nullData.isNull()).thenReturn(true); PersistedDataSerializer persistedDataSerializer = mock(PersistedDataSerializer.class); - when(persistedDataSerializer.createNull()).thenReturn(nullData); + when(persistedDataSerializer.serializeNull()).thenReturn(nullData); EnumTypeHandler handler = new EnumTypeHandler<>(TestEnum.class); PersistedData serializedNull = handler.serialize(null, persistedDataSerializer); assertEquals(nullData, serializedNull); @@ -53,7 +53,7 @@ public void testNonNullValue() throws Exception { when(data.isString()).thenReturn(true); PersistedDataSerializer persistedDataSerializer = mock(PersistedDataSerializer.class); - when(persistedDataSerializer.create(TestEnum.NON_NULL.toString())).thenReturn(data); + when(persistedDataSerializer.serialize(TestEnum.NON_NULL.toString())).thenReturn(data); EnumTypeHandler handler = new EnumTypeHandler<>(TestEnum.class); PersistedData serializedNonNull = handler.serialize(TestEnum.NON_NULL, persistedDataSerializer); assertEquals(data, serializedNonNull); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java index 1562ca0962a..9858c1b239d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java @@ -38,7 +38,7 @@ public class ColorTypeHandlerTest { public void testSerialize() { PersistedDataSerializer persistedDataSerializer = Mockito.mock(PersistedDataSerializer.class); handler.serialize(new Color(0x010380FF), persistedDataSerializer); - Mockito.verify(persistedDataSerializer).create(1, 3, 128, 255); + Mockito.verify(persistedDataSerializer).serialize(1, 3, 128, 255); } @Test diff --git a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java index 5fa1721b14b..e4d10e8c822 100644 --- a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java @@ -47,13 +47,13 @@ public PersistedData serialize(EntityRef value, PersistedDataSerializer serializ BlockComponent blockComponent = value.getComponent(BlockComponent.class); if (blockComponent != null) { Vector3i pos = blockComponent.position; - return serializer.create(pos.x, pos.y, pos.z); + return serializer.serialize(pos.x, pos.y, pos.z); } NetworkComponent netComponent = value.getComponent(NetworkComponent.class); if (netComponent != null) { - return serializer.create(netComponent.getNetworkId()); + return serializer.serialize(netComponent.getNetworkId()); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataSerializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataSerializer.java index 4a9740d559f..f09167c4c07 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataSerializer.java @@ -34,157 +34,157 @@ public interface PersistedDataSerializer { * @param value * @return A serialized string */ - PersistedData create(String value); + PersistedData serialize(String value); /** * Serializes an array of strings. * @param values * @return A serialized array of strings. */ - PersistedData create(String... values); + PersistedData serialize(String... values); /** * Serializes a collection of strings. Null values will be stripped. * @param value * @return A serialized array of strings */ - PersistedData createStrings(Iterable value); + PersistedData serializeStrings(Iterable value); /** * Serializes a single float * @param value * @return A serialized float */ - PersistedData create(float value); + PersistedData serialize(float value); /** * Serializes an array of floats * @param values * @return A serialized array of floats */ - PersistedData create(float... values); + PersistedData serialize(float... values); /** * Serializes a collection of floats * @param value * @return A serialized array of floats */ - PersistedData create(TFloatIterator value); + PersistedData serialize(TFloatIterator value); /** * Serializes a single integer * @param value * @return A serialized integer */ - PersistedData create(int value); + PersistedData serialize(int value); /** * Serializes an array of integers * @param values * @return A serialized array of integers */ - PersistedData create(int... values); + PersistedData serialize(int... values); /** * Serializes a collection of integers * @param value * @return A serialized array of integers */ - PersistedData create(TIntIterator value); + PersistedData serialize(TIntIterator value); /** * Serializes a single long * @param value * @return A serialized long */ - PersistedData create(long value); + PersistedData serialize(long value); /** * Serializes an array of longs * @param values * @return A serialized array of longs */ - PersistedData create(long... values); + PersistedData serialize(long... values); /** * Serializes a collection of longs * @param value * @return A serialized array of longs */ - PersistedData create(TLongIterator value); + PersistedData serialize(TLongIterator value); /** * Serializes a single boolean * @param value * @return A serialized boolean */ - PersistedData create(boolean value); + PersistedData serialize(boolean value); /** * Serializes an array of booleans * @param values * @return A serialized array of booleans */ - PersistedData create(boolean... values); + PersistedData serialize(boolean... values); /** * Serializes a single double * @param value * @return A serialized double */ - PersistedData create(double value); + PersistedData serialize(double value); /** * Serializes an array of doubles * @param values * @return A serialized array double */ - PersistedData create(double... values); + PersistedData serialize(double... values); /** * Serializes a collection of doubles * @param value * @return A serialized array of double */ - PersistedData create(TDoubleIterator value); + PersistedData serialize(TDoubleIterator value); /** * Serializes an array of bytes * @param value * @return Serialized bytes */ - PersistedData create(byte[] value); + PersistedData serialize(byte[] value); /** * Serializes a buffer of bytes * @param value * @return Serialized bytes */ - PersistedData create(ByteBuffer value); + PersistedData serialize(ByteBuffer value); /** * Serializes an array of values * @param values * @return */ - PersistedData create(PersistedData... values); + PersistedData serialize(PersistedData... values); /** * Serializes a collection of values * @param data * @return */ - PersistedData create(Iterable data); + PersistedData serialize(Iterable data); /** * Serializes a map of name-value pairs * @param data * @return */ - PersistedData create(Map data); + PersistedData serialize(Map data); /** * @return A 'null' PersistedData */ - PersistedData createNull(); + PersistedData serializeNull(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java index 44f198ef7b6..1c3fa5055a8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java @@ -64,7 +64,7 @@ public PersistedData serialize(FieldMetadata field, Object container, Pers return handler.serialize(rawValue, context); } } - return context.createNull(); + return context.serializeNull(); } /** diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index e427b065e00..a96dd1364b9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -27,9 +27,9 @@ public abstract class StringRepresentationTypeHandler implements TypeHandler< public PersistedData serialize(T value, PersistedDataSerializer serializer) { String stringValue = getAsString(value); if (stringValue == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(stringValue); + return serializer.serialize(stringValue); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index ba3cf111102..916e11e47a0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -26,9 +26,9 @@ public class BooleanTypeHandler implements TypeHandler { @Override public PersistedData serialize(Boolean value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(value); + return serializer.serialize(value); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index eceebd3abaa..8ed5652a7ca 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -22,9 +22,9 @@ public class ByteArrayTypeHandler implements org.terasology.persistence.typeHand @Override public PersistedData serialize(byte[] value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value); + return serializer.serialize(value); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index 39f5855af4f..232cefc34f0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -26,9 +26,9 @@ public class ByteTypeHandler implements TypeHandler { @Override public PersistedData serialize(Byte value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(new byte[]{value}); + return serializer.serialize(new byte[]{value}); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java index c00c5864cc5..3e4dec1409d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -41,7 +41,7 @@ public PersistedData serialize(Collection value, PersistedDataSerializer seri items.add(elementTypeHandler.serialize(element, serializer)); } - return serializer.create(items); + return serializer.serialize(items); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index 8c8b527e4ff..8eac6f585c0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -26,9 +26,9 @@ public class DoubleTypeHandler implements TypeHandler { @Override public PersistedData serialize(Double value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(value); + return serializer.serialize(value); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index d39b1ba0223..bdb253ea4a2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -43,9 +43,9 @@ public EnumTypeHandler(Class enumType) { @Override public PersistedData serialize(T value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(value.toString()); + return serializer.serialize(value.toString()); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index 1d91ca66c45..44d6eedca6b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -26,9 +26,9 @@ public class FloatTypeHandler implements TypeHandler { @Override public PersistedData serialize(Float value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(value); + return serializer.serialize(value); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index 0e8c5efe23d..0749f66d0b1 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -26,9 +26,9 @@ public class IntTypeHandler implements TypeHandler { @Override public PersistedData serialize(Integer value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(value); + return serializer.serialize(value); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index 13004c6cbe4..537fc0fe7c0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -26,9 +26,9 @@ public class LongTypeHandler implements TypeHandler { @Override public PersistedData serialize(Long value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(value); + return serializer.serialize(value); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index b0f84ef0196..268dffb198b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -27,9 +27,9 @@ public class NumberTypeHandler implements TypeHandler { @Override public PersistedData serialize(Number value, PersistedDataSerializer serializer) { if (value != null) { - return serializer.create(value.doubleValue()); + return serializer.serialize(value.doubleValue()); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 041b146cf30..7f64e539eea 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -49,7 +49,7 @@ public ObjectFieldMapTypeHandler(ObjectConstructor constructor, Map mappedData = Maps.newLinkedHashMap(); for (Map.Entry> entry : mappedFields.entrySet()) { @@ -72,7 +72,7 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { } } } - return serializer.create(mappedData); + return serializer.serialize(mappedData); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index b2e699ff625..4503b962cd5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -84,7 +84,7 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { typeValuePersistedDataMap.put( TYPE_FIELD, - serializer.create(runtimeClass.getName()) + serializer.serialize(runtimeClass.getName()) ); typeValuePersistedDataMap.put( @@ -92,7 +92,7 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { chosenHandler.serialize(value, serializer) ); - return serializer.create(typeValuePersistedDataMap); + return serializer.serialize(typeValuePersistedDataMap); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java index 6c2fedb65cd..ecb376a2d81 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java @@ -41,7 +41,7 @@ public PersistedData serialize(Map value, PersistedDataSerializer ser map.put(entry.getKey(), item); } } - return serializer.create(map); + return serializer.serialize(map); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index d81996773e5..cb9ecf3d4fb 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -26,9 +26,9 @@ public class StringTypeHandler implements TypeHandler { @Override public PersistedData serialize(String value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value); + return serializer.serialize(value); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 5616f94494c..931f03ac679 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -31,9 +31,9 @@ public class ColorTypeHandler implements org.terasology.persistence.typeHandling @Override public PersistedData serialize(Color value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value.r(), value.g(), value.b(), value.a()); + return serializer.serialize(value.r(), value.g(), value.b(), value.a()); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java index b7a5d2980ee..220611eb623 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java @@ -38,9 +38,9 @@ public EntityRefTypeHandler(EngineEntityManager engineEntityManager) { @Override public PersistedData serialize(EntityRef value, PersistedDataSerializer serializer) { if (value.exists() && value.isPersistent()) { - return serializer.create(value.getId()); + return serializer.serialize(value.getId()); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonPersistedDataSerializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonPersistedDataSerializer.java index 56bb9278cd0..621bd05a0b0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonPersistedDataSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonPersistedDataSerializer.java @@ -38,17 +38,17 @@ public class GsonPersistedDataSerializer implements PersistedDataSerializer { private static final PersistedData NULL_INSTANCE = new GsonPersistedData(JsonNull.INSTANCE); @Override - public PersistedData create(String value) { + public PersistedData serialize(String value) { return new GsonPersistedData(new JsonPrimitive(value)); } @Override - public PersistedData create(String... values) { - return createStrings(Arrays.asList(values)); + public PersistedData serialize(String... values) { + return serializeStrings(Arrays.asList(values)); } @Override - public PersistedData createStrings(Iterable value) { + public PersistedData serializeStrings(Iterable value) { JsonArray array = new JsonArray(); for (String val : value) { array.add(new JsonPrimitive(val)); @@ -57,12 +57,12 @@ public PersistedData createStrings(Iterable value) { } @Override - public PersistedData create(float value) { + public PersistedData serialize(float value) { return new GsonPersistedData(new JsonPrimitive(value)); } @Override - public PersistedData create(float... values) { + public PersistedData serialize(float... values) { JsonArray array = new JsonArray(); for (float val : values) { array.add(new JsonPrimitive(val)); @@ -71,7 +71,7 @@ public PersistedData create(float... values) { } @Override - public PersistedData create(TFloatIterator value) { + public PersistedData serialize(TFloatIterator value) { JsonArray array = new JsonArray(); while (value.hasNext()) { array.add(new JsonPrimitive(value.next())); @@ -80,12 +80,12 @@ public PersistedData create(TFloatIterator value) { } @Override - public PersistedData create(int value) { + public PersistedData serialize(int value) { return new GsonPersistedData(new JsonPrimitive(value)); } @Override - public PersistedData create(int... values) { + public PersistedData serialize(int... values) { JsonArray array = new JsonArray(); for (int val : values) { array.add(new JsonPrimitive(val)); @@ -94,7 +94,7 @@ public PersistedData create(int... values) { } @Override - public PersistedData create(TIntIterator value) { + public PersistedData serialize(TIntIterator value) { JsonArray array = new JsonArray(); while (value.hasNext()) { array.add(new JsonPrimitive(value.next())); @@ -103,12 +103,12 @@ public PersistedData create(TIntIterator value) { } @Override - public PersistedData create(long value) { + public PersistedData serialize(long value) { return new GsonPersistedData(new JsonPrimitive(value)); } @Override - public PersistedData create(long... values) { + public PersistedData serialize(long... values) { JsonArray array = new JsonArray(); for (long val : values) { array.add(new JsonPrimitive(val)); @@ -117,7 +117,7 @@ public PersistedData create(long... values) { } @Override - public PersistedData create(TLongIterator value) { + public PersistedData serialize(TLongIterator value) { JsonArray array = new JsonArray(); while (value.hasNext()) { array.add(new JsonPrimitive(value.next())); @@ -126,12 +126,12 @@ public PersistedData create(TLongIterator value) { } @Override - public PersistedData create(boolean value) { + public PersistedData serialize(boolean value) { return new GsonPersistedData(new JsonPrimitive(value)); } @Override - public PersistedData create(boolean... values) { + public PersistedData serialize(boolean... values) { JsonArray array = new JsonArray(); for (boolean val : values) { array.add(new JsonPrimitive(val)); @@ -140,12 +140,12 @@ public PersistedData create(boolean... values) { } @Override - public PersistedData create(double value) { + public PersistedData serialize(double value) { return new GsonPersistedData(new JsonPrimitive(value)); } @Override - public PersistedData create(double... values) { + public PersistedData serialize(double... values) { JsonArray array = new JsonArray(); for (double val : values) { array.add(new JsonPrimitive(val)); @@ -154,7 +154,7 @@ public PersistedData create(double... values) { } @Override - public PersistedData create(TDoubleIterator value) { + public PersistedData serialize(TDoubleIterator value) { JsonArray array = new JsonArray(); while (value.hasNext()) { array.add(new JsonPrimitive(value.next())); @@ -163,22 +163,22 @@ public PersistedData create(TDoubleIterator value) { } @Override - public PersistedData create(byte[] value) { + public PersistedData serialize(byte[] value) { return new GsonPersistedData(new JsonPrimitive(BaseEncoding.base64().encode(value))); } @Override - public PersistedData create(ByteBuffer value) { - return create(value.array()); + public PersistedData serialize(ByteBuffer value) { + return serialize(value.array()); } @Override - public PersistedData create(PersistedData... data) { - return create(Arrays.asList(data)); + public PersistedData serialize(PersistedData... data) { + return serialize(Arrays.asList(data)); } @Override - public PersistedData create(Iterable data) { + public PersistedData serialize(Iterable data) { JsonArray result = new JsonArray(); for (PersistedData val : data) { if (val != null) { @@ -191,7 +191,7 @@ public PersistedData create(Iterable data) { } @Override - public PersistedData create(Map data) { + public PersistedData serialize(Map data) { JsonObject object = new JsonObject(); for (Map.Entry entry : data.entrySet()) { object.add(entry.getKey(), ((GsonPersistedData) entry.getValue()).getElement()); @@ -200,7 +200,7 @@ public PersistedData create(Map data) { } @Override - public PersistedData createNull() { + public PersistedData serializeNull() { return NULL_INSTANCE; } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java index 5681fe3b769..66aef35f46c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java @@ -35,14 +35,14 @@ public class BorderTypeHandler implements org.terasology.persistence.typeHandlin public PersistedData serialize(Border value, PersistedDataSerializer serializer) { if (value != null) { Map map = Maps.newLinkedHashMap(); - map.put(LEFT_FIELD, serializer.create(value.getLeft())); - map.put(RIGHT_FIELD, serializer.create(value.getRight())); - map.put(TOP_FIELD, serializer.create(value.getTop())); - map.put(BOTTOM_FIELD, serializer.create(value.getBottom())); - return serializer.create(map); + map.put(LEFT_FIELD, serializer.serialize(value.getLeft())); + map.put(RIGHT_FIELD, serializer.serialize(value.getRight())); + map.put(TOP_FIELD, serializer.serialize(value.getTop())); + map.put(BOTTOM_FIELD, serializer.serialize(value.getBottom())); + return serializer.serialize(map); } - return serializer.createNull(); + return serializer.serializeNull(); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index ddb9170501c..44ff35d638b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -28,9 +28,9 @@ public class Quat4fTypeHandler implements org.terasology.persistence.typeHandlin @Override public PersistedData serialize(Quat4f value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value.x, value.y, value.z, value.w); + return serializer.serialize(value.x, value.y, value.z, value.w); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index 471bc167d28..03b0305ff03 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -42,14 +42,14 @@ public Rect2fTypeHandler(TypeHandler vector2fTypeHandler) { @Override public PersistedData serialize(Rect2f value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { Map map = Maps.newLinkedHashMap(); map.put(MIN_FIELD, vector2fTypeHandler.serialize(value.min(), serializer)); map.put(SIZE_FIELD, vector2fTypeHandler.serialize(value.size(), serializer)); - return serializer.create(map); + return serializer.serialize(map); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index f277c2acd48..db202d459ea 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -43,14 +43,14 @@ public Rect2iTypeHandler(TypeHandler vector2iTypeHandler) { @Override public PersistedData serialize(Rect2i value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { Map map = Maps.newLinkedHashMap(); map.put(MIN_FIELD, vector2iTypeHandler.serialize(value.min(), serializer)); map.put(SIZE_FIELD, vector2iTypeHandler.serialize(value.size(), serializer)); - return serializer.create(map); + return serializer.serialize(map); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java index d377a5dad18..9db958c7347 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java @@ -43,14 +43,14 @@ public Region3iTypeHandler(TypeHandler vector3iTypeHandler) { @Override public PersistedData serialize(Region3i value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { Map map = Maps.newLinkedHashMap(); map.put(MIN_FIELD, vector3iTypeHandler.serialize(value.min(), serializer)); map.put(SIZE_FIELD, vector3iTypeHandler.serialize(value.size(), serializer)); - return serializer.create(map); + return serializer.serialize(map); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index 639dc1c1742..471a6f3bc72 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -29,9 +29,9 @@ public class Vector2fTypeHandler implements org.terasology.persistence.typeHandl @Override public PersistedData serialize(Vector2f value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value.x, value.y); + return serializer.serialize(value.x, value.y); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index 2a92e83ba49..e9b116e186d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -28,9 +28,9 @@ public class Vector2iTypeHandler implements org.terasology.persistence.typeHandl @Override public PersistedData serialize(Vector2i value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value.x, value.y); + return serializer.serialize(value.x, value.y); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index f596ebcd2e5..f98872225dc 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -28,9 +28,9 @@ public class Vector3fTypeHandler implements org.terasology.persistence.typeHandl @Override public PersistedData serialize(Vector3f value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value.x, value.y, value.z); + return serializer.serialize(value.x, value.y, value.z); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index f9b2429b6e0..0a9fe41950c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -28,9 +28,9 @@ public class Vector3iTypeHandler implements org.terasology.persistence.typeHandl @Override public PersistedData serialize(Vector3i value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value.x, value.y, value.z); + return serializer.serialize(value.x, value.y, value.z); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index b62e47bee94..9f4a0e52fd9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -29,9 +29,9 @@ public class Vector4fTypeHandler implements org.terasology.persistence.typeHandl @Override public PersistedData serialize(Vector4f value, PersistedDataSerializer serializer) { if (value == null) { - return serializer.createNull(); + return serializer.serializeNull(); } else { - return serializer.create(value.x, value.y, value.z, value.w); + return serializer.serialize(value.x, value.y, value.z, value.w); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufPersistedDataSerializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufPersistedDataSerializer.java index cea428f70af..e58e80ac015 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufPersistedDataSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/protobuf/ProtobufPersistedDataSerializer.java @@ -33,27 +33,27 @@ public class ProtobufPersistedDataSerializer implements PersistedDataSerializer { @Override - public PersistedData create(String value) { - return createStrings(Arrays.asList(value)); + public PersistedData serialize(String value) { + return serializeStrings(Arrays.asList(value)); } @Override - public PersistedData create(String... values) { - return createStrings(Arrays.asList(values)); + public PersistedData serialize(String... values) { + return serializeStrings(Arrays.asList(values)); } @Override - public PersistedData createStrings(Iterable value) { + public PersistedData serializeStrings(Iterable value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().addAllString(value).build()); } @Override - public PersistedData create(float value) { + public PersistedData serialize(float value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().addFloat(value).build()); } @Override - public PersistedData create(float... values) { + public PersistedData serialize(float... values) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); for (float val : values) { builder.addFloat(val); @@ -62,7 +62,7 @@ public PersistedData create(float... values) { } @Override - public PersistedData create(TFloatIterator value) { + public PersistedData serialize(TFloatIterator value) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); while (value.hasNext()) { builder.addFloat(value.next()); @@ -71,12 +71,12 @@ public PersistedData create(TFloatIterator value) { } @Override - public PersistedData create(int value) { + public PersistedData serialize(int value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().addInteger(value).build()); } @Override - public PersistedData create(int... values) { + public PersistedData serialize(int... values) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); for (int val : values) { builder.addInteger(val); @@ -85,7 +85,7 @@ public PersistedData create(int... values) { } @Override - public PersistedData create(TIntIterator value) { + public PersistedData serialize(TIntIterator value) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); while (value.hasNext()) { builder.addInteger(value.next()); @@ -94,12 +94,12 @@ public PersistedData create(TIntIterator value) { } @Override - public PersistedData create(long value) { + public PersistedData serialize(long value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().addLong(value).build()); } @Override - public PersistedData create(long... values) { + public PersistedData serialize(long... values) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); for (long val : values) { builder.addLong(val); @@ -108,7 +108,7 @@ public PersistedData create(long... values) { } @Override - public PersistedData create(TLongIterator value) { + public PersistedData serialize(TLongIterator value) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); while (value.hasNext()) { builder.addLong(value.next()); @@ -117,12 +117,12 @@ public PersistedData create(TLongIterator value) { } @Override - public PersistedData create(boolean value) { + public PersistedData serialize(boolean value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().addBoolean(value).build()); } @Override - public PersistedData create(boolean... values) { + public PersistedData serialize(boolean... values) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); for (boolean val : values) { builder.addBoolean(val); @@ -131,12 +131,12 @@ public PersistedData create(boolean... values) { } @Override - public PersistedData create(double value) { + public PersistedData serialize(double value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().addDouble(value).build()); } @Override - public PersistedData create(double... values) { + public PersistedData serialize(double... values) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); for (double val : values) { builder.addDouble(val); @@ -145,7 +145,7 @@ public PersistedData create(double... values) { } @Override - public PersistedData create(TDoubleIterator value) { + public PersistedData serialize(TDoubleIterator value) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); while (value.hasNext()) { builder.addDouble(value.next()); @@ -154,22 +154,22 @@ public PersistedData create(TDoubleIterator value) { } @Override - public PersistedData create(byte[] value) { + public PersistedData serialize(byte[] value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().setBytes(ByteString.copyFrom(value)).build()); } @Override - public PersistedData create(ByteBuffer value) { + public PersistedData serialize(ByteBuffer value) { return new ProtobufPersistedData(EntityData.Value.newBuilder().setBytes(ByteString.copyFrom(value)).build()); } @Override - public PersistedData create(PersistedData... data) { - return create(Arrays.asList(data)); + public PersistedData serialize(PersistedData... data) { + return serialize(Arrays.asList(data)); } @Override - public PersistedData create(Iterable data) { + public PersistedData serialize(Iterable data) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); for (PersistedData value : data) { builder.addValue(((ProtobufPersistedData) value).getValue()); @@ -178,7 +178,7 @@ public PersistedData create(Iterable data) { } @Override - public PersistedData create(Map data) { + public PersistedData serialize(Map data) { EntityData.Value.Builder builder = EntityData.Value.newBuilder(); for (Map.Entry entry : data.entrySet()) { builder.addNameValue(EntityData.NameValue.newBuilder() @@ -189,7 +189,7 @@ public PersistedData create(Map data) { } @Override - public PersistedData createNull() { + public PersistedData serializeNull() { return new ProtobufPersistedData(EntityData.Value.newBuilder().build()); } } From 46333c2243b2f3fcaf6a4c7a902c268c8960f4c0 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 23:39:47 +0530 Subject: [PATCH 031/141] Use first available constructor as last resort in ConstructorLibrary.get --- .../RuntimeDelegatingTypeHandlerTest.java | 2 +- .../CollectionTypeHandlerFactoryTest.java | 2 +- .../ObjectFieldMapTypeHandlerFactoryTest.java | 2 +- .../TypeSerializationLibrary.java | 4 +- .../reflect/ConstructorLibrary.java | 45 +++++++++++-------- 5 files changed, 31 insertions(+), 24 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 7f3d9e19a38..b4e8ee83c84 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -34,7 +34,7 @@ public class RuntimeDelegatingTypeHandlerTest { private final ConstructorLibrary constructorLibrary = - new ConstructorLibrary(Maps.newHashMap(), new ReflectionReflectFactory()); + new ConstructorLibrary(Maps.newHashMap()); private final CollectionTypeHandlerFactory collectionHandlerFactory = new CollectionTypeHandlerFactory(constructorLibrary); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index b29656c5488..ba0859f252e 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -37,7 +37,7 @@ public class CollectionTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); - private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap(), new ReflectionReflectFactory())); + private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap())); @Test public void testList() { diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index b91113e5f46..9993cd560ee 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -36,7 +36,7 @@ public class ObjectFieldMapTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); - private final ConstructorLibrary constructorLibrary = new ConstructorLibrary(Maps.newHashMap(), new ReflectionReflectFactory()); + private final ConstructorLibrary constructorLibrary = new ConstructorLibrary(Maps.newHashMap()); private final ObjectFieldMapTypeHandlerFactory typeHandlerFactory = new ObjectFieldMapTypeHandlerFactory( constructorLibrary); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index d0a27a48452..c9293f8df8c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -22,7 +22,6 @@ import org.slf4j.LoggerFactory; import org.terasology.entitySystem.prefab.Prefab; import org.terasology.math.IntegerRange; -import org.terasology.math.Region3i; import org.terasology.math.geom.Quat4f; import org.terasology.math.geom.Vector2f; import org.terasology.math.geom.Vector2i; @@ -51,7 +50,6 @@ import org.terasology.persistence.typeHandling.extensionTypes.factories.TextureRegionAssetTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.IntegerRangeHandler; import org.terasology.persistence.typeHandling.mathTypes.Quat4fTypeHandler; -import org.terasology.persistence.typeHandling.mathTypes.Region3iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector2fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector2iTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector3fTypeHandler; @@ -102,7 +100,7 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy this.reflectFactory = factory; this.copyStrategies = copyStrategies; - constructorLibrary = new ConstructorLibrary(instanceCreators, reflectFactory); + constructorLibrary = new ConstructorLibrary(instanceCreators); addTypeHandlerFactory(new ObjectFieldMapTypeHandlerFactory(constructorLibrary)); diff --git a/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java index 60e2424bc2a..3353035afac 100644 --- a/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java +++ b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java @@ -18,6 +18,8 @@ */ package org.terasology.reflection.reflect; +import com.google.common.collect.Lists; +import com.google.common.primitives.Primitives; import org.terasology.persistence.typeHandling.InstanceCreator; import org.terasology.persistence.typeHandling.SerializationException; import org.terasology.reflection.TypeInfo; @@ -27,11 +29,14 @@ import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; +import java.util.Comparator; import java.util.EnumSet; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.LinkedList; +import java.util.List; import java.util.Map; import java.util.Queue; import java.util.Set; @@ -46,11 +51,9 @@ public class ConstructorLibrary { private final Map> instanceCreators; - private final ReflectFactory reflectFactory; - public ConstructorLibrary(Map> instanceCreators, ReflectFactory reflectFactory) { + public ConstructorLibrary(Map> instanceCreators) { this.instanceCreators = instanceCreators; - this.reflectFactory = reflectFactory; } public ObjectConstructor get(TypeInfo typeInfo) { @@ -73,27 +76,33 @@ public ObjectConstructor get(TypeInfo typeInfo) { return () -> rawTypeCreator.createInstance(type); } - ObjectConstructor defaultConstructor = newDefaultConstructor(rawType); - if (defaultConstructor != null) { - return defaultConstructor; - } - ObjectConstructor defaultImplementation = newDefaultImplementationConstructor(type, rawType); if (defaultImplementation != null) { return defaultImplementation; } - // We should never have to reach here - return null; - } + return () -> { + @SuppressWarnings({"unchecked"}) + Constructor constructor = (Constructor) Arrays.stream(rawType.getDeclaredConstructors()) + .min(Comparator.comparingInt(c -> c.getParameterTypes().length)) + .orElseThrow(() -> + new IllegalArgumentException("Type " + rawType + " does not have a constructor") + ); - @SuppressWarnings("unchecked") - private ObjectConstructor newDefaultConstructor(Class rawType) { - try { - return (ObjectConstructor) reflectFactory.createConstructor(rawType); - } catch (NoSuchMethodException e) { - return null; - } + constructor.setAccessible(true); + final List params = Lists.newArrayList(); + + try { + for (Class pType : constructor.getParameterTypes()) { + params.add((pType.isPrimitive()) ? Primitives.wrap(pType).newInstance() : null); + } + + return constructor.newInstance(params.toArray()); + + } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) { + throw new IllegalArgumentException("Type " + rawType + "cannot be instantiated"); + } + }; } /** From 99fa4dcb1512857a0b10844c84162b68bc6e2371 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 26 Jul 2018 23:43:09 +0530 Subject: [PATCH 032/141] Use runtime type only if it is more specific in RuntimeDelegating handler --- .../RuntimeDelegatingTypeHandler.java | 31 +++++++++++++++++-- 1 file changed, 28 insertions(+), 3 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 4503b962cd5..73fab57ebc3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -25,6 +25,7 @@ import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.reflection.TypeInfo; +import java.lang.reflect.Type; import java.util.Map; /** @@ -59,13 +60,18 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { } TypeHandler chosenHandler = delegateHandler; - Class runtimeClass = value.getClass(); + Class runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(runtimeClass); - if (!(runtimeTypeHandler instanceof ObjectFieldMapTypeHandler)) { + if (delegateHandler == null) { + chosenHandler = runtimeTypeHandler; + } else if (runtimeTypeHandler.getClass().equals(delegateHandler.getClass())) { + // Both handlers are of same type, use delegateHandler + chosenHandler = delegateHandler; + } else if (!(runtimeTypeHandler instanceof ObjectFieldMapTypeHandler)) { // Custom handler for runtime type chosenHandler = runtimeTypeHandler; } else if (!(delegateHandler instanceof ObjectFieldMapTypeHandler)) { @@ -80,7 +86,7 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { return delegateHandler.serialize(value, serializer); } - Map typeValuePersistedDataMap = Maps.newHashMap(); + Map typeValuePersistedDataMap = Maps.newLinkedHashMap(); typeValuePersistedDataMap.put( TYPE_FIELD, @@ -95,6 +101,25 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { return serializer.serialize(typeValuePersistedDataMap); } + private static Class getRuntimeTypeIfMoreSpecific(TypeInfo typeInfo, T value) { + if (value == null) { + return typeInfo.getRawType(); + } + + Class runtimeClass = value.getClass(); + + if (typeInfo.getRawType().isInterface()) { + // Given type is interface, use runtime type which will be a class and will have data + return runtimeClass; + } else if (typeInfo.getType() instanceof Class) { + // If given type is a simple class, use more specific runtime type + return runtimeClass; + } + + // Given type has more information than runtime type, use that + return typeInfo.getRawType(); + } + @Override public T deserialize(PersistedData data) { if (!data.isValueMap()) { From b716cd0939ad39c0ce6b9b69bf19384e4b022fc9 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 27 Jul 2018 00:00:58 +0530 Subject: [PATCH 033/141] Add type handling integration test --- .../TypeHandlingIntegrationTest.java | 229 ++++++++++++++++++ 1 file changed, 229 insertions(+) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java new file mode 100644 index 00000000000..839e2d62992 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java @@ -0,0 +1,229 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import org.junit.Test; +import org.terasology.math.geom.Vector3f; +import org.terasology.persistence.typeHandling.gson.GsonPersistedData; +import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; +import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; +import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; +import org.terasology.protobuf.EntityData; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.copy.CopyStrategyLibrary; +import org.terasology.reflection.reflect.ReflectionReflectFactory; +import org.terasology.rendering.nui.Color; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.List; +import java.util.Objects; +import java.util.Set; + +import static org.junit.Assert.assertEquals; + +public class TypeHandlingIntegrationTest { + private static final String INSTANCE_JSON = "{\"list\":[50,51,-52,-53],\"animals\":[{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Dog\",\"@value\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Cheetah\",\"@value\":{\"name\":\"Cheetah\",\"spotColor\":[255,0,255,255]}}],\"data\":-559038737}"; + + private static final SomeClass INSTANCE = new SomeClass<>(0xdeadbeef); + + static { + INSTANCE.list.addAll(Lists.newArrayList(50, 51, -52, -53)); + + INSTANCE.animals.add(new Dog(new Vector3f(3.15f, 54.51f, -0.001f))); + + INSTANCE.animals.add(new Cheetah(Color.MAGENTA)); + } + + private ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); + private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); + + @Test + public void testJsonSerialize() { + + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() { + }); + + GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(INSTANCE, new GsonPersistedDataSerializer()); + + Gson gson = new Gson(); + + assertEquals(INSTANCE_JSON, gson.toJson(persistedData.getElement())); + } + + @Test + public void testJsonDeserialize() { + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() { + }); + + Gson gson = new Gson(); + JsonElement jsonElement = gson.fromJson(INSTANCE_JSON, JsonElement.class); + + PersistedData persistedData = new GsonPersistedData(jsonElement); + + SomeClass deserializedInstance = typeHandler.deserialize(persistedData); + + assertEquals(INSTANCE, deserializedInstance); + } + + @Test + public void testProtobufSerializeDeserialize() throws IOException { + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() { + }); + + ProtobufPersistedData persistedData = (ProtobufPersistedData) typeHandler.serialize(INSTANCE, new ProtobufPersistedDataSerializer()); + + byte[] bytes; + + try (ByteArrayOutputStream out = new ByteArrayOutputStream()) { + persistedData.getValue().writeDelimitedTo(out); + bytes = out.toByteArray(); + } + + EntityData.Value value; + + try (ByteArrayInputStream in = new ByteArrayInputStream(bytes)) { + value = EntityData.Value.parseDelimitedFrom(in); + } + + persistedData = new ProtobufPersistedData(value); + SomeClass deserializedInstance = typeHandler.deserialize(persistedData); + + assertEquals(INSTANCE, deserializedInstance); + } + + private static class SomeClass { + private T data; + private List list = Lists.newArrayList(); + private Set animals = Sets.newHashSet(); + + private SomeClass(T data) { + this.data = data; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + SomeClass someClass = (SomeClass) o; + return Objects.equals(data, someClass.data) && + Objects.equals(list, someClass.list) && + Objects.equals(animals, someClass.animals); + } + + @Override + public int hashCode() { + return Objects.hash(data, list, animals); + } + + @Override + public String toString() { + return "SomeClass{" + + "data=" + data + + ", list=" + list + + ", animals=" + animals + + '}'; + } + } + + private static abstract class Animal { + protected final String name; + + private Animal(String name) { + this.name = name; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + Animal animal = (Animal) o; + return Objects.equals(name, animal.name); + } + + @Override + public int hashCode() { + return Objects.hash(name); + } + } + + private static class Dog extends Animal { + private final Vector3f tailPosition; + + private Dog(Vector3f tailPosition) { + super("Dog"); + this.tailPosition = tailPosition; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + if (!super.equals(o)) return false; + Dog dog = (Dog) o; + return Objects.equals(tailPosition, dog.tailPosition); + } + + @Override + public String toString() { + return "Dog{" + + "name='" + name + '\'' + + ", tailPosition=" + tailPosition + + '}'; + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), tailPosition); + } + } + + private static class Cheetah extends Animal { + private final Color spotColor; + + private Cheetah(Color spotColor) { + super("Cheetah"); + this.spotColor = spotColor; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + if (!super.equals(o)) return false; + Cheetah cheetah = (Cheetah) o; + return Objects.equals(spotColor, cheetah.spotColor); + } + + @Override + public String toString() { + return "Cheetah{" + + "name='" + name + '\'' + + ", spotColor=" + spotColor + + '}'; + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), spotColor); + } + } +} From 6c373107abc525527679b950f24f1765e8ec94f4 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 27 Jul 2018 09:58:50 +0530 Subject: [PATCH 034/141] Introduce different TypeHander class in runtime handler test --- .../coreTypes/RuntimeDelegatingTypeHandlerTest.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index b4e8ee83c84..7b98cf13c98 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -24,7 +24,6 @@ import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import java.lang.reflect.Type; import java.util.ArrayList; @@ -56,8 +55,10 @@ public void testSerialize() { Class subType = Sub.class; Type baseType = TypeInfo.of(Base.class).getType(); + abstract class SubHandler implements TypeHandler {} + TypeHandler baseTypeHandler = mock(TypeHandler.class); - TypeHandler subTypeHandler = mock(TypeHandler.class); + TypeHandler subTypeHandler = mock(SubHandler.class); when(typeSerializationLibrary.getTypeHandler(eq(baseType))).thenReturn(baseTypeHandler); when(typeSerializationLibrary.getTypeHandler(eq(subType))).thenReturn(subTypeHandler); From 58960802bcf8fe82f5a16d8ff1d02be3cab1f325 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 27 Jul 2018 14:12:40 +0530 Subject: [PATCH 035/141] Use Defaults.defaultValue while generating constructor params --- .../org/terasology/reflection/reflect/ConstructorLibrary.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java index 3353035afac..16dba13bb94 100644 --- a/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java +++ b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java @@ -18,6 +18,7 @@ */ package org.terasology.reflection.reflect; +import com.google.common.base.Defaults; import com.google.common.collect.Lists; import com.google.common.primitives.Primitives; import org.terasology.persistence.typeHandling.InstanceCreator; @@ -94,7 +95,7 @@ public ObjectConstructor get(TypeInfo typeInfo) { try { for (Class pType : constructor.getParameterTypes()) { - params.add((pType.isPrimitive()) ? Primitives.wrap(pType).newInstance() : null); + params.add(Defaults.defaultValue(Primitives.unwrap(pType))); } return constructor.newInstance(params.toArray()); From 027cd9565cc8d3698c11e918e8764e83b98b8e93 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 27 Jul 2018 14:20:40 +0530 Subject: [PATCH 036/141] Serialize field only if field value is not default --- .../typeHandling/coreTypes/ObjectFieldMapTypeHandler.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 7f64e539eea..bdde1cfa756 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -15,6 +15,7 @@ */ package org.terasology.persistence.typeHandling.coreTypes; +import com.google.common.base.Defaults; import com.google.common.collect.Maps; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -25,6 +26,7 @@ import java.lang.reflect.Field; import java.util.Map; +import java.util.Objects; /** * Serializes objects as a fieldName -> fieldValue map. It is used as the last resort while serializing an @@ -64,7 +66,7 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { continue; } - if (val != null) { + if (!Objects.equals(val, Defaults.defaultValue(field.getType()))) { TypeHandler handler = entry.getValue(); PersistedData fieldValue = handler.serialize(val, serializer); if (fieldValue != null) { From 819260b558569d8e762bf6d6526d1ed917aabc18 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 30 Jul 2018 22:14:15 +0530 Subject: [PATCH 037/141] Make TypeHandler abstract class --- .../coreTypes/RuntimeDelegatingTypeHandlerTest.java | 2 +- .../network/serialization/NetEntityRefTypeHandler.java | 2 +- .../typeHandling/StringRepresentationTypeHandler.java | 2 +- .../terasology/persistence/typeHandling/TypeHandler.java | 6 +++--- .../typeHandling/coreTypes/BooleanTypeHandler.java | 2 +- .../typeHandling/coreTypes/ByteArrayTypeHandler.java | 2 +- .../persistence/typeHandling/coreTypes/ByteTypeHandler.java | 2 +- .../typeHandling/coreTypes/CollectionTypeHandler.java | 2 +- .../typeHandling/coreTypes/DoubleTypeHandler.java | 2 +- .../persistence/typeHandling/coreTypes/EnumTypeHandler.java | 2 +- .../typeHandling/coreTypes/FloatTypeHandler.java | 2 +- .../persistence/typeHandling/coreTypes/IntTypeHandler.java | 2 +- .../persistence/typeHandling/coreTypes/LongTypeHandler.java | 2 +- .../typeHandling/coreTypes/NumberTypeHandler.java | 2 +- .../typeHandling/coreTypes/ObjectFieldMapTypeHandler.java | 2 +- .../coreTypes/RuntimeDelegatingTypeHandler.java | 2 +- .../typeHandling/coreTypes/StringMapTypeHandler.java | 2 +- .../typeHandling/coreTypes/StringTypeHandler.java | 2 +- .../typeHandling/extensionTypes/ColorTypeHandler.java | 2 +- .../typeHandling/extensionTypes/EntityRefTypeHandler.java | 2 +- .../typeHandling/mathTypes/BorderTypeHandler.java | 2 +- .../typeHandling/mathTypes/Quat4fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Rect2fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Rect2iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Region3iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector2fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector2iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector3fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector3iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector4fTypeHandler.java | 2 +- 30 files changed, 32 insertions(+), 32 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 7b98cf13c98..9778cd371d9 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -55,7 +55,7 @@ public void testSerialize() { Class subType = Sub.class; Type baseType = TypeInfo.of(Base.class).getType(); - abstract class SubHandler implements TypeHandler {} + abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); diff --git a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java index e4d10e8c822..ff7de3c7ab2 100644 --- a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java @@ -33,7 +33,7 @@ * For block entities the block position is used instead (this allows overriding simulated block entities). * */ -public class NetEntityRefTypeHandler implements TypeHandler { +public class NetEntityRefTypeHandler extends TypeHandler { private NetworkSystemImpl networkSystem; private BlockEntityRegistry blockEntityRegistry; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index a96dd1364b9..cf8868a1bee 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -17,7 +17,7 @@ /** */ -public abstract class StringRepresentationTypeHandler implements TypeHandler { +public abstract class StringRepresentationTypeHandler extends TypeHandler { public abstract String getAsString(T item); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index 5fc0e4e08d2..4fa4163f8aa 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -17,7 +17,7 @@ /** */ -public interface TypeHandler { +public abstract class TypeHandler { /** * Serializes a single value. @@ -27,7 +27,7 @@ public interface TypeHandler { * @param serializer The serializer used to serialize simple values * @return The serialized value. */ - PersistedData serialize(T value, PersistedDataSerializer serializer); + public abstract PersistedData serialize(T value, PersistedDataSerializer serializer); /** * Deserializes a single value. @@ -36,5 +36,5 @@ public interface TypeHandler { * @return The deserialized value. * @throws org.terasology.persistence.typeHandling.DeserializationException if there was an error deserializing the data */ - T deserialize(PersistedData data); + public abstract T deserialize(PersistedData data); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index 916e11e47a0..872d974061d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -21,7 +21,7 @@ /** */ -public class BooleanTypeHandler implements TypeHandler { +public class BooleanTypeHandler extends TypeHandler { @Override public PersistedData serialize(Boolean value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index 8ed5652a7ca..33c6bdf1210 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -18,7 +18,7 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataSerializer; -public class ByteArrayTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class ByteArrayTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(byte[] value, PersistedDataSerializer serializer) { if (value == null) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index 232cefc34f0..d399efbdffe 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -21,7 +21,7 @@ /** */ -public class ByteTypeHandler implements TypeHandler { +public class ByteTypeHandler extends TypeHandler { @Override public PersistedData serialize(Byte value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java index 3e4dec1409d..c27b7c30b4c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -24,7 +24,7 @@ import java.util.Collection; import java.util.List; -public class CollectionTypeHandler implements TypeHandler> { +public class CollectionTypeHandler extends TypeHandler> { private TypeHandler elementTypeHandler; private ObjectConstructor> constructor; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index 8eac6f585c0..00216b4abd8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -21,7 +21,7 @@ /** */ -public class DoubleTypeHandler implements TypeHandler { +public class DoubleTypeHandler extends TypeHandler { @Override public PersistedData serialize(Double value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index bdb253ea4a2..20b479e7690 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -27,7 +27,7 @@ /** */ -public class EnumTypeHandler implements TypeHandler { +public class EnumTypeHandler extends TypeHandler { private static final Logger logger = LoggerFactory.getLogger(EnumTypeHandler.class); private Class enumType; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index 44d6eedca6b..9bb57991124 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -21,7 +21,7 @@ /** */ -public class FloatTypeHandler implements TypeHandler { +public class FloatTypeHandler extends TypeHandler { @Override public PersistedData serialize(Float value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index 0749f66d0b1..3e2cf380610 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -21,7 +21,7 @@ /** */ -public class IntTypeHandler implements TypeHandler { +public class IntTypeHandler extends TypeHandler { @Override public PersistedData serialize(Integer value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index 537fc0fe7c0..9cf9fba31c8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -21,7 +21,7 @@ /** */ -public class LongTypeHandler implements TypeHandler { +public class LongTypeHandler extends TypeHandler { @Override public PersistedData serialize(Long value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index 268dffb198b..d1b557f4e17 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -22,7 +22,7 @@ /** */ -public class NumberTypeHandler implements TypeHandler { +public class NumberTypeHandler extends TypeHandler { @Override public PersistedData serialize(Number value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index bdde1cfa756..267eb413a5d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -32,7 +32,7 @@ * Serializes objects as a fieldName -> fieldValue map. It is used as the last resort while serializing an * object through a {@link org.terasology.persistence.typeHandling.TypeSerializationLibrary}. */ -public class ObjectFieldMapTypeHandler implements TypeHandler { +public class ObjectFieldMapTypeHandler extends TypeHandler { private static final Logger logger = LoggerFactory.getLogger(ObjectFieldMapTypeHandler.class); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 73fab57ebc3..d288bb7bd98 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -36,7 +36,7 @@ * * @param The base type whose instances may be delegated to a subtype's {@link TypeHandler} at runtime. */ -public class RuntimeDelegatingTypeHandler implements TypeHandler { +public class RuntimeDelegatingTypeHandler extends TypeHandler { private static final String TYPE_FIELD = "@type"; private static final String VALUE_FIELD = "@value"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java index ecb376a2d81..e36e891b018 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java @@ -24,7 +24,7 @@ /** */ -public class StringMapTypeHandler implements TypeHandler> { +public class StringMapTypeHandler extends TypeHandler> { private TypeHandler contentsHandler; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index cb9ecf3d4fb..e78e081d806 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -21,7 +21,7 @@ /** */ -public class StringTypeHandler implements TypeHandler { +public class StringTypeHandler extends TypeHandler { @Override public PersistedData serialize(String value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 931f03ac679..28fb8c69a5c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -26,7 +26,7 @@ * Serializes {@link Color} instances to an int array [r, g, b, a]. * De-serializing also supports hexadecimal strings such as "AAAAAAFF". */ -public class ColorTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class ColorTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Color value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java index 220611eb623..75bf67f75d0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java @@ -27,7 +27,7 @@ /** */ -public class EntityRefTypeHandler implements TypeHandler { +public class EntityRefTypeHandler extends TypeHandler { private EngineEntityManager entityManager; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java index 66aef35f46c..187b6552a28 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java @@ -25,7 +25,7 @@ /** */ -public class BorderTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class BorderTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { private static final String LEFT_FIELD = "left"; private static final String RIGHT_FIELD = "right"; private static final String TOP_FIELD = "top"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index 44ff35d638b..8c3426bc7e6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -23,7 +23,7 @@ /** */ -public class Quat4fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Quat4fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Quat4f value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index 03b0305ff03..7ee2500b7fc 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -28,7 +28,7 @@ /** */ -public class Rect2fTypeHandler implements TypeHandler { +public class Rect2fTypeHandler extends TypeHandler { private static final String MIN_FIELD = "min"; private static final String SIZE_FIELD = "size"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index db202d459ea..26144acca0a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -29,7 +29,7 @@ /** */ -public class Rect2iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Rect2iTypeHandler extends TypeHandler { private static final String MIN_FIELD = "min"; private static final String SIZE_FIELD = "size"; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java index 9db958c7347..d43c59fa6bd 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java @@ -29,7 +29,7 @@ /** */ -public class Region3iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Region3iTypeHandler extends TypeHandler { private static final String MIN_FIELD = UriUtil.normalise("min"); private static final String SIZE_FIELD = UriUtil.normalise("size"); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index 471a6f3bc72..bd486564376 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -24,7 +24,7 @@ /** */ -public class Vector2fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Vector2fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector2f value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index e9b116e186d..ef6039850cf 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -23,7 +23,7 @@ /** */ -public class Vector2iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Vector2iTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector2i value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index f98872225dc..b183a0c145f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -23,7 +23,7 @@ /** */ -public class Vector3fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Vector3fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector3f value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index 0a9fe41950c..6aa08d5c017 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -23,7 +23,7 @@ /** */ -public class Vector3iTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Vector3iTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector3i value, PersistedDataSerializer serializer) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index 9f4a0e52fd9..de91079421b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -24,7 +24,7 @@ /** */ -public class Vector4fTypeHandler implements org.terasology.persistence.typeHandling.TypeHandler { +public class Vector4fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serialize(Vector4f value, PersistedDataSerializer serializer) { From c3e8056d19568c3d6c45c0057dd838d03660cbb9 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 30 Jul 2018 22:23:17 +0530 Subject: [PATCH 038/141] TypeHandler.serialize -> serializeNonNull, null serialized by default --- .../network/serialization/NetEntityRefTypeHandler.java | 2 +- .../typeHandling/StringRepresentationTypeHandler.java | 2 +- .../persistence/typeHandling/TypeHandler.java | 10 +++++++++- .../typeHandling/coreTypes/BooleanTypeHandler.java | 2 +- .../typeHandling/coreTypes/ByteArrayTypeHandler.java | 2 +- .../typeHandling/coreTypes/ByteTypeHandler.java | 2 +- .../typeHandling/coreTypes/CollectionTypeHandler.java | 2 +- .../typeHandling/coreTypes/DoubleTypeHandler.java | 2 +- .../typeHandling/coreTypes/EnumTypeHandler.java | 2 +- .../typeHandling/coreTypes/FloatTypeHandler.java | 2 +- .../typeHandling/coreTypes/IntTypeHandler.java | 2 +- .../typeHandling/coreTypes/LongTypeHandler.java | 2 +- .../typeHandling/coreTypes/NumberTypeHandler.java | 2 +- .../coreTypes/ObjectFieldMapTypeHandler.java | 2 +- .../coreTypes/RuntimeDelegatingTypeHandler.java | 3 +-- .../typeHandling/coreTypes/StringMapTypeHandler.java | 2 +- .../typeHandling/coreTypes/StringTypeHandler.java | 2 +- .../typeHandling/extensionTypes/ColorTypeHandler.java | 2 +- .../extensionTypes/EntityRefTypeHandler.java | 2 +- .../typeHandling/mathTypes/BorderTypeHandler.java | 2 +- .../typeHandling/mathTypes/Quat4fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Rect2fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Rect2iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Region3iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector2fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector2iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector3fTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector3iTypeHandler.java | 2 +- .../typeHandling/mathTypes/Vector4fTypeHandler.java | 2 +- 29 files changed, 37 insertions(+), 30 deletions(-) diff --git a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java index ff7de3c7ab2..97c7068bed7 100644 --- a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java @@ -43,7 +43,7 @@ public NetEntityRefTypeHandler(NetworkSystemImpl networkSystem, BlockEntityRegis } @Override - public PersistedData serialize(EntityRef value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(EntityRef value, PersistedDataSerializer serializer) { BlockComponent blockComponent = value.getComponent(BlockComponent.class); if (blockComponent != null) { Vector3i pos = blockComponent.position; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index cf8868a1bee..f12fca9a5b4 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -24,7 +24,7 @@ public abstract class StringRepresentationTypeHandler extends TypeHandler public abstract T getFromString(String representation); @Override - public PersistedData serialize(T value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { String stringValue = getAsString(value); if (stringValue == null) { return serializer.serializeNull(); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index 4fa4163f8aa..7f26b5efa7a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -27,7 +27,15 @@ public abstract class TypeHandler { * @param serializer The serializer used to serialize simple values * @return The serialized value. */ - public abstract PersistedData serialize(T value, PersistedDataSerializer serializer); + protected abstract PersistedData serializeNonNull(T value, PersistedDataSerializer serializer); + + public PersistedData serialize(T value, PersistedDataSerializer serializer) { + if (value == null) { + return serializer.serializeNull(); + } + + return serializeNonNull(value, serializer); + } /** * Deserializes a single value. diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index 872d974061d..0ebb7fd23ef 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -24,7 +24,7 @@ public class BooleanTypeHandler extends TypeHandler { @Override - public PersistedData serialize(Boolean value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Boolean value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(value); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index 33c6bdf1210..7822f129faf 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -20,7 +20,7 @@ public class ByteArrayTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(byte[] value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(byte[] value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index d399efbdffe..22e0250e611 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -24,7 +24,7 @@ public class ByteTypeHandler extends TypeHandler { @Override - public PersistedData serialize(Byte value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Byte value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(new byte[]{value}); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java index c27b7c30b4c..682a2f08e9f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -34,7 +34,7 @@ public CollectionTypeHandler(TypeHandler elementTypeHandler, ObjectConstructo } @Override - public PersistedData serialize(Collection value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Collection value, PersistedDataSerializer serializer) { List items = Lists.newArrayList(); for (E element : value) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index 00216b4abd8..ddaffed88bd 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -24,7 +24,7 @@ public class DoubleTypeHandler extends TypeHandler { @Override - public PersistedData serialize(Double value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Double value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(value); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index 20b479e7690..8746becc763 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -41,7 +41,7 @@ public EnumTypeHandler(Class enumType) { } @Override - public PersistedData serialize(T value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(value.toString()); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index 9bb57991124..a4fe7f11071 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -24,7 +24,7 @@ public class FloatTypeHandler extends TypeHandler { @Override - public PersistedData serialize(Float value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Float value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(value); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index 3e2cf380610..7e95f8b7519 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -24,7 +24,7 @@ public class IntTypeHandler extends TypeHandler { @Override - public PersistedData serialize(Integer value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Integer value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(value); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index 9cf9fba31c8..fc499c7e4f2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -24,7 +24,7 @@ public class LongTypeHandler extends TypeHandler { @Override - public PersistedData serialize(Long value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Long value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(value); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index d1b557f4e17..11a55699cb4 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -25,7 +25,7 @@ public class NumberTypeHandler extends TypeHandler { @Override - public PersistedData serialize(Number value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Number value, PersistedDataSerializer serializer) { if (value != null) { return serializer.serialize(value.doubleValue()); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 267eb413a5d..a122de8ff76 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -49,7 +49,7 @@ public ObjectFieldMapTypeHandler(ObjectConstructor constructor, Map delegateHandler, TypeInfo } @Override - public PersistedData serialize(T value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { // If primitive, don't go looking for the runtime type, serialize as is if (typeInfo.getRawType().isPrimitive()) { return delegateHandler.serialize(value, serializer); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java index e36e891b018..028f33ab213 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java @@ -33,7 +33,7 @@ public StringMapTypeHandler(TypeHandler contentsHandler) { } @Override - public PersistedData serialize(Map value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Map value, PersistedDataSerializer serializer) { Map map = Maps.newLinkedHashMap(); for (Map.Entry entry : value.entrySet()) { PersistedData item = contentsHandler.serialize(entry.getValue(), serializer); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index e78e081d806..f03f5569aee 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -24,7 +24,7 @@ public class StringTypeHandler extends TypeHandler { @Override - public PersistedData serialize(String value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(String value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 28fb8c69a5c..42feee0df61 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -29,7 +29,7 @@ public class ColorTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Color value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Color value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java index 75bf67f75d0..8f5354f89db 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java @@ -36,7 +36,7 @@ public EntityRefTypeHandler(EngineEntityManager engineEntityManager) { } @Override - public PersistedData serialize(EntityRef value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(EntityRef value, PersistedDataSerializer serializer) { if (value.exists() && value.isPersistent()) { return serializer.serialize(value.getId()); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java index 187b6552a28..fd259db077a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java @@ -32,7 +32,7 @@ public class BorderTypeHandler extends org.terasology.persistence.typeHandling.T private static final String BOTTOM_FIELD = "bottom"; @Override - public PersistedData serialize(Border value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Border value, PersistedDataSerializer serializer) { if (value != null) { Map map = Maps.newLinkedHashMap(); map.put(LEFT_FIELD, serializer.serialize(value.getLeft())); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index 8c3426bc7e6..34e227734d6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -26,7 +26,7 @@ public class Quat4fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Quat4f value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Quat4f value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index 7ee2500b7fc..0c7791feebb 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -40,7 +40,7 @@ public Rect2fTypeHandler(TypeHandler vector2fTypeHandler) { } @Override - public PersistedData serialize(Rect2f value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Rect2f value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index 26144acca0a..ed8238c4953 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -41,7 +41,7 @@ public Rect2iTypeHandler(TypeHandler vector2iTypeHandler) { } @Override - public PersistedData serialize(Rect2i value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Rect2i value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java index d43c59fa6bd..852defbf04b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java @@ -41,7 +41,7 @@ public Region3iTypeHandler(TypeHandler vector3iTypeHandler) { } @Override - public PersistedData serialize(Region3i value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Region3i value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index bd486564376..28dce3f23e4 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -27,7 +27,7 @@ public class Vector2fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector2f value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Vector2f value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index ef6039850cf..5e4e742fceb 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -26,7 +26,7 @@ public class Vector2iTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector2i value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Vector2i value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index b183a0c145f..504bcdf183f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -26,7 +26,7 @@ public class Vector3fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector3f value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Vector3f value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index 6aa08d5c017..60ad78663cf 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -26,7 +26,7 @@ public class Vector3iTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector3i value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Vector3i value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index de91079421b..333e57c0b16 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -27,7 +27,7 @@ public class Vector4fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override - public PersistedData serialize(Vector4f value, PersistedDataSerializer serializer) { + public PersistedData serializeNonNull(Vector4f value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); } else { From aa5abeb171b0c884c83d8130552e22b99f2484b4 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 30 Jul 2018 23:13:12 +0530 Subject: [PATCH 039/141] Update TypeHandler documentation --- .../persistence/typeHandling/TypeHandler.java | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index 7f26b5efa7a..b7e61c241a7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -16,19 +16,28 @@ package org.terasology.persistence.typeHandling; /** + * Serializes objects of type {@link T} to and from a {@link PersistedData}. */ public abstract class TypeHandler { + /** + * Serializes a single non-null value. + * + * @param value The value to serialize - will never be null. + * @param serializer The serializer used to serialize simple values + * @return The serialized value. + */ + protected abstract PersistedData serializeNonNull(T value, PersistedDataSerializer serializer); /** * Serializes a single value. - * This method should return null if the value cannot or should not be serialized. An example would be if value itself is null. + * + * The default implementation of this method returns {@link PersistedDataSerializer#serializeNull()} + * if {@code value} is null, otherwise delegates to {@link #serializeNonNull}. * * @param value The value to serialize - may be null * @param serializer The serializer used to serialize simple values * @return The serialized value. */ - protected abstract PersistedData serializeNonNull(T value, PersistedDataSerializer serializer); - public PersistedData serialize(T value, PersistedDataSerializer serializer) { if (value == null) { return serializer.serializeNull(); From 710cbbc4c20455937d28996bb6c558595a88b3ab Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 09:56:05 +0530 Subject: [PATCH 040/141] Use UnsafeAllocator in ConstructorLibrary as last resort --- .../reflect/ConstructorLibrary.java | 64 +++++++---- .../reflect/internal/UnsafeAllocator.java | 106 ++++++++++++++++++ 2 files changed, 150 insertions(+), 20 deletions(-) create mode 100644 engine/src/main/java/org/terasology/reflection/reflect/internal/UnsafeAllocator.java diff --git a/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java index 16dba13bb94..a21393aefca 100644 --- a/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java +++ b/engine/src/main/java/org/terasology/reflection/reflect/ConstructorLibrary.java @@ -18,12 +18,10 @@ */ package org.terasology.reflection.reflect; -import com.google.common.base.Defaults; -import com.google.common.collect.Lists; -import com.google.common.primitives.Primitives; import org.terasology.persistence.typeHandling.InstanceCreator; import org.terasology.persistence.typeHandling.SerializationException; import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.reflect.internal.UnsafeAllocator; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; @@ -37,7 +35,6 @@ import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.LinkedList; -import java.util.List; import java.util.Map; import java.util.Queue; import java.util.Set; @@ -77,31 +74,58 @@ public ObjectConstructor get(TypeInfo typeInfo) { return () -> rawTypeCreator.createInstance(type); } + ObjectConstructor defaultConstructor = newDefaultConstructor(rawType); + if (defaultConstructor != null) { + return defaultConstructor; + } + ObjectConstructor defaultImplementation = newDefaultImplementationConstructor(type, rawType); if (defaultImplementation != null) { return defaultImplementation; } - return () -> { - @SuppressWarnings({"unchecked"}) - Constructor constructor = (Constructor) Arrays.stream(rawType.getDeclaredConstructors()) - .min(Comparator.comparingInt(c -> c.getParameterTypes().length)) - .orElseThrow(() -> - new IllegalArgumentException("Type " + rawType + " does not have a constructor") - ); - - constructor.setAccessible(true); - final List params = Lists.newArrayList(); + return newUnsafeAllocator(typeInfo); + } - try { - for (Class pType : constructor.getParameterTypes()) { - params.add(Defaults.defaultValue(Primitives.unwrap(pType))); + private ObjectConstructor newUnsafeAllocator(TypeInfo typeInfo) { + return new ObjectConstructor() { + private final UnsafeAllocator unsafeAllocator = UnsafeAllocator.create(); + @SuppressWarnings("unchecked") + @Override public T construct() { + try { + Object newInstance = unsafeAllocator.newInstance(typeInfo.getRawType()); + return (T) newInstance; + } catch (Exception e) { + throw new RuntimeException("Unable to create an instance of " + typeInfo.getType() + + ". Registering an InstanceCreator for this type may fix this problem.", e); } + } + }; + } - return constructor.newInstance(params.toArray()); + private ObjectConstructor newDefaultConstructor(Class rawType) { + @SuppressWarnings("unchecked") // T is the same raw type as is requested + Constructor constructor = (Constructor) Arrays.stream(rawType.getDeclaredConstructors()) + .min(Comparator.comparingInt(c -> c.getParameterTypes().length)) + .orElse(null); + + if (constructor == null || constructor.getParameterTypes().length != 0) { + return null; + } - } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) { - throw new IllegalArgumentException("Type " + rawType + "cannot be instantiated"); + if (!constructor.isAccessible()) { + constructor.setAccessible(true); + } + return () -> { + try { + return constructor.newInstance(); + } catch (InstantiationException e) { + throw new RuntimeException("Failed to invoke " + constructor + " with no args", e); + } catch (InvocationTargetException e) { + throw new RuntimeException("Failed to invoke " + constructor + " with no args", + e.getTargetException()); + } catch (IllegalAccessException e) { + throw new AssertionError(e); } }; } diff --git a/engine/src/main/java/org/terasology/reflection/reflect/internal/UnsafeAllocator.java b/engine/src/main/java/org/terasology/reflection/reflect/internal/UnsafeAllocator.java new file mode 100644 index 00000000000..d4a58f5010e --- /dev/null +++ b/engine/src/main/java/org/terasology/reflection/reflect/internal/UnsafeAllocator.java @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2011 Google Inc. + * Copyright 2018 MovingBlocks + * + * 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. + * + * com.google.gson.internal.UnsafeAllocator, Gson v2.6.2 + */ +package org.terasology.reflection.reflect.internal; + +import java.io.ObjectInputStream; +import java.io.ObjectStreamClass; +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +/** + * Do sneaky things to allocate objects without invoking their constructors. + * + * @author Joel Leitch + * @author Jesse Wilson + */ +public abstract class UnsafeAllocator { + public abstract T newInstance(Class c) throws Exception; + + public static UnsafeAllocator create() { + // try JVM + // public class Unsafe { + // public Object allocateInstance(Class type); + // } + try { + Class unsafeClass = Class.forName("sun.misc.Unsafe"); + Field f = unsafeClass.getDeclaredField("theUnsafe"); + f.setAccessible(true); + final Object unsafe = f.get(null); + final Method allocateInstance = unsafeClass.getMethod("allocateInstance", Class.class); + return new UnsafeAllocator() { + @Override + @SuppressWarnings("unchecked") + public T newInstance(Class c) throws Exception { + return (T) allocateInstance.invoke(unsafe, c); + } + }; + } catch (Exception ignored) { + } + + // try dalvikvm, post-gingerbread + // public class ObjectStreamClass { + // private static native int getConstructorId(Class c); + // private static native Object newInstance(Class instantiationClass, int methodId); + // } + try { + Method getConstructorId = ObjectStreamClass.class + .getDeclaredMethod("getConstructorId", Class.class); + getConstructorId.setAccessible(true); + final int constructorId = (Integer) getConstructorId.invoke(null, Object.class); + final Method newInstance = ObjectStreamClass.class + .getDeclaredMethod("newInstance", Class.class, int.class); + newInstance.setAccessible(true); + return new UnsafeAllocator() { + @Override + @SuppressWarnings("unchecked") + public T newInstance(Class c) throws Exception { + return (T) newInstance.invoke(null, c, constructorId); + } + }; + } catch (Exception ignored) { + } + + // try dalvikvm, pre-gingerbread + // public class ObjectInputStream { + // private static native Object newInstance( + // Class instantiationClass, Class constructorClass); + // } + try { + final Method newInstance = ObjectInputStream.class + .getDeclaredMethod("newInstance", Class.class, Class.class); + newInstance.setAccessible(true); + return new UnsafeAllocator() { + @Override + @SuppressWarnings("unchecked") + public T newInstance(Class c) throws Exception { + return (T) newInstance.invoke(null, c, Object.class); + } + }; + } catch (Exception ignored) { + } + + // give up + return new UnsafeAllocator() { + @Override + public T newInstance(Class c) { + throw new UnsupportedOperationException("Cannot allocate " + c); + } + }; + } +} From 786ac1c5074b58c080eb2a45a9a824ecf4f63d53 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 10:56:37 +0530 Subject: [PATCH 041/141] Remove null serialization in TypeHandler.serializeNotNull impls --- .../StringRepresentationTypeHandler.java | 6 +----- .../typeHandling/coreTypes/BooleanTypeHandler.java | 5 +---- .../typeHandling/coreTypes/ByteArrayTypeHandler.java | 6 +----- .../typeHandling/coreTypes/ByteTypeHandler.java | 5 +---- .../typeHandling/coreTypes/DoubleTypeHandler.java | 5 +---- .../typeHandling/coreTypes/EnumTypeHandler.java | 5 +---- .../typeHandling/coreTypes/FloatTypeHandler.java | 5 +---- .../typeHandling/coreTypes/IntTypeHandler.java | 5 +---- .../typeHandling/coreTypes/LongTypeHandler.java | 5 +---- .../typeHandling/coreTypes/NumberTypeHandler.java | 5 +---- .../coreTypes/ObjectFieldMapTypeHandler.java | 3 --- .../typeHandling/coreTypes/StringTypeHandler.java | 6 +----- .../extensionTypes/ColorTypeHandler.java | 6 +----- .../typeHandling/mathTypes/Quat4fTypeHandler.java | 7 +------ .../typeHandling/mathTypes/Rect2fTypeHandler.java | 12 ++++-------- .../typeHandling/mathTypes/Rect2iTypeHandler.java | 12 ++++-------- .../typeHandling/mathTypes/Vector2fTypeHandler.java | 7 +------ .../typeHandling/mathTypes/Vector2iTypeHandler.java | 6 +----- .../typeHandling/mathTypes/Vector3fTypeHandler.java | 6 +----- .../typeHandling/mathTypes/Vector3iTypeHandler.java | 6 +----- .../typeHandling/mathTypes/Vector4fTypeHandler.java | 6 +----- 21 files changed, 26 insertions(+), 103 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index f12fca9a5b4..471b5933a69 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -26,11 +26,7 @@ public abstract class StringRepresentationTypeHandler extends TypeHandler @Override public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { String stringValue = getAsString(value); - if (stringValue == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(stringValue); - } + return serializer.serialize(stringValue); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index 0ebb7fd23ef..1775e122b79 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -25,10 +25,7 @@ public class BooleanTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(Boolean value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(value); - } - return serializer.serializeNull(); + return serializer.serialize(value); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index 7822f129faf..9e394a32c38 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -21,11 +21,7 @@ public class ByteArrayTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serializeNonNull(byte[] value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value); - } + return serializer.serialize(value); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index 22e0250e611..22c39d025ac 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -25,10 +25,7 @@ public class ByteTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(Byte value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(new byte[]{value}); - } - return serializer.serializeNull(); + return serializer.serialize(new byte[]{value}); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index ddaffed88bd..1ed4a4f4c25 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -25,10 +25,7 @@ public class DoubleTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(Double value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(value); - } - return serializer.serializeNull(); + return serializer.serialize(value); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index 8746becc763..86711999d94 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -42,10 +42,7 @@ public EnumTypeHandler(Class enumType) { @Override public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(value.toString()); - } - return serializer.serializeNull(); + return serializer.serialize(value.toString()); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index a4fe7f11071..aa0b6fb2185 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -25,10 +25,7 @@ public class FloatTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(Float value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(value); - } - return serializer.serializeNull(); + return serializer.serialize(value); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index 7e95f8b7519..bb52e130f64 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -25,10 +25,7 @@ public class IntTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(Integer value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(value); - } - return serializer.serializeNull(); + return serializer.serialize(value); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index fc499c7e4f2..a233812be01 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -25,10 +25,7 @@ public class LongTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(Long value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(value); - } - return serializer.serializeNull(); + return serializer.serialize(value); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index 11a55699cb4..c45260d16de 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -26,10 +26,7 @@ public class NumberTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(Number value, PersistedDataSerializer serializer) { - if (value != null) { - return serializer.serialize(value.doubleValue()); - } - return serializer.serializeNull(); + return serializer.serialize(value.doubleValue()); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index a122de8ff76..d6ba6daf907 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -50,9 +50,6 @@ public ObjectFieldMapTypeHandler(ObjectConstructor constructor, Map mappedData = Maps.newLinkedHashMap(); for (Map.Entry> entry : mappedFields.entrySet()) { Field field = entry.getKey(); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index f03f5569aee..f027fe8d2f6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -25,11 +25,7 @@ public class StringTypeHandler extends TypeHandler { @Override public PersistedData serializeNonNull(String value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value); - } + return serializer.serialize(value); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 42feee0df61..3aa86f6a442 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -30,11 +30,7 @@ public class ColorTypeHandler extends org.terasology.persistence.typeHandling.Ty @Override public PersistedData serializeNonNull(Color value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value.r(), value.g(), value.b(), value.a()); - } + return serializer.serialize(value.r(), value.g(), value.b(), value.a()); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index 34e227734d6..b62c826aa14 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -27,12 +27,7 @@ public class Quat4fTypeHandler extends org.terasology.persistence.typeHandling.T @Override public PersistedData serializeNonNull(Quat4f value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value.x, value.y, value.z, value.w); - } - + return serializer.serialize(value.x, value.y, value.z, value.w); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index 0c7791feebb..c04b890cabc 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -41,16 +41,12 @@ public Rect2fTypeHandler(TypeHandler vector2fTypeHandler) { @Override public PersistedData serializeNonNull(Rect2f value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - Map map = Maps.newLinkedHashMap(); + Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, vector2fTypeHandler.serialize(value.min(), serializer)); - map.put(SIZE_FIELD, vector2fTypeHandler.serialize(value.size(), serializer)); + map.put(MIN_FIELD, vector2fTypeHandler.serialize(value.min(), serializer)); + map.put(SIZE_FIELD, vector2fTypeHandler.serialize(value.size(), serializer)); - return serializer.serialize(map); - } + return serializer.serialize(map); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index ed8238c4953..f0d5bdc408e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -42,16 +42,12 @@ public Rect2iTypeHandler(TypeHandler vector2iTypeHandler) { @Override public PersistedData serializeNonNull(Rect2i value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - Map map = Maps.newLinkedHashMap(); + Map map = Maps.newLinkedHashMap(); - map.put(MIN_FIELD, vector2iTypeHandler.serialize(value.min(), serializer)); - map.put(SIZE_FIELD, vector2iTypeHandler.serialize(value.size(), serializer)); + map.put(MIN_FIELD, vector2iTypeHandler.serialize(value.min(), serializer)); + map.put(SIZE_FIELD, vector2iTypeHandler.serialize(value.size(), serializer)); - return serializer.serialize(map); - } + return serializer.serialize(map); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index 28dce3f23e4..721e7c65e41 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -28,12 +28,7 @@ public class Vector2fTypeHandler extends org.terasology.persistence.typeHandling @Override public PersistedData serializeNonNull(Vector2f value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value.x, value.y); - } - + return serializer.serialize(value.x, value.y); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index 5e4e742fceb..3c60b47418f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -27,11 +27,7 @@ public class Vector2iTypeHandler extends org.terasology.persistence.typeHandling @Override public PersistedData serializeNonNull(Vector2i value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value.x, value.y); - } + return serializer.serialize(value.x, value.y); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index 504bcdf183f..4612bf6b9b7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -27,11 +27,7 @@ public class Vector3fTypeHandler extends org.terasology.persistence.typeHandling @Override public PersistedData serializeNonNull(Vector3f value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value.x, value.y, value.z); - } + return serializer.serialize(value.x, value.y, value.z); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index 60ad78663cf..a8069102d5c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -27,11 +27,7 @@ public class Vector3iTypeHandler extends org.terasology.persistence.typeHandling @Override public PersistedData serializeNonNull(Vector3i value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value.x, value.y, value.z); - } + return serializer.serialize(value.x, value.y, value.z); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index 333e57c0b16..eba31946525 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -28,11 +28,7 @@ public class Vector4fTypeHandler extends org.terasology.persistence.typeHandling @Override public PersistedData serializeNonNull(Vector4f value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - return serializer.serialize(value.x, value.y, value.z, value.w); - } + return serializer.serialize(value.x, value.y, value.z, value.w); } @Override From ed4b491f963dd8851c9a1415fc5c7c6721caf416 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 11:11:52 +0530 Subject: [PATCH 042/141] Use LinkedHashMaps in ObjectFieldMapTypeHandlerFactory --- .../coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 2a88f1d41df..d2d396b1e48 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -49,7 +49,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati if (!Modifier.isAbstract(typeClass.getModifiers()) && !typeClass.isLocalClass() && !(typeClass.isMemberClass() && !Modifier.isStatic(typeClass.getModifiers()))) { - Map> fieldTypeHandlerMap = Maps.newHashMap(); + Map> fieldTypeHandlerMap = Maps.newLinkedHashMap(); getResolvedFields(typeInfo).forEach( (field, fieldType) -> From 40fe5ca2d72178badc3431bdf348a211720c5a05 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 11:15:01 +0530 Subject: [PATCH 043/141] Remove BorderTypeHandler (already handled by ObjectMapTypeHandler) --- .../mathTypes/BorderTypeHandler.java | 56 ------------------- .../rendering/nui/asset/UIFormat.java | 3 - 2 files changed, 59 deletions(-) delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java deleted file mode 100644 index fd259db077a..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/BorderTypeHandler.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.mathTypes; - -import com.google.common.collect.Maps; -import org.terasology.math.Border; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataMap; -import org.terasology.persistence.typeHandling.PersistedDataSerializer; - -import java.util.Map; - -/** - */ -public class BorderTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { - private static final String LEFT_FIELD = "left"; - private static final String RIGHT_FIELD = "right"; - private static final String TOP_FIELD = "top"; - private static final String BOTTOM_FIELD = "bottom"; - - @Override - public PersistedData serializeNonNull(Border value, PersistedDataSerializer serializer) { - if (value != null) { - Map map = Maps.newLinkedHashMap(); - map.put(LEFT_FIELD, serializer.serialize(value.getLeft())); - map.put(RIGHT_FIELD, serializer.serialize(value.getRight())); - map.put(TOP_FIELD, serializer.serialize(value.getTop())); - map.put(BOTTOM_FIELD, serializer.serialize(value.getBottom())); - return serializer.serialize(map); - } - - return serializer.serializeNull(); - } - - @Override - public Border deserialize(PersistedData data) { - if (!data.isNull() && data.isValueMap()) { - PersistedDataMap map = data.getAsValueMap(); - return new Border(map.getAsInteger(LEFT_FIELD), map.getAsInteger(RIGHT_FIELD), map.getAsInteger(TOP_FIELD), map.getAsInteger(BOTTOM_FIELD)); - } - return null; - } -} diff --git a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java index 1c96ca1fc34..9cedcdc29a8 100644 --- a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java +++ b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java @@ -34,12 +34,10 @@ import org.terasology.assets.format.AssetDataFile; import org.terasology.assets.module.annotations.RegisterAssetFileFormat; import org.terasology.i18n.TranslationSystem; -import org.terasology.math.Border; import org.terasology.persistence.ModuleContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; import org.terasology.persistence.typeHandling.gson.GsonTypeSerializationLibraryAdapterFactory; -import org.terasology.persistence.typeHandling.mathTypes.BorderTypeHandler; import org.terasology.reflection.metadata.ClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; import org.terasology.registry.CoreRegistry; @@ -98,7 +96,6 @@ public UIData load(JsonElement element, Locale otherLocale) throws IOException { TranslationSystem translationSystem = CoreRegistry.get(TranslationSystem.class); TypeSerializationLibrary library = new TypeSerializationLibrary(CoreRegistry.get(TypeSerializationLibrary.class)); library.addTypeHandler(UISkin.class, new AssetTypeHandler<>(UISkin.class)); - library.addTypeHandler(Border.class, new BorderTypeHandler()); GsonBuilder gsonBuilder = new GsonBuilder() .registerTypeAdapterFactory(new GsonTypeSerializationLibraryAdapterFactory(library)) From 00b3a8f2bbf3185e61dfeb81f9b8e6f43363fe14 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 11:20:06 +0530 Subject: [PATCH 044/141] Remove Region3iTypeHandler (already handled by ObjectMapTypeHandler) --- .../TypeSerializationLibrary.java | 2 - .../mathTypes/Region3iTypeHandler.java | 70 ------------------- .../factories/Region3iTypeHandlerFactory.java | 46 ------------ 3 files changed, 118 deletions(-) delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java delete mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index c9293f8df8c..112bc025512 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -57,7 +57,6 @@ import org.terasology.persistence.typeHandling.mathTypes.Vector4fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2fTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2iTypeHandlerFactory; -import org.terasology.persistence.typeHandling.mathTypes.factories.Region3iTypeHandlerFactory; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.metadata.ClassMetadata; @@ -158,7 +157,6 @@ public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory facto serializationLibrary.addTypeHandler(Vector2i.class, new Vector2iTypeHandler()); serializationLibrary.addTypeHandlerFactory(new Rect2iTypeHandlerFactory()); serializationLibrary.addTypeHandlerFactory(new Rect2fTypeHandlerFactory()); - serializationLibrary.addTypeHandlerFactory(new Region3iTypeHandlerFactory()); serializationLibrary.addTypeHandler(Prefab.class, new PrefabTypeHandler()); serializationLibrary.addTypeHandler(IntegerRange.class, new IntegerRangeHandler()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java deleted file mode 100644 index 852defbf04b..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Region3iTypeHandler.java +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright 2013 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.mathTypes; - -import com.google.common.collect.Maps; -import org.terasology.engine.module.UriUtil; -import org.terasology.math.Region3i; -import org.terasology.math.geom.Vector3i; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataMap; -import org.terasology.persistence.typeHandling.PersistedDataSerializer; -import org.terasology.persistence.typeHandling.TypeHandler; - -import java.util.Map; - -/** - */ -public class Region3iTypeHandler extends TypeHandler { - - private static final String MIN_FIELD = UriUtil.normalise("min"); - private static final String SIZE_FIELD = UriUtil.normalise("size"); - - private TypeHandler vector3iTypeHandler; - - public Region3iTypeHandler(TypeHandler vector3iTypeHandler) { - this.vector3iTypeHandler = vector3iTypeHandler; - } - - @Override - public PersistedData serializeNonNull(Region3i value, PersistedDataSerializer serializer) { - if (value == null) { - return serializer.serializeNull(); - } else { - Map map = Maps.newLinkedHashMap(); - - map.put(MIN_FIELD, vector3iTypeHandler.serialize(value.min(), serializer)); - map.put(SIZE_FIELD, vector3iTypeHandler.serialize(value.size(), serializer)); - - return serializer.serialize(map); - } - } - - @Override - public Region3i deserialize(PersistedData data) { - if (!data.isNull() && data.isValueMap()) { - PersistedDataMap map = data.getAsValueMap(); - - Vector3i min = vector3iTypeHandler.deserialize(map.get(MIN_FIELD)); - Vector3i size = vector3iTypeHandler.deserialize(map.get(SIZE_FIELD)); - - return Region3i.createFromMinAndSize(min, size); - } - return null; - } - -} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java deleted file mode 100644 index e7b2866e1ae..00000000000 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Region3iTypeHandlerFactory.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright 2018 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.mathTypes.factories; - -import com.google.common.base.Preconditions; -import org.terasology.math.Region3i; -import org.terasology.math.geom.Vector3i; -import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.mathTypes.Region3iTypeHandler; -import org.terasology.reflection.TypeInfo; - -import java.util.Optional; - -public class Region3iTypeHandlerFactory implements TypeHandlerFactory { - @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { - if (!typeInfo.equals(TypeInfo.of(Region3i.class))) { - return Optional.empty(); - } - - TypeHandler vector3iTypeHandler = typeSerializationLibrary.getTypeHandler(Vector3i.class); - - Preconditions.checkNotNull(vector3iTypeHandler, "No Vector2f type handler found"); - - Region3iTypeHandler region3iTypeHandler = - new Region3iTypeHandler(vector3iTypeHandler); - - return Optional.of((TypeHandler) region3iTypeHandler); - - } -} From 583ea07c9f0763b7b0912048eb20f0750befb192 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 15:54:37 +0530 Subject: [PATCH 045/141] Make TypeHandler.deserialize return Optional --- .../TypeHandlingIntegrationTest.java | 6 +- .../EnumTypeHandlerSerializerTest.java | 6 +- .../extensionTypes/ColorTypeHandlerTest.java | 4 +- .../NetEntityRefTypeHandler.java | 10 ++- .../persistence/typeHandling/Serializer.java | 2 +- .../StringRepresentationTypeHandler.java | 8 +- .../persistence/typeHandling/TypeHandler.java | 7 +- .../coreTypes/BooleanTypeHandler.java | 8 +- .../coreTypes/ByteArrayTypeHandler.java | 8 +- .../coreTypes/ByteTypeHandler.java | 10 ++- .../coreTypes/CollectionTypeHandler.java | 8 +- .../coreTypes/DoubleTypeHandler.java | 8 +- .../coreTypes/EnumTypeHandler.java | 7 +- .../coreTypes/FloatTypeHandler.java | 8 +- .../coreTypes/IntTypeHandler.java | 8 +- .../coreTypes/LongTypeHandler.java | 8 +- .../coreTypes/NumberTypeHandler.java | 8 +- .../coreTypes/ObjectFieldMapTypeHandler.java | 15 ++-- .../RuntimeDelegatingTypeHandler.java | 3 +- .../coreTypes/StringMapTypeHandler.java | 18 +++-- .../coreTypes/StringTypeHandler.java | 8 +- .../extensionTypes/ColorTypeHandler.java | 11 ++- .../extensionTypes/EntityRefTypeHandler.java | 7 +- .../gson/GsonTypeHandlerAdapter.java | 2 +- .../gson/LegacyGsonTypeHandlerAdapter.java | 2 +- .../mathTypes/Quat4fTypeHandler.java | 8 +- .../mathTypes/Rect2fTypeHandler.java | 19 +++-- .../mathTypes/Rect2iTypeHandler.java | 19 +++-- .../mathTypes/Vector2fTypeHandler.java | 8 +- .../mathTypes/Vector2iTypeHandler.java | 8 +- .../mathTypes/Vector3fTypeHandler.java | 8 +- .../mathTypes/Vector3iTypeHandler.java | 8 +- .../mathTypes/Vector4fTypeHandler.java | 8 +- .../recording/RecordedEventSerializer.java | 74 ++++++++++--------- 34 files changed, 213 insertions(+), 137 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java index 839e2d62992..9482f858164 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java @@ -41,7 +41,7 @@ import static org.junit.Assert.assertEquals; public class TypeHandlingIntegrationTest { - private static final String INSTANCE_JSON = "{\"list\":[50,51,-52,-53],\"animals\":[{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Dog\",\"@value\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Cheetah\",\"@value\":{\"name\":\"Cheetah\",\"spotColor\":[255,0,255,255]}}],\"data\":-559038737}"; + private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Dog\",\"@value\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Cheetah\",\"@value\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; private static final SomeClass INSTANCE = new SomeClass<>(0xdeadbeef); @@ -79,7 +79,7 @@ public void testJsonDeserialize() { PersistedData persistedData = new GsonPersistedData(jsonElement); - SomeClass deserializedInstance = typeHandler.deserialize(persistedData); + SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); assertEquals(INSTANCE, deserializedInstance); } @@ -105,7 +105,7 @@ public void testProtobufSerializeDeserialize() throws IOException { } persistedData = new ProtobufPersistedData(value); - SomeClass deserializedInstance = typeHandler.deserialize(persistedData); + SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); assertEquals(INSTANCE, deserializedInstance); } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java index c72ad0f9670..b3bdc8a2f59 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandlerSerializerTest.java @@ -20,6 +20,7 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -42,8 +43,7 @@ public void testNullValue() throws Exception { PersistedData serializedNull = handler.serialize(null, persistedDataSerializer); assertEquals(nullData, serializedNull); - TestEnum deserializedValue = handler.deserialize(nullData); - assertEquals(null, deserializedValue); + assertFalse(handler.deserialize(nullData).isPresent()); } @Test @@ -58,7 +58,7 @@ public void testNonNullValue() throws Exception { PersistedData serializedNonNull = handler.serialize(TestEnum.NON_NULL, persistedDataSerializer); assertEquals(data, serializedNonNull); - TestEnum deserializedValue = handler.deserialize(data); + TestEnum deserializedValue = handler.deserialize(data).get(); assertEquals(TestEnum.NON_NULL, deserializedValue); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java index 9858c1b239d..bb1c7660384 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandlerTest.java @@ -44,7 +44,7 @@ public void testSerialize() { @Test public void testDeserializeHex() { PersistedData data = new PersistedString("DEADBEEF"); - Color color = handler.deserialize(data); + Color color = handler.deserialize(data).get(); Assert.assertEquals(0xDEADBEEF, color.rgba()); } @@ -52,7 +52,7 @@ public void testDeserializeHex() { public void testDeserializeArray() { JsonArray array = new Gson().fromJson("[12, 34, 56, 78]", JsonArray.class); PersistedData data = new GsonPersistedDataArray(array); - Color color = handler.deserialize(data); + Color color = handler.deserialize(data).get(); Assert.assertEquals(12, color.r()); Assert.assertEquals(34, color.g()); Assert.assertEquals(56, color.b()); diff --git a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java index 97c7068bed7..fc211051225 100644 --- a/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/network/serialization/NetEntityRefTypeHandler.java @@ -28,6 +28,8 @@ import org.terasology.world.BlockEntityRegistry; import org.terasology.world.block.BlockComponent; +import java.util.Optional; + /** * This type handler encodes EntityRef for network transferals. For normal entities, the Network Id of the entity is used. * For block entities the block position is used instead (this allows overriding simulated block entities). @@ -57,19 +59,19 @@ public PersistedData serializeNonNull(EntityRef value, PersistedDataSerializer s } @Override - public EntityRef deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray array = data.getAsArray(); if (array.isNumberArray() && array.size() == 3) { TIntList items = data.getAsArray().getAsIntegerArray(); Vector3i pos = new Vector3i(items.get(0), items.get(1), items.get(2)); - return blockEntityRegistry.getBlockEntityAt(pos); + return Optional.ofNullable(blockEntityRegistry.getBlockEntityAt(pos)); } } if (data.isNumber()) { - return networkSystem.getEntity(data.getAsInteger()); + return Optional.ofNullable(networkSystem.getEntity(data.getAsInteger())); } - return EntityRef.NULL; + return Optional.ofNullable(EntityRef.NULL); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java index 1c3fa5055a8..a3b7f622322 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java @@ -93,7 +93,7 @@ public void deserializeOnto(Object target, FieldMetadata fieldMetadata, Pe logger.error("No type handler for type {} used by {}::{}", fieldMetadata.getType(), target.getClass(), fieldMetadata); } else { try { - Object deserializedValue = handler.deserialize(data); + Object deserializedValue = handler.deserialize(data).orElse(null); fieldMetadata.setValue(target, deserializedValue); } catch (DeserializationException e) { logger.error("Unable to deserialize field '{}' from '{}'", fieldMetadata.getName(), data.toString(), e); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java index 471b5933a69..8f8b08409da 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/StringRepresentationTypeHandler.java @@ -15,6 +15,8 @@ */ package org.terasology.persistence.typeHandling; +import java.util.Optional; + /** */ public abstract class StringRepresentationTypeHandler extends TypeHandler { @@ -30,11 +32,11 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize } @Override - public T deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isString()) { - return getFromString(data.getAsString()); + return Optional.ofNullable(getFromString(data.getAsString())); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index b7e61c241a7..46d8b2074d0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -15,6 +15,8 @@ */ package org.terasology.persistence.typeHandling; +import java.util.Optional; + /** * Serializes objects of type {@link T} to and from a {@link PersistedData}. */ @@ -50,8 +52,7 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { * Deserializes a single value. * * @param data The persisted data to deserialize from - * @return The deserialized value. - * @throws org.terasology.persistence.typeHandling.DeserializationException if there was an error deserializing the data + * @return The deserialized value. {@link Optional#empty()} if the value could not be deserialized. */ - public abstract T deserialize(PersistedData data); + public abstract Optional deserialize(PersistedData data); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java index 1775e122b79..dd05b9311b5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/BooleanTypeHandler.java @@ -19,6 +19,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class BooleanTypeHandler extends TypeHandler { @@ -29,11 +31,11 @@ public PersistedData serializeNonNull(Boolean value, PersistedDataSerializer ser } @Override - public Boolean deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isBoolean()) { - return data.getAsBoolean(); + return Optional.of(data.getAsBoolean()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index 9e394a32c38..c6ae45e720f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -18,6 +18,8 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import java.util.Optional; + public class ByteArrayTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @Override public PersistedData serializeNonNull(byte[] value, PersistedDataSerializer serializer) { @@ -25,11 +27,11 @@ public PersistedData serializeNonNull(byte[] value, PersistedDataSerializer seri } @Override - public byte[] deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isBytes()) { - return data.getAsBytes(); + return Optional.of(data.getAsBytes()); } else { - return null; + return Optional.empty(); } } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java index 22c39d025ac..d9429609687 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteTypeHandler.java @@ -19,6 +19,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class ByteTypeHandler extends TypeHandler { @@ -29,14 +31,14 @@ public PersistedData serializeNonNull(Byte value, PersistedDataSerializer serial } @Override - public Byte deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isBytes()) { - return data.getAsBytes()[0]; + return Optional.of(data.getAsBytes()[0]); } else if (data.isNumber()) { - return (byte) data.getAsInteger(); + return Optional.of((byte) data.getAsInteger()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java index 682a2f08e9f..9d01719cccb 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -23,6 +23,7 @@ import java.util.Collection; import java.util.List; +import java.util.Optional; public class CollectionTypeHandler extends TypeHandler> { private TypeHandler elementTypeHandler; @@ -45,13 +46,14 @@ public PersistedData serializeNonNull(Collection value, PersistedDataSerializ } @Override - public Collection deserialize(PersistedData data) { + public Optional> deserialize(PersistedData data) { Collection collection = constructor.construct(); for (PersistedData item : data.getAsArray()) { - collection.add(elementTypeHandler.deserialize(item)); + Optional element = elementTypeHandler.deserialize(item); + element.ifPresent(collection::add); } - return collection; + return Optional.ofNullable(collection); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java index 1ed4a4f4c25..9ed0d6b77f1 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/DoubleTypeHandler.java @@ -19,6 +19,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class DoubleTypeHandler extends TypeHandler { @@ -29,11 +31,11 @@ public PersistedData serializeNonNull(Double value, PersistedDataSerializer seri } @Override - public Double deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isNumber()) { - return data.getAsDouble(); + return Optional.of(data.getAsDouble()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java index 86711999d94..0eb8ae6d2bc 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/EnumTypeHandler.java @@ -24,6 +24,7 @@ import java.util.Locale; import java.util.Map; +import java.util.Optional; /** */ @@ -46,15 +47,15 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize } @Override - public T deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isString()) { T result = caseInsensitiveLookup.get(data.getAsString().toLowerCase(Locale.ENGLISH)); if (result == null) { logger.warn("Unknown enum value: '{}' for enum {}", data.getAsString(), enumType.getSimpleName()); } - return result; + return Optional.ofNullable(result); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java index aa0b6fb2185..869d89aeb15 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/FloatTypeHandler.java @@ -19,6 +19,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class FloatTypeHandler extends TypeHandler { @@ -29,11 +31,11 @@ public PersistedData serializeNonNull(Float value, PersistedDataSerializer seria } @Override - public Float deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isNumber()) { - return data.getAsFloat(); + return Optional.of(data.getAsFloat()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java index bb52e130f64..0047a84acb5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/IntTypeHandler.java @@ -19,6 +19,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class IntTypeHandler extends TypeHandler { @@ -29,11 +31,11 @@ public PersistedData serializeNonNull(Integer value, PersistedDataSerializer ser } @Override - public Integer deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isNumber()) { - return data.getAsInteger(); + return Optional.of(data.getAsInteger()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java index a233812be01..287375681da 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/LongTypeHandler.java @@ -19,6 +19,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class LongTypeHandler extends TypeHandler { @@ -29,11 +31,11 @@ public PersistedData serializeNonNull(Long value, PersistedDataSerializer serial } @Override - public Long deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isNumber()) { - return data.getAsLong(); + return Optional.of(data.getAsLong()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java index c45260d16de..2b979fc6664 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/NumberTypeHandler.java @@ -20,6 +20,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class NumberTypeHandler extends TypeHandler { @@ -30,11 +32,11 @@ public PersistedData serializeNonNull(Number value, PersistedDataSerializer seri } @Override - public Number deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isNumber()) { - return data.getAsDouble(); + return Optional.of(data.getAsDouble()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index d6ba6daf907..49ec302ad20 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -27,6 +27,7 @@ import java.lang.reflect.Field; import java.util.Map; import java.util.Objects; +import java.util.Optional; /** * Serializes objects as a fieldName -> fieldValue map. It is used as the last resort while serializing an @@ -75,7 +76,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize } @Override - public T deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { try { T result = constructor.construct(); for (Map.Entry entry : data.getAsValueMap().entrySet()) { @@ -88,14 +89,18 @@ public T deserialize(PersistedData data) { } TypeHandler handler = mappedFields.get(field); - Object fieldValue = handler.deserialize(entry.getValue()); + Optional fieldValue = handler.deserialize(entry.getValue()); - field.set(result, fieldValue); + if (fieldValue.isPresent()) { + field.set(result, fieldValue.get()); + } else { + logger.error("Could not deserialize field {}", field.getName()); + } } - return result; + return Optional.ofNullable(result); } catch (Exception e) { logger.error("Unable to deserialize {}", data, e); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 0fded72f080..5d912960d7e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -26,6 +26,7 @@ import org.terasology.reflection.TypeInfo; import java.util.Map; +import java.util.Optional; /** * Delegates serialization of a value to a handler of its runtime type if needed. It is used in @@ -120,7 +121,7 @@ private static Class getRuntimeTypeIfMoreSpecific(TypeInfo typeInfo, T } @Override - public T deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (!data.isValueMap()) { return delegateHandler.deserialize(data); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java index 028f33ab213..f03c4e50c4e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringMapTypeHandler.java @@ -21,6 +21,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; +import java.util.Optional; /** */ @@ -45,13 +46,18 @@ public PersistedData serializeNonNull(Map value, PersistedDataSeriali } @Override - public Map deserialize(PersistedData data) { + public Optional> deserialize(PersistedData data) { + if (!data.isValueMap()) { + return Optional.empty(); + } + Map result = Maps.newLinkedHashMap(); - if (data.isValueMap()) { - for (Map.Entry item : data.getAsValueMap().entrySet()) { - result.put(item.getKey(), contentsHandler.deserialize(item.getValue())); - } + + for (Map.Entry item : data.getAsValueMap().entrySet()) { + Optional optionalValue = contentsHandler.deserialize(item.getValue()); + optionalValue.ifPresent(value -> result.put(item.getKey(), value)); } - return result; + + return Optional.of(result); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java index f027fe8d2f6..eb8b910789a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/StringTypeHandler.java @@ -19,6 +19,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import java.util.Optional; + /** */ public class StringTypeHandler extends TypeHandler { @@ -29,11 +31,11 @@ public PersistedData serializeNonNull(String value, PersistedDataSerializer seri } @Override - public String deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isString()) { - return data.getAsString(); + return Optional.ofNullable(data.getAsString()); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java index 3aa86f6a442..3362f9799d8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/ColorTypeHandler.java @@ -22,6 +22,8 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.rendering.nui.Color; +import java.util.Optional; + /** * Serializes {@link Color} instances to an int array [r, g, b, a]. * De-serializing also supports hexadecimal strings such as "AAAAAAFF". @@ -34,18 +36,19 @@ public PersistedData serializeNonNull(Color value, PersistedDataSerializer seria } @Override - public Color deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 3) { TIntList vals = dataArray.getAsIntegerArray(); - return new Color(vals.get(0), vals.get(1), vals.get(2), vals.get(3)); + return Optional.of(new Color(vals.get(0), vals.get(1), vals.get(2), vals.get(3))); } } if (data.isString()) { String value = data.getAsString(); - return new Color((int) Long.parseLong(value, 16)); + return Optional.of(new Color((int) Long.parseLong(value, 16))); } - throw new DeserializationException("Expecting integer array or hex-string, but found: " + String.valueOf(data)); + + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java index 8f5354f89db..01a26aa49c8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/EntityRefTypeHandler.java @@ -24,6 +24,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import java.util.List; +import java.util.Optional; /** */ @@ -44,11 +45,11 @@ public PersistedData serializeNonNull(EntityRef value, PersistedDataSerializer s } @Override - public EntityRef deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isNumber()) { - return entityManager.getEntity(data.getAsLong()); + return Optional.ofNullable(entityManager.getEntity(data.getAsLong())); } - return EntityRef.NULL; + return Optional.ofNullable(EntityRef.NULL); } private void addEntitiesFromLongArray(List result, PersistedDataArray array) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java index b1d29c25b50..9aad26231c4 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java @@ -62,7 +62,7 @@ public final class GsonTypeHandlerAdapter extends TypeAdapter { .getElement(); this.deserializer = (json, typeOfT, context) -> - typeHandler.deserialize(new GsonPersistedData(json)); + typeHandler.deserialize(new GsonPersistedData(json)).orElse(null); this.gson = gson; this.typeToken = typeToken; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java index 6c9e5e18e21..5954b2c71db 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java @@ -43,7 +43,7 @@ public LegacyGsonTypeHandlerAdapter(TypeHandler handler) { @Override public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { - return typeHandler.deserialize(new GsonPersistedData(json)); + return typeHandler.deserialize(new GsonPersistedData(json)).orElse(null); } @Override diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java index b62c826aa14..ce6568d621f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Quat4fTypeHandler.java @@ -21,6 +21,8 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import java.util.Optional; + /** */ public class Quat4fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @@ -31,14 +33,14 @@ public PersistedData serializeNonNull(Quat4f value, PersistedDataSerializer seri } @Override - public Quat4f deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 3) { TFloatList floats = dataArray.getAsFloatArray(); - return new Quat4f(floats.get(0), floats.get(1), floats.get(2), floats.get(3)); + return Optional.of(new Quat4f(floats.get(0), floats.get(1), floats.get(2), floats.get(3))); } } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index c04b890cabc..3c1df740b7a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -19,12 +19,14 @@ import com.google.common.collect.Maps; import org.terasology.math.geom.Rect2f; import org.terasology.math.geom.Vector2f; +import org.terasology.persistence.typeHandling.DeserializationException; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; +import java.util.Optional; /** */ @@ -50,16 +52,23 @@ public PersistedData serializeNonNull(Rect2f value, PersistedDataSerializer seri } @Override - public Rect2f deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2f min = vector2fTypeHandler.deserialize(map.get(MIN_FIELD)); - Vector2f size = vector2fTypeHandler.deserialize(map.get(SIZE_FIELD)); + Vector2f min = vector2fTypeHandler.deserialize(map.get(MIN_FIELD)) + .orElseThrow( + () -> new DeserializationException("Could not deserialize Rect2f." + MIN_FIELD) + ); - return Rect2f.createFromMinAndSize(min, size); + Vector2f size = vector2fTypeHandler.deserialize(map.get(SIZE_FIELD)) + .orElseThrow( + () -> new DeserializationException("Could not deserialize Rect2f." + SIZE_FIELD) + ); + + return Optional.ofNullable(Rect2f.createFromMinAndSize(min, size)); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index f0d5bdc408e..e2d9e5303a0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -20,12 +20,14 @@ import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector2i; +import org.terasology.persistence.typeHandling.DeserializationException; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import java.util.Map; +import java.util.Optional; /** */ @@ -51,16 +53,23 @@ public PersistedData serializeNonNull(Rect2i value, PersistedDataSerializer seri } @Override - public Rect2i deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2i min = vector2iTypeHandler.deserialize(map.get(MIN_FIELD)); - Vector2i size = vector2iTypeHandler.deserialize(map.get(SIZE_FIELD)); + Vector2i min = vector2iTypeHandler.deserialize(map.get(MIN_FIELD)) + .orElseThrow( + () -> new DeserializationException("Could not deserialize Rect2i." + MIN_FIELD) + ); - return Rect2i.createFromMinAndSize(min, size); + Vector2i size = vector2iTypeHandler.deserialize(map.get(SIZE_FIELD)) + .orElseThrow( + () -> new DeserializationException("Could not deserialize Rect2i." + SIZE_FIELD) + ); + + return Optional.ofNullable(Rect2i.createFromMinAndSize(min, size)); } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java index 721e7c65e41..bb1ca2abd94 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2fTypeHandler.java @@ -22,6 +22,8 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import java.util.Optional; + /** */ public class Vector2fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @@ -32,14 +34,14 @@ public PersistedData serializeNonNull(Vector2f value, PersistedDataSerializer se } @Override - public Vector2f deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 1) { TFloatList floats = dataArray.getAsFloatArray(); - return new Vector2f(floats.get(0), floats.get(1)); + return Optional.of(new Vector2f(floats.get(0), floats.get(1))); } } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java index 3c60b47418f..21b8be00bce 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector2iTypeHandler.java @@ -21,6 +21,8 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import java.util.Optional; + /** */ public class Vector2iTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @@ -31,14 +33,14 @@ public PersistedData serializeNonNull(Vector2i value, PersistedDataSerializer se } @Override - public Vector2i deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 1) { TIntList ints = dataArray.getAsIntegerArray(); - return new Vector2i(ints.get(0), ints.get(1)); + return Optional.of(new Vector2i(ints.get(0), ints.get(1))); } } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java index 4612bf6b9b7..0865a3cd61b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3fTypeHandler.java @@ -21,6 +21,8 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import java.util.Optional; + /** */ public class Vector3fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @@ -31,14 +33,14 @@ public PersistedData serializeNonNull(Vector3f value, PersistedDataSerializer se } @Override - public Vector3f deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 2) { TFloatList floats = dataArray.getAsFloatArray(); - return new Vector3f(floats.get(0), floats.get(1), floats.get(2)); + return Optional.of(new Vector3f(floats.get(0), floats.get(1), floats.get(2))); } } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java index a8069102d5c..5fa568ab04c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector3iTypeHandler.java @@ -21,6 +21,8 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import java.util.Optional; + /** */ public class Vector3iTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @@ -31,14 +33,14 @@ public PersistedData serializeNonNull(Vector3i value, PersistedDataSerializer se } @Override - public Vector3i deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 2) { TIntList ints = dataArray.getAsIntegerArray(); - return new Vector3i(ints.get(0), ints.get(1), ints.get(2)); + return Optional.of(new Vector3i(ints.get(0), ints.get(1), ints.get(2))); } } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java index eba31946525..c7ffaece261 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Vector4fTypeHandler.java @@ -22,6 +22,8 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import java.util.Optional; + /** */ public class Vector4fTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { @@ -32,14 +34,14 @@ public PersistedData serializeNonNull(Vector4f value, PersistedDataSerializer se } @Override - public Vector4f deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (data.isArray()) { PersistedDataArray dataArray = data.getAsArray(); if (dataArray.isNumberArray() && dataArray.size() > 3) { TFloatList floats = dataArray.getAsFloatArray(); - return new Vector4f(floats.get(0), floats.get(1), floats.get(2), floats.get(3)); + return Optional.of(new Vector4f(floats.get(0), floats.get(1), floats.get(2), floats.get(3))); } } - return null; + return Optional.empty(); } } diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index a62440da288..ed842f6dafa 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -17,9 +17,9 @@ import com.google.gson.Gson; import com.google.gson.GsonBuilder; -import com.google.gson.JsonObject; import com.google.gson.JsonArray; import com.google.gson.JsonElement; +import com.google.gson.JsonObject; import com.google.gson.JsonParser; import com.google.gson.stream.JsonWriter; import gnu.trove.list.TFloatList; @@ -34,7 +34,20 @@ import org.terasology.entitySystem.entity.LowLevelEntityManager; import org.terasology.entitySystem.entity.internal.EngineEntityManager; import org.terasology.entitySystem.event.Event; +import org.terasology.input.BindAxisEvent; +import org.terasology.input.BindButtonEvent; +import org.terasology.input.ButtonState; +import org.terasology.input.Keyboard; +import org.terasology.input.MouseInput; import org.terasology.input.cameraTarget.CameraTargetChangedEvent; +import org.terasology.input.events.InputEvent; +import org.terasology.input.events.KeyDownEvent; +import org.terasology.input.events.KeyEvent; +import org.terasology.input.events.KeyRepeatEvent; +import org.terasology.input.events.KeyUpEvent; +import org.terasology.input.events.MouseAxisEvent; +import org.terasology.input.events.MouseButtonEvent; +import org.terasology.input.events.MouseWheelEvent; import org.terasology.logic.characters.CharacterMoveInputEvent; import org.terasology.logic.characters.GetMaxSpeedEvent; import org.terasology.logic.characters.MovementMode; @@ -43,6 +56,7 @@ import org.terasology.math.geom.Vector3f; import org.terasology.math.geom.Vector3i; import org.terasology.module.ModuleEnvironment; +import org.terasology.naming.Name; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; @@ -52,21 +66,6 @@ import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; -import org.terasology.naming.Name; -import org.terasology.input.BindAxisEvent; -import org.terasology.input.BindButtonEvent; -import org.terasology.input.events.InputEvent; -import org.terasology.input.events.KeyUpEvent; -import org.terasology.input.events.KeyRepeatEvent; -import org.terasology.input.events.KeyDownEvent; -import org.terasology.input.events.KeyEvent; -import org.terasology.input.events.MouseAxisEvent; -import org.terasology.input.events.MouseButtonEvent; -import org.terasology.input.events.MouseWheelEvent; -import org.terasology.input.ButtonState; -import org.terasology.input.Keyboard; -import org.terasology.input.MouseInput; - import java.io.FileReader; import java.io.FileWriter; @@ -371,8 +370,8 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa } else if (className.equals(PlaySoundEvent.class.getName())) { float volume = jsonObject.get("volume").getAsFloat(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("sound")); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); - StaticSound sound = (StaticSound) handler.deserialize(data); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); + StaticSound sound = handler.deserialize(data).get(); result = new PlaySoundEvent(sound, volume); } else if (className.equals(CharacterMoveInputEvent.class.getName())) { long delta = jsonObject.get("delta").getAsLong(); @@ -390,9 +389,9 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa result = new CharacterMoveInputEvent(sequenceNumber, pitch, yaw, movementDirection, running, crouching, jumpRequested, delta); } else if (className.equals(GetMaxSpeedEvent.class.getName())) { float baseValue = jsonObject.get("baseValue").getAsFloat(); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); GsonPersistedData data = new GsonPersistedData(jsonObject.get("movementMode")); - MovementMode movementMode = (MovementMode) handler.deserialize(data); + MovementMode movementMode = handler.deserialize(data).get(); TFloatList modifiers = gson.fromJson(jsonObject.get("modifiers"), TFloatArrayList.class); TFloatList multipliers = gson.fromJson(jsonObject.get("multipliers"), TFloatArrayList.class); TFloatList postModifiers = gson.fromJson(jsonObject.get("postModifiers"), TFloatArrayList.class); @@ -420,11 +419,12 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = (InputEvent) clazz.getConstructor().newInstance(); } else if (clazz.equals(KeyDownEvent.class) || clazz.equals(KeyRepeatEvent.class) || clazz.equals(KeyUpEvent.class)) { //KeyEvent GsonPersistedData data = new GsonPersistedData(jsonObject.get("input")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); - Keyboard.Key input = (Keyboard.Key) typeHandler.deserialize(data); + TypeHandler keyTypeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); + Keyboard.Key input = keyTypeHandler.deserialize(data).get(); data = new GsonPersistedData(jsonObject.get("state")); - typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = (ButtonState) typeHandler.deserialize(data); + TypeHandler buttonStateTypeHandler = + typeSerializationLibrary.getTypeHandler(ButtonState.class); + ButtonState state = buttonStateTypeHandler.deserialize(data).get(); char keychar = jsonObject.get("keychar").getAsCharacter(); float delta = jsonObject.get("delta").getAsFloat(); KeyEvent aux; @@ -441,11 +441,13 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = aux; } else if (clazz.equals(MouseButtonEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("button")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(MouseInput.class); - MouseInput button = (MouseInput) typeHandler.deserialize(data); + TypeHandler mouseInputTypeHandler = + typeSerializationLibrary.getTypeHandler(MouseInput.class); + MouseInput button = mouseInputTypeHandler.deserialize(data).get(); data = new GsonPersistedData(jsonObject.get("state")); - typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = (ButtonState) typeHandler.deserialize(data); + TypeHandler buttonStateTypeHandler = + typeSerializationLibrary.getTypeHandler(ButtonState.class); + ButtonState state = buttonStateTypeHandler.deserialize(data).get(); JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); float delta = jsonObject.get("delta").getAsFloat(); @@ -454,8 +456,9 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = event; } else if (clazz.equals(MouseAxisEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("mouseAxis")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); - MouseAxisEvent.MouseAxis mouseAxis = (MouseAxisEvent.MouseAxis) typeHandler.deserialize(data); + TypeHandler typeHandler = + typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); + MouseAxisEvent.MouseAxis mouseAxis = typeHandler.deserialize(data).get(); float value = jsonObject.get("value").getAsFloat(); float delta = jsonObject.get("delta").getAsFloat(); MouseAxisEvent aux = MouseAxisEvent.create(mouseAxis, value, delta); @@ -486,15 +489,16 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); - TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = (ButtonState) typeHandler.deserialize(data); + TypeHandler buttonStateTypeHandler = + typeSerializationLibrary.getTypeHandler(ButtonState.class); + ButtonState state = buttonStateTypeHandler.deserialize(data).get(); float delta = jsonObject.get("delta").getAsFloat(); - typeHandler = typeSerializationLibrary.getTypeHandler(Name.class); + TypeHandler nameTypeHandler = typeSerializationLibrary.getTypeHandler(Name.class); JsonObject aux = jsonObject.get("id").getAsJsonObject(); data = new GsonPersistedData(aux.get("moduleName")); - Name moduleName = (Name) typeHandler.deserialize(data); + Name moduleName = nameTypeHandler.deserialize(data).get(); data = new GsonPersistedData(aux.get("objectName")); - Name objectName = (Name) typeHandler.deserialize(data); + Name objectName = nameTypeHandler.deserialize(data).get(); SimpleUri id = new SimpleUri(moduleName, objectName); event.prepare(id, state, delta); } From 70970c4a1525569ab6686c6b2124dc26bd7ba1ec Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 16:07:10 +0530 Subject: [PATCH 046/141] Add TypeHandler.deserializeOrNull, deserializeOrGet, deserializeOrThrow --- .../persistence/typeHandling/TypeHandler.java | 45 ++++++++++++++++++- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index 46d8b2074d0..107d3d607b3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -16,6 +16,7 @@ package org.terasology.persistence.typeHandling; import java.util.Optional; +import java.util.function.Supplier; /** * Serializes objects of type {@link T} to and from a {@link PersistedData}. @@ -49,10 +50,50 @@ public PersistedData serialize(T value, PersistedDataSerializer serializer) { } /** - * Deserializes a single value. + * Deserializes a single value to the type {@link T}. * - * @param data The persisted data to deserialize from + * @param data The persisted data to deserialize from. * @return The deserialized value. {@link Optional#empty()} if the value could not be deserialized. */ public abstract Optional deserialize(PersistedData data); + + /** + * Deserializes a single value to the type {@link T}. If the type was not serialized + * (i.e. {@link #deserialize(PersistedData)} returned {@link Optional#empty()}), null is returned. + * + * @param data The persisted data to deserialize from. + * @return The deserialized value. {@code null} if the value could not be deserialized. + */ + public final T deserializeOrNull(PersistedData data) { + return deserialize(data).orElse(null); + } + + /** + * Deserializes a single value to the type {@link T}. If the type was not serialized + * (i.e. {@link #deserialize(PersistedData)} returned {@link Optional#empty()}), the value retrieved + * from the {@link Supplier} is returned. + * + * @param data The persisted data to deserialize from. + * @param supplier The {@link Supplier} from which to retrieve the value to be returned if + * {@code data} could not be deserialized. + * @return The deserialized value. If the value could not be deserialized, the value returned by + * {@code supplier.get()} is returned. + */ + public final T deserializeOrGet(PersistedData data, Supplier supplier) { + return deserialize(data).orElseGet(supplier); + } + + /** + * Deserializes a single value to the type {@link T}. If the type was not serialized + * (i.e. {@link #deserialize(PersistedData)} returned {@link Optional#empty()}), a + * {@link DeserializationException} is thrown. + * + * @param data The persisted data to deserialize from. + * @return The deserialized value. + * @throws DeserializationException if {@code data} could not be deserialized to a value of type {@link T}. + */ + public final T deserializeOrThrow(PersistedData data) throws DeserializationException { + return deserialize(data) + .orElseThrow(() -> new DeserializationException("Unable to deserialize " + data)); + } } From ac5411c8ae4e1d33d24eb3a1da8561fc537d50e7 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 16:11:48 +0530 Subject: [PATCH 047/141] Add TypeHandler.deserializeOrNull usages --- .../org/terasology/persistence/typeHandling/Serializer.java | 2 +- .../persistence/typeHandling/gson/GsonTypeHandlerAdapter.java | 2 +- .../typeHandling/gson/LegacyGsonTypeHandlerAdapter.java | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java index a3b7f622322..17ffc15c526 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/Serializer.java @@ -93,7 +93,7 @@ public void deserializeOnto(Object target, FieldMetadata fieldMetadata, Pe logger.error("No type handler for type {} used by {}::{}", fieldMetadata.getType(), target.getClass(), fieldMetadata); } else { try { - Object deserializedValue = handler.deserialize(data).orElse(null); + Object deserializedValue = handler.deserializeOrNull(data); fieldMetadata.setValue(target, deserializedValue); } catch (DeserializationException e) { logger.error("Unable to deserialize field '{}' from '{}'", fieldMetadata.getName(), data.toString(), e); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java index 9aad26231c4..b720eb57d40 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerAdapter.java @@ -62,7 +62,7 @@ public final class GsonTypeHandlerAdapter extends TypeAdapter { .getElement(); this.deserializer = (json, typeOfT, context) -> - typeHandler.deserialize(new GsonPersistedData(json)).orElse(null); + typeHandler.deserializeOrNull(new GsonPersistedData(json)); this.gson = gson; this.typeToken = typeToken; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java index 5954b2c71db..93b914fb285 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/LegacyGsonTypeHandlerAdapter.java @@ -43,7 +43,7 @@ public LegacyGsonTypeHandlerAdapter(TypeHandler handler) { @Override public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { - return typeHandler.deserialize(new GsonPersistedData(json)).orElse(null); + return typeHandler.deserializeOrNull(new GsonPersistedData(json)); } @Override From 161f9000ffd83fbeb442b3f1d059e135305c8920 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 16:13:26 +0530 Subject: [PATCH 048/141] Add TypeHandler.deserializeOrThrow overload with error message --- .../persistence/typeHandling/TypeHandler.java | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java index 107d3d607b3..c53f2fa8657 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandler.java @@ -93,7 +93,21 @@ public final T deserializeOrGet(PersistedData data, Supplier supplier) { * @throws DeserializationException if {@code data} could not be deserialized to a value of type {@link T}. */ public final T deserializeOrThrow(PersistedData data) throws DeserializationException { + return deserializeOrThrow(data, "Unable to deserialize " + data); + } + + /** + * Deserializes a single value to the type {@link T}. If the type was not serialized + * (i.e. {@link #deserialize(PersistedData)} returned {@link Optional#empty()}), a + * {@link DeserializationException} is thrown. + * + * @param data The persisted data to deserialize from. + * @param errorMessage The error message to use if the value could not be deserialized. + * @return The deserialized value. + * @throws DeserializationException if {@code data} could not be deserialized to a value of type {@link T}. + */ + public final T deserializeOrThrow(PersistedData data, String errorMessage) throws DeserializationException { return deserialize(data) - .orElseThrow(() -> new DeserializationException("Unable to deserialize " + data)); + .orElseThrow(() -> new DeserializationException(errorMessage)); } } From 3783ecbcd7c050ff525729e50fa58c5e31d54475 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 16:20:56 +0530 Subject: [PATCH 049/141] Add TypeHandler.deserializeOrThrow usages --- .../mathTypes/Rect2fTypeHandler.java | 12 ++++------- .../mathTypes/Rect2iTypeHandler.java | 14 +++++-------- .../recording/RecordedEventSerializer.java | 20 +++++++++---------- 3 files changed, 19 insertions(+), 27 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java index 3c1df740b7a..5b0cba2bd33 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2fTypeHandler.java @@ -56,15 +56,11 @@ public Optional deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2f min = vector2fTypeHandler.deserialize(map.get(MIN_FIELD)) - .orElseThrow( - () -> new DeserializationException("Could not deserialize Rect2f." + MIN_FIELD) - ); + Vector2f min = vector2fTypeHandler.deserializeOrThrow(map.get(MIN_FIELD), + "Could not deserialize Rect2f." + MIN_FIELD); - Vector2f size = vector2fTypeHandler.deserialize(map.get(SIZE_FIELD)) - .orElseThrow( - () -> new DeserializationException("Could not deserialize Rect2f." + SIZE_FIELD) - ); + Vector2f size = vector2fTypeHandler.deserializeOrThrow(map.get(SIZE_FIELD), + "Could not deserialize Rect2f." + SIZE_FIELD); return Optional.ofNullable(Rect2f.createFromMinAndSize(min, size)); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java index e2d9e5303a0..9483553e115 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/Rect2iTypeHandler.java @@ -57,15 +57,11 @@ public Optional deserialize(PersistedData data) { if (!data.isNull() && data.isValueMap()) { PersistedDataMap map = data.getAsValueMap(); - Vector2i min = vector2iTypeHandler.deserialize(map.get(MIN_FIELD)) - .orElseThrow( - () -> new DeserializationException("Could not deserialize Rect2i." + MIN_FIELD) - ); - - Vector2i size = vector2iTypeHandler.deserialize(map.get(SIZE_FIELD)) - .orElseThrow( - () -> new DeserializationException("Could not deserialize Rect2i." + SIZE_FIELD) - ); + Vector2i min = vector2iTypeHandler.deserializeOrThrow(map.get(MIN_FIELD), + "Could not deserialize Rect2i." + MIN_FIELD); + + Vector2i size = vector2iTypeHandler.deserializeOrThrow(map.get(SIZE_FIELD), + "Could not deserialize Rect2i." + SIZE_FIELD); return Optional.ofNullable(Rect2i.createFromMinAndSize(min, size)); } diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index ed842f6dafa..bda911d1952 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -371,7 +371,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa float volume = jsonObject.get("volume").getAsFloat(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("sound")); TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); - StaticSound sound = handler.deserialize(data).get(); + StaticSound sound = handler.deserializeOrThrow(data); result = new PlaySoundEvent(sound, volume); } else if (className.equals(CharacterMoveInputEvent.class.getName())) { long delta = jsonObject.get("delta").getAsLong(); @@ -391,7 +391,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa float baseValue = jsonObject.get("baseValue").getAsFloat(); TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); GsonPersistedData data = new GsonPersistedData(jsonObject.get("movementMode")); - MovementMode movementMode = handler.deserialize(data).get(); + MovementMode movementMode = handler.deserializeOrThrow(data); TFloatList modifiers = gson.fromJson(jsonObject.get("modifiers"), TFloatArrayList.class); TFloatList multipliers = gson.fromJson(jsonObject.get("multipliers"), TFloatArrayList.class); TFloatList postModifiers = gson.fromJson(jsonObject.get("postModifiers"), TFloatArrayList.class); @@ -420,11 +420,11 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(KeyDownEvent.class) || clazz.equals(KeyRepeatEvent.class) || clazz.equals(KeyUpEvent.class)) { //KeyEvent GsonPersistedData data = new GsonPersistedData(jsonObject.get("input")); TypeHandler keyTypeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); - Keyboard.Key input = keyTypeHandler.deserialize(data).get(); + Keyboard.Key input = keyTypeHandler.deserializeOrThrow(data); data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = buttonStateTypeHandler.deserialize(data).get(); + ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); char keychar = jsonObject.get("keychar").getAsCharacter(); float delta = jsonObject.get("delta").getAsFloat(); KeyEvent aux; @@ -443,11 +443,11 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class GsonPersistedData data = new GsonPersistedData(jsonObject.get("button")); TypeHandler mouseInputTypeHandler = typeSerializationLibrary.getTypeHandler(MouseInput.class); - MouseInput button = mouseInputTypeHandler.deserialize(data).get(); + MouseInput button = mouseInputTypeHandler.deserializeOrThrow(data); data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = buttonStateTypeHandler.deserialize(data).get(); + ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); float delta = jsonObject.get("delta").getAsFloat(); @@ -458,7 +458,7 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class GsonPersistedData data = new GsonPersistedData(jsonObject.get("mouseAxis")); TypeHandler typeHandler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); - MouseAxisEvent.MouseAxis mouseAxis = typeHandler.deserialize(data).get(); + MouseAxisEvent.MouseAxis mouseAxis = typeHandler.deserializeOrThrow(data); float value = jsonObject.get("value").getAsFloat(); float delta = jsonObject.get("delta").getAsFloat(); MouseAxisEvent aux = MouseAxisEvent.create(mouseAxis, value, delta); @@ -491,14 +491,14 @@ private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject) GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = typeSerializationLibrary.getTypeHandler(ButtonState.class); - ButtonState state = buttonStateTypeHandler.deserialize(data).get(); + ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); float delta = jsonObject.get("delta").getAsFloat(); TypeHandler nameTypeHandler = typeSerializationLibrary.getTypeHandler(Name.class); JsonObject aux = jsonObject.get("id").getAsJsonObject(); data = new GsonPersistedData(aux.get("moduleName")); - Name moduleName = nameTypeHandler.deserialize(data).get(); + Name moduleName = nameTypeHandler.deserializeOrThrow(data); data = new GsonPersistedData(aux.get("objectName")); - Name objectName = nameTypeHandler.deserialize(data).get(); + Name objectName = nameTypeHandler.deserializeOrThrow(data); SimpleUri id = new SimpleUri(moduleName, objectName); event.prepare(id, state, delta); } From bee94160bf0b9c32504e0efe9c03d4cbd2e47c64 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 16:26:15 +0530 Subject: [PATCH 050/141] Return Optional.empty if data incorrect in TypeHandler.deserialize impls --- .../typeHandling/coreTypes/CollectionTypeHandler.java | 4 ++++ .../typeHandling/coreTypes/ObjectFieldMapTypeHandler.java | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java index 9d01719cccb..f160ab0e153 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CollectionTypeHandler.java @@ -47,6 +47,10 @@ public PersistedData serializeNonNull(Collection value, PersistedDataSerializ @Override public Optional> deserialize(PersistedData data) { + if (!data.isArray()) { + return Optional.empty(); + } + Collection collection = constructor.construct(); for (PersistedData item : data.getAsArray()) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 49ec302ad20..8afbc61260d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -77,6 +77,10 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize @Override public Optional deserialize(PersistedData data) { + if (!data.isValueMap()) { + return Optional.empty(); + } + try { T result = constructor.construct(); for (Map.Entry entry : data.getAsValueMap().entrySet()) { From 0f4f81a3eb8b4f972cde0e777a5ab72b6c1fdf73 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 31 Jul 2018 17:22:28 +0530 Subject: [PATCH 051/141] Add ArrayTypeHandler + Factory --- .../coreTypes/ArrayTypeHandlerTest.java | 83 +++++++++++++++++++ .../ArrayTypeHandlerFactoryTest.java | 74 +++++++++++++++++ .../TypeSerializationLibrary.java | 3 + .../coreTypes/ArrayTypeHandler.java | 68 +++++++++++++++ .../factories/ArrayTypeHandlerFactory.java | 60 ++++++++++++++ 5 files changed, 288 insertions(+) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandlerTest.java create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandlerTest.java new file mode 100644 index 00000000000..34133b3f439 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandlerTest.java @@ -0,0 +1,83 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import com.google.common.collect.Queues; +import com.google.gson.JsonArray; +import org.junit.Test; +import org.mockito.ArgumentMatcher; +import org.mockito.stubbing.Answer; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import org.terasology.persistence.typeHandling.gson.GsonPersistedDataArray; +import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.reflect.ObjectConstructor; + +import java.util.Collection; +import java.util.Collections; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.Mockito.*; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +public class ArrayTypeHandlerTest { + private static final int ARRAY_SIZE = 500; + + @Test + public void testSerialize() { + IntTypeHandler elementTypeHandler = mock(IntTypeHandler.class); + + ArrayTypeHandler typeHandler = new ArrayTypeHandler<>( + elementTypeHandler, + TypeInfo.of(Integer.class) + ); + + Integer[] array = new Integer[ARRAY_SIZE]; + final int[] c = {0}; + Collections.nCopies(array.length, -1).forEach(i -> array[c[0]++] = i); + + PersistedDataSerializer context = mock(PersistedDataSerializer.class); + + typeHandler.serialize(array, context); + + verify(elementTypeHandler, times(array.length)).serialize(any(), any()); + + verify(context).serialize(argThat((ArgumentMatcher>) argument -> + argument instanceof Collection && ((Collection) argument).size() == array.length)); + } + + @Test + public void testDeserialize() { + IntTypeHandler elementTypeHandler = mock(IntTypeHandler.class); + + ArrayTypeHandler typeHandler = new ArrayTypeHandler<>( + elementTypeHandler, + TypeInfo.of(Integer.class) + ); + + JsonArray jsonArray = new JsonArray(); + + for (Integer i : Collections.nCopies(ARRAY_SIZE, -1)) { + jsonArray.add(i); + } + + typeHandler.deserialize(new GsonPersistedDataArray(jsonArray)); + + verify(elementTypeHandler, times(jsonArray.size())).deserialize(any()); + } +} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java new file mode 100644 index 00000000000..af98ea5c579 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java @@ -0,0 +1,74 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.junit.Test; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.util.List; +import java.util.Optional; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public class ArrayTypeHandlerFactoryTest { + private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final ArrayTypeHandlerFactory typeHandlerFactory = new ArrayTypeHandlerFactory(); + + @Test + public void testArray() { + TypeInfo arrayTypeInfo = TypeInfo.of(int[].class); + + Optional> typeHandler = + typeHandlerFactory.create(arrayTypeInfo, typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof ArrayTypeHandler); + + // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType())); + } + + @Test + public void testGenericArray() { + TypeInfo[]> arrayTypeInfo = new TypeInfo[]>() {}; + + Optional[]>> typeHandler = + typeHandlerFactory.create(arrayTypeInfo, typeSerializationLibrary); + + assertTrue(typeHandler.isPresent()); + assertTrue(typeHandler.get() instanceof ArrayTypeHandler); + + // Verify that the List TypeHandler was loaded from the TypeSerializationLibrary + verify(typeSerializationLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType())); + } + + @Test + public void testNonArray() { + TypeInfo> arrayTypeInfo = new TypeInfo>() {}; + + Optional>> typeHandler = + typeHandlerFactory.create(arrayTypeInfo, typeSerializationLibrary); + + assertFalse(typeHandler.isPresent()); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 112bc025512..b0d1b269818 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -38,6 +38,7 @@ import org.terasology.persistence.typeHandling.coreTypes.LongTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.NumberTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.factories.ArrayTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.EnumTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.ObjectFieldMapTypeHandlerFactory; @@ -117,6 +118,8 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy addTypeHandler(Long.TYPE, new LongTypeHandler()); addTypeHandler(String.class, new StringTypeHandler()); addTypeHandler(Number.class, new NumberTypeHandler()); + + addTypeHandlerFactory(new ArrayTypeHandlerFactory()); addTypeHandler(byte[].class, new ByteArrayTypeHandler()); addTypeHandlerFactory(new EnumTypeHandlerFactory()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java new file mode 100644 index 00000000000..a9ae42613dd --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java @@ -0,0 +1,68 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import com.google.common.collect.Lists; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.lang.reflect.Array; +import java.util.List; +import java.util.Optional; + +/** + * Serializes arrays of type {@code E[]}. + * + * @param The type of an element in the array to serialize. + */ +public class ArrayTypeHandler extends TypeHandler { + private TypeHandler elementTypeHandler; + private TypeInfo elementType; + + public ArrayTypeHandler(TypeHandler elementTypeHandler, TypeInfo elementType) { + this.elementTypeHandler = elementTypeHandler; + this.elementType = elementType; + } + + @Override + protected PersistedData serializeNonNull(E[] value, PersistedDataSerializer serializer) { + List items = Lists.newArrayList(); + + for (E element : value) { + items.add(elementTypeHandler.serialize(element, serializer)); + } + + return serializer.serialize(items); + } + + @Override + public Optional deserialize(PersistedData data) { + if (!data.isArray()) { + return Optional.empty(); + } + + @SuppressWarnings({"unchecked"}) + E[] array = data.getAsArray().getAsValueArray().stream() + .map(itemData -> elementTypeHandler.deserialize(itemData)) + .filter(Optional::isPresent) + .map(Optional::get) + .toArray(size -> (E[]) Array.newInstance(elementType.getRawType(), size)); + + return Optional.of(array); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java new file mode 100644 index 00000000000..cb8671756b0 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java @@ -0,0 +1,60 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes.factories; + +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; +import org.terasology.reflection.TypeInfo; + +import java.lang.reflect.GenericArrayType; +import java.lang.reflect.Type; +import java.util.Optional; + + +/** + * Creates type handlers for arrays. + */ +public class ArrayTypeHandlerFactory implements TypeHandlerFactory { + @Override + public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + Type type = typeInfo.getType(); + + if (!(type instanceof GenericArrayType || type instanceof Class && ((Class) type).isArray())) { + return Optional.empty(); + } + + Type elementType = type instanceof GenericArrayType + ? ((GenericArrayType) type).getGenericComponentType() + : ((Class) type).getComponentType(); + + TypeInfo elementTypeInfo = TypeInfo.of(elementType); + + TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( + typeSerializationLibrary.getTypeHandler(elementType), + elementTypeInfo, + typeSerializationLibrary + ); + + + @SuppressWarnings({"unchecked"}) + TypeHandler typeHandler = new ArrayTypeHandler(elementTypeHandler, elementTypeInfo); + + return Optional.of(typeHandler); + } +} From fa0de1605953a63b50244fc5e6dd8c8735bd6330 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 1 Aug 2018 22:24:20 +0530 Subject: [PATCH 052/141] Refer arrays as Object in ArrayTypeHandler to avoid cast exceptions --- .../coreTypes/ArrayTypeHandler.java | 26 ++++++++++++++----- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java index a9ae42613dd..e7f86be1719 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ArrayTypeHandler.java @@ -24,13 +24,19 @@ import java.lang.reflect.Array; import java.util.List; import java.util.Optional; +import java.util.stream.Collectors; /** * Serializes arrays of type {@code E[]}. * + * {@link ArrayTypeHandler} extends {@link TypeHandler} because the type parameter {@link E} + * supports only wrapper types, and primitive array to wrapper type array (and vice versa) casts are + * unsupported. The array is accessed via the {@link Array} utility class as an {@link Object} so that + * the cast can be avoided. + * * @param The type of an element in the array to serialize. */ -public class ArrayTypeHandler extends TypeHandler { +public class ArrayTypeHandler extends TypeHandler { private TypeHandler elementTypeHandler; private TypeInfo elementType; @@ -40,10 +46,11 @@ public ArrayTypeHandler(TypeHandler elementTypeHandler, TypeInfo elementTy } @Override - protected PersistedData serializeNonNull(E[] value, PersistedDataSerializer serializer) { + protected PersistedData serializeNonNull(Object value, PersistedDataSerializer serializer) { List items = Lists.newArrayList(); - for (E element : value) { + for (int i = 0; i < Array.getLength(value); i++) { + E element = (E) Array.get(value, i); items.add(elementTypeHandler.serialize(element, serializer)); } @@ -51,17 +58,22 @@ protected PersistedData serializeNonNull(E[] value, PersistedDataSerializer seri } @Override - public Optional deserialize(PersistedData data) { + public Optional deserialize(PersistedData data) { if (!data.isArray()) { return Optional.empty(); } @SuppressWarnings({"unchecked"}) - E[] array = data.getAsArray().getAsValueArray().stream() + List items = data.getAsArray().getAsValueArray().stream() .map(itemData -> elementTypeHandler.deserialize(itemData)) .filter(Optional::isPresent) - .map(Optional::get) - .toArray(size -> (E[]) Array.newInstance(elementType.getRawType(), size)); + .map(Optional::get).collect(Collectors.toList()); + + Object array = Array.newInstance(elementType.getRawType(), items.size()); + + for (int i = 0; i < items.size(); i++) { + Array.set(array, i, items.get(i)); + } return Optional.of(array); } From c65188cfdf42a3a7dac985047cc1d2bc82f2edc0 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 3 Aug 2018 12:43:34 +0530 Subject: [PATCH 053/141] Set bytes only if byteList non-empty in EntityData.ValueAdapter --- .../persistence/serializers/EntityDataJSONFormat.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/EntityDataJSONFormat.java b/engine/src/main/java/org/terasology/persistence/serializers/EntityDataJSONFormat.java index 68867cc049c..7321edcdae7 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/EntityDataJSONFormat.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/EntityDataJSONFormat.java @@ -377,7 +377,10 @@ public EntityData.Value deserialize(JsonElement json, Type typeOfT, JsonDeserial } } } - value.setBytes(ByteString.copyFrom(byteList.toArray())); + + if (byteList.size() > 0) { + value.setBytes(ByteString.copyFrom(byteList.toArray())); + } } return value.build(); } From 8ebb06435d4dd78e91de79c7db268d5790e984ab Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 02:03:39 -0500 Subject: [PATCH 054/141] Complete RuntimeDelegatingTypeHandlerAdapter.testSerialize --- .../RuntimeDelegatingTypeHandlerTest.java | 16 ++++++++++++++-- .../coreTypes/RuntimeDelegatingTypeHandler.java | 4 ++-- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 9778cd371d9..48e2ea246b3 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -18,16 +18,20 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.junit.Test; +import org.mockito.ArgumentMatcher; +import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; +import org.terasology.persistence.typeHandling.inMemory.PersistedString; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.List; +import java.util.Map; import static org.mockito.Mockito.*; @@ -50,7 +54,9 @@ private static class Sub extends Base { @Test public void testSerialize() { - PersistedDataSerializer context = mock(PersistedDataSerializer.class); + PersistedDataSerializer serializer = mock(PersistedDataSerializer.class); + when(serializer.serialize(any(String.class))) + .then(invocation -> new PersistedString((String) invocation.getArguments()[0])); Class subType = Sub.class; Type baseType = TypeInfo.of(Base.class).getType(); @@ -67,13 +73,19 @@ abstract class SubHandler extends TypeHandler {} }, typeSerializationLibrary).get(); ArrayList bases = Lists.newArrayList(new Sub(), new Base(), new Sub(), new Base(), new Sub()); - listTypeHandler.serialize(bases, context); + listTypeHandler.serialize(bases, serializer); verify(typeSerializationLibrary).getTypeHandler(baseType); verify(typeSerializationLibrary, times(3)).getTypeHandler(subType); verify(baseTypeHandler, times(2)).serialize(any(), any()); verify(subTypeHandler, times(3)).serialize(any(), any()); + + verify(serializer, times(3)).serialize( + argThat((ArgumentMatcher>) argument -> + argument.get(RuntimeDelegatingTypeHandler.TYPE_FIELD).getAsString().equals(subType.getName()) && + argument.containsKey(RuntimeDelegatingTypeHandler.VALUE_FIELD)) + ); } @Test diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 5d912960d7e..585be504be0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -37,8 +37,8 @@ * @param The base type whose instances may be delegated to a subtype's {@link TypeHandler} at runtime. */ public class RuntimeDelegatingTypeHandler extends TypeHandler { - private static final String TYPE_FIELD = "@type"; - private static final String VALUE_FIELD = "@value"; + static final String TYPE_FIELD = "@type"; + static final String VALUE_FIELD = "@value"; private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeDelegatingTypeHandler.class); From 2db667e0a7fcd6302f4cbefa21616e01d462f461 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 02:26:09 -0500 Subject: [PATCH 055/141] Add PersistedMap.isValueMap and getAsValueMap implementations --- .../typeHandling/inMemory/PersistedMap.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/inMemory/PersistedMap.java b/engine/src/main/java/org/terasology/persistence/typeHandling/inMemory/PersistedMap.java index f9509a09008..17401f21753 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/inMemory/PersistedMap.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/inMemory/PersistedMap.java @@ -31,6 +31,16 @@ public PersistedMap(Map map) { this.map = map; } + @Override + public PersistedDataMap getAsValueMap() { + return this; + } + + @Override + public boolean isValueMap() { + return true; + } + @Override public boolean has(String name) { return map.containsKey(name); From d8e7a4c63b71c7347aa6c8aa768ae6a6d253cfae Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 02:26:36 -0500 Subject: [PATCH 056/141] Add RuntimeDelegatingTypeHandlerAdapter.testDeserialize --- .../RuntimeDelegatingTypeHandlerTest.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 48e2ea246b3..36ad5f43551 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -15,15 +15,18 @@ */ package org.terasology.persistence.typeHandling.coreTypes; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.junit.Test; import org.mockito.ArgumentMatcher; import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; +import org.terasology.persistence.typeHandling.inMemory.PersistedMap; import org.terasology.persistence.typeHandling.inMemory.PersistedString; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; @@ -90,5 +93,45 @@ abstract class SubHandler extends TypeHandler {} @Test public void testDeserialize() { + Class subType = Sub.class; + Type baseType = TypeInfo.of(Base.class).getType(); + + abstract class SubHandler extends TypeHandler {} + + TypeHandler baseTypeHandler = mock(TypeHandler.class); + TypeHandler subTypeHandler = mock(SubHandler.class); + + when(typeSerializationLibrary.getTypeHandler(eq(baseType))).thenReturn(baseTypeHandler); + when(typeSerializationLibrary.getTypeHandler(eq(subType))).thenReturn(subTypeHandler); + + TypeHandler> listTypeHandler = collectionHandlerFactory.create( + new TypeInfo>() {}, typeSerializationLibrary + ).get(); + + PersistedData persistedBase = new PersistedMap(ImmutableMap.of()); + + PersistedData persistedSub = new PersistedMap( + ImmutableMap.of( + RuntimeDelegatingTypeHandler.TYPE_FIELD, + new PersistedString(subType.getName()), + RuntimeDelegatingTypeHandler.VALUE_FIELD, + new PersistedMap(ImmutableMap.of()) + ) + ); + + PersistedDataArray persistedBases = mock(PersistedDataArray.class); + when(persistedBases.isArray()).thenReturn(true); + when(persistedBases.getAsArray()).thenReturn(persistedBases); + when(persistedBases.iterator()).thenReturn( + Lists.newArrayList(persistedSub, persistedBase, persistedSub, persistedBase, persistedSub).iterator() + ); + + listTypeHandler.deserialize(persistedBases); + + verify(typeSerializationLibrary).getTypeHandler(baseType); + verify(typeSerializationLibrary, times(3)).getTypeHandler(subType); + + verify(baseTypeHandler, times(2)).deserialize(any()); + verify(subTypeHandler, times(3)).deserialize(any()); } } From 98ab2036c68a634975f0465d39fd331268055fb3 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 16:37:06 -0500 Subject: [PATCH 057/141] Return Optional in TypeSerializationLibrary.getTypeHandler --- .../TypeHandlingIntegrationTest.java | 9 +-- .../TypeSerializationLibraryTest.java | 19 +++--- .../RuntimeDelegatingTypeHandlerTest.java | 17 +++-- .../TypeSerializationLibrary.java | 27 ++++---- .../RuntimeDelegatingTypeHandler.java | 66 ++++++++++++------- .../factories/ArrayTypeHandlerFactory.java | 6 +- .../CollectionTypeHandlerFactory.java | 9 ++- .../ObjectFieldMapTypeHandlerFactory.java | 22 ++++--- .../StringMapTypeHandlerFactory.java | 11 +++- ...ypeSerializationLibraryAdapterFactory.java | 2 +- .../factories/Rect2fTypeHandlerFactory.java | 14 ++-- .../factories/Rect2iTypeHandlerFactory.java | 16 +++-- .../recording/RecordedEventSerializer.java | 46 ++++++------- 13 files changed, 158 insertions(+), 106 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java index 9482f858164..1c44e635aaa 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java @@ -59,8 +59,7 @@ public class TypeHandlingIntegrationTest { @Test public void testJsonSerialize() { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() { - }); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(INSTANCE, new GsonPersistedDataSerializer()); @@ -71,8 +70,7 @@ public void testJsonSerialize() { @Test public void testJsonDeserialize() { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() { - }); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); Gson gson = new Gson(); JsonElement jsonElement = gson.fromJson(INSTANCE_JSON, JsonElement.class); @@ -86,8 +84,7 @@ public void testJsonDeserialize() { @Test public void testProtobufSerializeDeserialize() throws IOException { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() { - }); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); ProtobufPersistedData persistedData = (ProtobufPersistedData) typeHandler.serialize(INSTANCE, new ProtobufPersistedDataSerializer()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java index de84cefe0d9..9acdddbe6fa 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java @@ -27,10 +27,11 @@ import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Queue; import java.util.Set; -import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; public class TypeSerializationLibraryTest { @@ -46,14 +47,14 @@ private static class AMappedContainer {} @Test public void testEnumHandler() { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(AnEnum.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(AnEnum.class).get(); assertTrue(handler instanceof EnumTypeHandler); } @Test public void testMappedContainerHandler() { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(AMappedContainer.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(AMappedContainer.class).get(); assertTrue(handler instanceof ObjectFieldMapTypeHandler); } @@ -61,17 +62,17 @@ public void testMappedContainerHandler() { @Test public void testCollectionHandler() { TypeHandler> setHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(setHandler instanceof CollectionTypeHandler); TypeHandler> listHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(listHandler instanceof CollectionTypeHandler); TypeHandler> queueHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(queueHandler instanceof CollectionTypeHandler); } @@ -79,16 +80,16 @@ public void testCollectionHandler() { @Test public void testStringMapHandler() { TypeHandler> handler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(handler instanceof StringMapTypeHandler); } @Test public void testInvalidTypeHandler() { - TypeHandler> handler = + Optional>> handler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); - assertNull(handler); + assertFalse(handler.isPresent()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 36ad5f43551..a69d3d1ba1b 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -35,6 +35,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.Optional; import static org.mockito.Mockito.*; @@ -69,8 +70,11 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType))).thenReturn(baseTypeHandler); - when(typeSerializationLibrary.getTypeHandler(eq(subType))).thenReturn(subTypeHandler); + when(typeSerializationLibrary.getTypeHandler(eq(baseType))) + .thenReturn(Optional.of(baseTypeHandler)); + + when(typeSerializationLibrary.getTypeHandler(eq((Type) subType))) + .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = collectionHandlerFactory.create(new TypeInfo>() { }, typeSerializationLibrary).get(); @@ -79,7 +83,7 @@ abstract class SubHandler extends TypeHandler {} listTypeHandler.serialize(bases, serializer); verify(typeSerializationLibrary).getTypeHandler(baseType); - verify(typeSerializationLibrary, times(3)).getTypeHandler(subType); + verify(typeSerializationLibrary, times(3)).getTypeHandler((Type) subType); verify(baseTypeHandler, times(2)).serialize(any(), any()); verify(subTypeHandler, times(3)).serialize(any(), any()); @@ -101,8 +105,11 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType))).thenReturn(baseTypeHandler); - when(typeSerializationLibrary.getTypeHandler(eq(subType))).thenReturn(subTypeHandler); + when(typeSerializationLibrary.getTypeHandler(eq(baseType))) + .thenReturn(Optional.of(baseTypeHandler)); + + when(typeSerializationLibrary.getTypeHandler(eq(subType))) + .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = collectionHandlerFactory.create( new TypeInfo>() {}, typeSerializationLibrary diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index b0d1b269818..7a04355cac3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -210,18 +210,21 @@ public void addInstanceCreator(TypeInfo typeInfo, InstanceCreator inst instanceCreators.put(typeInfo.getType(), instanceCreator); } - public TypeHandler getTypeHandler(Type type) { - return getTypeHandler(TypeInfo.of(type)); + @SuppressWarnings({"unchecked"}) + public Optional> getTypeHandler(Type type) { + TypeInfo typeInfo = TypeInfo.of(type); + return (Optional>) getTypeHandler(typeInfo); } - public TypeHandler getTypeHandler(Class typeClass) { + + public Optional> getTypeHandler(Class typeClass) { return getTypeHandler(TypeInfo.of(typeClass)); } @SuppressWarnings("unchecked") - public TypeHandler getTypeHandler(TypeInfo type) { + public Optional> getTypeHandler(TypeInfo type) { if (typeHandlerCache.containsKey(type)) { - return (TypeHandler) typeHandlerCache.get(type); + return Optional.of((TypeHandler) typeHandlerCache.get(type)); } // TODO: Explore reversing typeHandlerFactories itself before building object @@ -232,22 +235,22 @@ public TypeHandler getTypeHandler(TypeInfo type) { if (typeHandler.isPresent()) { TypeHandler handler = typeHandler.get(); typeHandlerCache.put(type, handler); - return handler; + return Optional.of(handler); } } - // TODO: Log error and/or return Optional.empty() - return null; + return Optional.empty(); } private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type) { Map, TypeHandler> handlerMap = Maps.newHashMap(); for (FieldMetadata field : type.getFields()) { - TypeHandler handler = getTypeHandler(field.getField().getGenericType()); - if (handler != null) { - handlerMap.put(field, handler); + Optional> handler = getTypeHandler(field.getField().getGenericType()); + + if (handler.isPresent()) { + handlerMap.put(field, handler.get()); } else { - logger.info("Unsupported field: '{}.{}'", type.getUri(), field.getName()); + logger.error("Unsupported field: '{}.{}'", type.getUri(), field.getName()); } } return handlerMap; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 585be504be0..a468ff299e6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -25,6 +25,7 @@ import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.reflection.TypeInfo; +import java.lang.reflect.Type; import java.util.Map; import java.util.Optional; @@ -56,30 +57,38 @@ public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { // If primitive, don't go looking for the runtime type, serialize as is if (typeInfo.getRawType().isPrimitive()) { - return delegateHandler.serialize(value, serializer); + if (delegateHandler != null) { + return delegateHandler.serialize(value, serializer); + } + + LOGGER.error("Primitive {} does not have a TypeHandler", typeInfo.getRawType().getName()); + return serializer.serializeNull(); } TypeHandler chosenHandler = delegateHandler; Class runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { - TypeHandler runtimeTypeHandler = - (TypeHandler) typeSerializationLibrary.getTypeHandler(runtimeClass); - - if (delegateHandler == null) { - chosenHandler = runtimeTypeHandler; - } else if (runtimeTypeHandler.getClass().equals(delegateHandler.getClass())) { - // Both handlers are of same type, use delegateHandler - chosenHandler = delegateHandler; - } else if (!(runtimeTypeHandler instanceof ObjectFieldMapTypeHandler)) { - // Custom handler for runtime type - chosenHandler = runtimeTypeHandler; - } else if (!(delegateHandler instanceof ObjectFieldMapTypeHandler)) { - // Custom handler for specified type - chosenHandler = delegateHandler; - } else { - chosenHandler = runtimeTypeHandler; - } + Optional> runtimeTypeHandler = typeSerializationLibrary.getTypeHandler((Type) runtimeClass); + + chosenHandler = (TypeHandler) runtimeTypeHandler + .map(typeHandler -> { + if (delegateHandler == null) { + return typeHandler; + } else if (typeHandler.getClass().equals(delegateHandler.getClass())) { + // Both handlers are of same type, use delegateHandler + return delegateHandler; + } else if (!(typeHandler instanceof ObjectFieldMapTypeHandler)) { + // Custom handler for runtime type + return typeHandler; + } else if (!(delegateHandler instanceof ObjectFieldMapTypeHandler)) { + // Custom handler for specified type + return delegateHandler; + } + + return typeHandler; + }) + .orElse(delegateHandler); } if (chosenHandler == delegateHandler) { @@ -132,24 +141,31 @@ public Optional deserialize(PersistedData data) { return delegateHandler.deserialize(data); } - String typeName = valueMap.getAsString(TYPE_FIELD); + String runtimeTypeName = valueMap.getAsString(TYPE_FIELD); // TODO: Use context class loaders Class typeToDeserializeAs; try { - typeToDeserializeAs = Class.forName(typeName); + typeToDeserializeAs = Class.forName(runtimeTypeName); } catch (ClassNotFoundException e) { - LOGGER.error("Cannot find class {}", typeName); - return null; + LOGGER.error("Cannot find class to deserialize {}", runtimeTypeName); + return Optional.empty(); } - TypeHandler typeHandler = - (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs); + TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs) + // To avoid compile errors in the orElseGet + .map(typeHandler -> (TypeHandler) typeHandler) + .orElseGet(() -> { + LOGGER.warn("Cannot find TypeHandler for runtime class {}, " + + "deserializing as base class {}", + runtimeTypeName, typeInfo.getRawType().getName()); + return delegateHandler; + }); PersistedData valueData = valueMap.get(VALUE_FIELD); - return typeHandler.deserialize(valueData); + return runtimeTypeHandler.deserialize(valueData); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java index cb8671756b0..01d6ee76a89 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java @@ -45,13 +45,15 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati TypeInfo elementTypeInfo = TypeInfo.of(elementType); + Optional> declaredElementTypeHandler = typeSerializationLibrary.getTypeHandler(elementType); + + @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( - typeSerializationLibrary.getTypeHandler(elementType), + declaredElementTypeHandler.orElse(null), elementTypeInfo, typeSerializationLibrary ); - @SuppressWarnings({"unchecked"}) TypeHandler typeHandler = new ArrayTypeHandler(elementTypeHandler, elementTypeInfo); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index e1b3d643de2..58feeedde3a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -58,9 +58,14 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } + TypeInfo elementTypeInfo = TypeInfo.of(elementType); + + Optional> declaredElementTypeHandler = typeSerializationLibrary.getTypeHandler(elementType); + + @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( - typeSerializationLibrary.getTypeHandler(elementType), - TypeInfo.of(elementType), + declaredElementTypeHandler.orElse(null), + elementTypeInfo, typeSerializationLibrary ); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index d2d396b1e48..0d556410305 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -53,14 +53,20 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati getResolvedFields(typeInfo).forEach( (field, fieldType) -> - fieldTypeHandlerMap.put( - field, - new RuntimeDelegatingTypeHandler( - typeSerializationLibrary.getTypeHandler(fieldType), - TypeInfo.of(fieldType), - typeSerializationLibrary - ) - ) + { + Optional> declaredFieldTypeHandler = typeSerializationLibrary.getTypeHandler(fieldType); + + TypeInfo fieldTypeInfo = TypeInfo.of(fieldType); + + fieldTypeHandlerMap.put( + field, + new RuntimeDelegatingTypeHandler( + declaredFieldTypeHandler.orElse(null), + fieldTypeInfo, + typeSerializationLibrary + ) + ); + } ); ObjectFieldMapTypeHandler mappedHandler = diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index 738d5e9e796..53370631dab 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -51,9 +51,14 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } - TypeHandler valueTypeHandler = new RuntimeDelegatingTypeHandler( - typeSerializationLibrary.getTypeHandler(valueType), - TypeInfo.of(valueType), + Optional> declaredValueTypeHandler = typeSerializationLibrary.getTypeHandler(valueType); + + TypeInfo valueTypeInfo = TypeInfo.of(valueType); + + @SuppressWarnings({"unchecked"}) + TypeHandler valueTypeHandler = new RuntimeDelegatingTypeHandler( + declaredValueTypeHandler.orElse(null), + valueTypeInfo, typeSerializationLibrary ); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java index 9d36d6ddfc8..d7574219193 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java @@ -42,7 +42,7 @@ public GsonTypeSerializationLibraryAdapterFactory(TypeSerializationLibrary typeS public TypeAdapter create(Gson gson, TypeToken type) { Type rawType = type.getType(); - TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType); + TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType).orElse(null); if (typeHandler == null || typeHandler instanceof ObjectFieldMapTypeHandler) { return null; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java index a193790f249..16030eb01d7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java @@ -15,7 +15,8 @@ */ package org.terasology.persistence.typeHandling.mathTypes.factories; -import com.google.common.base.Preconditions; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.terasology.math.geom.Rect2f; import org.terasology.math.geom.Vector2f; import org.terasology.persistence.typeHandling.TypeHandler; @@ -27,18 +28,23 @@ import java.util.Optional; public class Rect2fTypeHandlerFactory implements TypeHandlerFactory { + private static final Logger LOGGER = LoggerFactory.getLogger(Rect2fTypeHandlerFactory.class); + @Override public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { if (!typeInfo.equals(TypeInfo.of(Rect2f.class))) { return Optional.empty(); } - TypeHandler vector2fTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2f.class); + Optional> vector2fTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2f.class); - Preconditions.checkNotNull(vector2fTypeHandler, "No Vector2f type handler found"); + if (!vector2fTypeHandler.isPresent()) { + LOGGER.error("No Vector2f type handler found"); + return Optional.empty(); + } Rect2fTypeHandler rect2fTypeHandler = - new Rect2fTypeHandler(vector2fTypeHandler); + new Rect2fTypeHandler(vector2fTypeHandler.get()); return Optional.of((TypeHandler) rect2fTypeHandler); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java index d139f63fde8..3b6adacdfd7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java @@ -15,32 +15,36 @@ */ package org.terasology.persistence.typeHandling.mathTypes.factories; -import com.google.common.base.Preconditions; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.terasology.math.geom.Rect2i; -import org.terasology.math.geom.Vector2f; import org.terasology.math.geom.Vector2i; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.mathTypes.Rect2fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Rect2iTypeHandler; import org.terasology.reflection.TypeInfo; import java.util.Optional; public class Rect2iTypeHandlerFactory implements TypeHandlerFactory { + private static final Logger LOGGER = LoggerFactory.getLogger(Rect2iTypeHandlerFactory.class); + @Override public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { if (!typeInfo.equals(TypeInfo.of(Rect2i.class))) { return Optional.empty(); } - TypeHandler vector2iTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2i.class); + Optional> vector2iTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2i.class); - Preconditions.checkNotNull(vector2iTypeHandler, "No Vector2f type handler found"); + if (!vector2iTypeHandler.isPresent()) { + LOGGER.error("No Vector2i type handler found"); + return Optional.empty(); + } Rect2iTypeHandler rect2fTypeHandler = - new Rect2iTypeHandler(vector2iTypeHandler); + new Rect2iTypeHandler(vector2iTypeHandler.get()); return Optional.of((TypeHandler) rect2fTypeHandler); diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index bda911d1952..191f5585231 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -151,7 +151,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { } else if (event instanceof PlaySoundEvent) { PlaySoundEvent e = (PlaySoundEvent) event; writer.name("volume").value(e.getVolume()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class).get(); PersistedData data = handler.serialize(e.getSound(), serializationContext); writer.name("sound").value(data.getAsString()); @@ -165,7 +165,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { writer.name("jumpRequested").value(e.isJumpRequested()); writer.name("sequeceNumber").value(e.getSequenceNumber()); writer.name("firstRun").value(e.isFirstRun()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementDirection(), serializationContext); writer.name("movementDirection"); writer.beginObject(); @@ -178,7 +178,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { } else if (event instanceof GetMaxSpeedEvent) { GetMaxSpeedEvent e = (GetMaxSpeedEvent) event; writer.name("baseValue").value(e.getBaseValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementMode(), serializationContext); writer.name("movementMode").value(data.getAsString()); writer.name("modifiers"); @@ -208,7 +208,7 @@ private void writeVector3fData(JsonWriter writer, GsonPersistedDataSerializer se } private void writeRealVector3fData(JsonWriter writer, GsonPersistedDataSerializer serializationContext, InputEvent e) throws IOException { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getHitNormal(), serializationContext); writer.name("hitNormal"); writer.beginObject(); @@ -227,7 +227,7 @@ private void writeRealVector3fData(JsonWriter writer, GsonPersistedDataSerialize writer.name("z").value(array.get(2).getAsFloat()); writer.endObject(); - handler = typeSerializationLibrary.getTypeHandler(Vector3i.class); + handler = typeSerializationLibrary.getTypeHandler(Vector3i.class).get(); data = (GsonPersistedData) handler.serialize(e.getTargetBlockPosition(), serializationContext); writer.name("targetBlockPosition"); writer.beginObject(); @@ -265,7 +265,7 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer if (event instanceof MouseWheelEvent) { MouseWheelEvent e = (MouseWheelEvent) event; writer.name("wheelTurns").value(e.getWheelTurns()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector2i.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector2i.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); writer.name("mousePosition"); writer.beginObject(); @@ -276,7 +276,7 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer } else if (event instanceof MouseAxisEvent) { MouseAxisEvent e = (MouseAxisEvent) event; writer.name("value").value(e.getValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMouseAxis(), serializationContext); writer.name("mouseAxis").value(data.getAsString()); } else if (event instanceof BindAxisEvent) { @@ -285,12 +285,12 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer writer.name("value").value(e.getValue()); } else if (event instanceof BindButtonEvent) { BindButtonEvent e = (BindButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); writer.name("id"); writer.beginObject(); - handler = typeSerializationLibrary.getTypeHandler(Name.class); + handler = typeSerializationLibrary.getTypeHandler(Name.class).get(); data = (GsonPersistedData) handler.serialize(e.getId().getModuleName(), serializationContext); writer.name("moduleName").value(data.getAsString()); data = (GsonPersistedData) handler.serialize(e.getId().getObjectName(), serializationContext); @@ -299,21 +299,21 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer } else if (event instanceof KeyEvent) { KeyEvent e = (KeyEvent) event; writer.name("keychar").value(e.getKeyCharacter()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); // might need to add some things to key + handler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class).get(); // might need to add some things to key data = (GsonPersistedData) handler.serialize(e.getKey(), serializationContext); writer.name("input").value(data.getAsString()); } else if (event instanceof MouseButtonEvent) { MouseButtonEvent e = (MouseButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(MouseInput.class); + handler = typeSerializationLibrary.getTypeHandler(MouseInput.class).get(); data = (GsonPersistedData) handler.serialize(e.getButton(), serializationContext); writer.name("button").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(Vector2i.class); + handler = typeSerializationLibrary.getTypeHandler(Vector2i.class).get(); data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); writer.name("mousePosition"); writer.beginObject(); @@ -370,7 +370,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa } else if (className.equals(PlaySoundEvent.class.getName())) { float volume = jsonObject.get("volume").getAsFloat(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("sound")); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class).get(); StaticSound sound = handler.deserializeOrThrow(data); result = new PlaySoundEvent(sound, volume); } else if (className.equals(CharacterMoveInputEvent.class.getName())) { @@ -389,7 +389,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa result = new CharacterMoveInputEvent(sequenceNumber, pitch, yaw, movementDirection, running, crouching, jumpRequested, delta); } else if (className.equals(GetMaxSpeedEvent.class.getName())) { float baseValue = jsonObject.get("baseValue").getAsFloat(); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class).get(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("movementMode")); MovementMode movementMode = handler.deserializeOrThrow(data); TFloatList modifiers = gson.fromJson(jsonObject.get("modifiers"), TFloatArrayList.class); @@ -419,11 +419,11 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = (InputEvent) clazz.getConstructor().newInstance(); } else if (clazz.equals(KeyDownEvent.class) || clazz.equals(KeyRepeatEvent.class) || clazz.equals(KeyUpEvent.class)) { //KeyEvent GsonPersistedData data = new GsonPersistedData(jsonObject.get("input")); - TypeHandler keyTypeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class); + TypeHandler keyTypeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class).get(); Keyboard.Key input = keyTypeHandler.deserializeOrThrow(data); data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class); + typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); char keychar = jsonObject.get("keychar").getAsCharacter(); float delta = jsonObject.get("delta").getAsFloat(); @@ -442,11 +442,11 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(MouseButtonEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("button")); TypeHandler mouseInputTypeHandler = - typeSerializationLibrary.getTypeHandler(MouseInput.class); + typeSerializationLibrary.getTypeHandler(MouseInput.class).get(); MouseInput button = mouseInputTypeHandler.deserializeOrThrow(data); data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class); + typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); @@ -457,7 +457,7 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(MouseAxisEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("mouseAxis")); TypeHandler typeHandler = - typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class); + typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class).get(); MouseAxisEvent.MouseAxis mouseAxis = typeHandler.deserializeOrThrow(data); float value = jsonObject.get("value").getAsFloat(); float delta = jsonObject.get("delta").getAsFloat(); @@ -490,10 +490,10 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class); + typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); float delta = jsonObject.get("delta").getAsFloat(); - TypeHandler nameTypeHandler = typeSerializationLibrary.getTypeHandler(Name.class); + TypeHandler nameTypeHandler = typeSerializationLibrary.getTypeHandler(Name.class).get(); JsonObject aux = jsonObject.get("id").getAsJsonObject(); data = new GsonPersistedData(aux.get("moduleName")); Name moduleName = nameTypeHandler.deserializeOrThrow(data); From e47023bec72df89c89a73ce2336c85965b99e53b Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 16:58:10 -0500 Subject: [PATCH 058/141] Add CharacterTypeHandler (credit @llvieira) --- .../TypeSerializationLibrary.java | 3 ++ .../coreTypes/CharacterTypeHandler.java | 37 +++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 7a04355cac3..78cc83bcd5d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -32,6 +32,7 @@ import org.terasology.persistence.typeHandling.coreTypes.BooleanTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ByteArrayTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ByteTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.CharacterTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.DoubleTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.FloatTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.IntTypeHandler; @@ -108,6 +109,8 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy addTypeHandler(Boolean.TYPE, new BooleanTypeHandler()); addTypeHandler(Byte.class, new ByteTypeHandler()); addTypeHandler(Byte.TYPE, new ByteTypeHandler()); + addTypeHandler(Character.class, new CharacterTypeHandler()); + addTypeHandler(Character.TYPE, new CharacterTypeHandler()); addTypeHandler(Double.class, new DoubleTypeHandler()); addTypeHandler(Double.TYPE, new DoubleTypeHandler()); addTypeHandler(Float.class, new FloatTypeHandler()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java new file mode 100644 index 00000000000..4e4623b1e4d --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java @@ -0,0 +1,37 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import org.terasology.persistence.typeHandling.TypeHandler; + +import java.util.Optional; + +public class CharacterTypeHandler extends TypeHandler { + @Override + protected PersistedData serializeNonNull(Character value, PersistedDataSerializer serializer) { + return serializer.serialize(Character.toString(value)); + } + + @Override + public Optional deserialize(PersistedData data) { + if (data.isString()) { + return Optional.of(data.getAsString().charAt(0)); + } + return Optional.empty(); + } +} From d1685596fbbccf2e3ac883e2b8245535bef800f0 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 17:10:12 -0500 Subject: [PATCH 059/141] Add CharacterTypeHandlerTest --- .../coreTypes/CharacterTypeHandlerTest.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java new file mode 100644 index 00000000000..11ec4f72037 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java @@ -0,0 +1,54 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import org.junit.Test; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import org.terasology.persistence.typeHandling.inMemory.PersistedString; + +import java.util.Optional; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public class CharacterTypeHandlerTest { + CharacterTypeHandler typeHandler = new CharacterTypeHandler(); + + @Test + public void testSerialize() { + PersistedDataSerializer serializer = mock(PersistedDataSerializer.class); + + char linefeedChar = '\n'; + + typeHandler.serializeNonNull(linefeedChar, serializer); + + verify(serializer).serialize(eq("\n")); + } + + @Test + public void testDeserialize() { + PersistedData persistedLinefeed = new PersistedString("\n"); + + Optional deserializedLinefeed = typeHandler.deserialize(persistedLinefeed); + + assertTrue(deserializedLinefeed.isPresent()); + assertEquals('\n', (char) deserializedLinefeed.get()); + } +} From 30e5b3ce20bc374cdaf9cb090db439d7b1364d37 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 17:14:02 -0500 Subject: [PATCH 060/141] Add fail case to CharacterTypeHandler.testDeserialize --- .../coreTypes/CharacterTypeHandlerTest.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java index 11ec4f72037..9bdb40d3892 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandlerTest.java @@ -16,13 +16,14 @@ package org.terasology.persistence.typeHandling.coreTypes; import org.junit.Test; -import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import org.terasology.persistence.typeHandling.inMemory.PersistedInteger; import org.terasology.persistence.typeHandling.inMemory.PersistedString; import java.util.Optional; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; @@ -44,11 +45,13 @@ public void testSerialize() { @Test public void testDeserialize() { - PersistedData persistedLinefeed = new PersistedString("\n"); - - Optional deserializedLinefeed = typeHandler.deserialize(persistedLinefeed); + Optional deserializedLinefeed = typeHandler.deserialize(new PersistedString("\n")); assertTrue(deserializedLinefeed.isPresent()); assertEquals('\n', (char) deserializedLinefeed.get()); + + Optional deserializedInteger = typeHandler.deserialize(new PersistedInteger((int) '\n')); + + assertFalse(deserializedInteger.isPresent()); } } From e25defbdc539dc580c72b9ea532ac3bb927dd9d3 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 17:39:56 -0500 Subject: [PATCH 061/141] Add TypeHandlerFactoryContext --- .../TypeHandlerFactoryContext.java | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java new file mode 100644 index 00000000000..a8f975a50ce --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java @@ -0,0 +1,52 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + +import org.terasology.reflection.TypeInfo; + +/** + * Represents the context in which a {@link TypeHandlerFactory} creates {@link TypeHandler} instances. + *

+ * The {@link TypeHandlerFactoryContext} is used to look up {@link TypeHandler} instances and load classes + * while staying within the sandbox rules if called from a module. + */ +public class TypeHandlerFactoryContext { + private TypeSerializationLibrary typeSerializationLibrary; + private ClassLoader contextClassLoader; + + public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibrary, ClassLoader contextClassLoader) { + this.typeSerializationLibrary = typeSerializationLibrary; + this.contextClassLoader = contextClassLoader; + } + + /** + * Returns the {@link TypeSerializationLibrary} that called the {@link TypeHandlerFactory#create(TypeInfo, TypeSerializationLibrary)} method. + */ + public TypeSerializationLibrary getTypeSerializationLibrary() { + return typeSerializationLibrary; + } + + /** + * Returns the {@link ClassLoader} to use to load classes in the + * {@link TypeHandlerFactory#create(TypeInfo, TypeSerializationLibrary)} method. + *

+ * If classes are loaded manually using a method like {@link Class#forName(String)}, this + * {@link ClassLoader} must be used so that modules remain sandboxed. + */ + public ClassLoader getContextClassLoader() { + return contextClassLoader; + } +} From 1552df9433803ef262af22238b6b38548392acfb Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 21:58:00 -0500 Subject: [PATCH 062/141] Add context param in TypeHandlerFactory.create, ClassLoader in getTypeHandler --- .../TypeHandlingIntegrationTest.java | 6 +-- .../TypeSerializationLibraryTest.java | 14 +++--- .../RuntimeDelegatingTypeHandlerTest.java | 26 ++++++----- .../ArrayTypeHandlerFactoryTest.java | 14 ++++-- .../CollectionTypeHandlerFactoryTest.java | 24 ++++++---- .../ObjectFieldMapTypeHandlerFactoryTest.java | 19 ++++---- .../StringMapTypeHandlerFactoryTest.java | 15 ++++-- .../typeHandling/TypeHandlerFactory.java | 6 +-- .../TypeHandlerFactoryContext.java | 4 +- .../TypeSerializationLibrary.java | 18 ++++---- .../RuntimeDelegatingTypeHandler.java | 14 +++--- .../factories/ArrayTypeHandlerFactory.java | 8 ++-- .../CollectionTypeHandlerFactory.java | 8 ++-- .../factories/EnumTypeHandlerFactory.java | 4 +- .../ObjectFieldMapTypeHandlerFactory.java | 8 ++-- .../StringMapTypeHandlerFactory.java | 8 ++-- .../factories/AssetTypeHandlerFactory.java | 4 +- .../TextureRegionAssetTypeHandlerFactory.java | 4 +- ...ypeSerializationLibraryAdapterFactory.java | 2 +- .../factories/Rect2fTypeHandlerFactory.java | 6 +-- .../factories/Rect2iTypeHandlerFactory.java | 6 +-- .../recording/RecordedEventSerializer.java | 46 +++++++++---------- 22 files changed, 144 insertions(+), 120 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java index 1c44e635aaa..08dbb3f331a 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java @@ -59,7 +59,7 @@ public class TypeHandlingIntegrationTest { @Test public void testJsonSerialize() { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(INSTANCE, new GsonPersistedDataSerializer()); @@ -70,7 +70,7 @@ public void testJsonSerialize() { @Test public void testJsonDeserialize() { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); Gson gson = new Gson(); JsonElement jsonElement = gson.fromJson(INSTANCE_JSON, JsonElement.class); @@ -84,7 +84,7 @@ public void testJsonDeserialize() { @Test public void testProtobufSerializeDeserialize() throws IOException { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); ProtobufPersistedData persistedData = (ProtobufPersistedData) typeHandler.serialize(INSTANCE, new ProtobufPersistedDataSerializer()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java index 9acdddbe6fa..56b9b2b22f3 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java @@ -47,14 +47,14 @@ private static class AMappedContainer {} @Test public void testEnumHandler() { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(AnEnum.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(AnEnum.class, getClass().getClassLoader()).get(); assertTrue(handler instanceof EnumTypeHandler); } @Test public void testMappedContainerHandler() { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(AMappedContainer.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(AMappedContainer.class, getClass().getClassLoader()).get(); assertTrue(handler instanceof ObjectFieldMapTypeHandler); } @@ -62,17 +62,17 @@ public void testMappedContainerHandler() { @Test public void testCollectionHandler() { TypeHandler> setHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(setHandler instanceof CollectionTypeHandler); TypeHandler> listHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(listHandler instanceof CollectionTypeHandler); TypeHandler> queueHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(queueHandler instanceof CollectionTypeHandler); } @@ -80,7 +80,7 @@ public void testCollectionHandler() { @Test public void testStringMapHandler() { TypeHandler> handler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(handler instanceof StringMapTypeHandler); } @@ -88,7 +88,7 @@ public void testStringMapHandler() { @Test public void testInvalidTypeHandler() { Optional>> handler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}); + typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()); assertFalse(handler.isPresent()); } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index a69d3d1ba1b..b01cf2f2bec 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -24,6 +24,7 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; @@ -48,6 +49,9 @@ public class RuntimeDelegatingTypeHandlerTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final TypeHandlerFactoryContext context = + new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + private static class Base { int x; } @@ -70,20 +74,20 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType))) + when(typeSerializationLibrary.getTypeHandler(eq(baseType), any())) .thenReturn(Optional.of(baseTypeHandler)); - when(typeSerializationLibrary.getTypeHandler(eq((Type) subType))) + when(typeSerializationLibrary.getTypeHandler(eq((Type) subType), any())) .thenReturn(Optional.of(subTypeHandler)); - TypeHandler> listTypeHandler = collectionHandlerFactory.create(new TypeInfo>() { - }, typeSerializationLibrary).get(); + TypeHandler> listTypeHandler = + collectionHandlerFactory.create(new TypeInfo>() {}, context).get(); ArrayList bases = Lists.newArrayList(new Sub(), new Base(), new Sub(), new Base(), new Sub()); listTypeHandler.serialize(bases, serializer); - verify(typeSerializationLibrary).getTypeHandler(baseType); - verify(typeSerializationLibrary, times(3)).getTypeHandler((Type) subType); + verify(typeSerializationLibrary).getTypeHandler(eq(baseType), any()); + verify(typeSerializationLibrary, times(3)).getTypeHandler(eq((Type) subType), any()); verify(baseTypeHandler, times(2)).serialize(any(), any()); verify(subTypeHandler, times(3)).serialize(any(), any()); @@ -105,14 +109,14 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType))) + when(typeSerializationLibrary.getTypeHandler(eq(baseType), any())) .thenReturn(Optional.of(baseTypeHandler)); - when(typeSerializationLibrary.getTypeHandler(eq(subType))) + when(typeSerializationLibrary.getTypeHandler(eq(subType), any())) .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = collectionHandlerFactory.create( - new TypeInfo>() {}, typeSerializationLibrary + new TypeInfo>() {}, context ).get(); PersistedData persistedBase = new PersistedMap(ImmutableMap.of()); @@ -135,8 +139,8 @@ abstract class SubHandler extends TypeHandler {} listTypeHandler.deserialize(persistedBases); - verify(typeSerializationLibrary).getTypeHandler(baseType); - verify(typeSerializationLibrary, times(3)).getTypeHandler(subType); + verify(typeSerializationLibrary).getTypeHandler(eq(baseType), any()); + verify(typeSerializationLibrary, times(3)).getTypeHandler(eq(subType), any()); verify(baseTypeHandler, times(2)).deserialize(any()); verify(subTypeHandler, times(3)).deserialize(any()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java index af98ea5c579..c1b94d9db5e 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java @@ -17,6 +17,7 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; import org.terasology.reflection.TypeInfo; @@ -26,6 +27,7 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -33,19 +35,21 @@ public class ArrayTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); private final ArrayTypeHandlerFactory typeHandlerFactory = new ArrayTypeHandlerFactory(); + private final TypeHandlerFactoryContext context = + new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); @Test public void testArray() { TypeInfo arrayTypeInfo = TypeInfo.of(int[].class); Optional> typeHandler = - typeHandlerFactory.create(arrayTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(arrayTypeInfo, context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof ArrayTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType())); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType()), any()); } @Test @@ -53,13 +57,13 @@ public void testGenericArray() { TypeInfo[]> arrayTypeInfo = new TypeInfo[]>() {}; Optional[]>> typeHandler = - typeHandlerFactory.create(arrayTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(arrayTypeInfo, context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof ArrayTypeHandler); // Verify that the List TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType())); + verify(typeSerializationLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType()), any()); } @Test @@ -67,7 +71,7 @@ public void testNonArray() { TypeInfo> arrayTypeInfo = new TypeInfo>() {}; Optional>> typeHandler = - typeHandlerFactory.create(arrayTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(arrayTypeInfo, context); assertFalse(typeHandler.isPresent()); } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index ba0859f252e..c8c08d1f893 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -17,13 +17,12 @@ import com.google.common.collect.Maps; import org.junit.Test; -import org.mockito.ArgumentMatchers; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import java.util.ArrayList; import java.util.List; @@ -32,6 +31,8 @@ import java.util.Set; import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -39,18 +40,21 @@ public class CollectionTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap())); + private final TypeHandlerFactoryContext context = + new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + @Test public void testList() { TypeInfo> listTypeInfo = new TypeInfo>() {}; Optional>> typeHandler = - typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(listTypeInfo, context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); } @Test @@ -58,13 +62,13 @@ public void testSet() { TypeInfo> listTypeInfo = new TypeInfo>() {}; Optional>> typeHandler = - typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(listTypeInfo, context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); } @Test @@ -72,13 +76,13 @@ public void testQueue() { TypeInfo> listTypeInfo = new TypeInfo>() {}; Optional>> typeHandler = - typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(listTypeInfo, context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); } @Test @@ -86,12 +90,12 @@ public void testNonGenericCollection() { class IntList extends ArrayList {} Optional> typeHandler = - typeHandlerFactory.create(TypeInfo.of(IntList.class), typeSerializationLibrary); + typeHandlerFactory.create(TypeInfo.of(IntList.class), context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index 9993cd560ee..78da2d3d4ec 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -17,19 +17,19 @@ import com.google.common.collect.Maps; import org.junit.Test; -import org.mockito.ArgumentMatchers; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.reflection.TypeInfo; -import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ConstructorLibrary; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import java.util.List; import java.util.Optional; import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -40,6 +40,9 @@ public class ObjectFieldMapTypeHandlerFactoryTest { private final ObjectFieldMapTypeHandlerFactory typeHandlerFactory = new ObjectFieldMapTypeHandlerFactory( constructorLibrary); + private final TypeHandlerFactoryContext context = + new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + private static class SomeClass { private T t; private List list; @@ -48,18 +51,18 @@ private static class SomeClass { @Test public void testObject() { Optional>> typeHandler = - typeHandlerFactory.create(new TypeInfo>() {}, typeSerializationLibrary); + typeHandlerFactory.create(new TypeInfo>() {}, context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof ObjectFieldMapTypeHandler); // Verify that the Integer and List TypeHandlers were loaded from the TypeSerializationLibrary verify(typeSerializationLibrary).getTypeHandler( - ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()) - ); + eq(TypeInfo.of(Integer.class).getType()), + any()); verify(typeSerializationLibrary).getTypeHandler( - ArgumentMatchers.eq(new TypeInfo>() {}.getType()) - ); + eq(new TypeInfo>() {}.getType()), + any()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java index f5dc59294c6..50f05fd9c99 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -18,6 +18,7 @@ import org.junit.Test; import org.mockito.ArgumentMatchers; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.TypeInfo; @@ -28,6 +29,7 @@ import java.util.Set; import static org.junit.Assert.*; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -35,18 +37,21 @@ public class StringMapTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); private final StringMapTypeHandlerFactory typeHandlerFactory = new StringMapTypeHandlerFactory(); + private final TypeHandlerFactoryContext context = + new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + @Test public void testStringMap() { TypeInfo> listTypeInfo = new TypeInfo>() {}; Optional>> typeHandler = - typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(listTypeInfo, context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof StringMapTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), any()); } @Test @@ -54,7 +59,7 @@ public void testNonStringMap() { TypeInfo> listTypeInfo = new TypeInfo>() {}; Optional>> typeHandler = - typeHandlerFactory.create(listTypeInfo, typeSerializationLibrary); + typeHandlerFactory.create(listTypeInfo, context); assertFalse(typeHandler.isPresent()); } @@ -64,12 +69,12 @@ public void testNonGenericMap() { class IntMap extends HashMap {} Optional> typeHandler = - typeHandlerFactory.create(TypeInfo.of(IntMap.class), typeSerializationLibrary); + typeHandlerFactory.create(TypeInfo.of(IntMap.class), context); assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof StringMapTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), any()); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java index 96846068fe0..2dd7d9723ba 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java @@ -33,12 +33,12 @@ public interface TypeHandlerFactory { * {@link TypeHandler#serialize(Object, PersistedDataSerializer)} and * {@link TypeHandler#deserialize(PersistedData)} implementations are fast. * + * @param The type for which a {@link TypeHandler} must be generated. * @param typeInfo The {@link TypeInfo} of the type for which a {@link TypeHandler} must be generated. - * @param typeSerializationLibrary The {@link TypeSerializationLibrary} for which the {@link TypeHandler} + * @param context The {@link TypeSerializationLibrary} for which the {@link TypeHandler} * is being created. - * @param The type for which a {@link TypeHandler} must be generated. * @return An {@link Optional} wrapping the created {@link TypeHandler}, or {@link Optional#empty()} * if the type is not supported by this {@link TypeHandlerFactory}. */ - Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary); + Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java index a8f975a50ce..20c02d8604a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java @@ -33,7 +33,7 @@ public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibra } /** - * Returns the {@link TypeSerializationLibrary} that called the {@link TypeHandlerFactory#create(TypeInfo, TypeSerializationLibrary)} method. + * Returns the {@link TypeSerializationLibrary} that called the {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerFactoryContext)} method. */ public TypeSerializationLibrary getTypeSerializationLibrary() { return typeSerializationLibrary; @@ -41,7 +41,7 @@ public TypeSerializationLibrary getTypeSerializationLibrary() { /** * Returns the {@link ClassLoader} to use to load classes in the - * {@link TypeHandlerFactory#create(TypeInfo, TypeSerializationLibrary)} method. + * {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerFactoryContext)} method. *

* If classes are loaded manually using a method like {@link Class#forName(String)}, this * {@link ClassLoader} must be used so that modules remain sandboxed. diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 78cc83bcd5d..ee83956e5be 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -197,7 +197,7 @@ public void addTypeHandler(TypeInfo type, TypeHandler typeHandler) { TypeHandlerFactory factory = new TypeHandlerFactory() { @SuppressWarnings("unchecked") @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { return typeInfo.equals(type) ? Optional.of((TypeHandler) typeHandler) : Optional.empty(); } }; @@ -214,18 +214,20 @@ public void addInstanceCreator(TypeInfo typeInfo, InstanceCreator inst } @SuppressWarnings({"unchecked"}) - public Optional> getTypeHandler(Type type) { + public Optional> getTypeHandler(Type type, ClassLoader contextClassLoader) { TypeInfo typeInfo = TypeInfo.of(type); - return (Optional>) getTypeHandler(typeInfo); + return (Optional>) getTypeHandler(typeInfo, contextClassLoader); } - public Optional> getTypeHandler(Class typeClass) { - return getTypeHandler(TypeInfo.of(typeClass)); + public Optional> getTypeHandler(Class typeClass, ClassLoader contextClassLoader) { + return getTypeHandler(TypeInfo.of(typeClass), contextClassLoader); } @SuppressWarnings("unchecked") - public Optional> getTypeHandler(TypeInfo type) { + public Optional> getTypeHandler(TypeInfo type, ClassLoader contextClassLoader) { + TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(this, contextClassLoader); + if (typeHandlerCache.containsKey(type)) { return Optional.of((TypeHandler) typeHandlerCache.get(type)); } @@ -233,7 +235,7 @@ public Optional> getTypeHandler(TypeInfo type) { // TODO: Explore reversing typeHandlerFactories itself before building object for (int i = typeHandlerFactories.size() - 1; i >= 0; i--) { TypeHandlerFactory typeHandlerFactory = typeHandlerFactories.get(i); - Optional> typeHandler = typeHandlerFactory.create(type, this); + Optional> typeHandler = typeHandlerFactory.create(type, context); if (typeHandler.isPresent()) { TypeHandler handler = typeHandler.get(); @@ -248,7 +250,7 @@ public Optional> getTypeHandler(TypeInfo type) { private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type) { Map, TypeHandler> handlerMap = Maps.newHashMap(); for (FieldMetadata field : type.getFields()) { - Optional> handler = getTypeHandler(field.getField().getGenericType()); + Optional> handler = getTypeHandler(field.getField().getGenericType(), getClass().getClassLoader()); if (handler.isPresent()) { handlerMap.put(field, handler.get()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index a468ff299e6..66e0b16ca76 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -22,6 +22,7 @@ import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.reflection.TypeInfo; @@ -46,11 +47,13 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private TypeHandler delegateHandler; private TypeInfo typeInfo; private TypeSerializationLibrary typeSerializationLibrary; + private ClassLoader classLoader; - public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeHandlerFactoryContext context) { this.delegateHandler = delegateHandler; this.typeInfo = typeInfo; - this.typeSerializationLibrary = typeSerializationLibrary; + this.typeSerializationLibrary = context.getTypeSerializationLibrary(); + this.classLoader = context.getContextClassLoader(); } @Override @@ -69,7 +72,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize Class runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { - Optional> runtimeTypeHandler = typeSerializationLibrary.getTypeHandler((Type) runtimeClass); + Optional> runtimeTypeHandler = typeSerializationLibrary.getTypeHandler((Type) runtimeClass, classLoader); chosenHandler = (TypeHandler) runtimeTypeHandler .map(typeHandler -> { @@ -143,17 +146,16 @@ public Optional deserialize(PersistedData data) { String runtimeTypeName = valueMap.getAsString(TYPE_FIELD); - // TODO: Use context class loaders Class typeToDeserializeAs; try { - typeToDeserializeAs = Class.forName(runtimeTypeName); + typeToDeserializeAs = Class.forName(runtimeTypeName, true, classLoader); } catch (ClassNotFoundException e) { LOGGER.error("Cannot find class to deserialize {}", runtimeTypeName); return Optional.empty(); } - TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs) + TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs, classLoader) // To avoid compile errors in the orElseGet .map(typeHandler -> (TypeHandler) typeHandler) .orElseGet(() -> { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java index 01d6ee76a89..6ef69deb6af 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java @@ -17,7 +17,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; @@ -32,7 +32,7 @@ */ public class ArrayTypeHandlerFactory implements TypeHandlerFactory { @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { Type type = typeInfo.getType(); if (!(type instanceof GenericArrayType || type instanceof Class && ((Class) type).isArray())) { @@ -45,13 +45,13 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = typeSerializationLibrary.getTypeHandler(elementType); + Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getContextClassLoader()); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( declaredElementTypeHandler.orElse(null), elementTypeInfo, - typeSerializationLibrary + context ); @SuppressWarnings({"unchecked"}) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index 58feeedde3a..ac16c69a1de 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -19,7 +19,7 @@ import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; @@ -44,7 +44,7 @@ public CollectionTypeHandlerFactory(ConstructorLibrary constructorLibrary) { } @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { Class rawType = typeInfo.getRawType(); if (!Collection.class.isAssignableFrom(rawType)) { @@ -60,13 +60,13 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = typeSerializationLibrary.getTypeHandler(elementType); + Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getContextClassLoader()); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( declaredElementTypeHandler.orElse(null), elementTypeInfo, - typeSerializationLibrary + context ); ObjectConstructor collectionConstructor = constructorLibrary.get(typeInfo); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java index 67602dcb73c..ef875d9eaaa 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java @@ -17,7 +17,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.reflection.TypeInfo; @@ -29,7 +29,7 @@ public class EnumTypeHandlerFactory implements TypeHandlerFactory { @SuppressWarnings("unchecked") @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { Class enumClass = typeInfo.getRawType(); if (!Enum.class.isAssignableFrom(enumClass) || Enum.class.equals(enumClass)) { return Optional.empty(); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 0d556410305..ec8f41242d3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -20,7 +20,7 @@ import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; @@ -43,7 +43,7 @@ public ObjectFieldMapTypeHandlerFactory(ConstructorLibrary constructorLibrary) { } @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { Class typeClass = typeInfo.getRawType(); if (!Modifier.isAbstract(typeClass.getModifiers()) @@ -54,7 +54,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati getResolvedFields(typeInfo).forEach( (field, fieldType) -> { - Optional> declaredFieldTypeHandler = typeSerializationLibrary.getTypeHandler(fieldType); + Optional> declaredFieldTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(fieldType, context.getContextClassLoader()); TypeInfo fieldTypeInfo = TypeInfo.of(fieldType); @@ -63,7 +63,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati new RuntimeDelegatingTypeHandler( declaredFieldTypeHandler.orElse(null), fieldTypeInfo, - typeSerializationLibrary + context ) ); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index 53370631dab..33545afaf7f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -19,7 +19,7 @@ import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.TypeInfo; @@ -34,7 +34,7 @@ public class StringMapTypeHandlerFactory implements TypeHandlerFactory { @SuppressWarnings("unchecked") @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { if (!Map.class.isAssignableFrom(typeInfo.getRawType())) { return Optional.empty(); } @@ -51,7 +51,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati return Optional.empty(); } - Optional> declaredValueTypeHandler = typeSerializationLibrary.getTypeHandler(valueType); + Optional> declaredValueTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(valueType, context.getContextClassLoader()); TypeInfo valueTypeInfo = TypeInfo.of(valueType); @@ -59,7 +59,7 @@ public Optional> create(TypeInfo typeInfo, TypeSerializati TypeHandler valueTypeHandler = new RuntimeDelegatingTypeHandler( declaredValueTypeHandler.orElse(null), valueTypeInfo, - typeSerializationLibrary + context ); return Optional.of((TypeHandler) new StringMapTypeHandler<>(valueTypeHandler)); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java index e6ed7481155..8622e1f2597 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java @@ -18,7 +18,7 @@ import org.terasology.assets.Asset; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; import org.terasology.reflection.TypeInfo; @@ -30,7 +30,7 @@ */ public class AssetTypeHandlerFactory implements TypeHandlerFactory { @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { Class rawType = typeInfo.getRawType(); if (!Asset.class.isAssignableFrom(rawType)) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java index 0785db3cce0..5f9a9dc55d3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java @@ -17,7 +17,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.extensionTypes.TextureRegionAssetTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.rendering.assets.texture.TextureRegionAsset; @@ -26,7 +26,7 @@ public class TextureRegionAssetTypeHandlerFactory implements TypeHandlerFactory { @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { if (!TextureRegionAsset.class.equals(typeInfo.getRawType())) { return Optional.empty(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java index d7574219193..4cc83f34a41 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java @@ -42,7 +42,7 @@ public GsonTypeSerializationLibraryAdapterFactory(TypeSerializationLibrary typeS public TypeAdapter create(Gson gson, TypeToken type) { Type rawType = type.getType(); - TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType).orElse(null); + TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType, getClass().getClassLoader()).orElse(null); if (typeHandler == null || typeHandler instanceof ObjectFieldMapTypeHandler) { return null; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java index 16030eb01d7..34721c1a6ea 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java @@ -21,7 +21,7 @@ import org.terasology.math.geom.Vector2f; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.mathTypes.Rect2fTypeHandler; import org.terasology.reflection.TypeInfo; @@ -31,12 +31,12 @@ public class Rect2fTypeHandlerFactory implements TypeHandlerFactory { private static final Logger LOGGER = LoggerFactory.getLogger(Rect2fTypeHandlerFactory.class); @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { if (!typeInfo.equals(TypeInfo.of(Rect2f.class))) { return Optional.empty(); } - Optional> vector2fTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2f.class); + Optional> vector2fTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2f.class, context.getContextClassLoader()); if (!vector2fTypeHandler.isPresent()) { LOGGER.error("No Vector2f type handler found"); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java index 3b6adacdfd7..3ef91d3ca49 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java @@ -21,7 +21,7 @@ import org.terasology.math.geom.Vector2i; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.mathTypes.Rect2iTypeHandler; import org.terasology.reflection.TypeInfo; @@ -31,12 +31,12 @@ public class Rect2iTypeHandlerFactory implements TypeHandlerFactory { private static final Logger LOGGER = LoggerFactory.getLogger(Rect2iTypeHandlerFactory.class); @Override - public Optional> create(TypeInfo typeInfo, TypeSerializationLibrary typeSerializationLibrary) { + public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { if (!typeInfo.equals(TypeInfo.of(Rect2i.class))) { return Optional.empty(); } - Optional> vector2iTypeHandler = typeSerializationLibrary.getTypeHandler(Vector2i.class); + Optional> vector2iTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2i.class, context.getContextClassLoader()); if (!vector2iTypeHandler.isPresent()) { LOGGER.error("No Vector2i type handler found"); diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 191f5585231..db5e8d040e4 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -151,7 +151,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { } else if (event instanceof PlaySoundEvent) { PlaySoundEvent e = (PlaySoundEvent) event; writer.name("volume").value(e.getVolume()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class, getClass().getClassLoader()).get(); PersistedData data = handler.serialize(e.getSound(), serializationContext); writer.name("sound").value(data.getAsString()); @@ -165,7 +165,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { writer.name("jumpRequested").value(e.isJumpRequested()); writer.name("sequeceNumber").value(e.getSequenceNumber()); writer.name("firstRun").value(e.isFirstRun()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementDirection(), serializationContext); writer.name("movementDirection"); writer.beginObject(); @@ -178,7 +178,7 @@ private void writeSpecificEventData(JsonWriter writer, Event event) { } else if (event instanceof GetMaxSpeedEvent) { GetMaxSpeedEvent e = (GetMaxSpeedEvent) event; writer.name("baseValue").value(e.getBaseValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementMode(), serializationContext); writer.name("movementMode").value(data.getAsString()); writer.name("modifiers"); @@ -208,7 +208,7 @@ private void writeVector3fData(JsonWriter writer, GsonPersistedDataSerializer se } private void writeRealVector3fData(JsonWriter writer, GsonPersistedDataSerializer serializationContext, InputEvent e) throws IOException { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getHitNormal(), serializationContext); writer.name("hitNormal"); writer.beginObject(); @@ -227,7 +227,7 @@ private void writeRealVector3fData(JsonWriter writer, GsonPersistedDataSerialize writer.name("z").value(array.get(2).getAsFloat()); writer.endObject(); - handler = typeSerializationLibrary.getTypeHandler(Vector3i.class).get(); + handler = typeSerializationLibrary.getTypeHandler(Vector3i.class, getClass().getClassLoader()).get(); data = (GsonPersistedData) handler.serialize(e.getTargetBlockPosition(), serializationContext); writer.name("targetBlockPosition"); writer.beginObject(); @@ -265,7 +265,7 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer if (event instanceof MouseWheelEvent) { MouseWheelEvent e = (MouseWheelEvent) event; writer.name("wheelTurns").value(e.getWheelTurns()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector2i.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector2i.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); writer.name("mousePosition"); writer.beginObject(); @@ -276,7 +276,7 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer } else if (event instanceof MouseAxisEvent) { MouseAxisEvent e = (MouseAxisEvent) event; writer.name("value").value(e.getValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMouseAxis(), serializationContext); writer.name("mouseAxis").value(data.getAsString()); } else if (event instanceof BindAxisEvent) { @@ -285,12 +285,12 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer writer.name("value").value(e.getValue()); } else if (event instanceof BindButtonEvent) { BindButtonEvent e = (BindButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); writer.name("id"); writer.beginObject(); - handler = typeSerializationLibrary.getTypeHandler(Name.class).get(); + handler = typeSerializationLibrary.getTypeHandler(Name.class, getClass().getClassLoader()).get(); data = (GsonPersistedData) handler.serialize(e.getId().getModuleName(), serializationContext); writer.name("moduleName").value(data.getAsString()); data = (GsonPersistedData) handler.serialize(e.getId().getObjectName(), serializationContext); @@ -299,21 +299,21 @@ private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPer } else if (event instanceof KeyEvent) { KeyEvent e = (KeyEvent) event; writer.name("keychar").value(e.getKeyCharacter()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class).get(); // might need to add some things to key + handler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class, getClass().getClassLoader()).get(); // might need to add some things to key data = (GsonPersistedData) handler.serialize(e.getKey(), serializationContext); writer.name("input").value(data.getAsString()); } else if (event instanceof MouseButtonEvent) { MouseButtonEvent e = (MouseButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(MouseInput.class).get(); + handler = typeSerializationLibrary.getTypeHandler(MouseInput.class, getClass().getClassLoader()).get(); data = (GsonPersistedData) handler.serialize(e.getButton(), serializationContext); writer.name("button").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(Vector2i.class).get(); + handler = typeSerializationLibrary.getTypeHandler(Vector2i.class, getClass().getClassLoader()).get(); data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); writer.name("mousePosition"); writer.beginObject(); @@ -370,7 +370,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa } else if (className.equals(PlaySoundEvent.class.getName())) { float volume = jsonObject.get("volume").getAsFloat(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("sound")); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class, getClass().getClassLoader()).get(); StaticSound sound = handler.deserializeOrThrow(data); result = new PlaySoundEvent(sound, volume); } else if (className.equals(CharacterMoveInputEvent.class.getName())) { @@ -389,7 +389,7 @@ private Event deserializeSpecificEventData(JsonObject jsonObject, String classNa result = new CharacterMoveInputEvent(sequenceNumber, pitch, yaw, movementDirection, running, crouching, jumpRequested, delta); } else if (className.equals(GetMaxSpeedEvent.class.getName())) { float baseValue = jsonObject.get("baseValue").getAsFloat(); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class).get(); + TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class, getClass().getClassLoader()).get(); GsonPersistedData data = new GsonPersistedData(jsonObject.get("movementMode")); MovementMode movementMode = handler.deserializeOrThrow(data); TFloatList modifiers = gson.fromJson(jsonObject.get("modifiers"), TFloatArrayList.class); @@ -419,11 +419,11 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class newEvent = (InputEvent) clazz.getConstructor().newInstance(); } else if (clazz.equals(KeyDownEvent.class) || clazz.equals(KeyRepeatEvent.class) || clazz.equals(KeyUpEvent.class)) { //KeyEvent GsonPersistedData data = new GsonPersistedData(jsonObject.get("input")); - TypeHandler keyTypeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class).get(); + TypeHandler keyTypeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class, getClass().getClassLoader()).get(); Keyboard.Key input = keyTypeHandler.deserializeOrThrow(data); data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); + typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); char keychar = jsonObject.get("keychar").getAsCharacter(); float delta = jsonObject.get("delta").getAsFloat(); @@ -442,11 +442,11 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(MouseButtonEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("button")); TypeHandler mouseInputTypeHandler = - typeSerializationLibrary.getTypeHandler(MouseInput.class).get(); + typeSerializationLibrary.getTypeHandler(MouseInput.class, getClass().getClassLoader()).get(); MouseInput button = mouseInputTypeHandler.deserializeOrThrow(data); data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); + typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); @@ -457,7 +457,7 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class } else if (clazz.equals(MouseAxisEvent.class)) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("mouseAxis")); TypeHandler typeHandler = - typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class).get(); + typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class, getClass().getClassLoader()).get(); MouseAxisEvent.MouseAxis mouseAxis = typeHandler.deserializeOrThrow(data); float value = jsonObject.get("value").getAsFloat(); float delta = jsonObject.get("delta").getAsFloat(); @@ -490,10 +490,10 @@ private InputEvent getInputEventSpecificType(JsonObject jsonObject, String class private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject) { GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class).get(); + typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); float delta = jsonObject.get("delta").getAsFloat(); - TypeHandler nameTypeHandler = typeSerializationLibrary.getTypeHandler(Name.class).get(); + TypeHandler nameTypeHandler = typeSerializationLibrary.getTypeHandler(Name.class, getClass().getClassLoader()).get(); JsonObject aux = jsonObject.get("id").getAsJsonObject(); data = new GsonPersistedData(aux.get("moduleName")); Name moduleName = nameTypeHandler.deserializeOrThrow(data); From 23dc409f80684d608f101b046ca951f642f608e8 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 22:46:14 -0500 Subject: [PATCH 063/141] Store multiple ClassLoaders in TypeHandlerFactoryContext --- .../typeHandling/TypeHandlerFactoryContext.java | 16 ++++++++-------- .../typeHandling/TypeSerializationLibrary.java | 12 ++++++------ .../coreTypes/RuntimeDelegatingTypeHandler.java | 16 ++++++++-------- .../factories/ArrayTypeHandlerFactory.java | 2 +- .../factories/CollectionTypeHandlerFactory.java | 2 +- .../ObjectFieldMapTypeHandlerFactory.java | 2 +- .../factories/StringMapTypeHandlerFactory.java | 2 +- .../factories/Rect2fTypeHandlerFactory.java | 2 +- .../factories/Rect2iTypeHandlerFactory.java | 2 +- .../org/terasology/utilities/ReflectionUtil.java | 12 ++++++++++++ 10 files changed, 40 insertions(+), 28 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java index 20c02d8604a..fd4e4048719 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java @@ -25,11 +25,11 @@ */ public class TypeHandlerFactoryContext { private TypeSerializationLibrary typeSerializationLibrary; - private ClassLoader contextClassLoader; + private ClassLoader[] classLoaders; - public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibrary, ClassLoader contextClassLoader) { + public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibrary, ClassLoader... classLoaders) { this.typeSerializationLibrary = typeSerializationLibrary; - this.contextClassLoader = contextClassLoader; + this.classLoaders = classLoaders; } /** @@ -40,13 +40,13 @@ public TypeSerializationLibrary getTypeSerializationLibrary() { } /** - * Returns the {@link ClassLoader} to use to load classes in the + * Returns the {@link ClassLoader}s to use to load classes in the * {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerFactoryContext)} method. *

- * If classes are loaded manually using a method like {@link Class#forName(String)}, this - * {@link ClassLoader} must be used so that modules remain sandboxed. + * If classes are loaded manually using a method like {@link Class#forName(String)}, these + * {@link ClassLoader}s must be used so that modules remain sandboxed. */ - public ClassLoader getContextClassLoader() { - return contextClassLoader; + public ClassLoader[] getClassLoaders() { + return classLoaders; } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index ee83956e5be..74d001e6b9e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -214,19 +214,19 @@ public void addInstanceCreator(TypeInfo typeInfo, InstanceCreator inst } @SuppressWarnings({"unchecked"}) - public Optional> getTypeHandler(Type type, ClassLoader contextClassLoader) { + public Optional> getTypeHandler(Type type, ClassLoader... contextClassLoaders) { TypeInfo typeInfo = TypeInfo.of(type); - return (Optional>) getTypeHandler(typeInfo, contextClassLoader); + return (Optional>) getTypeHandler(typeInfo, contextClassLoaders); } - public Optional> getTypeHandler(Class typeClass, ClassLoader contextClassLoader) { - return getTypeHandler(TypeInfo.of(typeClass), contextClassLoader); + public Optional> getTypeHandler(Class typeClass, ClassLoader... contextClassLoaders) { + return getTypeHandler(TypeInfo.of(typeClass), contextClassLoaders); } @SuppressWarnings("unchecked") - public Optional> getTypeHandler(TypeInfo type, ClassLoader contextClassLoader) { - TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(this, contextClassLoader); + public Optional> getTypeHandler(TypeInfo type, ClassLoader... contextClassLoaders) { + TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(this, contextClassLoaders); if (typeHandlerCache.containsKey(type)) { return Optional.of((TypeHandler) typeHandlerCache.get(type)); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 66e0b16ca76..c0664d39329 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -25,6 +25,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.reflection.TypeInfo; +import org.terasology.utilities.ReflectionUtil; import java.lang.reflect.Type; import java.util.Map; @@ -47,13 +48,13 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private TypeHandler delegateHandler; private TypeInfo typeInfo; private TypeSerializationLibrary typeSerializationLibrary; - private ClassLoader classLoader; + private ClassLoader[] classLoaders; public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeHandlerFactoryContext context) { this.delegateHandler = delegateHandler; this.typeInfo = typeInfo; this.typeSerializationLibrary = context.getTypeSerializationLibrary(); - this.classLoader = context.getContextClassLoader(); + this.classLoaders = context.getClassLoaders(); } @Override @@ -72,7 +73,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize Class runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { - Optional> runtimeTypeHandler = typeSerializationLibrary.getTypeHandler((Type) runtimeClass, classLoader); + Optional> runtimeTypeHandler = typeSerializationLibrary.getTypeHandler((Type) runtimeClass, classLoaders); chosenHandler = (TypeHandler) runtimeTypeHandler .map(typeHandler -> { @@ -146,16 +147,14 @@ public Optional deserialize(PersistedData data) { String runtimeTypeName = valueMap.getAsString(TYPE_FIELD); - Class typeToDeserializeAs; + Optional> typeToDeserializeAs = ReflectionUtil.findClassInClassLoaders(runtimeTypeName, classLoaders); - try { - typeToDeserializeAs = Class.forName(runtimeTypeName, true, classLoader); - } catch (ClassNotFoundException e) { + if (!typeToDeserializeAs.isPresent()) { LOGGER.error("Cannot find class to deserialize {}", runtimeTypeName); return Optional.empty(); } - TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs, classLoader) + TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs.get(), classLoaders) // To avoid compile errors in the orElseGet .map(typeHandler -> (TypeHandler) typeHandler) .orElseGet(() -> { @@ -170,4 +169,5 @@ public Optional deserialize(PersistedData data) { return runtimeTypeHandler.deserialize(valueData); } + } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java index 6ef69deb6af..eb95a1f844e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java @@ -45,7 +45,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getContextClassLoader()); + Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getClassLoaders()); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index ac16c69a1de..7668ba53e51 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -60,7 +60,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getContextClassLoader()); + Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getClassLoaders()); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index ec8f41242d3..2b4b007acfe 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -54,7 +54,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact getResolvedFields(typeInfo).forEach( (field, fieldType) -> { - Optional> declaredFieldTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(fieldType, context.getContextClassLoader()); + Optional> declaredFieldTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(fieldType, context.getClassLoaders()); TypeInfo fieldTypeInfo = TypeInfo.of(fieldType); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index 33545afaf7f..00bf16fa4a9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -51,7 +51,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact return Optional.empty(); } - Optional> declaredValueTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(valueType, context.getContextClassLoader()); + Optional> declaredValueTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(valueType, context.getClassLoaders()); TypeInfo valueTypeInfo = TypeInfo.of(valueType); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java index 34721c1a6ea..bc1071f0bf2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java @@ -36,7 +36,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact return Optional.empty(); } - Optional> vector2fTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2f.class, context.getContextClassLoader()); + Optional> vector2fTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2f.class, context.getClassLoaders()); if (!vector2fTypeHandler.isPresent()) { LOGGER.error("No Vector2f type handler found"); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java index 3ef91d3ca49..d071f92c772 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java @@ -36,7 +36,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact return Optional.empty(); } - Optional> vector2iTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2i.class, context.getContextClassLoader()); + Optional> vector2iTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2i.class, context.getClassLoaders()); if (!vector2iTypeHandler.isPresent()) { LOGGER.error("No Vector2i type handler found"); diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 72d6c8bcf67..d59df9505fd 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -32,6 +32,7 @@ import java.util.Arrays; import java.util.List; import java.util.Locale; +import java.util.Optional; import java.util.Set; /** @@ -461,4 +462,15 @@ public static Object readField(Object object, String fieldName) { throw new IllegalArgumentException( "Cannot find field " + cls.getName() + "." + fieldName); } + + public static Optional> findClassInClassLoaders(String className, ClassLoader... classLoaders) { + for (ClassLoader classLoader : classLoaders) { + try { + return Optional.of(Class.forName(className, true, classLoader)); + } catch (ClassNotFoundException ignored) { + } + } + + return Optional.empty(); + } } From a1aaeb842cebcbfdc1452836cbbd12ac82281b93 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 29 Oct 2018 23:00:33 -0500 Subject: [PATCH 064/141] Add ReflectionUtil.getComprehensiveEngineClassLoaders --- .../org/terasology/utilities/ReflectionUtil.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index d59df9505fd..f98d385b63c 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -19,6 +19,7 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import org.terasology.module.ModuleEnvironment; import org.terasology.rendering.nui.UIWidget; import java.lang.reflect.Array; @@ -473,4 +474,18 @@ public static Optional> findClassInClassLoaders(String className, Class return Optional.empty(); } + + /** + * Returns a list of {@link ClassLoader}s which have access to all engine and loaded module + * classes. This function must NOT be accessible to modules. + * + * @param moduleEnvironment The {@link ModuleEnvironment} managing all loaded modules. + */ + public static ClassLoader[] getComprehensiveEngineClassLoaders(ModuleEnvironment moduleEnvironment) { + return new ClassLoader[]{ + ReflectionUtil.class.getClassLoader(), + // TODO: Reflection - can break with updates to gestalt + (ClassLoader) readField(moduleEnvironment, "finalClassLoader") + }; + } } From 11b2678ae53ed708d08512e1c526c78a5fc17ce6 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Oct 2018 01:46:53 -0500 Subject: [PATCH 065/141] Add RuntimeDelegatingTypeHandlerSandboxTest + test module --- ...ntimeDelegatingTypeHandlerSandboxTest.java | 204 ++++++++++++++++++ engine-tests/test-modules/.gitignore | 1 + .../module-with-empty-class/build.gradle | 34 +++ .../module-with-empty-class/module.info | 6 + .../emptyClassModule/EmptyClass.java | 23 ++ 5 files changed, 268 insertions(+) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java create mode 100644 engine-tests/test-modules/.gitignore create mode 100644 engine-tests/test-modules/module-with-empty-class/build.gradle create mode 100644 engine-tests/test-modules/module-with-empty-class/module.info create mode 100644 engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java new file mode 100644 index 00000000000..5a4eb1ff1f8 --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java @@ -0,0 +1,204 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.coreTypes; + +import com.google.common.collect.ImmutableMap; +import org.junit.Before; +import org.junit.Test; +import org.terasology.math.AABB; +import org.terasology.math.Region3i; +import org.terasology.module.DependencyResolver; +import org.terasology.module.ModuleEnvironment; +import org.terasology.module.ModulePathScanner; +import org.terasology.module.ModuleRegistry; +import org.terasology.module.TableModuleRegistry; +import org.terasology.module.sandbox.ModuleSecurityManager; +import org.terasology.module.sandbox.ModuleSecurityPolicy; +import org.terasology.module.sandbox.PermissionSet; +import org.terasology.module.sandbox.StandardPermissionProviderFactory; +import org.terasology.naming.Name; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.inMemory.PersistedInteger; +import org.terasology.persistence.typeHandling.inMemory.PersistedMap; +import org.terasology.persistence.typeHandling.inMemory.PersistedString; +import org.terasology.reflection.TypeInfo; +import org.terasology.utilities.ReflectionUtil; + +import java.io.FilePermission; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.security.Policy; +import java.util.Collections; +import java.util.Optional; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.*; + +public class RuntimeDelegatingTypeHandlerSandboxTest { + private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final Class apiClass = AABB.class; + private final Class nonApiClass = Region3i.class; + + private ModuleEnvironment moduleEnvironment; + private Class moduleClass; + + private TypeHandler baseTypeHandlerMock; + private TypeHandler moduleClassHandlerMock; + private TypeHandler apiClassHandlerMock; + + @Before + public void setup() { + ModuleRegistry registry = new TableModuleRegistry(); + Path modulesPath = Paths.get("engine-tests", "test-modules").toAbsolutePath(); + new ModulePathScanner().scan(registry, modulesPath); + + StandardPermissionProviderFactory permissionProviderFactory = new StandardPermissionProviderFactory(); + permissionProviderFactory.getBasePermissionSet().addAPIPackage("sun.reflect"); + permissionProviderFactory.getBasePermissionSet().addAPIPackage("java.lang"); + permissionProviderFactory.getBasePermissionSet().addAPIPackage("java.util"); + permissionProviderFactory.getBasePermissionSet().addAPIClass(apiClass); + PermissionSet ioPermissionSet = new PermissionSet(); + ioPermissionSet.addAPIPackage("java.io"); + ioPermissionSet.addAPIPackage("java.nio.file"); + ioPermissionSet.addAPIPackage("java.nio.file.attribute"); + ioPermissionSet.grantPermission(FilePermission.class); + permissionProviderFactory.addPermissionSet("io", ioPermissionSet); + + Policy.setPolicy(new ModuleSecurityPolicy()); + System.setSecurityManager(new ModuleSecurityManager()); + + DependencyResolver resolver = new DependencyResolver(registry); + moduleEnvironment = new ModuleEnvironment(resolver.resolve(new Name("EmptyClassModule")).getModules(), permissionProviderFactory, Collections.emptyList()); + + moduleClass = moduleEnvironment.getSubtypesOf(AutoCloseable.class).iterator().next(); + + baseTypeHandlerMock = mock(TypeHandler.class); + moduleClassHandlerMock = mock(TypeHandler.class); + apiClassHandlerMock = mock(TypeHandler.class); + + when(baseTypeHandlerMock.deserialize(any())) + .thenReturn(Optional.of(new PersistedInteger(0))); + + when(moduleClassHandlerMock.deserialize(any())) + .thenReturn(Optional.of(new PersistedInteger(0))); + + when(apiClassHandlerMock.deserialize(any())) + .thenReturn(Optional.of(new PersistedInteger(0))); + + when(typeSerializationLibrary.getTypeHandler(eq(Object.class), any())) + .thenReturn(Optional.of(baseTypeHandlerMock)); + + when(typeSerializationLibrary.getTypeHandler(eq(moduleClass), any())) + .thenReturn(Optional.of(moduleClassHandlerMock)); + + when(typeSerializationLibrary.getTypeHandler(eq(apiClass), any())) + .thenReturn(Optional.of(apiClassHandlerMock)); + } + + @Test + public void testAccessModuleClassFromEngine() { + TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment)); + + RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); + + PersistedData persistedModuleClassInstance = new PersistedMap( + ImmutableMap.of( + RuntimeDelegatingTypeHandler.TYPE_FIELD, + new PersistedString(moduleClass.getName()), + RuntimeDelegatingTypeHandler.VALUE_FIELD, + new PersistedMap(ImmutableMap.of()) + ) + ); + + assertTrue(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); + + verify(baseTypeHandlerMock, times(0)).deserialize(any()); + verify(moduleClassHandlerMock, times(1)).deserialize(any()); + } + + @Test + public void testCannotAccessModuleClassFromEngineWithoutClassLoader() { + TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + ReflectionUtil.class.getClassLoader()); + + RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); + + PersistedData persistedModuleClassInstance = new PersistedMap( + ImmutableMap.of( + RuntimeDelegatingTypeHandler.TYPE_FIELD, + new PersistedString(moduleClass.getName()), + RuntimeDelegatingTypeHandler.VALUE_FIELD, + new PersistedMap(ImmutableMap.of()) + ) + ); + + assertFalse(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); + + verify(baseTypeHandlerMock, times(0)).deserialize(any()); + verify(moduleClassHandlerMock, times(0)).deserialize(any()); + } + + @Test + public void testAccessApiClassFromModule() { + TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + moduleClass.getClassLoader()); + + RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); + + PersistedData persistedModuleClassInstance = new PersistedMap( + ImmutableMap.of( + RuntimeDelegatingTypeHandler.TYPE_FIELD, + new PersistedString(apiClass.getName()), + RuntimeDelegatingTypeHandler.VALUE_FIELD, + new PersistedMap(ImmutableMap.of()) + ) + ); + + assertTrue(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); + + verify(baseTypeHandlerMock, times(0)).deserialize(any()); + verify(apiClassHandlerMock, times(1)).deserialize(any()); + } + + @Test + public void testCannotAccessNonApiClassFromModule() { + TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + moduleClass.getClassLoader()); + + RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); + + PersistedData persistedModuleClassInstance = new PersistedMap( + ImmutableMap.of( + RuntimeDelegatingTypeHandler.TYPE_FIELD, + new PersistedString(nonApiClass.getName()), + RuntimeDelegatingTypeHandler.VALUE_FIELD, + new PersistedMap(ImmutableMap.of()) + ) + ); + + assertFalse(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); + + verify(baseTypeHandlerMock, times(0)).deserialize(any()); + verify(apiClassHandlerMock, times(0)).deserialize(any()); + } +} diff --git a/engine-tests/test-modules/.gitignore b/engine-tests/test-modules/.gitignore new file mode 100644 index 00000000000..08a55c09bdf --- /dev/null +++ b/engine-tests/test-modules/.gitignore @@ -0,0 +1 @@ +.gradle diff --git a/engine-tests/test-modules/module-with-empty-class/build.gradle b/engine-tests/test-modules/module-with-empty-class/build.gradle new file mode 100644 index 00000000000..d7fef2c9de2 --- /dev/null +++ b/engine-tests/test-modules/module-with-empty-class/build.gradle @@ -0,0 +1,34 @@ +/* + * Copyright 2015 MovingBlocks + * + * 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. + */ + +/* + * This is a Gradle build file: + * - Gradle Homepage: http://gradle.org/ + * - Gradle Documentation: http://gradle.org/documentation + * - View tasks for this project: $ gradlew tasks + */ + +apply plugin: 'java' + +println this.getGradle().gradleUserHomeDir + +sourceSets { + main { + java { + output.classesDir 'build/classes' + } + } +} diff --git a/engine-tests/test-modules/module-with-empty-class/module.info b/engine-tests/test-modules/module-with-empty-class/module.info new file mode 100644 index 00000000000..c81e3ec7541 --- /dev/null +++ b/engine-tests/test-modules/module-with-empty-class/module.info @@ -0,0 +1,6 @@ +{ + "id" : "EmptyClassModule", + "version" : "1.0.0", + "displayName" : "Empty Class Module", + "description" : "This module contains an empty class" +} diff --git a/engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java b/engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java new file mode 100644 index 00000000000..10c5c8d9ace --- /dev/null +++ b/engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java @@ -0,0 +1,23 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.emptyClassModule; + +public class EmptyClass implements AutoCloseable { + public void close() { + + } +} From 1dd161eba07d7abeb7a350fed1dec03528fd5ce6 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Oct 2018 15:48:08 -0500 Subject: [PATCH 066/141] Add test-modules to engine-tests build config --- ...ntimeDelegatingTypeHandlerSandboxTest.java | 15 +++++++-- engine-tests/subprojects.gradle | 32 +++++++++++++++++++ 2 files changed, 45 insertions(+), 2 deletions(-) create mode 100644 engine-tests/subprojects.gradle diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java index 5a4eb1ff1f8..a4de7b7b4db 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java @@ -45,10 +45,12 @@ import java.nio.file.Paths; import java.security.Policy; import java.util.Collections; +import java.util.Iterator; import java.util.Optional; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; @@ -68,7 +70,11 @@ public class RuntimeDelegatingTypeHandlerSandboxTest { @Before public void setup() { ModuleRegistry registry = new TableModuleRegistry(); - Path modulesPath = Paths.get("engine-tests", "test-modules").toAbsolutePath(); + Path modulesPath = Paths.get("").toAbsolutePath(); + if (!modulesPath.endsWith("engine-tests")){ + modulesPath = modulesPath.resolve("engine-tests"); + } + modulesPath = modulesPath.resolve("test-modules"); new ModulePathScanner().scan(registry, modulesPath); StandardPermissionProviderFactory permissionProviderFactory = new StandardPermissionProviderFactory(); @@ -89,7 +95,12 @@ public void setup() { DependencyResolver resolver = new DependencyResolver(registry); moduleEnvironment = new ModuleEnvironment(resolver.resolve(new Name("EmptyClassModule")).getModules(), permissionProviderFactory, Collections.emptyList()); - moduleClass = moduleEnvironment.getSubtypesOf(AutoCloseable.class).iterator().next(); + Iterator> moduleClasses = + moduleEnvironment.getSubtypesOf(AutoCloseable.class).iterator(); + + assumeTrue(moduleClasses.hasNext()); + + moduleClass = moduleClasses.next(); baseTypeHandlerMock = mock(TypeHandler.class); moduleClassHandlerMock = mock(TypeHandler.class); diff --git a/engine-tests/subprojects.gradle b/engine-tests/subprojects.gradle new file mode 100644 index 00000000000..95ffa79df9a --- /dev/null +++ b/engine-tests/subprojects.gradle @@ -0,0 +1,32 @@ +import java.nio.file.Paths + +/* + * Copyright 2018 MovingBlocks + * + * 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. + */ + +new File(rootDir, Paths.get('engine-tests', 'test-modules').toString()).eachDir { testModuleDir -> + def testModuleName = 'testModules:' + testModuleDir.name + //println "Gradle is reviewing module $testModuleName for inclusion as a sub-project" + File buildFile = new File(testModuleDir, "build.gradle") + if (buildFile.exists()) { + println "Test module $testModuleName has a build file so counting it complete and including it" + include testModuleName + def testModulePath = ':' + testModuleName + def testModuleProject = project(testModulePath) + testModuleProject.projectDir = testModuleDir + } else { + println "***** WARNING: Found a test module without a build.gradle, corrupt dir? NOT including $testModuleName *****" + } +} From 93fc43c94090c6877688f9fa773872c989e488fe Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Mon, 29 Oct 2018 21:18:27 -0300 Subject: [PATCH 067/141] Adapted (and refactored) RR serializer to use CollectionTypeHandler --- .../coreTypes/CharacterTypeHandler.java | 3 + .../recording/RecordAndReplaySerializer.java | 12 +- .../recording/RecordedEventSerializer.java | 487 ++---------------- 3 files changed, 45 insertions(+), 457 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java index 4e4623b1e4d..1805e44cc2c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/CharacterTypeHandler.java @@ -22,14 +22,17 @@ import java.util.Optional; public class CharacterTypeHandler extends TypeHandler { + @Override protected PersistedData serializeNonNull(Character value, PersistedDataSerializer serializer) { + // converts value to string since char is not a JSON primitive type return serializer.serialize(Character.toString(value)); } @Override public Optional deserialize(PersistedData data) { if (data.isString()) { + // returns the character that was serialized as string return Optional.of(data.getAsString().charAt(0)); } return Optional.empty(); diff --git a/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java b/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java index 183dec6a62d..8ce81097d07 100644 --- a/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java @@ -47,7 +47,6 @@ public final class RecordAndReplaySerializer { private static final String STATE_EVENT_POSITION = "/state_event_position" + JSON; private static final String DIRECTION_ORIGIN_LIST = "/direction_origin_list" + JSON; - private EntityManager entityManager; private RecordedEventStore recordedEventStore; private RecordAndReplayUtils recordAndReplayUtils; private CharacterStateEventPositionMap characterStateEventPositionMap; @@ -57,12 +56,11 @@ public final class RecordAndReplaySerializer { public RecordAndReplaySerializer(EntityManager manager, RecordedEventStore store, RecordAndReplayUtils recordAndReplayUtils, CharacterStateEventPositionMap characterStateEventPositionMap, DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList, ModuleEnvironment moduleEnvironment) { - this.entityManager = manager; this.recordedEventStore = store; this.recordAndReplayUtils = recordAndReplayUtils; this.characterStateEventPositionMap = characterStateEventPositionMap; this.directionAndOriginPosRecorderList = directionAndOriginPosRecorderList; - this.recordedEventSerializer = new RecordedEventSerializer(entityManager, moduleEnvironment); + this.recordedEventSerializer = new RecordedEventSerializer(manager, moduleEnvironment); } /** @@ -73,7 +71,7 @@ public void serializeRecordAndReplayData() { serializeRecordedEvents(recordingPath); Gson gson = new GsonBuilder().create(); serializeFileAmount(gson, recordingPath); - serializeCharacterStateEventPositonMap(gson, recordingPath); + serializeCharacterStateEventPositionMap(gson, recordingPath); serializeAttackEventExtraRecorder(gson, recordingPath); } @@ -97,7 +95,7 @@ public void deserializeRecordAndReplayData() { deserializeRecordedEvents(recordingPath); Gson gson = new GsonBuilder().create(); deserializeFileAmount(gson, recordingPath); - deserializeCharacterStateEventPositonMap(gson, recordingPath); + deserializeCharacterStateEventPositionMap(gson, recordingPath); deserializeAttackEventExtraRecorder(gson, recordingPath); } @@ -135,7 +133,7 @@ private void deserializeFileAmount(Gson gson, String recordingPath) { } } - private void serializeCharacterStateEventPositonMap(Gson gson, String recordingPath) { + private void serializeCharacterStateEventPositionMap(Gson gson, String recordingPath) { try { JsonWriter writer = new JsonWriter(new FileWriter(recordingPath + STATE_EVENT_POSITION)); gson.toJson(characterStateEventPositionMap.getIdToData(), HashMap.class, writer); @@ -147,7 +145,7 @@ private void serializeCharacterStateEventPositonMap(Gson gson, String recordingP } } - private void deserializeCharacterStateEventPositonMap(Gson gson, String recordingPath) { + private void deserializeCharacterStateEventPositionMap(Gson gson, String recordingPath) { try (FileReader fileReader = new FileReader(recordingPath + STATE_EVENT_POSITION)) { JsonParser parser = new JsonParser(); JsonElement jsonElement = parser.parse(fileReader); diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index db5e8d040e4..b96647ce098 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -17,46 +17,17 @@ import com.google.gson.Gson; import com.google.gson.GsonBuilder; -import com.google.gson.JsonArray; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonParser; -import com.google.gson.stream.JsonWriter; -import gnu.trove.list.TFloatList; -import gnu.trove.list.array.TFloatArrayList; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.terasology.audio.StaticSound; -import org.terasology.audio.events.PlaySoundEvent; -import org.terasology.engine.SimpleUri; import org.terasology.entitySystem.entity.EntityManager; import org.terasology.entitySystem.entity.EntityRef; -import org.terasology.entitySystem.entity.LowLevelEntityManager; import org.terasology.entitySystem.entity.internal.EngineEntityManager; -import org.terasology.entitySystem.event.Event; -import org.terasology.input.BindAxisEvent; -import org.terasology.input.BindButtonEvent; import org.terasology.input.ButtonState; import org.terasology.input.Keyboard; import org.terasology.input.MouseInput; -import org.terasology.input.cameraTarget.CameraTargetChangedEvent; -import org.terasology.input.events.InputEvent; -import org.terasology.input.events.KeyDownEvent; -import org.terasology.input.events.KeyEvent; -import org.terasology.input.events.KeyRepeatEvent; -import org.terasology.input.events.KeyUpEvent; import org.terasology.input.events.MouseAxisEvent; -import org.terasology.input.events.MouseButtonEvent; -import org.terasology.input.events.MouseWheelEvent; -import org.terasology.logic.characters.CharacterMoveInputEvent; -import org.terasology.logic.characters.GetMaxSpeedEvent; import org.terasology.logic.characters.MovementMode; -import org.terasology.logic.characters.events.AttackEvent; -import org.terasology.math.geom.Vector2i; -import org.terasology.math.geom.Vector3f; -import org.terasology.math.geom.Vector3i; import org.terasology.module.ModuleEnvironment; -import org.terasology.naming.Name; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; @@ -64,16 +35,18 @@ import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; import org.terasology.persistence.typeHandling.gson.GsonPersistedData; import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; +import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; +import java.io.Reader; import java.io.FileReader; +import java.io.Writer; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; -import java.util.Map; +import java.util.Optional; /** * Serializes and deserializes RecordedEvents. @@ -81,445 +54,59 @@ class RecordedEventSerializer { private static final Logger logger = LoggerFactory.getLogger(RecordedEventSerializer.class); - private static final double DEFAULT_DOUBLE_VALUE = 0.0; - private TypeSerializationLibrary typeSerializationLibrary; - private EntityManager entityManager; - private ModuleEnvironment moduleEnvironment; - private Map> inputEventClassMap; + private TypeHandler> recordedEventListTypeHandler; - RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment moduleEnvironment) { + public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment moduleEnvironment) { ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - this.typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); + + TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); typeSerializationLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); typeSerializationLibrary.addTypeHandler(MouseAxisEvent.MouseAxis.class, new EnumTypeHandler<>(MouseAxisEvent.MouseAxis.class)); typeSerializationLibrary.addTypeHandler(ButtonState.class, new EnumTypeHandler<>(ButtonState.class)); typeSerializationLibrary.addTypeHandler(Keyboard.Key.class, new EnumTypeHandler<>(Keyboard.Key.class)); typeSerializationLibrary.addTypeHandler(MouseInput.class, new EnumTypeHandler<>(MouseInput.class)); typeSerializationLibrary.addTypeHandler(MovementMode.class, new EnumTypeHandler<>(MovementMode.class)); - this.entityManager = entityManager; - this.moduleEnvironment = moduleEnvironment; - } - - void serializeRecordedEvents(List events, String filePath) { - try { - JsonWriter writer = new JsonWriter(new FileWriter(filePath)); - writer.beginObject(); - writer.name("events"); - writer.beginArray(); - for (RecordedEvent event : events) { - writer.beginObject(); - writer.name("entityRef_ID").value(event.getEntityId()); - writer.name("timestamp").value(event.getTimestamp()); - writer.name("index").value(event.getIndex()); - writer.name("event_class").value(event.getEvent().getClass().getName()); - writer.name("event_data"); - writer.beginObject(); - writeSpecificEventData(writer, event.getEvent()); - writer.endObject(); - writer.endObject(); - } - writer.endArray(); - writer.endObject(); - writer.close(); - } catch (Exception e) { - logger.error("Error while serializing events:", e); - } - + this.recordedEventListTypeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); } - private void writeSpecificEventData(JsonWriter writer, Event event) { - try { - GsonPersistedDataSerializer serializationContext = new GsonPersistedDataSerializer(); + /** + * Serializes RecordedEvent's list. + * + * @param events RecordedEvent's list. + * @param filePath path where the data should be saved. + */ + public void serializeRecordedEvents(List events, String filePath) { + GsonPersistedDataSerializer serializationContext = new GsonPersistedDataSerializer(); + PersistedData data = recordedEventListTypeHandler.serialize(events, serializationContext); + + try (Writer writer = new FileWriter(filePath)) { Gson gson = new GsonBuilder().create(); - if (event instanceof InputEvent) { - InputEvent e = (InputEvent) event; - writer.name("delta").value(e.getDelta()); - writer.name("consumed").value(e.isConsumed()); - writer.name("target").value(e.getTarget().getId()); - - writeVector3fData(writer, serializationContext, e); - writeInputEventInstanceData(writer, event, serializationContext); - - - } else if (event instanceof CameraTargetChangedEvent) { - CameraTargetChangedEvent e = (CameraTargetChangedEvent) event; - writer.name("OldTarget").value(e.getOldTarget().getId()); - writer.name("NewTarget").value(e.getNewTarget().getId()); - } else if (event instanceof PlaySoundEvent) { - PlaySoundEvent e = (PlaySoundEvent) event; - writer.name("volume").value(e.getVolume()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class, getClass().getClassLoader()).get(); - PersistedData data = handler.serialize(e.getSound(), serializationContext); - writer.name("sound").value(data.getAsString()); - - } else if (event instanceof CharacterMoveInputEvent) { - CharacterMoveInputEvent e = (CharacterMoveInputEvent) event; - writer.name("delta").value(e.getDeltaMs()); - writer.name("pitch").value(e.getPitch()); - writer.name("yaw").value(e.getYaw()); - writer.name("running").value(e.isRunning()); - writer.name("crouching").value(e.isCrouching()); - writer.name("jumpRequested").value(e.isJumpRequested()); - writer.name("sequeceNumber").value(e.getSequenceNumber()); - writer.name("firstRun").value(e.isFirstRun()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementDirection(), serializationContext); - writer.name("movementDirection"); - writer.beginObject(); - JsonArray array = data.getElement().getAsJsonArray(); - writer.name("x").value(array.get(0).getAsFloat()); - writer.name("y").value(array.get(1).getAsFloat()); - writer.name("z").value(array.get(2).getAsFloat()); - writer.endObject(); - - } else if (event instanceof GetMaxSpeedEvent) { - GetMaxSpeedEvent e = (GetMaxSpeedEvent) event; - writer.name("baseValue").value(e.getBaseValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMovementMode(), serializationContext); - writer.name("movementMode").value(data.getAsString()); - writer.name("modifiers"); - gson.toJson(e.getModifiers(), TFloatArrayList.class, writer); - writer.name("multipliers"); - gson.toJson(e.getMultipliers(), TFloatArrayList.class, writer); - writer.name("postModifiers"); - gson.toJson(e.getPostModifiers(), TFloatArrayList.class, writer); - } else if (event instanceof AttackEvent) { - AttackEvent e = (AttackEvent) event; - writer.name("instigator").value(e.getInstigator().getId()); - writer.name("directCause").value(e.getDirectCause().getId()); - } else { - logger.error("ERROR: EVENT NOT SUPPORTED FOR SERIALIZATION"); - } - } catch (Exception e) { - logger.error("Could not serialize this event: " + event.toString(), e); - } - } - - private void writeVector3fData(JsonWriter writer, GsonPersistedDataSerializer serializationContext, InputEvent e) throws IOException { - if (e.getHitNormal() == null) { - writeDefaultVector3fData(writer); - } else { - writeRealVector3fData(writer, serializationContext, e); - } - } - - private void writeRealVector3fData(JsonWriter writer, GsonPersistedDataSerializer serializationContext, InputEvent e) throws IOException { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector3f.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getHitNormal(), serializationContext); - writer.name("hitNormal"); - writer.beginObject(); - JsonArray array = data.getElement().getAsJsonArray(); - writer.name("x").value(array.get(0).getAsFloat()); - writer.name("y").value(array.get(1).getAsFloat()); - writer.name("z").value(array.get(2).getAsFloat()); - writer.endObject(); - - data = (GsonPersistedData) handler.serialize(e.getHitPosition(), serializationContext); - writer.name("hitPosition"); - writer.beginObject(); - array = data.getElement().getAsJsonArray(); - writer.name("x").value(array.get(0).getAsFloat()); - writer.name("y").value(array.get(1).getAsFloat()); - writer.name("z").value(array.get(2).getAsFloat()); - writer.endObject(); - - handler = typeSerializationLibrary.getTypeHandler(Vector3i.class, getClass().getClassLoader()).get(); - data = (GsonPersistedData) handler.serialize(e.getTargetBlockPosition(), serializationContext); - writer.name("targetBlockPosition"); - writer.beginObject(); - array = data.getElement().getAsJsonArray(); - writer.name("x").value(array.get(0).getAsInt()); - writer.name("y").value(array.get(1).getAsInt()); - writer.name("z").value(array.get(2).getAsInt()); - writer.endObject(); - } - - private void writeDefaultVector3fData(JsonWriter writer) throws IOException { - writer.name("hitNormal"); - writer.beginObject(); - writer.name("x").value(DEFAULT_DOUBLE_VALUE); - writer.name("y").value(DEFAULT_DOUBLE_VALUE); - writer.name("z").value(DEFAULT_DOUBLE_VALUE); - writer.endObject(); - - writer.name("hitPosition"); - writer.beginObject(); - writer.name("x").value(DEFAULT_DOUBLE_VALUE); - writer.name("y").value(DEFAULT_DOUBLE_VALUE); - writer.name("z").value(DEFAULT_DOUBLE_VALUE); - writer.endObject(); - - writer.name("targetBlockPosition"); - writer.beginObject(); - writer.name("x").value(DEFAULT_DOUBLE_VALUE); - writer.name("y").value(DEFAULT_DOUBLE_VALUE); - writer.name("z").value(DEFAULT_DOUBLE_VALUE); - writer.endObject(); - } - - private void writeInputEventInstanceData(JsonWriter writer, Event event, GsonPersistedDataSerializer serializationContext) throws Exception { - if (event instanceof MouseWheelEvent) { - MouseWheelEvent e = (MouseWheelEvent) event; - writer.name("wheelTurns").value(e.getWheelTurns()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(Vector2i.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); - writer.name("mousePosition"); - writer.beginObject(); - JsonArray array = data.getElement().getAsJsonArray(); - writer.name("x").value(array.get(0).getAsInt()); - writer.name("y").value(array.get(1).getAsInt()); - writer.endObject(); - } else if (event instanceof MouseAxisEvent) { - MouseAxisEvent e = (MouseAxisEvent) event; - writer.name("value").value(e.getValue()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getMouseAxis(), serializationContext); - writer.name("mouseAxis").value(data.getAsString()); - } else if (event instanceof BindAxisEvent) { - BindAxisEvent e = (BindAxisEvent) event; - writer.name("id").value(e.getId()); - writer.name("value").value(e.getValue()); - } else if (event instanceof BindButtonEvent) { - BindButtonEvent e = (BindButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); - writer.name("state").value(data.getAsString()); - writer.name("id"); - writer.beginObject(); - handler = typeSerializationLibrary.getTypeHandler(Name.class, getClass().getClassLoader()).get(); - data = (GsonPersistedData) handler.serialize(e.getId().getModuleName(), serializationContext); - writer.name("moduleName").value(data.getAsString()); - data = (GsonPersistedData) handler.serialize(e.getId().getObjectName(), serializationContext); - writer.name("objectName").value(data.getAsString()); - writer.endObject(); - } else if (event instanceof KeyEvent) { - KeyEvent e = (KeyEvent) event; - writer.name("keychar").value(e.getKeyCharacter()); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); - writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class, getClass().getClassLoader()).get(); // might need to add some things to key - data = (GsonPersistedData) handler.serialize(e.getKey(), serializationContext); - writer.name("input").value(data.getAsString()); - } else if (event instanceof MouseButtonEvent) { - MouseButtonEvent e = (MouseButtonEvent) event; - TypeHandler handler = typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); - GsonPersistedData data = (GsonPersistedData) handler.serialize(e.getState(), serializationContext); - writer.name("state").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(MouseInput.class, getClass().getClassLoader()).get(); - data = (GsonPersistedData) handler.serialize(e.getButton(), serializationContext); - writer.name("button").value(data.getAsString()); - handler = typeSerializationLibrary.getTypeHandler(Vector2i.class, getClass().getClassLoader()).get(); - data = (GsonPersistedData) handler.serialize(e.getMousePosition(), serializationContext); - writer.name("mousePosition"); - writer.beginObject(); - JsonArray array = data.getElement().getAsJsonArray(); - writer.name("x").value(array.get(0).getAsInt()); - writer.name("y").value(array.get(1).getAsInt()); - writer.endObject(); - } else { - logger.error("ERROR, EVENT NOT COMPATIBLE"); + gson.toJson(data, writer); + } catch (IOException e) { + logger.error("Error while serializing recorded events", e); } } - List deserializeRecordedEvents(String path) { + /** + * Deserializes RecordedEvent's list. + * + * @param filePath path where the data should be saved. + */ + public List deserializeRecordedEvents(String filePath) { List events = new ArrayList<>(); - createInputEventClassMap(); - JsonObject jsonObject; - try (FileReader fileReader = new FileReader(path)) { - JsonParser parser = new JsonParser(); - JsonElement jsonElement = parser.parse(fileReader); - jsonObject = jsonElement.getAsJsonObject(); - JsonArray jsonEvents = jsonObject.getAsJsonArray("events"); - for (JsonElement element : jsonEvents) { - jsonObject = element.getAsJsonObject(); - String className = jsonObject.get("event_class").getAsString(); - long refId = jsonObject.get("entityRef_ID").getAsLong(); - long index = jsonObject.get("index").getAsLong(); - long timestamp = jsonObject.get("timestamp").getAsLong(); - Event event = deserializeSpecificEventData(jsonObject.get("event_data").getAsJsonObject(), className); - RecordedEvent re = new RecordedEvent(refId, event, timestamp, index); - events.add(re); - } - } catch (Exception e) { - logger.error("Error while deserializing event:", e); - } - - return events; - } - - private void createInputEventClassMap() { - this.inputEventClassMap = new HashMap<>(); - Iterable> classes = moduleEnvironment.getSubtypesOf(InputEvent.class); - for (Class c : classes) { - this.inputEventClassMap.put(c.getName(), c); - } - } - - private Event deserializeSpecificEventData(JsonObject jsonObject, String className) { - Event result = null; - Gson gson = new GsonBuilder().create(); - if (className.equals(CameraTargetChangedEvent.class.getName())) { - EntityRef oldTarget = new RecordedEntityRef(jsonObject.get("OldTarget").getAsLong(), (LowLevelEntityManager) this.entityManager); - EntityRef newTarget = new RecordedEntityRef(jsonObject.get("NewTarget").getAsLong(), (LowLevelEntityManager) this.entityManager); - result = new CameraTargetChangedEvent(oldTarget, newTarget); - } else if (className.equals(PlaySoundEvent.class.getName())) { - float volume = jsonObject.get("volume").getAsFloat(); - GsonPersistedData data = new GsonPersistedData(jsonObject.get("sound")); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(StaticSound.class, getClass().getClassLoader()).get(); - StaticSound sound = handler.deserializeOrThrow(data); - result = new PlaySoundEvent(sound, volume); - } else if (className.equals(CharacterMoveInputEvent.class.getName())) { - long delta = jsonObject.get("delta").getAsLong(); - float pitch = jsonObject.get("pitch").getAsFloat(); - float yaw = jsonObject.get("yaw").getAsFloat(); - boolean running = jsonObject.get("running").getAsBoolean(); - boolean crouching = jsonObject.get("crouching").getAsBoolean(); - boolean jumpRequested = jsonObject.get("jumpRequested").getAsBoolean(); - int sequenceNumber = jsonObject.get("sequeceNumber").getAsInt(); - boolean firstRun = jsonObject.get("firstRun").getAsBoolean(); - JsonObject objMoveDirection = jsonObject.get("movementDirection").getAsJsonObject(); - Vector3f movementDirection = new Vector3f(objMoveDirection.get("x").getAsFloat(), - objMoveDirection.get("y").getAsFloat(), - objMoveDirection.get("z").getAsFloat()); - result = new CharacterMoveInputEvent(sequenceNumber, pitch, yaw, movementDirection, running, crouching, jumpRequested, delta); - } else if (className.equals(GetMaxSpeedEvent.class.getName())) { - float baseValue = jsonObject.get("baseValue").getAsFloat(); - TypeHandler handler = typeSerializationLibrary.getTypeHandler(MovementMode.class, getClass().getClassLoader()).get(); - GsonPersistedData data = new GsonPersistedData(jsonObject.get("movementMode")); - MovementMode movementMode = handler.deserializeOrThrow(data); - TFloatList modifiers = gson.fromJson(jsonObject.get("modifiers"), TFloatArrayList.class); - TFloatList multipliers = gson.fromJson(jsonObject.get("multipliers"), TFloatArrayList.class); - TFloatList postModifiers = gson.fromJson(jsonObject.get("postModifiers"), TFloatArrayList.class); - GetMaxSpeedEvent event = new GetMaxSpeedEvent(baseValue, movementMode); - event.setPostModifiers(postModifiers); - event.setMultipliers(multipliers); - event.setModifiers(modifiers); - result = event; - } else if (className.equals(AttackEvent.class.getName())) { - EntityRef instigator = new RecordedEntityRef(jsonObject.get("instigator").getAsLong(), (LowLevelEntityManager) this.entityManager); - EntityRef directCause = new RecordedEntityRef(jsonObject.get("directCause").getAsLong(), (LowLevelEntityManager) this.entityManager); - result = new AttackEvent(instigator, directCause); - } else if (getInputEventSpecificType(jsonObject, className) != null) { //input events - result = getInputEventSpecificType(jsonObject, className); - } - return result; - } - - private InputEvent getInputEventSpecificType(JsonObject jsonObject, String className) { - InputEvent newEvent = null; - try { - Class clazz = this.inputEventClassMap.get(className); - if (BindButtonEvent.class.isAssignableFrom(clazz) || BindAxisEvent.class.isAssignableFrom(clazz)) { - newEvent = (InputEvent) clazz.getConstructor().newInstance(); - } else if (clazz.equals(KeyDownEvent.class) || clazz.equals(KeyRepeatEvent.class) || clazz.equals(KeyUpEvent.class)) { //KeyEvent - GsonPersistedData data = new GsonPersistedData(jsonObject.get("input")); - TypeHandler keyTypeHandler = typeSerializationLibrary.getTypeHandler(Keyboard.Key.class, getClass().getClassLoader()).get(); - Keyboard.Key input = keyTypeHandler.deserializeOrThrow(data); - data = new GsonPersistedData(jsonObject.get("state")); - TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); - ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); - char keychar = jsonObject.get("keychar").getAsCharacter(); - float delta = jsonObject.get("delta").getAsFloat(); - KeyEvent aux; - if (clazz.equals(KeyDownEvent.class)) { - aux = KeyDownEvent.create(input, keychar, delta); // The instance created here is static - aux = KeyDownEvent.createCopy((KeyDownEvent) aux); // This copies the static value so each KeyEvent does not have the same value - } else if (clazz.equals(KeyRepeatEvent.class)) { - aux = KeyRepeatEvent.create(input, keychar, delta); - aux = KeyRepeatEvent.createCopy((KeyRepeatEvent) aux); - } else { - aux = KeyUpEvent.create(input, keychar, delta); - aux = KeyUpEvent.createCopy((KeyUpEvent) aux); - } - newEvent = aux; - } else if (clazz.equals(MouseButtonEvent.class)) { - GsonPersistedData data = new GsonPersistedData(jsonObject.get("button")); - TypeHandler mouseInputTypeHandler = - typeSerializationLibrary.getTypeHandler(MouseInput.class, getClass().getClassLoader()).get(); - MouseInput button = mouseInputTypeHandler.deserializeOrThrow(data); - data = new GsonPersistedData(jsonObject.get("state")); - TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); - ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); - JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); - Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); - float delta = jsonObject.get("delta").getAsFloat(); - MouseButtonEvent event = new MouseButtonEvent(button, state, delta); - event.setMousePosition(mousePosition); - newEvent = event; - } else if (clazz.equals(MouseAxisEvent.class)) { - GsonPersistedData data = new GsonPersistedData(jsonObject.get("mouseAxis")); - TypeHandler typeHandler = - typeSerializationLibrary.getTypeHandler(MouseAxisEvent.MouseAxis.class, getClass().getClassLoader()).get(); - MouseAxisEvent.MouseAxis mouseAxis = typeHandler.deserializeOrThrow(data); - float value = jsonObject.get("value").getAsFloat(); - float delta = jsonObject.get("delta").getAsFloat(); - MouseAxisEvent aux = MouseAxisEvent.create(mouseAxis, value, delta); - newEvent = MouseAxisEvent.createCopy(aux); - } else if (clazz.equals(MouseWheelEvent.class)) { - JsonObject aux = jsonObject.get("mousePosition").getAsJsonObject(); - Vector2i mousePosition = new Vector2i(aux.get("x").getAsInt(), aux.get("y").getAsInt()); - int wheelTurns = jsonObject.get("wheelTurns").getAsInt(); - float delta = jsonObject.get("delta").getAsFloat(); - newEvent = new MouseWheelEvent(mousePosition, wheelTurns, delta); - } else { - logger.error("Not an Input Event"); - return null; - } - - if (newEvent instanceof BindButtonEvent) { - bindButtonEventSetup((BindButtonEvent) newEvent, jsonObject); - } else if (newEvent instanceof BindAxisEvent) { - bindAxisEvent((BindAxisEvent) newEvent, jsonObject); - } - - inputEventSetup(newEvent, jsonObject); - } catch (Exception e) { - logger.error("Error while deserializing event. Could not find class " + className, e); + try (Reader reader = new FileReader(filePath)) { + Gson gson = new GsonBuilder().create(); + PersistedData record = gson.fromJson(reader, GsonPersistedData.class); + Optional> recordedEvents = recordedEventListTypeHandler.deserialize(record); + recordedEvents.ifPresent(events::addAll); + } catch (IOException e) { + logger.error("Error while serializing recorded events", e); } - return newEvent; - } - private void bindButtonEventSetup(BindButtonEvent event, JsonObject jsonObject) { - GsonPersistedData data = new GsonPersistedData(jsonObject.get("state")); - TypeHandler buttonStateTypeHandler = - typeSerializationLibrary.getTypeHandler(ButtonState.class, getClass().getClassLoader()).get(); - ButtonState state = buttonStateTypeHandler.deserializeOrThrow(data); - float delta = jsonObject.get("delta").getAsFloat(); - TypeHandler nameTypeHandler = typeSerializationLibrary.getTypeHandler(Name.class, getClass().getClassLoader()).get(); - JsonObject aux = jsonObject.get("id").getAsJsonObject(); - data = new GsonPersistedData(aux.get("moduleName")); - Name moduleName = nameTypeHandler.deserializeOrThrow(data); - data = new GsonPersistedData(aux.get("objectName")); - Name objectName = nameTypeHandler.deserializeOrThrow(data); - SimpleUri id = new SimpleUri(moduleName, objectName); - event.prepare(id, state, delta); - } - - private void bindAxisEvent(BindAxisEvent event, JsonObject jsonObject) { - String id = jsonObject.get("id").getAsString(); - float value = jsonObject.get("value").getAsFloat(); - float delta = jsonObject.get("delta").getAsFloat(); - event.prepare(id, value, delta); - } - - private void inputEventSetup(InputEvent event, JsonObject jsonObject) { - float delta = jsonObject.get("delta").getAsFloat(); - boolean consumed = jsonObject.get("consumed").getAsBoolean(); - EntityRef target = new RecordedEntityRef(jsonObject.get("target").getAsLong(), (LowLevelEntityManager) this.entityManager); - JsonObject aux = jsonObject.get("hitNormal").getAsJsonObject(); - Vector3f hitNormal = new Vector3f(aux.get("x").getAsFloat(), aux.get("y").getAsFloat(), aux.get("z").getAsFloat()); - aux = jsonObject.get("hitPosition").getAsJsonObject(); - Vector3f hitPosition = new Vector3f(aux.get("x").getAsFloat(), aux.get("y").getAsFloat(), aux.get("z").getAsFloat()); - aux = jsonObject.get("targetBlockPosition").getAsJsonObject(); - Vector3i targetBlockPosition = new Vector3i(aux.get("x").getAsInt(), aux.get("y").getAsInt(), aux.get("z").getAsInt()); - event.setTargetInfo(target, targetBlockPosition, hitPosition, hitNormal); + return events; } } From 6575e49affda912ae39e96c775c12fc77e0afc73 Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Tue, 30 Oct 2018 00:55:42 -0300 Subject: [PATCH 068/141] Write and read JsonElement instead of PersistentData itself --- .../terasology/recording/RecordedEventSerializer.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index b96647ce098..f63c92411eb 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -17,6 +17,7 @@ import com.google.gson.Gson; import com.google.gson.GsonBuilder; +import com.google.gson.JsonElement; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.entitySystem.entity.EntityManager; @@ -80,11 +81,11 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo */ public void serializeRecordedEvents(List events, String filePath) { GsonPersistedDataSerializer serializationContext = new GsonPersistedDataSerializer(); - PersistedData data = recordedEventListTypeHandler.serialize(events, serializationContext); + GsonPersistedData data = (GsonPersistedData) recordedEventListTypeHandler.serialize(events, serializationContext); try (Writer writer = new FileWriter(filePath)) { Gson gson = new GsonBuilder().create(); - gson.toJson(data, writer); + gson.toJson(data.getElement(), writer); } catch (IOException e) { logger.error("Error while serializing recorded events", e); } @@ -100,8 +101,10 @@ public List deserializeRecordedEvents(String filePath) { try (Reader reader = new FileReader(filePath)) { Gson gson = new GsonBuilder().create(); - PersistedData record = gson.fromJson(reader, GsonPersistedData.class); - Optional> recordedEvents = recordedEventListTypeHandler.deserialize(record); + JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); + PersistedData persistedData = new GsonPersistedData(jsonElement); + + Optional> recordedEvents = recordedEventListTypeHandler.deserialize(persistedData); recordedEvents.ifPresent(events::addAll); } catch (IOException e) { logger.error("Error while serializing recorded events", e); From 9764023747192cbda184c188791496b6746e4865 Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Tue, 30 Oct 2018 01:21:30 -0300 Subject: [PATCH 069/141] Pass in classLoaders to recorded event list TypeHandler --- .../org/terasology/recording/RecordedEventSerializer.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index f63c92411eb..1f7db715ec3 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -39,6 +39,7 @@ import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; +import org.terasology.utilities.ReflectionUtil; import java.io.Reader; import java.io.FileReader; @@ -70,7 +71,10 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo typeSerializationLibrary.addTypeHandler(MouseInput.class, new EnumTypeHandler<>(MouseInput.class)); typeSerializationLibrary.addTypeHandler(MovementMode.class, new EnumTypeHandler<>(MovementMode.class)); - this.recordedEventListTypeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}).get(); + ClassLoader[] classLoaders = ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment); + + this.recordedEventListTypeHandler = typeSerializationLibrary.getTypeHandler( + new TypeInfo>() {}, classLoaders).get(); } /** From a585967cbb9282118e06199d0effe62813b9295c Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Tue, 30 Oct 2018 20:33:09 -0300 Subject: [PATCH 070/141] Mock ModuleEnvironmnet to prevent tests from failing --- .../terasology/persistence/internal/StorageManagerTest.java | 2 +- .../org/terasology/recording/EventSystemReplayImplTest.java | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java b/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java index 850a6c62100..74e26a39f42 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java @@ -108,7 +108,7 @@ public void setup() throws Exception { assert !Files.isRegularFile(vfs.getPath("global.dat")); entityManager = context.get(EngineEntityManager.class); - moduleEnvironment = context.get(ModuleEnvironment.class); + moduleEnvironment = mock(ModuleEnvironment.class); blockManager = context.get(BlockManager.class); extraDataManager = context.get(ExtraBlockDataManager.class); diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 2074ea77404..511ec640ccf 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -31,6 +31,7 @@ import org.terasology.entitySystem.systems.BaseComponentSystem; import org.terasology.input.binds.interaction.AttackButton; import org.terasology.input.events.InputEvent; +import org.terasology.module.ModuleEnvironment; import org.terasology.network.NetworkMode; import org.terasology.network.NetworkSystem; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; @@ -73,7 +74,9 @@ public void setup() { RecordAndReplayUtils recordAndReplayUtils = new RecordAndReplayUtils(); CharacterStateEventPositionMap characterStateEventPositionMap = new CharacterStateEventPositionMap(); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = new DirectionAndOriginPosRecorderList(); - RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, eventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, null); + ModuleEnvironment moduleEnvironment = mock(ModuleEnvironment.class); + RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, eventStore, + recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleEnvironment); recordAndReplayCurrentStatus.setStatus(RecordAndReplayStatus.REPLAYING); entity = entityManager.create(); Long id = entity.getId(); From fedf155727a2a68356cdfd0db5a52c56d0f22492 Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Wed, 31 Oct 2018 23:31:38 -0300 Subject: [PATCH 071/141] Added error log when occur problems with recorded events deserialization --- .../org/terasology/recording/RecordedEventSerializer.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 1f7db715ec3..b7c528ebc4b 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -110,6 +110,10 @@ public List deserializeRecordedEvents(String filePath) { Optional> recordedEvents = recordedEventListTypeHandler.deserialize(persistedData); recordedEvents.ifPresent(events::addAll); + + if (!recordedEvents.isPresent()) { + logger.error("Some problem occurred during deserialization, no recorded events was found"); + } } catch (IOException e) { logger.error("Error while serializing recorded events", e); } From ef25400c9c3c7076e9d136e9ad7f9ae4a1aeef79 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 5 Nov 2018 13:26:00 -0600 Subject: [PATCH 072/141] Add TypeHandler overloads that take classes instead of class loaders --- .../RuntimeDelegatingTypeHandlerSandboxTest.java | 10 +++++----- .../RuntimeDelegatingTypeHandlerTest.java | 16 ++++++++-------- .../factories/ArrayTypeHandlerFactoryTest.java | 4 ++-- .../CollectionTypeHandlerFactoryTest.java | 8 ++++---- .../ObjectFieldMapTypeHandlerFactoryTest.java | 4 ++-- .../StringMapTypeHandlerFactoryTest.java | 4 ++-- .../typeHandling/TypeHandlerFactoryContext.java | 11 +++++++++++ .../typeHandling/TypeSerializationLibrary.java | 16 +++++++++++++++- ...onTypeSerializationLibraryAdapterFactory.java | 3 ++- 9 files changed, 51 insertions(+), 25 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java index a4de7b7b4db..4da4a2dda98 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java @@ -115,13 +115,13 @@ public void setup() { when(apiClassHandlerMock.deserialize(any())) .thenReturn(Optional.of(new PersistedInteger(0))); - when(typeSerializationLibrary.getTypeHandler(eq(Object.class), any())) + when(typeSerializationLibrary.getTypeHandler(eq(Object.class), (ClassLoader) any())) .thenReturn(Optional.of(baseTypeHandlerMock)); - when(typeSerializationLibrary.getTypeHandler(eq(moduleClass), any())) + when(typeSerializationLibrary.getTypeHandler(eq(moduleClass), (ClassLoader) any())) .thenReturn(Optional.of(moduleClassHandlerMock)); - when(typeSerializationLibrary.getTypeHandler(eq(apiClass), any())) + when(typeSerializationLibrary.getTypeHandler(eq(apiClass), (ClassLoader) any())) .thenReturn(Optional.of(apiClassHandlerMock)); } @@ -172,7 +172,7 @@ public void testCannotAccessModuleClassFromEngineWithoutClassLoader() { @Test public void testAccessApiClassFromModule() { TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, - moduleClass.getClassLoader()); + moduleClass); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); @@ -194,7 +194,7 @@ public void testAccessApiClassFromModule() { @Test public void testCannotAccessNonApiClassFromModule() { TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, - moduleClass.getClassLoader()); + moduleClass); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index b01cf2f2bec..06e21282080 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -74,10 +74,10 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType), any())) + when(typeSerializationLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) .thenReturn(Optional.of(baseTypeHandler)); - when(typeSerializationLibrary.getTypeHandler(eq((Type) subType), any())) + when(typeSerializationLibrary.getTypeHandler(eq((Type) subType), (ClassLoader) any())) .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = @@ -86,8 +86,8 @@ abstract class SubHandler extends TypeHandler {} ArrayList bases = Lists.newArrayList(new Sub(), new Base(), new Sub(), new Base(), new Sub()); listTypeHandler.serialize(bases, serializer); - verify(typeSerializationLibrary).getTypeHandler(eq(baseType), any()); - verify(typeSerializationLibrary, times(3)).getTypeHandler(eq((Type) subType), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); + verify(typeSerializationLibrary, times(3)).getTypeHandler(eq((Type) subType), (ClassLoader) any()); verify(baseTypeHandler, times(2)).serialize(any(), any()); verify(subTypeHandler, times(3)).serialize(any(), any()); @@ -109,10 +109,10 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType), any())) + when(typeSerializationLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) .thenReturn(Optional.of(baseTypeHandler)); - when(typeSerializationLibrary.getTypeHandler(eq(subType), any())) + when(typeSerializationLibrary.getTypeHandler(eq(subType), (ClassLoader) any())) .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = collectionHandlerFactory.create( @@ -139,8 +139,8 @@ abstract class SubHandler extends TypeHandler {} listTypeHandler.deserialize(persistedBases); - verify(typeSerializationLibrary).getTypeHandler(eq(baseType), any()); - verify(typeSerializationLibrary, times(3)).getTypeHandler(eq(subType), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); + verify(typeSerializationLibrary, times(3)).getTypeHandler(eq(subType), (ClassLoader) any()); verify(baseTypeHandler, times(2)).deserialize(any()); verify(subTypeHandler, times(3)).deserialize(any()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java index c1b94d9db5e..be5a141d86a 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java @@ -49,7 +49,7 @@ public void testArray() { assertTrue(typeHandler.get() instanceof ArrayTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType()), (ClassLoader) any()); } @Test @@ -63,7 +63,7 @@ public void testGenericArray() { assertTrue(typeHandler.get() instanceof ArrayTypeHandler); // Verify that the List TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType()), (ClassLoader) any()); } @Test diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index c8c08d1f893..75211a247fc 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -54,7 +54,7 @@ public void testList() { assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -68,7 +68,7 @@ public void testSet() { assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -82,7 +82,7 @@ public void testQueue() { assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -96,6 +96,6 @@ class IntList extends ArrayList {} assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index 78da2d3d4ec..0fa232b3b51 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -59,10 +59,10 @@ public void testObject() { // Verify that the Integer and List TypeHandlers were loaded from the TypeSerializationLibrary verify(typeSerializationLibrary).getTypeHandler( eq(TypeInfo.of(Integer.class).getType()), - any()); + (ClassLoader) any()); verify(typeSerializationLibrary).getTypeHandler( eq(new TypeInfo>() {}.getType()), - any()); + (ClassLoader) any()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java index 50f05fd9c99..6d5af3db38e 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -51,7 +51,7 @@ public void testStringMap() { assertTrue(typeHandler.get() instanceof StringMapTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -75,6 +75,6 @@ class IntMap extends HashMap {} assertTrue(typeHandler.get() instanceof StringMapTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), any()); + verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java index fd4e4048719..300fe548d21 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java @@ -17,6 +17,8 @@ import org.terasology.reflection.TypeInfo; +import java.util.Arrays; + /** * Represents the context in which a {@link TypeHandlerFactory} creates {@link TypeHandler} instances. *

@@ -27,6 +29,15 @@ public class TypeHandlerFactoryContext { private TypeSerializationLibrary typeSerializationLibrary; private ClassLoader[] classLoaders; + public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibrary, Class... classes) { + this( + typeSerializationLibrary, + Arrays.stream(classes) + .map(Class::getClassLoader) + .toArray(ClassLoader[]::new) + ); + } + public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibrary, ClassLoader... classLoaders) { this.typeSerializationLibrary = typeSerializationLibrary; this.classLoaders = classLoaders; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 74d001e6b9e..59142b93197 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -69,6 +69,7 @@ import org.terasology.rendering.nui.Color; import java.lang.reflect.Type; +import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Optional; @@ -213,6 +214,13 @@ public void addInstanceCreator(TypeInfo typeInfo, InstanceCreator inst instanceCreators.put(typeInfo.getType(), instanceCreator); } + @SuppressWarnings({"unchecked"}) + public Optional> getTypeHandler(Type type, Class... classes) { + return getTypeHandler(type, Arrays.stream(classes) + .map(Class::getClassLoader) + .toArray(ClassLoader[]::new)); + } + @SuppressWarnings({"unchecked"}) public Optional> getTypeHandler(Type type, ClassLoader... contextClassLoaders) { TypeInfo typeInfo = TypeInfo.of(type); @@ -220,6 +228,12 @@ public Optional> getTypeHandler(Type type, ClassLoader... context } + public Optional> getTypeHandler(Class typeClass, Class... classes) { + return getTypeHandler(typeClass, Arrays.stream(classes) + .map(Class::getClassLoader) + .toArray(ClassLoader[]::new)); + } + public Optional> getTypeHandler(Class typeClass, ClassLoader... contextClassLoaders) { return getTypeHandler(TypeInfo.of(typeClass), contextClassLoaders); } @@ -250,7 +264,7 @@ public Optional> getTypeHandler(TypeInfo type, ClassLoader private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type) { Map, TypeHandler> handlerMap = Maps.newHashMap(); for (FieldMetadata field : type.getFields()) { - Optional> handler = getTypeHandler(field.getField().getGenericType(), getClass().getClassLoader()); + Optional> handler = getTypeHandler(field.getField().getGenericType(), getClass()); if (handler.isPresent()) { handlerMap.put(field, handler.get()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java index 4cc83f34a41..8d3ad0ef7ad 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java @@ -42,7 +42,8 @@ public GsonTypeSerializationLibraryAdapterFactory(TypeSerializationLibrary typeS public TypeAdapter create(Gson gson, TypeToken type) { Type rawType = type.getType(); - TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType, getClass().getClassLoader()).orElse(null); + TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType, + GsonTypeSerializationLibraryAdapterFactory.class).orElse(null); if (typeHandler == null || typeHandler instanceof ObjectFieldMapTypeHandler) { return null; From ad4d51131095a946ac41fb8feef3a0abda070096 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 5 Nov 2018 13:30:48 -0600 Subject: [PATCH 073/141] Test RuntimeDelegatingTypeHandler access of module class from module --- .../RuntimeDelegatingTypeHandlerSandboxTest.java | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java index 4da4a2dda98..c0609ff9681 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java @@ -171,6 +171,15 @@ public void testCannotAccessModuleClassFromEngineWithoutClassLoader() { @Test public void testAccessApiClassFromModule() { + testCanAccessClassFromModule(apiClass, apiClassHandlerMock); + } + + @Test + public void testAccessModuleClassFromModule() { + testCanAccessClassFromModule(moduleClass, moduleClassHandlerMock); + } + + private void testCanAccessClassFromModule(Class testClass, TypeHandler testClassHandlerMock) { TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, moduleClass); @@ -179,7 +188,7 @@ public void testAccessApiClassFromModule() { PersistedData persistedModuleClassInstance = new PersistedMap( ImmutableMap.of( RuntimeDelegatingTypeHandler.TYPE_FIELD, - new PersistedString(apiClass.getName()), + new PersistedString(testClass.getName()), RuntimeDelegatingTypeHandler.VALUE_FIELD, new PersistedMap(ImmutableMap.of()) ) @@ -188,7 +197,7 @@ public void testAccessApiClassFromModule() { assertTrue(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); verify(baseTypeHandlerMock, times(0)).deserialize(any()); - verify(apiClassHandlerMock, times(1)).deserialize(any()); + verify(testClassHandlerMock, times(1)).deserialize(any()); } @Test From 77ba36bc74473fc5d64a13b40754788bc5135119 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 5 Nov 2018 16:39:42 -0600 Subject: [PATCH 074/141] Add getTypeHandler(TypeInfo, Class...) overload --- .../persistence/typeHandling/TypeSerializationLibrary.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 59142b93197..83bad1011df 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -238,6 +238,13 @@ public Optional> getTypeHandler(Class typeClass, ClassLoad return getTypeHandler(TypeInfo.of(typeClass), contextClassLoaders); } + @SuppressWarnings("unchecked") + public Optional> getTypeHandler(TypeInfo type, Class... contextClasses) { + return getTypeHandler(type, Arrays.stream(contextClasses) + .map(Class::getClassLoader) + .toArray(ClassLoader[]::new)); + } + @SuppressWarnings("unchecked") public Optional> getTypeHandler(TypeInfo type, ClassLoader... contextClassLoaders) { TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(this, contextClassLoaders); From ba5c4bac98d2ebcab90fd5047e44f5067b7f4e81 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 5 Nov 2018 16:45:42 -0600 Subject: [PATCH 075/141] Simplify serialization interface via Gson and ProtobufSerializer --- .../TypeSerializerTest.java} | 87 ++++++++---------- .../serializers/GsonSerializer.java | 90 +++++++++++++++++++ .../serializers/ProtobufSerializer.java | 70 +++++++++++++++ .../rendering/nui/asset/UIFormat.java | 2 + 4 files changed, 200 insertions(+), 49 deletions(-) rename engine-tests/src/test/java/org/terasology/persistence/{typeHandling/TypeHandlingIntegrationTest.java => serializers/TypeSerializerTest.java} (59%) create mode 100644 engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java create mode 100644 engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java similarity index 59% rename from engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java rename to engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 08dbb3f331a..18a41b68a7b 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlingIntegrationTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -13,26 +13,22 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.terasology.persistence.typeHandling; +package org.terasology.persistence.serializers; import com.google.common.collect.Lists; import com.google.common.collect.Sets; -import com.google.gson.Gson; -import com.google.gson.JsonElement; import org.junit.Test; +import org.junit.experimental.runners.Enclosed; +import org.junit.runner.RunWith; import org.terasology.math.geom.Vector3f; -import org.terasology.persistence.typeHandling.gson.GsonPersistedData; -import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; -import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; -import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; -import org.terasology.protobuf.EntityData; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.rendering.nui.Color; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.List; import java.util.Objects; @@ -40,9 +36,8 @@ import static org.junit.Assert.assertEquals; -public class TypeHandlingIntegrationTest { - private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Dog\",\"@value\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"@type\":\"org.terasology.persistence.typeHandling.TypeHandlingIntegrationTest$Cheetah\",\"@value\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; - +@RunWith(Enclosed.class) +public class TypeSerializerTest { private static final SomeClass INSTANCE = new SomeClass<>(0xdeadbeef); static { @@ -53,58 +48,52 @@ public class TypeHandlingIntegrationTest { INSTANCE.animals.add(new Cheetah(Color.MAGENTA)); } - private ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); - private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); - - @Test - public void testJsonSerialize() { + public static class Json { + private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"@type\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"@value\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"@type\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"@value\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + private ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); + private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); - GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(INSTANCE, new GsonPersistedDataSerializer()); + @Test + public void testJsonSerialize() { + GsonSerializer gsonSerializer = new GsonSerializer(); - Gson gson = new Gson(); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, TypeSerializerTest.class).get(); - assertEquals(INSTANCE_JSON, gson.toJson(persistedData.getElement())); - } - - @Test - public void testJsonDeserialize() { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + assertEquals(INSTANCE_JSON, gsonSerializer.toJson(INSTANCE, typeHandler)); + } - Gson gson = new Gson(); - JsonElement jsonElement = gson.fromJson(INSTANCE_JSON, JsonElement.class); + @Test + public void testDeserialize() { + GsonSerializer gsonSerializer = new GsonSerializer(); + PersistedData persistedData = gsonSerializer.persistedDatafromJson(INSTANCE_JSON); - PersistedData persistedData = new GsonPersistedData(jsonElement); + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); - SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); + SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); - assertEquals(INSTANCE, deserializedInstance); + assertEquals(INSTANCE, deserializedInstance); + } } - @Test - public void testProtobufSerializeDeserialize() throws IOException { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + public static class Protobuf { + private ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); + private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); - ProtobufPersistedData persistedData = (ProtobufPersistedData) typeHandler.serialize(INSTANCE, new ProtobufPersistedDataSerializer()); + @Test + public void testSerializeDeserialize() throws IOException { + TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); - byte[] bytes; + ProtobufSerializer protobufSerializer = new ProtobufSerializer(); - try (ByteArrayOutputStream out = new ByteArrayOutputStream()) { - persistedData.getValue().writeDelimitedTo(out); - bytes = out.toByteArray(); - } + byte[] bytes = protobufSerializer.toBytes(INSTANCE, typeHandler); - EntityData.Value value; + PersistedData persistedData = protobufSerializer.persistedDatafromBytes(bytes); - try (ByteArrayInputStream in = new ByteArrayInputStream(bytes)) { - value = EntityData.Value.parseDelimitedFrom(in); - } + SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); - persistedData = new ProtobufPersistedData(value); - SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); - - assertEquals(INSTANCE, deserializedInstance); + assertEquals(INSTANCE, deserializedInstance); + } } private static class SomeClass { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java new file mode 100644 index 00000000000..a80fd6069e7 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -0,0 +1,90 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.serializers; + +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.gson.GsonPersistedData; +import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.Reader; +import java.io.StringReader; +import java.io.StringWriter; +import java.io.Writer; + +// TODO: Document +public class GsonSerializer { + private Gson gson; + + public GsonSerializer() { + this.gson = new Gson(); + } + + public String toJson(T object, TypeHandler typeHandler) { + StringWriter writer = new StringWriter(); + + writeJson(object, typeHandler, writer); + + return writer.toString(); + } + + public void writeJson(T object, TypeHandler typeHandler, Writer writer) { + GsonPersistedData persistedData = + (GsonPersistedData) typeHandler.serialize(object, new GsonPersistedDataSerializer()); + + gson.toJson(persistedData.getElement(), writer); + } + + public void writeJson(T object, TypeHandler typeHandler, OutputStream stream) { + writeJson(object, typeHandler, new BufferedWriter(new OutputStreamWriter(stream))); + } + + public void writeJson(T object, TypeHandler typeHandler, File file) throws IOException { + writeJson(object, typeHandler, new BufferedWriter(new FileWriter(file))); + } + + public PersistedData persistedDatafromJson(Reader reader) { + JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); + + return new GsonPersistedData(jsonElement); + } + + public PersistedData persistedDatafromJson(InputStream stream) { + return persistedDatafromJson(new InputStreamReader(stream)); + } + + public PersistedData persistedDatafromJson(File file) throws FileNotFoundException { + return persistedDatafromJson(new FileReader(file)); + } + + public PersistedData persistedDatafromJson(String json) { + try (StringReader reader = new StringReader(json)) { + return persistedDatafromJson(reader); + } + } +} diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java new file mode 100644 index 00000000000..186ee84578a --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java @@ -0,0 +1,70 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.serializers; + +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; +import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; +import org.terasology.protobuf.EntityData; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +// TODO: Document +public class ProtobufSerializer { + public byte[] toBytes(T object, TypeHandler typeHandler) throws IOException { + try (ByteArrayOutputStream stream = new ByteArrayOutputStream()) { + writeBytes(object, typeHandler, stream); + return stream.toByteArray(); + } + } + + public void writeBytes(T object, TypeHandler typeHandler, File file) throws IOException { + writeBytes(object, typeHandler, new FileOutputStream(file)); + } + + public void writeBytes(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { + ProtobufPersistedData persistedData = + (ProtobufPersistedData) typeHandler.serialize(object, new ProtobufPersistedDataSerializer()); + + persistedData.getValue().writeDelimitedTo(stream); + } + + public PersistedData persistedDatafromBytes(InputStream stream) throws IOException { + EntityData.Value value = EntityData.Value.parseDelimitedFrom(stream); + + return new ProtobufPersistedData(value); + } + + public PersistedData persistedDatafromBytes(File file) throws IOException { + try (InputStream stream = new FileInputStream(file)) { + return persistedDatafromBytes(stream); + } + } + + public PersistedData persistedDatafromBytes(byte[] bytes) throws IOException { + try (InputStream reader = new ByteArrayInputStream(bytes)) { + return persistedDatafromBytes(reader); + } + } +} diff --git a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java index 9cedcdc29a8..a85e1782ed1 100644 --- a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java +++ b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java @@ -97,6 +97,8 @@ public UIData load(JsonElement element, Locale otherLocale) throws IOException { TypeSerializationLibrary library = new TypeSerializationLibrary(CoreRegistry.get(TypeSerializationLibrary.class)); library.addTypeHandler(UISkin.class, new AssetTypeHandler<>(UISkin.class)); + // TODO: Rewrite to use TypeSerializationLibrary + GsonBuilder gsonBuilder = new GsonBuilder() .registerTypeAdapterFactory(new GsonTypeSerializationLibraryAdapterFactory(library)) .registerTypeAdapterFactory(new CaseInsensitiveEnumTypeAdapterFactory()) From eae5d58eebfe62f28b4f879af21004a04149101f Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 5 Nov 2018 23:22:11 -0600 Subject: [PATCH 076/141] Add string path overloads for writeJson and writeBytes --- .../terasology/persistence/serializers/GsonSerializer.java | 4 ++++ .../persistence/serializers/ProtobufSerializer.java | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index a80fd6069e7..d6e5d0b34dd 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -68,6 +68,10 @@ public void writeJson(T object, TypeHandler typeHandler, File file) throw writeJson(object, typeHandler, new BufferedWriter(new FileWriter(file))); } + public void writeJson(T object, TypeHandler typeHandler, String path) throws IOException { + writeJson(object, typeHandler, new File(path)); + } + public PersistedData persistedDatafromJson(Reader reader) { JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java index 186ee84578a..a3ece4dad2f 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java @@ -43,6 +43,10 @@ public void writeBytes(T object, TypeHandler typeHandler, File file) thro writeBytes(object, typeHandler, new FileOutputStream(file)); } + public void writeBytes(T object, TypeHandler typeHandler, String path) throws IOException { + writeBytes(object, typeHandler, new File(path)); + } + public void writeBytes(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { ProtobufPersistedData persistedData = (ProtobufPersistedData) typeHandler.serialize(object, new ProtobufPersistedDataSerializer()); From 54c89f3c6b85fbba176d573c58070dd50b68fe98 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 5 Nov 2018 23:23:30 -0600 Subject: [PATCH 077/141] Use GsonSerializer in RecordedEventSerializer --- .../recording/RecordedEventSerializer.java | 37 ++++--------------- 1 file changed, 7 insertions(+), 30 deletions(-) diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index b7c528ebc4b..2725d80fb16 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -15,36 +15,23 @@ */ package org.terasology.recording; -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; -import com.google.gson.JsonElement; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.entitySystem.entity.EntityManager; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.EngineEntityManager; -import org.terasology.input.ButtonState; -import org.terasology.input.Keyboard; -import org.terasology.input.MouseInput; -import org.terasology.input.events.MouseAxisEvent; -import org.terasology.logic.characters.MovementMode; import org.terasology.module.ModuleEnvironment; +import org.terasology.persistence.serializers.GsonSerializer; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; -import org.terasology.persistence.typeHandling.gson.GsonPersistedData; -import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.utilities.ReflectionUtil; -import java.io.Reader; -import java.io.FileReader; -import java.io.Writer; -import java.io.FileWriter; +import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.List; @@ -57,6 +44,7 @@ class RecordedEventSerializer { private static final Logger logger = LoggerFactory.getLogger(RecordedEventSerializer.class); + private GsonSerializer gsonSerializer = new GsonSerializer(); private TypeHandler> recordedEventListTypeHandler; public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment moduleEnvironment) { @@ -65,11 +53,6 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); typeSerializationLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); - typeSerializationLibrary.addTypeHandler(MouseAxisEvent.MouseAxis.class, new EnumTypeHandler<>(MouseAxisEvent.MouseAxis.class)); - typeSerializationLibrary.addTypeHandler(ButtonState.class, new EnumTypeHandler<>(ButtonState.class)); - typeSerializationLibrary.addTypeHandler(Keyboard.Key.class, new EnumTypeHandler<>(Keyboard.Key.class)); - typeSerializationLibrary.addTypeHandler(MouseInput.class, new EnumTypeHandler<>(MouseInput.class)); - typeSerializationLibrary.addTypeHandler(MovementMode.class, new EnumTypeHandler<>(MovementMode.class)); ClassLoader[] classLoaders = ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment); @@ -84,12 +67,8 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo * @param filePath path where the data should be saved. */ public void serializeRecordedEvents(List events, String filePath) { - GsonPersistedDataSerializer serializationContext = new GsonPersistedDataSerializer(); - GsonPersistedData data = (GsonPersistedData) recordedEventListTypeHandler.serialize(events, serializationContext); - - try (Writer writer = new FileWriter(filePath)) { - Gson gson = new GsonBuilder().create(); - gson.toJson(data.getElement(), writer); + try { + gsonSerializer.writeJson(events, recordedEventListTypeHandler, filePath); } catch (IOException e) { logger.error("Error while serializing recorded events", e); } @@ -103,10 +82,8 @@ public void serializeRecordedEvents(List events, String filePath) public List deserializeRecordedEvents(String filePath) { List events = new ArrayList<>(); - try (Reader reader = new FileReader(filePath)) { - Gson gson = new GsonBuilder().create(); - JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); - PersistedData persistedData = new GsonPersistedData(jsonElement); + try { + PersistedData persistedData = gsonSerializer.persistedDatafromJson(new File(filePath)); Optional> recordedEvents = recordedEventListTypeHandler.deserialize(persistedData); recordedEvents.ifPresent(events::addAll); From 749c12a13409437008908d03fb8d2cae7b865ac4 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 12 Nov 2018 14:11:11 -0600 Subject: [PATCH 078/141] Add cyclic object graph support via FutureTypeHandler --- .../typeHandling/FutureTypeHandler.java | 46 +++++++++++++++ .../TypeSerializationLibrary.java | 59 +++++++++++++++---- 2 files changed, 95 insertions(+), 10 deletions(-) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/FutureTypeHandler.java diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/FutureTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/FutureTypeHandler.java new file mode 100644 index 00000000000..c23dee529fa --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/FutureTypeHandler.java @@ -0,0 +1,46 @@ +/* + * Copyright 2018 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + +import java.util.Optional; + +class FutureTypeHandler extends TypeHandler { + public TypeHandler typeHandler; + + private void throwIfTypeHandlerNull() { + if (typeHandler == null) { + throw new SerializationException("Future TypeHandler has not been generated yet"); + } + } + + @Override + public PersistedData serialize(T value, PersistedDataSerializer serializer) { + throwIfTypeHandlerNull(); + return typeHandler.serialize(value, serializer); + } + + @Override + protected PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { + throwIfTypeHandlerNull(); + return typeHandler.serializeNonNull(value, serializer); + } + + @Override + public Optional deserialize(PersistedData data) { + throwIfTypeHandlerNull(); + return typeHandler.deserialize(data); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 83bad1011df..23419a9850e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -70,6 +70,7 @@ import java.lang.reflect.Type; import java.util.Arrays; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; @@ -86,6 +87,15 @@ public class TypeSerializationLibrary { private Map, TypeHandler> typeHandlerCache = Maps.newHashMap(); + /** + * In certain object graphs, creating a {@link TypeHandler} for a type may recursively + * require an {@link TypeHandler} for the same type. Without intervention, the recursive + * lookup would stack overflow. Thus, for type handlers in the process of being created, + * we return a delegate to the {@link TypeHandler} via {@link FutureTypeHandler} which is + * wired after the {@link TypeHandler} has been created. + */ + private final ThreadLocal, FutureTypeHandler>> futureTypeHandlers = new ThreadLocal<>(); + private Map> instanceCreators = Maps.newHashMap(); private ConstructorLibrary constructorLibrary; @@ -253,19 +263,48 @@ public Optional> getTypeHandler(TypeInfo type, ClassLoader return Optional.of((TypeHandler) typeHandlerCache.get(type)); } - // TODO: Explore reversing typeHandlerFactories itself before building object - for (int i = typeHandlerFactories.size() - 1; i >= 0; i--) { - TypeHandlerFactory typeHandlerFactory = typeHandlerFactories.get(i); - Optional> typeHandler = typeHandlerFactory.create(type, context); + Map, FutureTypeHandler> futures = futureTypeHandlers.get(); + boolean cleanupFutureTypeHandlers = false; - if (typeHandler.isPresent()) { - TypeHandler handler = typeHandler.get(); - typeHandlerCache.put(type, handler); - return Optional.of(handler); - } + if (futures == null) { + cleanupFutureTypeHandlers = true; + futures = new HashMap<>(); + futureTypeHandlers.set(futures); } - return Optional.empty(); + FutureTypeHandler future = (FutureTypeHandler) futures.get(type); + + if (future != null) { + return Optional.of(future); + } + + try { + future = new FutureTypeHandler<>(); + futures.put(type, future); + + // TODO: Explore reversing typeHandlerFactories itself before building object + for (int i = typeHandlerFactories.size() - 1; i >= 0; i--) { + TypeHandlerFactory typeHandlerFactory = typeHandlerFactories.get(i); + Optional> typeHandler = typeHandlerFactory.create(type, context); + + if (typeHandler.isPresent()) { + TypeHandler handler = typeHandler.get(); + + typeHandlerCache.put(type, handler); + future.typeHandler = handler; + + return Optional.of(handler); + } + } + + return Optional.empty(); + } finally { + futures.remove(type); + + if (cleanupFutureTypeHandlers) { + futureTypeHandlers.remove(); + } + } } private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type) { From 4a51f4490fc225c8547544fa0f71b5c88d9e99f7 Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Wed, 14 Nov 2018 22:25:12 -0300 Subject: [PATCH 079/141] Close writer to prevent file from not being fully written --- .../persistence/serializers/TypeSerializerTest.java | 2 +- .../persistence/serializers/GsonSerializer.java | 8 +++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 18a41b68a7b..3eb322e82c8 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -55,7 +55,7 @@ public static class Json { private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); @Test - public void testJsonSerialize() { + public void testJsonSerialize() throws IOException { GsonSerializer gsonSerializer = new GsonSerializer(); TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, TypeSerializerTest.class).get(); diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index d6e5d0b34dd..c5cf8cdad2a 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -45,7 +45,7 @@ public GsonSerializer() { this.gson = new Gson(); } - public String toJson(T object, TypeHandler typeHandler) { + public String toJson(T object, TypeHandler typeHandler) throws IOException { StringWriter writer = new StringWriter(); writeJson(object, typeHandler, writer); @@ -53,14 +53,16 @@ public String toJson(T object, TypeHandler typeHandler) { return writer.toString(); } - public void writeJson(T object, TypeHandler typeHandler, Writer writer) { + public void writeJson(T object, TypeHandler typeHandler, Writer writer) throws IOException { GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(object, new GsonPersistedDataSerializer()); gson.toJson(persistedData.getElement(), writer); + + writer.close(); } - public void writeJson(T object, TypeHandler typeHandler, OutputStream stream) { + public void writeJson(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { writeJson(object, typeHandler, new BufferedWriter(new OutputStreamWriter(stream))); } From 65bc6e02dd40b1900ab71683f5c77d073c3b6679 Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Wed, 14 Nov 2018 22:50:29 -0300 Subject: [PATCH 080/141] Add try-with-resource to close readers automatically --- .../serializers/TypeSerializerTest.java | 2 +- .../serializers/GsonSerializer.java | 19 +++++++++++-------- .../recording/RecordedEventSerializer.java | 2 +- 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 3eb322e82c8..60f32a2269b 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -66,7 +66,7 @@ public void testJsonSerialize() throws IOException { @Test public void testDeserialize() { GsonSerializer gsonSerializer = new GsonSerializer(); - PersistedData persistedData = gsonSerializer.persistedDatafromJson(INSTANCE_JSON); + PersistedData persistedData = gsonSerializer.persistedDataFromJson(INSTANCE_JSON); TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index c5cf8cdad2a..93b5c211797 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -24,7 +24,6 @@ import java.io.BufferedWriter; import java.io.File; -import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; @@ -74,23 +73,27 @@ public void writeJson(T object, TypeHandler typeHandler, String path) thr writeJson(object, typeHandler, new File(path)); } - public PersistedData persistedDatafromJson(Reader reader) { + public PersistedData persistedDataFromJson(Reader reader) { JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); return new GsonPersistedData(jsonElement); } - public PersistedData persistedDatafromJson(InputStream stream) { - return persistedDatafromJson(new InputStreamReader(stream)); + public PersistedData persistedDataFromJson(InputStream stream) throws IOException { + try (Reader reader = new InputStreamReader(stream)) { + return persistedDataFromJson(reader); + } } - public PersistedData persistedDatafromJson(File file) throws FileNotFoundException { - return persistedDatafromJson(new FileReader(file)); + public PersistedData persistedDataFromJson(File file) throws IOException { + try (Reader reader = new FileReader(file)) { + return persistedDataFromJson(reader); + } } - public PersistedData persistedDatafromJson(String json) { + public PersistedData persistedDataFromJson(String json) { try (StringReader reader = new StringReader(json)) { - return persistedDatafromJson(reader); + return persistedDataFromJson(reader); } } } diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 2725d80fb16..900485f2cf7 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -83,7 +83,7 @@ public List deserializeRecordedEvents(String filePath) { List events = new ArrayList<>(); try { - PersistedData persistedData = gsonSerializer.persistedDatafromJson(new File(filePath)); + PersistedData persistedData = gsonSerializer.persistedDataFromJson(new File(filePath)); Optional> recordedEvents = recordedEventListTypeHandler.deserialize(persistedData); recordedEvents.ifPresent(events::addAll); From 28ba172a9262575046767b9c029cfe03685531f1 Mon Sep 17 00:00:00 2001 From: Lucas Vieira Date: Thu, 15 Nov 2018 11:12:31 -0300 Subject: [PATCH 081/141] Closing writers in the right place --- .../serializers/TypeSerializerTest.java | 2 +- .../persistence/serializers/GsonSerializer.java | 14 ++++++++------ 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 60f32a2269b..060f8823860 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -55,7 +55,7 @@ public static class Json { private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); @Test - public void testJsonSerialize() throws IOException { + public void testJsonSerialize() { GsonSerializer gsonSerializer = new GsonSerializer(); TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, TypeSerializerTest.class).get(); diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 93b5c211797..3567f88c0c0 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -44,7 +44,7 @@ public GsonSerializer() { this.gson = new Gson(); } - public String toJson(T object, TypeHandler typeHandler) throws IOException { + public String toJson(T object, TypeHandler typeHandler) { StringWriter writer = new StringWriter(); writeJson(object, typeHandler, writer); @@ -52,21 +52,23 @@ public String toJson(T object, TypeHandler typeHandler) throws IOExceptio return writer.toString(); } - public void writeJson(T object, TypeHandler typeHandler, Writer writer) throws IOException { + public void writeJson(T object, TypeHandler typeHandler, Writer writer) { GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(object, new GsonPersistedDataSerializer()); gson.toJson(persistedData.getElement(), writer); - - writer.close(); } public void writeJson(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { - writeJson(object, typeHandler, new BufferedWriter(new OutputStreamWriter(stream))); + try (Writer writer = new BufferedWriter(new OutputStreamWriter(stream))) { + writeJson(object, typeHandler, writer); + } } public void writeJson(T object, TypeHandler typeHandler, File file) throws IOException { - writeJson(object, typeHandler, new BufferedWriter(new FileWriter(file))); + try (Writer writer = new BufferedWriter(new FileWriter(file))) { + writeJson(object, typeHandler, writer); + } } public void writeJson(T object, TypeHandler typeHandler, String path) throws IOException { From 7f4c69c9cb3220518548d43e3dbd4878dd191710 Mon Sep 17 00:00:00 2001 From: Nathan Date: Fri, 30 Nov 2018 18:12:06 -0500 Subject: [PATCH 082/141] Further changes to ProtobufSerialization Documentation --- .../serializers/ProtobufSerializer.java | 73 +++++++++++++++++-- 1 file changed, 66 insertions(+), 7 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java index a3ece4dad2f..9efbe226e0f 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java @@ -30,8 +30,16 @@ import java.io.InputStream; import java.io.OutputStream; -// TODO: Document public class ProtobufSerializer { + + /** + * Converts the object into an array of bytes and forwards it to {@link #writeBytes(Object, TypeHandler, OutputStream)} + * + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @return the byte array of the object + * @throws IOException throws if there is an error writing to the stream + */ public byte[] toBytes(T object, TypeHandler typeHandler) throws IOException { try (ByteArrayOutputStream stream = new ByteArrayOutputStream()) { writeBytes(object, typeHandler, stream); @@ -39,33 +47,84 @@ public byte[] toBytes(T object, TypeHandler typeHandler) throws IOExcepti } } - public void writeBytes(T object, TypeHandler typeHandler, File file) throws IOException { - writeBytes(object, typeHandler, new FileOutputStream(file)); + /** + * Takes a string path of a file and writes the serialized bytes into that file + * + * @see #writeBytes(Object, TypeHandler, File) + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @param fileName the path of the file in which it is being written to + * @throws IOException gets thrown if there is an error writing to the file + */ + public void writeBytes(T object, TypeHandler typeHandler, String fileName) throws IOException { + writeBytes(object, typeHandler, new File(fileName)); } - public void writeBytes(T object, TypeHandler typeHandler, String path) throws IOException { - writeBytes(object, typeHandler, new File(path)); + /** + * Writes an object's bytes to a file. + * + * @see #writeBytes(Object, TypeHandler, OutputStream) + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @param file file that the bytes will be written to + * @throws IOException gets thrown if there is an error writing to the file + */ + public void writeBytes(T object, TypeHandler typeHandler, File file) throws IOException { + writeBytes(object, typeHandler, new FileOutputStream(file)); } + /** + * Writes a given object to an OutputStream using protobuf and TypeHandler + * serialization + * + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @param stream stream that the bytes will be written to + * @throws IOException will be thrown if there is an error writing to the stream + */ public void writeBytes(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { - ProtobufPersistedData persistedData = - (ProtobufPersistedData) typeHandler.serialize(object, new ProtobufPersistedDataSerializer()); + ProtobufPersistedData persistedData = (ProtobufPersistedData) typeHandler.serialize(object, + new ProtobufPersistedDataSerializer()); persistedData.getValue().writeDelimitedTo(stream); } + /** + * Gets the PersistedData from a byte stream (InputStream). + * + * @see #persistedDatafromBytes(File) + * @param stream InputStream that will be deserialized + * @return deserialized ProtobufPersistedData object + * @throws IOException if there is an issue parsing the stream + */ public PersistedData persistedDatafromBytes(InputStream stream) throws IOException { EntityData.Value value = EntityData.Value.parseDelimitedFrom(stream); return new ProtobufPersistedData(value); } + /** + * Gets the PersistedData from a File. + * + * @see #persistedDatafromBytes(InputStream) + * @param file contains the bytes that will be deserialized + * @return deserialized ProtobufPersistedData object + * @throws IOException gets thrown if there is an issue reading the file + */ public PersistedData persistedDatafromBytes(File file) throws IOException { try (InputStream stream = new FileInputStream(file)) { return persistedDatafromBytes(stream); } } + /** + * Gets the PersistedData from an array of bytes. + * + * @see #persistedDatafromBytes(InputStream) + * @param bytes array of bytes to be deserialized + * @return deserialized ProtobufData object + * @throws IOException gets thrown if there is an issue creating the InputStream + */ public PersistedData persistedDatafromBytes(byte[] bytes) throws IOException { try (InputStream reader = new ByteArrayInputStream(bytes)) { return persistedDatafromBytes(reader); From 2c71e69ae5703f5aaf579d32075f7371b84f091e Mon Sep 17 00:00:00 2001 From: Nathan Date: Sat, 1 Dec 2018 14:50:46 -0500 Subject: [PATCH 083/141] Added Class Documentation to ProtobufSerializer --- .../persistence/serializers/ProtobufSerializer.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java index 9efbe226e0f..aa100be08c8 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java @@ -30,6 +30,14 @@ import java.io.InputStream; import java.io.OutputStream; +/** + * ProtobufSerializer provides the ability to serialize and deserialize between objects and bytes + *

+ * Serialized bytes can be forwarded/written to a File object, a File with a specific file name or OutputStream + *

+ * Bytes from byte arrays, File objects, and InputStreams can be deserialized and returned as PersistedData objects + * + */ public class ProtobufSerializer { /** From edd8e31d923b65d82782bc21f3459baf42d76c37 Mon Sep 17 00:00:00 2001 From: Nathan Date: Sat, 1 Dec 2018 15:22:46 -0500 Subject: [PATCH 084/141] Minor Changes to Class Documentation of ProtobufSerializer --- .../persistence/serializers/ProtobufSerializer.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java index aa100be08c8..b1a60b68c62 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java @@ -33,9 +33,9 @@ /** * ProtobufSerializer provides the ability to serialize and deserialize between objects and bytes *

- * Serialized bytes can be forwarded/written to a File object, a File with a specific file name or OutputStream + * Serialized bytes can be forwarded/written to various output types *

- * Bytes from byte arrays, File objects, and InputStreams can be deserialized and returned as PersistedData objects + * Various input types of serialized bytes can be deserialized and returned as PersistedData objects * */ public class ProtobufSerializer { From 90fe7b55e78f6f3c4434152eb587b66fe6367d3f Mon Sep 17 00:00:00 2001 From: nschnitzer Date: Sun, 2 Dec 2018 09:49:04 -0500 Subject: [PATCH 085/141] Added Documentation to GsonSerializer.java --- .../serializers/GsonSerializer.java | 94 ++++++++++++++++++- 1 file changed, 89 insertions(+), 5 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 3567f88c0c0..d5bfbd8af4a 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -36,14 +36,33 @@ import java.io.StringWriter; import java.io.Writer; -// TODO: Document +/** + * GsonSerializer provides the ability to serialize and deserialize between + * JSONs and Objects
+ *
+ * Serialized JSONs can be forwarded/written to various output types
+ *
+ * Various input types can be deserialized and returned as PersistedData types + * + */ public class GsonSerializer { private Gson gson; + /** + * Constructs a new GsonSerializer object + */ public GsonSerializer() { this.gson = new Gson(); } + /** + * Converts the object into an array of bytes and forwards it to + * {@link #writeJson(Object, TypeHandler, Writer)} + * + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @return contents of the JSON as a string + */ public String toJson(T object, TypeHandler typeHandler) { StringWriter writer = new StringWriter(); @@ -52,47 +71,112 @@ public String toJson(T object, TypeHandler typeHandler) { return writer.toString(); } + /** + * Writes an object's serialized persisted data to a Writer + * + * @see #writeJson(Object, TypeHandler, OutputStream) + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @param writer The writer in which the JSON will be written to + */ public void writeJson(T object, TypeHandler typeHandler, Writer writer) { - GsonPersistedData persistedData = - (GsonPersistedData) typeHandler.serialize(object, new GsonPersistedDataSerializer()); + GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(object, + new GsonPersistedDataSerializer()); gson.toJson(persistedData.getElement(), writer); } + /** + * Writes an object's serialized persisted data to an OutputStream + * + * @see #writeJson(Object, TypeHandler, Writer) + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @param stream stream that the data will be written to + * @throws IOException will be thrown if there is an error writing to the stream + */ public void writeJson(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { try (Writer writer = new BufferedWriter(new OutputStreamWriter(stream))) { writeJson(object, typeHandler, writer); } } + /** + * Writes the object's persisted data to a File object + * + * @see #writeJson(Object, TypeHandler, String) + * @param object the file to be serialized + * @param typeHandler contains how the object will be serialized + * @param file file that the bytes will be written to + * @throws IOException gets thrown if there is an issue writing to the file + */ public void writeJson(T object, TypeHandler typeHandler, File file) throws IOException { try (Writer writer = new BufferedWriter(new FileWriter(file))) { writeJson(object, typeHandler, writer); } } - public void writeJson(T object, TypeHandler typeHandler, String path) throws IOException { - writeJson(object, typeHandler, new File(path)); + /** + * Writes the a the object's persisted data to a File located at a specified file name + * + * @see #writeJson(Object, TypeHandler, String) + * @param object the object to be serialized + * @param typeHandler contains how the object will be serialized + * @param fileName the file name where the JSON will be written + * @throws IOException gets thrown if there is an error writing to the file at the specified location + */ + public void writeJson(T object, TypeHandler typeHandler, String fileName) throws IOException { + writeJson(object, typeHandler, new File(fileName)); } + /** + * Gets the PersistedData from a Reader object + * + * @see #persistedDataFromJson(InputStream) + * @param reader Reader object that will be deserialized + * @return deserialized GsonPersistedData object + */ public PersistedData persistedDataFromJson(Reader reader) { JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); return new GsonPersistedData(jsonElement); } + /** + * Gets the PersistedData from an InputStream + * + * @see #persistedDataFromJson(Reader) + * @param stream the InputStream that will be serialized + * @return deserialized GsonPersistedData object + * @throws IOException if there is an issue parsing the stream + */ public PersistedData persistedDataFromJson(InputStream stream) throws IOException { try (Reader reader = new InputStreamReader(stream)) { return persistedDataFromJson(reader); } } + /** + * Gets the PersistedData from a File object + * + * @see #persistedDataFromJson(String) + * @param file File object containing the JSON that will be deserialized + * @return deserialized GsonPersistedData object + * @throws IOException gets thrown if there is an issue reading the File object + */ public PersistedData persistedDataFromJson(File file) throws IOException { try (Reader reader = new FileReader(file)) { return persistedDataFromJson(reader); } } + /** + * Gets the PersistedData by forwarding a Reader which contains a String to {@link #persistedDataFromJson(Reader)} + * + * @see #persistedDataFromJson(Reader) + * @param json the String that will be deserialized + * @return deserialized GsonPersistedData Object + */ public PersistedData persistedDataFromJson(String json) { try (StringReader reader = new StringReader(json)) { return persistedDataFromJson(reader); From 684a20c9c76f40ef27b8d31dcea04edd423ccd47 Mon Sep 17 00:00:00 2001 From: nschnitzer Date: Mon, 3 Dec 2018 17:50:22 -0500 Subject: [PATCH 086/141] Enhanced Gson Serializer --- .../serializers/GsonSerializer.java | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index d5bfbd8af4a..4ad7699961e 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -56,8 +56,7 @@ public GsonSerializer() { } /** - * Converts the object into an array of bytes and forwards it to - * {@link #writeJson(Object, TypeHandler, Writer)} + * writes the serialized persisted data as a JSON to {@link Writer} and returns the JSON as a string. * * @param object the object to be serialized * @param typeHandler contains how the object will be serialized @@ -72,7 +71,7 @@ public String toJson(T object, TypeHandler typeHandler) { } /** - * Writes an object's serialized persisted data to a Writer + * Writes an object's serialized persisted data to the {@link Writer} as a JSON. * * @see #writeJson(Object, TypeHandler, OutputStream) * @param object the object to be serialized @@ -87,7 +86,7 @@ public void writeJson(T object, TypeHandler typeHandler, Writer writer) { } /** - * Writes an object's serialized persisted data to an OutputStream + * Writes an object's serialized persisted data to the {@link OutputStream} as a JSON. * * @see #writeJson(Object, TypeHandler, Writer) * @param object the object to be serialized @@ -102,7 +101,7 @@ public void writeJson(T object, TypeHandler typeHandler, OutputStream str } /** - * Writes the object's persisted data to a File object + * Writes the object's persisted data to the {@link File} as a JSON. * * @see #writeJson(Object, TypeHandler, String) * @param object the file to be serialized @@ -117,7 +116,7 @@ public void writeJson(T object, TypeHandler typeHandler, File file) throw } /** - * Writes the a the object's persisted data to a File located at a specified file name + * Writes the a the object's persisted data to {@link File} of a specified file name as a JSON * * @see #writeJson(Object, TypeHandler, String) * @param object the object to be serialized @@ -130,10 +129,10 @@ public void writeJson(T object, TypeHandler typeHandler, String fileName) } /** - * Gets the PersistedData from a Reader object + * Gets the PersistedData from the {@link Reader}'s contents. * * @see #persistedDataFromJson(InputStream) - * @param reader Reader object that will be deserialized + * @param reader Reader object that contains the contents that will be deserialized * @return deserialized GsonPersistedData object */ public PersistedData persistedDataFromJson(Reader reader) { @@ -143,10 +142,10 @@ public PersistedData persistedDataFromJson(Reader reader) { } /** - * Gets the PersistedData from an InputStream + * Gets the PersistedData from an {@link InputStream}'s contents. * * @see #persistedDataFromJson(Reader) - * @param stream the InputStream that will be serialized + * @param stream Contents of the InputStream will be serialized * @return deserialized GsonPersistedData object * @throws IOException if there is an issue parsing the stream */ @@ -157,7 +156,7 @@ public PersistedData persistedDataFromJson(InputStream stream) throws IOExceptio } /** - * Gets the PersistedData from a File object + * Gets the PersistedData from a {@link File} object's contents. * * @see #persistedDataFromJson(String) * @param file File object containing the JSON that will be deserialized @@ -171,7 +170,7 @@ public PersistedData persistedDataFromJson(File file) throws IOException { } /** - * Gets the PersistedData by forwarding a Reader which contains a String to {@link #persistedDataFromJson(Reader)} + * Gets the PersistedData from a {@link String}'s contents. * * @see #persistedDataFromJson(Reader) * @param json the String that will be deserialized From 9c3c70c3a84220524dee268507eefac2fb91ccbb Mon Sep 17 00:00:00 2001 From: nschnitzer Date: Mon, 3 Dec 2018 17:52:49 -0500 Subject: [PATCH 087/141] Forgot one thing --- .../org/terasology/persistence/serializers/GsonSerializer.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 4ad7699961e..04ba3f991e0 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -37,8 +37,7 @@ import java.io.Writer; /** - * GsonSerializer provides the ability to serialize and deserialize between - * JSONs and Objects
+ * GsonSerializer provides the ability to serialize and deserialize objects to and from JSON *
* Serialized JSONs can be forwarded/written to various output types
*
From f55a9344b4d795b0ce88bdc6120e476addd0ed8e Mon Sep 17 00:00:00 2001 From: nschnitzer Date: Tue, 4 Dec 2018 18:28:47 -0500 Subject: [PATCH 088/141] Fixed Grammatical Errors --- .../persistence/serializers/GsonSerializer.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 04ba3f991e0..7c9a20f0ecd 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -55,7 +55,7 @@ public GsonSerializer() { } /** - * writes the serialized persisted data as a JSON to {@link Writer} and returns the JSON as a string. + * Writes the serialized persisted data as a JSON to {@link Writer} and returns the JSON as a string. * * @param object the object to be serialized * @param typeHandler contains how the object will be serialized @@ -70,7 +70,7 @@ public String toJson(T object, TypeHandler typeHandler) { } /** - * Writes an object's serialized persisted data to the {@link Writer} as a JSON. + * Writes an object's serialized persisted data to the {@link Writer} as JSON. * * @see #writeJson(Object, TypeHandler, OutputStream) * @param object the object to be serialized @@ -85,7 +85,7 @@ public void writeJson(T object, TypeHandler typeHandler, Writer writer) { } /** - * Writes an object's serialized persisted data to the {@link OutputStream} as a JSON. + * Writes an object's serialized persisted data to the {@link OutputStream} as JSON. * * @see #writeJson(Object, TypeHandler, Writer) * @param object the object to be serialized @@ -100,7 +100,7 @@ public void writeJson(T object, TypeHandler typeHandler, OutputStream str } /** - * Writes the object's persisted data to the {@link File} as a JSON. + * Writes the object's persisted data to the {@link File} as JSON. * * @see #writeJson(Object, TypeHandler, String) * @param object the file to be serialized @@ -115,7 +115,7 @@ public void writeJson(T object, TypeHandler typeHandler, File file) throw } /** - * Writes the a the object's persisted data to {@link File} of a specified file name as a JSON + * Writes the a the object's persisted data to {@link File} of a specified file name as JSON * * @see #writeJson(Object, TypeHandler, String) * @param object the object to be serialized From c02804bab3a1ed590501688ab32e91a9e327ae03 Mon Sep 17 00:00:00 2001 From: nschnitzer <33706405+nschnitzer@users.noreply.github.com> Date: Tue, 11 Dec 2018 13:47:37 -0500 Subject: [PATCH 089/141] Minor Grammatical Fixes --- .../terasology/persistence/serializers/GsonSerializer.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 7c9a20f0ecd..545112ba8a2 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -39,7 +39,7 @@ /** * GsonSerializer provides the ability to serialize and deserialize objects to and from JSON *
- * Serialized JSONs can be forwarded/written to various output types
+ * Serialized JSON can be forwarded/written to various output types
*
* Various input types can be deserialized and returned as PersistedData types * @@ -115,7 +115,7 @@ public void writeJson(T object, TypeHandler typeHandler, File file) throw } /** - * Writes the a the object's persisted data to {@link File} of a specified file name as JSON + * Writes an object's persisted data to {@link File} of a specified file name as JSON * * @see #writeJson(Object, TypeHandler, String) * @param object the object to be serialized From 5d4d484dc36db9718032f7642b776b98f78262f5 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 15 Mar 2019 23:42:41 -0500 Subject: [PATCH 090/141] Add TypeHandlerFactoryContext.getTypeHandler --- .../TypeHandlerFactoryContext.java | 23 +++++++++++++++++++ .../RuntimeDelegatingTypeHandler.java | 1 + .../factories/ArrayTypeHandlerFactory.java | 2 +- .../CollectionTypeHandlerFactory.java | 3 ++- .../ObjectFieldMapTypeHandlerFactory.java | 2 +- .../StringMapTypeHandlerFactory.java | 2 +- .../factories/Rect2fTypeHandlerFactory.java | 2 +- .../factories/Rect2iTypeHandlerFactory.java | 2 +- 8 files changed, 31 insertions(+), 6 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java index 300fe548d21..d1baaf7e800 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java @@ -17,7 +17,9 @@ import org.terasology.reflection.TypeInfo; +import java.lang.reflect.Type; import java.util.Arrays; +import java.util.Optional; /** * Represents the context in which a {@link TypeHandlerFactory} creates {@link TypeHandler} instances. @@ -60,4 +62,25 @@ public TypeSerializationLibrary getTypeSerializationLibrary() { public ClassLoader[] getClassLoaders() { return classLoaders; } + + /** + * Retrieve the {@link TypeHandler} for the given type in the current context. + */ + public Optional> getTypeHandler(Type elementType) { + return typeSerializationLibrary.getTypeHandler(elementType, classLoaders); + } + + /** + * Retrieve the {@link TypeHandler} for the given type in the current context. + */ + public Optional> getTypeHandler(Class elementType) { + return typeSerializationLibrary.getTypeHandler(elementType, classLoaders); + } + + /** + * Retrieve the {@link TypeHandler} for the given type in the current context. + */ + public Optional> getTypeHandler(TypeInfo elementType) { + return typeSerializationLibrary.getTypeHandler(elementType, classLoaders); + } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index c0664d39329..3a40fabc38a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -45,6 +45,7 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeDelegatingTypeHandler.class); + // TODO: Use Optional private TypeHandler delegateHandler; private TypeInfo typeInfo; private TypeSerializationLibrary typeSerializationLibrary; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java index eb95a1f844e..59a99a76433 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java @@ -45,7 +45,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getClassLoaders()); + Optional> declaredElementTypeHandler = context.getTypeHandler(elementType); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index 7668ba53e51..c06be30c1f5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -60,7 +60,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(elementType, context.getClassLoaders()); + Optional> declaredElementTypeHandler = context.getTypeHandler(elementType); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( @@ -76,4 +76,5 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact return Optional.of(typeHandler); } + } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 2b4b007acfe..2de1f560811 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -54,7 +54,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact getResolvedFields(typeInfo).forEach( (field, fieldType) -> { - Optional> declaredFieldTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(fieldType, context.getClassLoaders()); + Optional> declaredFieldTypeHandler = context.getTypeHandler(fieldType); TypeInfo fieldTypeInfo = TypeInfo.of(fieldType); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index 00bf16fa4a9..a3c1ba8c86c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -51,7 +51,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact return Optional.empty(); } - Optional> declaredValueTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(valueType, context.getClassLoaders()); + Optional> declaredValueTypeHandler = context.getTypeHandler(valueType); TypeInfo valueTypeInfo = TypeInfo.of(valueType); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java index bc1071f0bf2..a33b29e2e7b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java @@ -36,7 +36,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact return Optional.empty(); } - Optional> vector2fTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2f.class, context.getClassLoaders()); + Optional> vector2fTypeHandler = context.getTypeHandler(Vector2f.class); if (!vector2fTypeHandler.isPresent()) { LOGGER.error("No Vector2f type handler found"); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java index d071f92c772..5c0036d8b43 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java @@ -36,7 +36,7 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerFact return Optional.empty(); } - Optional> vector2iTypeHandler = context.getTypeSerializationLibrary().getTypeHandler(Vector2i.class, context.getClassLoaders()); + Optional> vector2iTypeHandler = context.getTypeHandler(Vector2i.class); if (!vector2iTypeHandler.isPresent()) { LOGGER.error("No Vector2i type handler found"); From d03a1718d93e7c68b43ef9f7cf3ea1d7292f2b32 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 16 Mar 2019 00:03:56 -0500 Subject: [PATCH 091/141] Check for runtime type assignability during deserialization in RuntimeDelegatingTypeHandler --- .../coreTypes/RuntimeDelegatingTypeHandler.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 3a40fabc38a..3c47f3ff07c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -134,6 +134,7 @@ private static Class getRuntimeTypeIfMoreSpecific(TypeInfo typeInfo, T return typeInfo.getRawType(); } + @SuppressWarnings({"unchecked"}) @Override public Optional deserialize(PersistedData data) { if (!data.isValueMap()) { @@ -155,6 +156,11 @@ public Optional deserialize(PersistedData data) { return Optional.empty(); } + if (!typeInfo.getRawType().isAssignableFrom(typeToDeserializeAs.get())) { + LOGGER.error("Given type {} is not a sub-type of expected type {}", typeToDeserializeAs.get(), typeInfo.getType()); + return Optional.empty(); + } + TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs.get(), classLoaders) // To avoid compile errors in the orElseGet .map(typeHandler -> (TypeHandler) typeHandler) From 1043f9b0bc204ce6103e6cb1ac40552ce07bbafe Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 16 Mar 2019 00:12:50 -0500 Subject: [PATCH 092/141] Change RuntimeDelegatingTypeHandler.TYPE_FIELD to "class" and VALUE_FIELD to "content" --- .../typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 3c47f3ff07c..433c857334d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -40,8 +40,8 @@ * @param The base type whose instances may be delegated to a subtype's {@link TypeHandler} at runtime. */ public class RuntimeDelegatingTypeHandler extends TypeHandler { - static final String TYPE_FIELD = "@type"; - static final String VALUE_FIELD = "@value"; + static final String TYPE_FIELD = "class"; + static final String VALUE_FIELD = "content"; private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeDelegatingTypeHandler.class); From aaaa19c1101f00b0ce3f72a406e133fa222584d2 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 1 Apr 2019 15:47:45 -0500 Subject: [PATCH 093/141] Rename TypeHandlerFactoryContext to TypeHandlerContext --- .../persistence/serializers/TypeSerializerTest.java | 2 +- .../RuntimeDelegatingTypeHandlerSandboxTest.java | 10 +++++----- .../coreTypes/RuntimeDelegatingTypeHandlerTest.java | 6 +++--- .../factories/ArrayTypeHandlerFactoryTest.java | 6 +++--- .../factories/CollectionTypeHandlerFactoryTest.java | 6 +++--- .../ObjectFieldMapTypeHandlerFactoryTest.java | 6 +++--- .../factories/StringMapTypeHandlerFactoryTest.java | 6 +++--- ...erFactoryContext.java => TypeHandlerContext.java} | 12 ++++++------ .../persistence/typeHandling/TypeHandlerFactory.java | 2 +- .../typeHandling/TypeSerializationLibrary.java | 4 ++-- .../coreTypes/RuntimeDelegatingTypeHandler.java | 4 ++-- .../coreTypes/factories/ArrayTypeHandlerFactory.java | 4 ++-- .../factories/CollectionTypeHandlerFactory.java | 4 ++-- .../coreTypes/factories/EnumTypeHandlerFactory.java | 4 ++-- .../factories/ObjectFieldMapTypeHandlerFactory.java | 4 ++-- .../factories/StringMapTypeHandlerFactory.java | 4 ++-- .../factories/AssetTypeHandlerFactory.java | 4 ++-- .../TextureRegionAssetTypeHandlerFactory.java | 4 ++-- .../factories/Rect2fTypeHandlerFactory.java | 4 ++-- .../factories/Rect2iTypeHandlerFactory.java | 4 ++-- 20 files changed, 50 insertions(+), 50 deletions(-) rename engine/src/main/java/org/terasology/persistence/typeHandling/{TypeHandlerFactoryContext.java => TypeHandlerContext.java} (83%) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 060f8823860..11bc1e07bd6 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -49,7 +49,7 @@ public class TypeSerializerTest { } public static class Json { - private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"@type\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"@value\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"@type\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"@value\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; + private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; private ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java index c0609ff9681..98f0114a358 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java @@ -32,7 +32,7 @@ import org.terasology.naming.Name; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.inMemory.PersistedInteger; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; @@ -127,7 +127,7 @@ public void setup() { @Test public void testAccessModuleClassFromEngine() { - TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment)); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); @@ -149,7 +149,7 @@ public void testAccessModuleClassFromEngine() { @Test public void testCannotAccessModuleClassFromEngineWithoutClassLoader() { - TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, ReflectionUtil.class.getClassLoader()); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); @@ -180,7 +180,7 @@ public void testAccessModuleClassFromModule() { } private void testCanAccessClassFromModule(Class testClass, TypeHandler testClassHandlerMock) { - TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, moduleClass); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); @@ -202,7 +202,7 @@ private void testCanAccessClassFromModule(Class testClass, TypeHandler testCl @Test public void testCannotAccessNonApiClassFromModule() { - TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, moduleClass); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 06e21282080..0ce7487d7a1 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -24,7 +24,7 @@ import org.terasology.persistence.typeHandling.PersistedDataArray; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; @@ -49,8 +49,8 @@ public class RuntimeDelegatingTypeHandlerTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); - private final TypeHandlerFactoryContext context = - new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + private final TypeHandlerContext context = + new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); private static class Base { int x; diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java index be5a141d86a..01da98ecef7 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java @@ -17,7 +17,7 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; import org.terasology.reflection.TypeInfo; @@ -35,8 +35,8 @@ public class ArrayTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); private final ArrayTypeHandlerFactory typeHandlerFactory = new ArrayTypeHandlerFactory(); - private final TypeHandlerFactoryContext context = - new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + private final TypeHandlerContext context = + new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); @Test public void testArray() { diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index 75211a247fc..5c42552341f 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -18,7 +18,7 @@ import com.google.common.collect.Maps; import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.reflection.TypeInfo; @@ -40,8 +40,8 @@ public class CollectionTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap())); - private final TypeHandlerFactoryContext context = - new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + private final TypeHandlerContext context = + new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); @Test public void testList() { diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index 0fa232b3b51..b5b68df9d72 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -18,7 +18,7 @@ import com.google.common.collect.Maps; import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.reflection.TypeInfo; @@ -40,8 +40,8 @@ public class ObjectFieldMapTypeHandlerFactoryTest { private final ObjectFieldMapTypeHandlerFactory typeHandlerFactory = new ObjectFieldMapTypeHandlerFactory( constructorLibrary); - private final TypeHandlerFactoryContext context = - new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + private final TypeHandlerContext context = + new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); private static class SomeClass { private T t; diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java index 6d5af3db38e..8ca5c84e0f0 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -18,7 +18,7 @@ import org.junit.Test; import org.mockito.ArgumentMatchers; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.TypeInfo; @@ -37,8 +37,8 @@ public class StringMapTypeHandlerFactoryTest { private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); private final StringMapTypeHandlerFactory typeHandlerFactory = new StringMapTypeHandlerFactory(); - private final TypeHandlerFactoryContext context = - new TypeHandlerFactoryContext(typeSerializationLibrary, getClass().getClassLoader()); + private final TypeHandlerContext context = + new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); @Test public void testStringMap() { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java similarity index 83% rename from engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java rename to engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java index d1baaf7e800..b91f0db8afb 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactoryContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java @@ -24,14 +24,14 @@ /** * Represents the context in which a {@link TypeHandlerFactory} creates {@link TypeHandler} instances. *

- * The {@link TypeHandlerFactoryContext} is used to look up {@link TypeHandler} instances and load classes + * The {@link TypeHandlerContext} is used to look up {@link TypeHandler} instances and load classes * while staying within the sandbox rules if called from a module. */ -public class TypeHandlerFactoryContext { +public class TypeHandlerContext { private TypeSerializationLibrary typeSerializationLibrary; private ClassLoader[] classLoaders; - public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibrary, Class... classes) { + public TypeHandlerContext(TypeSerializationLibrary typeSerializationLibrary, Class... classes) { this( typeSerializationLibrary, Arrays.stream(classes) @@ -40,13 +40,13 @@ public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibra ); } - public TypeHandlerFactoryContext(TypeSerializationLibrary typeSerializationLibrary, ClassLoader... classLoaders) { + public TypeHandlerContext(TypeSerializationLibrary typeSerializationLibrary, ClassLoader... classLoaders) { this.typeSerializationLibrary = typeSerializationLibrary; this.classLoaders = classLoaders; } /** - * Returns the {@link TypeSerializationLibrary} that called the {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerFactoryContext)} method. + * Returns the {@link TypeSerializationLibrary} that called the {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerContext)} method. */ public TypeSerializationLibrary getTypeSerializationLibrary() { return typeSerializationLibrary; @@ -54,7 +54,7 @@ public TypeSerializationLibrary getTypeSerializationLibrary() { /** * Returns the {@link ClassLoader}s to use to load classes in the - * {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerFactoryContext)} method. + * {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerContext)} method. *

* If classes are loaded manually using a method like {@link Class#forName(String)}, these * {@link ClassLoader}s must be used so that modules remain sandboxed. diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java index 2dd7d9723ba..6b95936dfb0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java @@ -40,5 +40,5 @@ public interface TypeHandlerFactory { * @return An {@link Optional} wrapping the created {@link TypeHandler}, or {@link Optional#empty()} * if the type is not supported by this {@link TypeHandlerFactory}. */ - Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context); + Optional> create(TypeInfo typeInfo, TypeHandlerContext context); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 23419a9850e..41d1f00b542 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -208,7 +208,7 @@ public void addTypeHandler(TypeInfo type, TypeHandler typeHandler) { TypeHandlerFactory factory = new TypeHandlerFactory() { @SuppressWarnings("unchecked") @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { return typeInfo.equals(type) ? Optional.of((TypeHandler) typeHandler) : Optional.empty(); } }; @@ -257,7 +257,7 @@ public Optional> getTypeHandler(TypeInfo type, Class... @SuppressWarnings("unchecked") public Optional> getTypeHandler(TypeInfo type, ClassLoader... contextClassLoaders) { - TypeHandlerFactoryContext context = new TypeHandlerFactoryContext(this, contextClassLoaders); + TypeHandlerContext context = new TypeHandlerContext(this, contextClassLoaders); if (typeHandlerCache.containsKey(type)) { return Optional.of((TypeHandler) typeHandlerCache.get(type)); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 433c857334d..2849355c5db 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -22,7 +22,7 @@ import org.terasology.persistence.typeHandling.PersistedDataMap; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.reflection.TypeInfo; import org.terasology.utilities.ReflectionUtil; @@ -51,7 +51,7 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private TypeSerializationLibrary typeSerializationLibrary; private ClassLoader[] classLoaders; - public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeHandlerContext context) { this.delegateHandler = delegateHandler; this.typeInfo = typeInfo; this.typeSerializationLibrary = context.getTypeSerializationLibrary(); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java index 59a99a76433..65cfb9cc25e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java @@ -17,7 +17,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; @@ -32,7 +32,7 @@ */ public class ArrayTypeHandlerFactory implements TypeHandlerFactory { @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { Type type = typeInfo.getType(); if (!(type instanceof GenericArrayType || type instanceof Class && ((Class) type).isArray())) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index c06be30c1f5..3a367272d6c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -19,7 +19,7 @@ import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; @@ -44,7 +44,7 @@ public CollectionTypeHandlerFactory(ConstructorLibrary constructorLibrary) { } @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { Class rawType = typeInfo.getRawType(); if (!Collection.class.isAssignableFrom(rawType)) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java index ef875d9eaaa..ffee059f06a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactory.java @@ -17,7 +17,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.reflection.TypeInfo; @@ -29,7 +29,7 @@ public class EnumTypeHandlerFactory implements TypeHandlerFactory { @SuppressWarnings("unchecked") @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { Class enumClass = typeInfo.getRawType(); if (!Enum.class.isAssignableFrom(enumClass) || Enum.class.equals(enumClass)) { return Optional.empty(); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 2de1f560811..5a331ef7be7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -20,7 +20,7 @@ import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.reflection.TypeInfo; @@ -43,7 +43,7 @@ public ObjectFieldMapTypeHandlerFactory(ConstructorLibrary constructorLibrary) { } @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { Class typeClass = typeInfo.getRawType(); if (!Modifier.isAbstract(typeClass.getModifiers()) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index a3c1ba8c86c..49ca59e77ea 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -19,7 +19,7 @@ import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.TypeInfo; @@ -34,7 +34,7 @@ public class StringMapTypeHandlerFactory implements TypeHandlerFactory { @SuppressWarnings("unchecked") @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { if (!Map.class.isAssignableFrom(typeInfo.getRawType())) { return Optional.empty(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java index 8622e1f2597..eeedc5502c2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/AssetTypeHandlerFactory.java @@ -18,7 +18,7 @@ import org.terasology.assets.Asset; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; import org.terasology.reflection.TypeInfo; @@ -30,7 +30,7 @@ */ public class AssetTypeHandlerFactory implements TypeHandlerFactory { @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { Class rawType = typeInfo.getRawType(); if (!Asset.class.isAssignableFrom(rawType)) { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java index 5f9a9dc55d3..4149fd4acc9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/extensionTypes/factories/TextureRegionAssetTypeHandlerFactory.java @@ -17,7 +17,7 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.extensionTypes.TextureRegionAssetTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.rendering.assets.texture.TextureRegionAsset; @@ -26,7 +26,7 @@ public class TextureRegionAssetTypeHandlerFactory implements TypeHandlerFactory { @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { if (!TextureRegionAsset.class.equals(typeInfo.getRawType())) { return Optional.empty(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java index a33b29e2e7b..f2c80fe6919 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java @@ -21,7 +21,7 @@ import org.terasology.math.geom.Vector2f; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.mathTypes.Rect2fTypeHandler; import org.terasology.reflection.TypeInfo; @@ -31,7 +31,7 @@ public class Rect2fTypeHandlerFactory implements TypeHandlerFactory { private static final Logger LOGGER = LoggerFactory.getLogger(Rect2fTypeHandlerFactory.class); @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { if (!typeInfo.equals(TypeInfo.of(Rect2f.class))) { return Optional.empty(); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java index 5c0036d8b43..1e6018a54d9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java @@ -21,7 +21,7 @@ import org.terasology.math.geom.Vector2i; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerFactory; -import org.terasology.persistence.typeHandling.TypeHandlerFactoryContext; +import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.mathTypes.Rect2iTypeHandler; import org.terasology.reflection.TypeInfo; @@ -31,7 +31,7 @@ public class Rect2iTypeHandlerFactory implements TypeHandlerFactory { private static final Logger LOGGER = LoggerFactory.getLogger(Rect2iTypeHandlerFactory.class); @Override - public Optional> create(TypeInfo typeInfo, TypeHandlerFactoryContext context) { + public Optional> create(TypeInfo typeInfo, TypeHandlerContext context) { if (!typeInfo.equals(TypeInfo.of(Rect2i.class))) { return Optional.empty(); } From 98283de762a6f3926af734cb7261d2ce7b475a5a Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 4 May 2019 15:46:24 +0530 Subject: [PATCH 094/141] Handle null chosenHandler in RuntimeDelegatingTypeHandler --- .../coreTypes/RuntimeDelegatingTypeHandler.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 2849355c5db..5794e32d71b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -45,7 +45,6 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeDelegatingTypeHandler.class); - // TODO: Use Optional private TypeHandler delegateHandler; private TypeInfo typeInfo; private TypeSerializationLibrary typeSerializationLibrary; @@ -96,6 +95,11 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize .orElse(delegateHandler); } + if (chosenHandler == null) { + LOGGER.error("Could not find appropriate TypeHandler for runtime type {}", runtimeClass); + return serializer.serializeNull(); + } + if (chosenHandler == delegateHandler) { return delegateHandler.serialize(value, serializer); } From cad700d571eaf338025958c8eb9f475ff3a5abfe Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 1 Jun 2019 17:02:31 +0530 Subject: [PATCH 095/141] Remove TypeSerializationLibrary.reflectFactory and copyStrategies --- .../entitySystem/PojoEventSystemTests.java | 4 +--- .../entitySystem/PojoPrefabManagerTest.java | 4 +--- .../metadata/ComponentMetadataTest.java | 4 ++-- .../persistence/ComponentSerializerTest.java | 4 +--- .../serializers/TypeSerializerTest.java | 6 ++---- .../TypeSerializationLibraryTest.java | 5 +---- ...eSerializationLibraryAdapterFactoryTest.java | 2 +- .../recording/EventSystemReplayImplTest.java | 4 +--- .../org/terasology/engine/TerasologyEngine.java | 3 +-- .../engine/bootstrap/EntitySystemSetupUtil.java | 2 +- .../bootstrap/EnvironmentSwitchHandler.java | 2 +- .../typeHandling/TypeSerializationLibrary.java | 17 +++-------------- .../recording/RecordedEventSerializer.java | 2 +- 13 files changed, 17 insertions(+), 42 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java index b936356bb08..ee8d3d3124f 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java @@ -64,9 +64,7 @@ public class PojoEventSystemTests { public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - ReflectFactory reflectFactory = new ReflectionReflectFactory(); - CopyStrategyLibrary copyStrategies = new CopyStrategyLibrary(reflectFactory); - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(reflectFactory, copyStrategies); + TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); compLibrary = entitySystemLibrary.getComponentLibrary(); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java index d804f5ff428..67fff7f2c52 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java @@ -60,9 +60,7 @@ public void setup() throws Exception { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); ModuleManager moduleManager = ModuleManagerFactory.create(); - ReflectFactory reflectFactory = new ReflectionReflectFactory(); - CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - TypeSerializationLibrary lib = new TypeSerializationLibrary(reflectFactory, copyStrategyLibrary); + TypeSerializationLibrary lib = new TypeSerializationLibrary(); lib.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); lib.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); entitySystemLibrary = new EntitySystemLibrary(context, lib); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java index 48cd84cbb00..eab9d2e851d 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java @@ -48,7 +48,7 @@ public void prepare() { @Test public void testStaticFieldsIgnored() { - EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeSerializationLibrary(reflectFactory, copyStrategies)); + EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeSerializationLibrary()); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:string"), StringComponent.class); ComponentMetadata metadata = lib.getMetadata(StringComponent.class); @@ -57,7 +57,7 @@ public void testStaticFieldsIgnored() { @Test public void testOwnsReferencesPopulated() { - EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeSerializationLibrary(reflectFactory, copyStrategies)); + EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeSerializationLibrary()); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:owner"), OwnerComponent.class); ComponentMetadata metadata = lib.getMetadata(OwnerComponent.class); diff --git a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java index 74bf8978b4f..2492ee984ac 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java @@ -55,8 +55,6 @@ public class ComponentSerializerTest { private static ModuleManager moduleManager; private ComponentSerializer componentSerializer; - private ReflectFactory reflectFactory = new ReflectionReflectFactory(); - private CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); private Context context; @BeforeClass @@ -71,7 +69,7 @@ public void setup() { context.put(ModuleManager.class, moduleManager); CoreRegistry.setContext(context); - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(reflectFactory, copyStrategyLibrary); + TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); serializationLibrary.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 11bc1e07bd6..028e91c05c2 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -51,8 +51,7 @@ public class TypeSerializerTest { public static class Json { private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; - private ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); - private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); + private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); @Test public void testJsonSerialize() { @@ -77,8 +76,7 @@ public void testDeserialize() { } public static class Protobuf { - private ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); - private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, new CopyStrategyLibrary(reflectFactory)); + private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); @Test public void testSerializeDeserialize() throws IOException { diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java index 56b9b2b22f3..7a7598dc0cc 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java @@ -35,10 +35,7 @@ import static org.junit.Assert.assertTrue; public class TypeSerializationLibraryTest { - private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); - private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - private final TypeSerializationLibrary typeSerializationLibrary = - new TypeSerializationLibrary(reflectFactory, copyStrategyLibrary); + private final TypeSerializationLibrary typeSerializationLibrary = new TypeSerializationLibrary(); private enum AnEnum {} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactoryTest.java index ea97d846087..4f88fe411ae 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactoryTest.java @@ -49,7 +49,7 @@ public class GsonTypeSerializationLibraryAdapterFactoryTest { private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); private final TypeSerializationLibrary typeSerializationLibrary = - TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); + TypeSerializationLibrary.createDefaultLibrary(); private final Gson gson = GsonBuilderFactory.createGsonBuilderWithTypeSerializationLibrary(typeSerializationLibrary) diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 511ec640ccf..569d9d8f34b 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -60,9 +60,7 @@ public class EventSystemReplayImplTest { public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - ReflectFactory reflectFactory = new ReflectionReflectFactory(); - CopyStrategyLibrary copyStrategies = new CopyStrategyLibrary(reflectFactory); - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(reflectFactory, copyStrategies); + TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); PojoEntityManager entityManager = new PojoEntityManager(); entityManager.setComponentLibrary(entitySystemLibrary.getComponentLibrary()); diff --git a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java index 1e377d16fc9..14f4daa35b1 100644 --- a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java +++ b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java @@ -315,8 +315,7 @@ private void initManagers() { CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); rootContext.put(CopyStrategyLibrary.class, copyStrategyLibrary); - rootContext.put(TypeSerializationLibrary.class, new TypeSerializationLibrary(reflectFactory, - copyStrategyLibrary)); + rootContext.put(TypeSerializationLibrary.class, new TypeSerializationLibrary()); changeStatus(TerasologyEngineStatus.INITIALIZING_ASSET_TYPES); assetTypeManager = new ModuleAwareAssetTypeManager(); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java index cf4177f0b3b..2b92bd205b9 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java @@ -74,7 +74,7 @@ public static void addReflectionBasedLibraries(Context context) { context.put(ReflectFactory.class, reflectFactory); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); context.put(CopyStrategyLibrary.class, copyStrategyLibrary); - TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); + TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); context.put(TypeSerializationLibrary.class, typeSerializationLibrary); EntitySystemLibrary library = new EntitySystemLibrary(context, typeSerializationLibrary); context.put(EntitySystemLibrary.class, library); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java index 4e905991c9c..743ce615dc2 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java @@ -79,7 +79,7 @@ public void handleSwitchToGameEnvironment(Context context) { } ReflectFactory reflectFactory = context.get(ReflectFactory.class); - TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); + TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); typeSerializationLibrary.addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(context.get(CollisionGroupManager.class))); context.put(TypeSerializationLibrary.class, typeSerializationLibrary); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java index 41d1f00b542..08f1e2265c1 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java @@ -64,7 +64,6 @@ import org.terasology.reflection.metadata.ClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; import org.terasology.reflection.reflect.ConstructorLibrary; -import org.terasology.reflection.reflect.ReflectFactory; import org.terasology.rendering.assets.texture.TextureRegion; import org.terasology.rendering.nui.Color; @@ -99,18 +98,11 @@ public class TypeSerializationLibrary { private Map> instanceCreators = Maps.newHashMap(); private ConstructorLibrary constructorLibrary; - private ReflectFactory reflectFactory; - private CopyStrategyLibrary copyStrategies; - private Map, Serializer> serializerMap = Maps.newHashMap(); /** - * @param factory The factory providing reflect implementation. - * @param copyStrategies The provider of copy strategies */ - public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copyStrategies) { - this.reflectFactory = factory; - this.copyStrategies = copyStrategies; + public TypeSerializationLibrary() { constructorLibrary = new ConstructorLibrary(instanceCreators); @@ -148,14 +140,11 @@ public TypeSerializationLibrary(ReflectFactory factory, CopyStrategyLibrary copy * @param original The original type serialization library to copy. */ public TypeSerializationLibrary(TypeSerializationLibrary original) { - this.reflectFactory = original.reflectFactory; - this.copyStrategies = original.copyStrategies; this.typeHandlerFactories.addAll(original.typeHandlerFactories); } - public static TypeSerializationLibrary createDefaultLibrary(ReflectFactory factory, - CopyStrategyLibrary copyStrategies) { - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(factory, copyStrategies); + public static TypeSerializationLibrary createDefaultLibrary() { + TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); serializationLibrary.addTypeHandler(Color.class, new ColorTypeHandler()); serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 900485f2cf7..4cdfc7b7a21 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -51,7 +51,7 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(reflectFactory, copyStrategyLibrary); + TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); typeSerializationLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); ClassLoader[] classLoaders = ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment); From 635dd6addfde7fc9b2387c39c8c24a6803ca429b Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 7 Jun 2019 20:56:44 +0530 Subject: [PATCH 096/141] Rename TypeSerializationLibrary to TypeHandlerLibrary --- .../org/terasology/HeadlessEnvironment.java | 10 +++---- .../entitySystem/PojoEventSystemTests.java | 7 ++--- .../entitySystem/PojoPrefabManagerTest.java | 7 ++--- .../terasology/entitySystem/PrefabTest.java | 6 ++-- .../metadata/ComponentMetadataTest.java | 6 ++-- .../persistence/ComponentSerializerTest.java | 7 ++--- .../serializers/TypeSerializerTest.java | 14 ++++------ ...yTest.java => TypeHandlerLibraryTest.java} | 20 ++++++------- ...ntimeDelegatingTypeHandlerSandboxTest.java | 18 ++++++------ .../RuntimeDelegatingTypeHandlerTest.java | 28 ++++++++----------- .../ArrayTypeHandlerFactoryTest.java | 14 +++++----- .../CollectionTypeHandlerFactoryTest.java | 22 +++++++-------- .../factories/EnumTypeHandlerFactoryTest.java | 5 ++-- .../ObjectFieldMapTypeHandlerFactoryTest.java | 12 ++++---- .../StringMapTypeHandlerFactoryTest.java | 14 +++++----- ...TypeHandlerLibraryAdapterFactoryTest.java} | 10 +++---- .../recording/EventSystemReplayImplTest.java | 7 ++--- .../terasology/engine/TerasologyEngine.java | 4 +-- .../bootstrap/EntitySystemSetupUtil.java | 16 +++++------ .../bootstrap/EnvironmentSwitchHandler.java | 18 ++++++------ .../modes/loadProcesses/RegisterBlocks.java | 6 ++-- .../entity/internal/EngineEntityManager.java | 4 +-- .../entity/internal/PojoEntityManager.java | 8 +++--- .../metadata/EntitySystemLibrary.java | 12 ++++---- .../prefab/internal/PrefabDeltaFormat.java | 10 +++---- .../prefab/internal/PrefabFormat.java | 10 +++---- .../network/internal/NetworkSystemImpl.java | 10 +++---- .../internal/ReadWriteStorageManager.java | 4 +-- .../serializers/ComponentSerializer.java | 14 +++++----- .../serializers/EntitySerializer.java | 6 ++-- .../serializers/EventSerializer.java | 12 ++++---- .../serializers/NetworkEntitySerializer.java | 14 +++++----- .../serializers/PrefabSerializer.java | 6 ++-- .../typeHandling/RegisterTypeHandler.java | 2 +- .../typeHandling/TypeHandlerContext.java | 22 +++++++-------- .../typeHandling/TypeHandlerFactory.java | 2 +- ...onLibrary.java => TypeHandlerLibrary.java} | 13 ++++----- .../coreTypes/ObjectFieldMapTypeHandler.java | 3 +- .../RuntimeDelegatingTypeHandler.java | 12 ++++---- .../typeHandling/gson/GsonBuilderFactory.java | 11 ++++---- ...ypeSerializationLibraryAdapterFactory.java | 12 ++++---- .../recording/RecordedEventSerializer.java | 8 +++--- .../rendering/nui/asset/UIFormat.java | 6 ++-- 43 files changed, 215 insertions(+), 237 deletions(-) rename engine-tests/src/test/java/org/terasology/persistence/typeHandling/{TypeSerializationLibraryTest.java => TypeHandlerLibraryTest.java} (66%) rename engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/{GsonTypeSerializationLibraryAdapterFactoryTest.java => GsonTypeHandlerLibraryAdapterFactoryTest.java} (92%) rename engine/src/main/java/org/terasology/persistence/typeHandling/{TypeSerializationLibrary.java => TypeHandlerLibrary.java} (97%) diff --git a/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java b/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java index 0c3fdfc8a5c..4e9bc1fe529 100644 --- a/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java +++ b/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java @@ -55,7 +55,7 @@ import org.terasology.network.internal.NetworkSystemImpl; import org.terasology.persistence.StorageManager; import org.terasology.persistence.internal.ReadWriteStorageManager; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.BlockFamilyTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.BlockTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.CollisionGroupTypeHandler; @@ -164,7 +164,7 @@ protected void setupEntitySystem() { protected void setupCollisionManager() { CollisionGroupManager collisionGroupManager = new CollisionGroupManager(); context.put(CollisionGroupManager.class, collisionGroupManager); - context.get(TypeSerializationLibrary.class).addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(collisionGroupManager)); + context.get(TypeHandlerLibrary.class).addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(collisionGroupManager)); } @Override @@ -172,9 +172,9 @@ protected void setupBlockManager(AssetManager assetManager) { WorldAtlas worldAtlas = new NullWorldAtlas(); BlockManagerImpl blockManager = new BlockManagerImpl(worldAtlas, assetManager); context.put(BlockManager.class, blockManager); - TypeSerializationLibrary typeSerializationLibrary = context.get(TypeSerializationLibrary.class); - typeSerializationLibrary.addTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); - typeSerializationLibrary.addTypeHandler(Block.class, new BlockTypeHandler(blockManager)); + TypeHandlerLibrary typeHandlerLibrary = context.get(TypeHandlerLibrary.class); + typeHandlerLibrary.addTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); + typeHandlerLibrary.addTypeHandler(Block.class, new BlockTypeHandler(blockManager)); } @Override diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java index ee8d3d3124f..391aec8907a 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java @@ -36,12 +36,9 @@ import org.terasology.entitySystem.systems.BaseComponentSystem; import org.terasology.network.NetworkMode; import org.terasology.network.NetworkSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.recording.EventCatcher; import org.terasology.recording.RecordAndReplayCurrentStatus; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectFactory; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.registry.CoreRegistry; import java.util.List; @@ -64,7 +61,7 @@ public class PojoEventSystemTests { public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); compLibrary = entitySystemLibrary.getComponentLibrary(); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java index 67fff7f2c52..b799815a19e 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java @@ -32,12 +32,9 @@ import org.terasology.entitySystem.stubs.StringComponent; import org.terasology.math.geom.Quat4f; import org.terasology.math.geom.Vector3f; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.mathTypes.Quat4fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector3fTypeHandler; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectFactory; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.registry.CoreRegistry; import org.terasology.testUtil.ModuleManagerFactory; import org.terasology.utilities.Assets; @@ -60,7 +57,7 @@ public void setup() throws Exception { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); ModuleManager moduleManager = ModuleManagerFactory.create(); - TypeSerializationLibrary lib = new TypeSerializationLibrary(); + TypeHandlerLibrary lib = new TypeHandlerLibrary(); lib.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); lib.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); entitySystemLibrary = new EntitySystemLibrary(context, lib); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PrefabTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/PrefabTest.java index d4a5f343757..187cc5ac592 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PrefabTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PrefabTest.java @@ -40,7 +40,7 @@ import org.terasology.math.Side; import org.terasology.network.NetworkMode; import org.terasology.network.NetworkSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.recording.RecordAndReplayCurrentStatus; import org.terasology.registry.CoreRegistry; import org.terasology.testUtil.ModuleManagerFactory; @@ -78,8 +78,8 @@ public void setup() throws Exception { assetTypeManager.registerCoreAssetType(Prefab.class, (AssetFactory) PojoPrefab::new, "prefabs"); ComponentLibrary componentLibrary = context.get(ComponentLibrary.class); - TypeSerializationLibrary typeSerializationLibrary = context.get(TypeSerializationLibrary.class); - PrefabFormat prefabFormat = new PrefabFormat(componentLibrary, typeSerializationLibrary); + TypeHandlerLibrary typeHandlerLibrary = context.get(TypeHandlerLibrary.class); + PrefabFormat prefabFormat = new PrefabFormat(componentLibrary, typeHandlerLibrary); assetTypeManager.registerCoreFormat(Prefab.class, prefabFormat); assetTypeManager.switchEnvironment(moduleManager.getEnvironment()); context.put(AssetManager.class, assetTypeManager.getAssetManager()); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java index eab9d2e851d..2ebad16bf95 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java @@ -23,7 +23,7 @@ import org.terasology.engine.SimpleUri; import org.terasology.entitySystem.stubs.OwnerComponent; import org.terasology.entitySystem.stubs.StringComponent; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectFactory; import org.terasology.reflection.reflect.ReflectionReflectFactory; @@ -48,7 +48,7 @@ public void prepare() { @Test public void testStaticFieldsIgnored() { - EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeSerializationLibrary()); + EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary()); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:string"), StringComponent.class); ComponentMetadata metadata = lib.getMetadata(StringComponent.class); @@ -57,7 +57,7 @@ public void testStaticFieldsIgnored() { @Test public void testOwnsReferencesPopulated() { - EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeSerializationLibrary()); + EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary()); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:owner"), OwnerComponent.class); ComponentMetadata metadata = lib.getMetadata(OwnerComponent.class); diff --git a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java index 2492ee984ac..ac8137a1731 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java @@ -34,14 +34,11 @@ import org.terasology.math.geom.Vector3f; import org.terasology.network.NetworkSystem; import org.terasology.persistence.serializers.ComponentSerializer; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.mathTypes.Quat4fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.Vector3fTypeHandler; import org.terasology.protobuf.EntityData; import org.terasology.recording.RecordAndReplayCurrentStatus; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectFactory; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.registry.CoreRegistry; import org.terasology.testUtil.ModuleManagerFactory; @@ -69,7 +66,7 @@ public void setup() { context.put(ModuleManager.class, moduleManager); CoreRegistry.setContext(context); - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); serializationLibrary.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 028e91c05c2..29df232b1ce 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -23,10 +23,8 @@ import org.terasology.math.geom.Vector3f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.reflection.TypeInfo; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.rendering.nui.Color; import java.io.IOException; @@ -51,13 +49,13 @@ public class TypeSerializerTest { public static class Json { private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; - private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); + private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); @Test public void testJsonSerialize() { GsonSerializer gsonSerializer = new GsonSerializer(); - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, TypeSerializerTest.class).get(); + TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, TypeSerializerTest.class).get(); assertEquals(INSTANCE_JSON, gsonSerializer.toJson(INSTANCE, typeHandler)); } @@ -67,7 +65,7 @@ public void testDeserialize() { GsonSerializer gsonSerializer = new GsonSerializer(); PersistedData persistedData = gsonSerializer.persistedDataFromJson(INSTANCE_JSON); - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); @@ -76,11 +74,11 @@ public void testDeserialize() { } public static class Protobuf { - private final TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); + private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); @Test public void testSerializeDeserialize() throws IOException { - TypeHandler> typeHandler = typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); ProtobufSerializer protobufSerializer = new ProtobufSerializer(); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java similarity index 66% rename from engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java rename to engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java index 7a7598dc0cc..6c2eb5f72c7 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeSerializationLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java @@ -22,8 +22,6 @@ import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.MappedContainer; import org.terasology.reflection.TypeInfo; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import java.util.List; import java.util.Map; @@ -34,8 +32,8 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -public class TypeSerializationLibraryTest { - private final TypeSerializationLibrary typeSerializationLibrary = new TypeSerializationLibrary(); +public class TypeHandlerLibraryTest { + private final TypeHandlerLibrary typeHandlerLibrary = new TypeHandlerLibrary(); private enum AnEnum {} @@ -44,14 +42,14 @@ private static class AMappedContainer {} @Test public void testEnumHandler() { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(AnEnum.class, getClass().getClassLoader()).get(); + TypeHandler handler = typeHandlerLibrary.getTypeHandler(AnEnum.class, getClass().getClassLoader()).get(); assertTrue(handler instanceof EnumTypeHandler); } @Test public void testMappedContainerHandler() { - TypeHandler handler = typeSerializationLibrary.getTypeHandler(AMappedContainer.class, getClass().getClassLoader()).get(); + TypeHandler handler = typeHandlerLibrary.getTypeHandler(AMappedContainer.class, getClass().getClassLoader()).get(); assertTrue(handler instanceof ObjectFieldMapTypeHandler); } @@ -59,17 +57,17 @@ public void testMappedContainerHandler() { @Test public void testCollectionHandler() { TypeHandler> setHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(setHandler instanceof CollectionTypeHandler); TypeHandler> listHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(listHandler instanceof CollectionTypeHandler); TypeHandler> queueHandler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(queueHandler instanceof CollectionTypeHandler); } @@ -77,7 +75,7 @@ public void testCollectionHandler() { @Test public void testStringMapHandler() { TypeHandler> handler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); assertTrue(handler instanceof StringMapTypeHandler); } @@ -85,7 +83,7 @@ public void testStringMapHandler() { @Test public void testInvalidTypeHandler() { Optional>> handler = - typeSerializationLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()); assertFalse(handler.isPresent()); } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java index 98f0114a358..acf81434582 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java @@ -33,7 +33,7 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.inMemory.PersistedInteger; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; import org.terasology.persistence.typeHandling.inMemory.PersistedString; @@ -56,7 +56,7 @@ import static org.mockito.Mockito.*; public class RuntimeDelegatingTypeHandlerSandboxTest { - private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final Class apiClass = AABB.class; private final Class nonApiClass = Region3i.class; @@ -115,19 +115,19 @@ public void setup() { when(apiClassHandlerMock.deserialize(any())) .thenReturn(Optional.of(new PersistedInteger(0))); - when(typeSerializationLibrary.getTypeHandler(eq(Object.class), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(Object.class), (ClassLoader) any())) .thenReturn(Optional.of(baseTypeHandlerMock)); - when(typeSerializationLibrary.getTypeHandler(eq(moduleClass), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(moduleClass), (ClassLoader) any())) .thenReturn(Optional.of(moduleClassHandlerMock)); - when(typeSerializationLibrary.getTypeHandler(eq(apiClass), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(apiClass), (ClassLoader) any())) .thenReturn(Optional.of(apiClassHandlerMock)); } @Test public void testAccessModuleClassFromEngine() { - TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment)); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); @@ -149,7 +149,7 @@ public void testAccessModuleClassFromEngine() { @Test public void testCannotAccessModuleClassFromEngineWithoutClassLoader() { - TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, ReflectionUtil.class.getClassLoader()); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); @@ -180,7 +180,7 @@ public void testAccessModuleClassFromModule() { } private void testCanAccessClassFromModule(Class testClass, TypeHandler testClassHandlerMock) { - TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, moduleClass); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); @@ -202,7 +202,7 @@ private void testCanAccessClassFromModule(Class testClass, TypeHandler testCl @Test public void testCannotAccessNonApiClassFromModule() { - TypeHandlerContext context = new TypeHandlerContext(typeSerializationLibrary, + TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, moduleClass); RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 0ce7487d7a1..849046b0ba4 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -20,12 +20,8 @@ import com.google.common.collect.Maps; import org.junit.Test; import org.mockito.ArgumentMatcher; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.PersistedDataArray; -import org.terasology.persistence.typeHandling.PersistedDataSerializer; -import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.*; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; import org.terasology.persistence.typeHandling.inMemory.PersistedString; @@ -47,10 +43,10 @@ public class RuntimeDelegatingTypeHandlerTest { private final CollectionTypeHandlerFactory collectionHandlerFactory = new CollectionTypeHandlerFactory(constructorLibrary); - private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final TypeHandlerContext context = - new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); private static class Base { int x; @@ -74,10 +70,10 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) .thenReturn(Optional.of(baseTypeHandler)); - when(typeSerializationLibrary.getTypeHandler(eq((Type) subType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq((Type) subType), (ClassLoader) any())) .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = @@ -86,8 +82,8 @@ abstract class SubHandler extends TypeHandler {} ArrayList bases = Lists.newArrayList(new Sub(), new Base(), new Sub(), new Base(), new Sub()); listTypeHandler.serialize(bases, serializer); - verify(typeSerializationLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); - verify(typeSerializationLibrary, times(3)).getTypeHandler(eq((Type) subType), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); + verify(typeHandlerLibrary, times(3)).getTypeHandler(eq((Type) subType), (ClassLoader) any()); verify(baseTypeHandler, times(2)).serialize(any(), any()); verify(subTypeHandler, times(3)).serialize(any(), any()); @@ -109,10 +105,10 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeSerializationLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) .thenReturn(Optional.of(baseTypeHandler)); - when(typeSerializationLibrary.getTypeHandler(eq(subType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(subType), (ClassLoader) any())) .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = collectionHandlerFactory.create( @@ -139,8 +135,8 @@ abstract class SubHandler extends TypeHandler {} listTypeHandler.deserialize(persistedBases); - verify(typeSerializationLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); - verify(typeSerializationLibrary, times(3)).getTypeHandler(eq(subType), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); + verify(typeHandlerLibrary, times(3)).getTypeHandler(eq(subType), (ClassLoader) any()); verify(baseTypeHandler, times(2)).deserialize(any()); verify(subTypeHandler, times(3)).deserialize(any()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java index 01da98ecef7..3324148f82b 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java @@ -18,7 +18,7 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; import org.terasology.reflection.TypeInfo; @@ -33,10 +33,10 @@ import static org.mockito.Mockito.verify; public class ArrayTypeHandlerFactoryTest { - private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final ArrayTypeHandlerFactory typeHandlerFactory = new ArrayTypeHandlerFactory(); private final TypeHandlerContext context = - new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); @Test public void testArray() { @@ -48,8 +48,8 @@ public void testArray() { assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof ArrayTypeHandler); - // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType()), (ClassLoader) any()); + // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType()), (ClassLoader) any()); } @Test @@ -62,8 +62,8 @@ public void testGenericArray() { assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof ArrayTypeHandler); - // Verify that the List TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType()), (ClassLoader) any()); + // Verify that the List TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType()), (ClassLoader) any()); } @Test diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index 5c42552341f..e07e888aabe 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -19,7 +19,7 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; @@ -37,11 +37,11 @@ import static org.mockito.Mockito.verify; public class CollectionTypeHandlerFactoryTest { - private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap())); private final TypeHandlerContext context = - new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); @Test public void testList() { @@ -53,8 +53,8 @@ public void testList() { assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); - // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -67,8 +67,8 @@ public void testSet() { assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); - // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -81,8 +81,8 @@ public void testQueue() { assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); - // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -95,7 +95,7 @@ class IntList extends ArrayList {} assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof CollectionTypeHandler); - // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java index c1bb965b641..45b7bd5effa 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/EnumTypeHandlerFactoryTest.java @@ -17,7 +17,6 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.reflection.TypeInfo; @@ -33,7 +32,7 @@ private enum SomeEnum { @Test public void testEnum() { EnumTypeHandlerFactory typeHandlerFactory = new EnumTypeHandlerFactory(); - // EnumTypeHandlerFactory does not require a TypeSerializationLibrary + // EnumTypeHandlerFactory does not require a TypeHandlerLibrary Optional> typeHandler = typeHandlerFactory.create(TypeInfo.of(SomeEnum.class), null); assertTrue(typeHandler.isPresent()); @@ -44,7 +43,7 @@ public void testEnum() { public void testNonEnum() { EnumTypeHandlerFactory typeHandlerFactory = new EnumTypeHandlerFactory(); - // EnumTypeHandlerFactory does not require a TypeSerializationLibrary + // EnumTypeHandlerFactory does not require a TypeHandlerLibrary Optional> typeHandler = typeHandlerFactory.create(TypeInfo.of(Integer.class), null); assertFalse(typeHandler.isPresent()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index b5b68df9d72..7c71c78488d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -19,7 +19,7 @@ import org.junit.Test; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; @@ -34,14 +34,14 @@ import static org.mockito.Mockito.verify; public class ObjectFieldMapTypeHandlerFactoryTest { - private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final ConstructorLibrary constructorLibrary = new ConstructorLibrary(Maps.newHashMap()); private final ObjectFieldMapTypeHandlerFactory typeHandlerFactory = new ObjectFieldMapTypeHandlerFactory( constructorLibrary); private final TypeHandlerContext context = - new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); private static class SomeClass { private T t; @@ -56,12 +56,12 @@ public void testObject() { assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof ObjectFieldMapTypeHandler); - // Verify that the Integer and List TypeHandlers were loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler( + // Verify that the Integer and List TypeHandlers were loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler( eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); - verify(typeSerializationLibrary).getTypeHandler( + verify(typeHandlerLibrary).getTypeHandler( eq(new TypeInfo>() {}.getType()), (ClassLoader) any()); } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java index 8ca5c84e0f0..cc2d23c0411 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -19,7 +19,7 @@ import org.mockito.ArgumentMatchers; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.TypeInfo; @@ -34,11 +34,11 @@ import static org.mockito.Mockito.verify; public class StringMapTypeHandlerFactoryTest { - private final TypeSerializationLibrary typeSerializationLibrary = mock(TypeSerializationLibrary.class); + private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final StringMapTypeHandlerFactory typeHandlerFactory = new StringMapTypeHandlerFactory(); private final TypeHandlerContext context = - new TypeHandlerContext(typeSerializationLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); @Test public void testStringMap() { @@ -50,8 +50,8 @@ public void testStringMap() { assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof StringMapTypeHandler); - // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } @Test @@ -74,7 +74,7 @@ class IntMap extends HashMap {} assertTrue(typeHandler.isPresent()); assertTrue(typeHandler.get() instanceof StringMapTypeHandler); - // Verify that the Integer TypeHandler was loaded from the TypeSerializationLibrary - verify(typeSerializationLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary + verify(typeHandlerLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java similarity index 92% rename from engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactoryTest.java rename to engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java index 4f88fe411ae..d47d3fe8a93 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java @@ -22,7 +22,7 @@ import org.junit.Test; import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector4f; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.rendering.nui.Color; @@ -31,7 +31,7 @@ import java.util.Objects; import java.util.Set; -public class GsonTypeSerializationLibraryAdapterFactoryTest { +public class GsonTypeHandlerLibraryAdapterFactoryTest { private static final TestClass OBJECT = new TestClass( new Color(0xDEADBEEF), ImmutableSet.of(Vector4f.zero(), Vector4f.one()), @@ -48,11 +48,11 @@ public class GsonTypeSerializationLibraryAdapterFactoryTest { private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - private final TypeSerializationLibrary typeSerializationLibrary = - TypeSerializationLibrary.createDefaultLibrary(); + private final TypeHandlerLibrary typeHandlerLibrary = + TypeHandlerLibrary.createDefaultLibrary(); private final Gson gson = - GsonBuilderFactory.createGsonBuilderWithTypeSerializationLibrary(typeSerializationLibrary) + GsonBuilderFactory.createGsonBuilderWithTypeSerializationLibrary(typeHandlerLibrary) .create(); @Test diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 569d9d8f34b..1b43f5fc854 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -34,10 +34,7 @@ import org.terasology.module.ModuleEnvironment; import org.terasology.network.NetworkMode; import org.terasology.network.NetworkSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectFactory; -import org.terasology.reflection.reflect.ReflectionReflectFactory; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.registry.CoreRegistry; import java.util.ArrayList; @@ -60,7 +57,7 @@ public class EventSystemReplayImplTest { public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); PojoEntityManager entityManager = new PojoEntityManager(); entityManager.setComponentLibrary(entitySystemLibrary.getComponentLibrary()); diff --git a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java index 14f4daa35b1..6797cfce865 100644 --- a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java +++ b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java @@ -55,7 +55,7 @@ import org.terasology.monitoring.Activity; import org.terasology.monitoring.PerformanceMonitor; import org.terasology.network.NetworkSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.recording.CharacterStateEventPositionMap; import org.terasology.recording.DirectionAndOriginPosRecorderList; import org.terasology.recording.RecordAndReplayCurrentStatus; @@ -315,7 +315,7 @@ private void initManagers() { CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); rootContext.put(CopyStrategyLibrary.class, copyStrategyLibrary); - rootContext.put(TypeSerializationLibrary.class, new TypeSerializationLibrary()); + rootContext.put(TypeHandlerLibrary.class, new TypeHandlerLibrary()); changeStatus(TerasologyEngineStatus.INITIALIZING_ASSET_TYPES); assetTypeManager = new ModuleAwareAssetTypeManager(); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java index 2b92bd205b9..a1d92b9796c 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java @@ -40,7 +40,7 @@ import org.terasology.logic.characters.CharacterMoveInputEvent; import org.terasology.module.ModuleEnvironment; import org.terasology.network.NetworkSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; import org.terasology.recording.CharacterStateEventPositionMap; import org.terasology.recording.DirectionAndOriginPosRecorderList; @@ -74,9 +74,9 @@ public static void addReflectionBasedLibraries(Context context) { context.put(ReflectFactory.class, reflectFactory); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); context.put(CopyStrategyLibrary.class, copyStrategyLibrary); - TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); - context.put(TypeSerializationLibrary.class, typeSerializationLibrary); - EntitySystemLibrary library = new EntitySystemLibrary(context, typeSerializationLibrary); + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + context.put(TypeHandlerLibrary.class, typeHandlerLibrary); + EntitySystemLibrary library = new EntitySystemLibrary(context, typeHandlerLibrary); context.put(EntitySystemLibrary.class, library); context.put(ComponentLibrary.class, library.getComponentLibrary()); context.put(EventLibrary.class, library.getEventLibrary()); @@ -90,7 +90,7 @@ public static void addReflectionBasedLibraries(Context context) { *

  • {@link NetworkSystem}
    • *
  • {@link ReflectFactory}
    • *
  • {@link CopyStrategyLibrary}
    • - *
  • {@link org.terasology.persistence.typeHandling.TypeSerializationLibrary}
    • + *
  • {@link TypeHandlerLibrary}
    • * *

    * The method will make objects for the following classes available in the context: @@ -112,9 +112,9 @@ public static void addEntityManagementRelatedClasses(Context context) { context.put(EngineEntityManager.class, entityManager); // Standard serialization library - TypeSerializationLibrary typeSerializationLibrary = context.get(TypeSerializationLibrary.class); - typeSerializationLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler(entityManager)); - entityManager.setTypeSerializerLibrary(typeSerializationLibrary); + TypeHandlerLibrary typeHandlerLibrary = context.get(TypeHandlerLibrary.class); + typeHandlerLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler(entityManager)); + entityManager.setTypeSerializerLibrary(typeHandlerLibrary); // Prefab Manager PrefabManager prefabManager = new PojoPrefabManager(context); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java index 743ce615dc2..944cb9cf795 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java @@ -36,7 +36,7 @@ import org.terasology.module.ModuleEnvironment; import org.terasology.persistence.typeHandling.RegisterTypeHandler; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.CollisionGroupTypeHandler; import org.terasology.physics.CollisionGroup; import org.terasology.physics.CollisionGroupManager; @@ -79,12 +79,12 @@ public void handleSwitchToGameEnvironment(Context context) { } ReflectFactory reflectFactory = context.get(ReflectFactory.class); - TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); - typeSerializationLibrary.addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(context.get(CollisionGroupManager.class))); - context.put(TypeSerializationLibrary.class, typeSerializationLibrary); + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + typeHandlerLibrary.addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(context.get(CollisionGroupManager.class))); + context.put(TypeHandlerLibrary.class, typeHandlerLibrary); // Entity System Library - EntitySystemLibrary library = new EntitySystemLibrary(context, typeSerializationLibrary); + EntitySystemLibrary library = new EntitySystemLibrary(context, typeHandlerLibrary); context.put(EntitySystemLibrary.class, library); ComponentLibrary componentLibrary = library.getComponentLibrary(); context.put(ComponentLibrary.class, componentLibrary); @@ -92,7 +92,7 @@ public void handleSwitchToGameEnvironment(Context context) { context.put(ClassMetaLibrary.class, new ClassMetaLibraryImpl(context)); registerComponents(componentLibrary, moduleManager.getEnvironment()); - registerTypeHandlers(context, typeSerializationLibrary, moduleManager.getEnvironment()); + registerTypeHandlers(context, typeHandlerLibrary, moduleManager.getEnvironment()); ModuleAwareAssetTypeManager assetTypeManager = context.get(ModuleAwareAssetTypeManager.class); @@ -104,9 +104,9 @@ public void handleSwitchToGameEnvironment(Context context) { * existing then yet. */ unregisterPrefabFormats(assetTypeManager); - registeredPrefabFormat = new PrefabFormat(componentLibrary, typeSerializationLibrary); + registeredPrefabFormat = new PrefabFormat(componentLibrary, typeHandlerLibrary); assetTypeManager.registerCoreFormat(Prefab.class, registeredPrefabFormat); - registeredPrefabDeltaFormat = new PrefabDeltaFormat(componentLibrary, typeSerializationLibrary); + registeredPrefabDeltaFormat = new PrefabDeltaFormat(componentLibrary, typeHandlerLibrary); assetTypeManager.registerCoreDeltaFormat(Prefab.class, registeredPrefabDeltaFormat); assetTypeManager.switchEnvironment(moduleManager.getEnvironment()); @@ -178,7 +178,7 @@ private static void registerComponents(ComponentLibrary library, ModuleEnvironme } @SuppressWarnings({"rawtypes", "unchecked"}) - private static void registerTypeHandlers(Context context, TypeSerializationLibrary library, ModuleEnvironment environment) { + private static void registerTypeHandlers(Context context, TypeHandlerLibrary library, ModuleEnvironment environment) { for (Class handler : environment.getSubtypesOf(TypeHandler.class)) { RegisterTypeHandler register = handler.getAnnotation(RegisterTypeHandler.class); if (register != null) { diff --git a/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java b/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java index 369e5ecf070..5ccff9ba03a 100644 --- a/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java +++ b/engine/src/main/java/org/terasology/engine/modes/loadProcesses/RegisterBlocks.java @@ -23,7 +23,7 @@ import org.terasology.game.GameManifest; import org.terasology.module.ModuleEnvironment; import org.terasology.network.NetworkSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.BlockFamilyTypeHandler; import org.terasology.persistence.typeHandling.extensionTypes.BlockTypeHandler; import org.terasology.world.block.Block; @@ -68,8 +68,8 @@ public boolean step() { blockManager = new BlockManagerImpl(atlas, context.get(AssetManager.class), false); } context.put(BlockManager.class, blockManager); - context.get(TypeSerializationLibrary.class).addTypeHandler(Block.class, new BlockTypeHandler(blockManager)); - context.get(TypeSerializationLibrary.class).addTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); + context.get(TypeHandlerLibrary.class).addTypeHandler(Block.class, new BlockTypeHandler(blockManager)); + context.get(TypeHandlerLibrary.class).addTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler(blockManager)); blockManager.initialise(gameManifest.getRegisteredBlockFamilies(), gameManifest.getBlockIdMap()); diff --git a/engine/src/main/java/org/terasology/entitySystem/entity/internal/EngineEntityManager.java b/engine/src/main/java/org/terasology/entitySystem/entity/internal/EngineEntityManager.java index c8d87987a0a..7fa5f1c80dd 100644 --- a/engine/src/main/java/org/terasology/entitySystem/entity/internal/EngineEntityManager.java +++ b/engine/src/main/java/org/terasology/entitySystem/entity/internal/EngineEntityManager.java @@ -19,7 +19,7 @@ import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.LowLevelEntityManager; import org.terasology.entitySystem.event.internal.EventSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import java.util.Optional; @@ -113,7 +113,7 @@ public interface EngineEntityManager extends LowLevelEntityManager, EngineEntity /** * @return The default serialization library to use for serializing components */ - TypeSerializationLibrary getTypeSerializerLibrary(); + TypeHandlerLibrary getTypeSerializerLibrary(); /** * Gets the entity pool associated with a given entity. diff --git a/engine/src/main/java/org/terasology/entitySystem/entity/internal/PojoEntityManager.java b/engine/src/main/java/org/terasology/entitySystem/entity/internal/PojoEntityManager.java index bfe766752b2..5911216e975 100644 --- a/engine/src/main/java/org/terasology/entitySystem/entity/internal/PojoEntityManager.java +++ b/engine/src/main/java/org/terasology/entitySystem/entity/internal/PojoEntityManager.java @@ -43,7 +43,7 @@ import org.terasology.game.GameManifest; import org.terasology.math.geom.Quat4f; import org.terasology.math.geom.Vector3f; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.world.internal.WorldInfo; import java.util.ArrayList; @@ -81,7 +81,7 @@ public class PojoEntityManager implements EngineEntityManager { private RefStrategy refStrategy = new DefaultRefStrategy(); - private TypeSerializationLibrary typeSerializerLibrary; + private TypeHandlerLibrary typeSerializerLibrary; @Override public RefStrategy getEntityRefStrategy() { @@ -405,11 +405,11 @@ public void unsubscribe(EntityChangeSubscriber subscriber) { } @Override - public TypeSerializationLibrary getTypeSerializerLibrary() { + public TypeHandlerLibrary getTypeSerializerLibrary() { return typeSerializerLibrary; } - public void setTypeSerializerLibrary(TypeSerializationLibrary serializerLibrary) { + public void setTypeSerializerLibrary(TypeHandlerLibrary serializerLibrary) { this.typeSerializerLibrary = serializerLibrary; } diff --git a/engine/src/main/java/org/terasology/entitySystem/metadata/EntitySystemLibrary.java b/engine/src/main/java/org/terasology/entitySystem/metadata/EntitySystemLibrary.java index adeebd303ee..abc34f721c1 100644 --- a/engine/src/main/java/org/terasology/entitySystem/metadata/EntitySystemLibrary.java +++ b/engine/src/main/java/org/terasology/entitySystem/metadata/EntitySystemLibrary.java @@ -17,7 +17,7 @@ package org.terasology.entitySystem.metadata; import org.terasology.context.Context; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; /** * The set of metadata libraries used by the entity system @@ -25,12 +25,12 @@ */ public class EntitySystemLibrary { - private final TypeSerializationLibrary typeSerializationLibrary; + private final TypeHandlerLibrary typeHandlerLibrary; private final ComponentLibrary componentLibrary; private final EventLibrary eventLibrary; - public EntitySystemLibrary(Context context, TypeSerializationLibrary typeSerializationLibrary) { - this.typeSerializationLibrary = typeSerializationLibrary; + public EntitySystemLibrary(Context context, TypeHandlerLibrary typeHandlerLibrary) { + this.typeHandlerLibrary = typeHandlerLibrary; this.componentLibrary = new ComponentLibrary(context); this.eventLibrary = new EventLibrary(context); @@ -46,8 +46,8 @@ public ComponentLibrary getComponentLibrary() { /** * @return The library of serializers */ - public TypeSerializationLibrary getSerializationLibrary() { - return typeSerializationLibrary; + public TypeHandlerLibrary getSerializationLibrary() { + return typeHandlerLibrary; } /** diff --git a/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabDeltaFormat.java b/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabDeltaFormat.java index 014ed9d5c54..465435e83b4 100644 --- a/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabDeltaFormat.java +++ b/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabDeltaFormat.java @@ -22,7 +22,7 @@ import org.terasology.entitySystem.prefab.PrefabData; import org.terasology.persistence.serializers.EntityDataJSONFormat; import org.terasology.persistence.serializers.PrefabSerializer; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.protobuf.EntityData; import java.io.BufferedReader; @@ -34,12 +34,12 @@ public class PrefabDeltaFormat extends AbstractAssetAlterationFileFormat { private final ComponentLibrary componentLibrary; - private final TypeSerializationLibrary typeSerializationLibrary; + private final TypeHandlerLibrary typeHandlerLibrary; - public PrefabDeltaFormat(ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { + public PrefabDeltaFormat(ComponentLibrary componentLibrary, TypeHandlerLibrary typeHandlerLibrary) { super("prefab"); this.componentLibrary = componentLibrary; - this.typeSerializationLibrary = typeSerializationLibrary; + this.typeHandlerLibrary = typeHandlerLibrary; } @Override @@ -47,7 +47,7 @@ public void apply(AssetDataFile assetDataFile, PrefabData assetData) throws IOEx try (BufferedReader deltaReader = new BufferedReader(new InputStreamReader(assetDataFile.openStream(), Charsets.UTF_8))) { EntityData.Prefab delta = EntityDataJSONFormat.readPrefab(deltaReader); - PrefabSerializer serializer = new PrefabSerializer(componentLibrary, typeSerializationLibrary); + PrefabSerializer serializer = new PrefabSerializer(componentLibrary, typeHandlerLibrary); serializer.deserializeDeltaOnto(delta, assetData); } } diff --git a/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabFormat.java b/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabFormat.java index 5dd7063f752..785f50843ad 100644 --- a/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabFormat.java +++ b/engine/src/main/java/org/terasology/entitySystem/prefab/internal/PrefabFormat.java @@ -25,7 +25,7 @@ import org.terasology.entitySystem.prefab.PrefabData; import org.terasology.persistence.serializers.EntityDataJSONFormat; import org.terasology.persistence.serializers.PrefabSerializer; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.protobuf.EntityData; import java.io.BufferedReader; @@ -37,12 +37,12 @@ public class PrefabFormat extends AbstractAssetFileFormat { private static final Logger logger = LoggerFactory.getLogger(PrefabFormat.class); private ComponentLibrary componentLibrary; - private TypeSerializationLibrary typeSerializationLibrary; + private TypeHandlerLibrary typeHandlerLibrary; - public PrefabFormat(ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { + public PrefabFormat(ComponentLibrary componentLibrary, TypeHandlerLibrary typeHandlerLibrary) { super("prefab"); this.componentLibrary = componentLibrary; - this.typeSerializationLibrary = typeSerializationLibrary; + this.typeHandlerLibrary = typeHandlerLibrary; } @Override @@ -51,7 +51,7 @@ public PrefabData load(ResourceUrn resourceUrn, List inputs) thro EntityData.Prefab prefabData = EntityDataJSONFormat.readPrefab(reader); if (prefabData != null) { logger.info("Attempting to deserialize prefab {} with inputs {}", resourceUrn, inputs); - PrefabSerializer serializer = new PrefabSerializer(componentLibrary, typeSerializationLibrary); + PrefabSerializer serializer = new PrefabSerializer(componentLibrary, typeHandlerLibrary); return serializer.deserialize(prefabData); } else { throw new IOException("Failed to read prefab for '" + resourceUrn + "'"); diff --git a/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java b/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java index 6169491b6e9..3caca827a7a 100644 --- a/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java +++ b/engine/src/main/java/org/terasology/network/internal/NetworkSystemImpl.java @@ -76,7 +76,7 @@ import org.terasology.persistence.StorageManager; import org.terasology.persistence.serializers.EventSerializer; import org.terasology.persistence.serializers.NetworkEntitySerializer; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.protobuf.NetData; import org.terasology.reflection.metadata.ClassLibrary; import org.terasology.reflection.metadata.ClassMetadata; @@ -534,12 +534,12 @@ public void connectToEntitySystem(EngineEntityManager newEntityManager, EventLib context.get(ComponentSystemManager.class).register(new NetworkEntitySystem(this), "engine:networkEntitySystem"); - TypeSerializationLibrary typeSerializationLibrary = new TypeSerializationLibrary(entityManager.getTypeSerializerLibrary()); - typeSerializationLibrary.addTypeHandler(EntityRef.class, new NetEntityRefTypeHandler(this, blockEntityRegistry)); + TypeHandlerLibrary typeHandlerLibrary = new TypeHandlerLibrary(entityManager.getTypeSerializerLibrary()); + typeHandlerLibrary.addTypeHandler(EntityRef.class, new NetEntityRefTypeHandler(this, blockEntityRegistry)); // TODO: Add network override types here (that use id lookup tables) - eventSerializer = new EventSerializer(eventLibrary, typeSerializationLibrary); - entitySerializer = new NetworkEntitySerializer(newEntityManager, entityManager.getComponentLibrary(), typeSerializationLibrary); + eventSerializer = new EventSerializer(eventLibrary, typeHandlerLibrary); + entitySerializer = new NetworkEntitySerializer(newEntityManager, entityManager.getComponentLibrary(), typeHandlerLibrary); entitySerializer.setComponentSerializeCheck(new NetComponentSerializeCheck()); if (mode == NetworkMode.CLIENT) { diff --git a/engine/src/main/java/org/terasology/persistence/internal/ReadWriteStorageManager.java b/engine/src/main/java/org/terasology/persistence/internal/ReadWriteStorageManager.java index 4805d6dc652..7295c32f7b2 100644 --- a/engine/src/main/java/org/terasology/persistence/internal/ReadWriteStorageManager.java +++ b/engine/src/main/java/org/terasology/persistence/internal/ReadWriteStorageManager.java @@ -44,7 +44,7 @@ import org.terasology.network.Client; import org.terasology.network.ClientComponent; import org.terasology.network.NetworkSystem; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.protobuf.EntityData; import org.terasology.recording.RecordAndReplayCurrentStatus; import org.terasology.recording.RecordAndReplaySerializer; @@ -153,7 +153,7 @@ public ReadWriteStorageManager(Path savePath, ModuleEnvironment environment, Eng private static EngineEntityManager createPrivateEntityManager(ComponentLibrary componentLibrary) { PojoEntityManager pojoEntityManager = new PojoEntityManager(); pojoEntityManager.setComponentLibrary(componentLibrary); - pojoEntityManager.setTypeSerializerLibrary(CoreRegistry.get(TypeSerializationLibrary.class)); + pojoEntityManager.setTypeSerializerLibrary(CoreRegistry.get(TypeHandlerLibrary.class)); return pojoEntityManager; } diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java index 0373373728c..36b1f01c4f5 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ComponentSerializer.java @@ -30,7 +30,7 @@ import org.terasology.module.Module; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.Serializer; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; import org.terasology.protobuf.EntityData; @@ -55,7 +55,7 @@ public class ComponentSerializer { private ComponentLibrary componentLibrary; private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); private boolean usingFieldIds; - private TypeSerializationLibrary typeSerializationLibrary; + private TypeHandlerLibrary typeHandlerLibrary; private ProtobufPersistedDataSerializer serializationContext; /** @@ -63,9 +63,9 @@ public class ComponentSerializer { * * @param componentLibrary The component library used to provide information on each component and its fields. */ - public ComponentSerializer(ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { + public ComponentSerializer(ComponentLibrary componentLibrary, TypeHandlerLibrary typeHandlerLibrary) { this.componentLibrary = componentLibrary; - this.typeSerializationLibrary = typeSerializationLibrary; + this.typeHandlerLibrary = typeHandlerLibrary; this.serializationContext = new ProtobufPersistedDataSerializer(); } @@ -179,7 +179,7 @@ public Component deserializeOnto(Component target, EntityData.Component componen private Component deserializeOnto(Component targetComponent, EntityData.Component componentData, ComponentMetadata componentMetadata, FieldSerializeCheck fieldCheck) { - Serializer serializer = typeSerializationLibrary.getSerializerFor(componentMetadata); + Serializer serializer = typeHandlerLibrary.getSerializerFor(componentMetadata); Map, PersistedData> dataMap = Maps.newHashMapWithExpectedSize(componentData.getFieldCount()); for (EntityData.NameValue field : componentData.getFieldList()) { FieldMetadata fieldInfo = null; @@ -225,7 +225,7 @@ public EntityData.Component serialize(Component component, FieldSerializeCheck field : componentMetadata.getFields()) { if (check.shouldSerializeField(field, component)) { PersistedData result = serializer.serialize(field, component, serializationContext); @@ -281,7 +281,7 @@ public EntityData.Component serialize(Component base, Component delta, FieldSeri EntityData.Component.Builder componentMessage = EntityData.Component.newBuilder(); serializeComponentType(componentMetadata, componentMessage); - Serializer serializer = typeSerializationLibrary.getSerializerFor(componentMetadata); + Serializer serializer = typeHandlerLibrary.getSerializerFor(componentMetadata); boolean changed = false; for (ReplicatedFieldMetadata field : componentMetadata.getFields()) { if (check.shouldSerializeField(field, delta) && serializer.getHandlerFor(field) != null) { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/EntitySerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/EntitySerializer.java index 6fcacedf390..90b177af44e 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/EntitySerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/EntitySerializer.java @@ -27,7 +27,7 @@ import org.terasology.entitySystem.metadata.ComponentMetadata; import org.terasology.entitySystem.prefab.Prefab; import org.terasology.entitySystem.prefab.PrefabManager; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.protobuf.EntityData; import java.util.Map; @@ -63,11 +63,11 @@ public EntitySerializer(EngineEntityManager entityManager) { this(entityManager, entityManager.getComponentLibrary(), entityManager.getTypeSerializerLibrary()); } - public EntitySerializer(EngineEntityManager entityManager, ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { + public EntitySerializer(EngineEntityManager entityManager, ComponentLibrary componentLibrary, TypeHandlerLibrary typeHandlerLibrary) { this.entityManager = entityManager; this.prefabManager = entityManager.getPrefabManager(); this.componentLibrary = componentLibrary; - this.componentSerializer = new ComponentSerializer(componentLibrary, typeSerializationLibrary); + this.componentSerializer = new ComponentSerializer(componentLibrary, typeHandlerLibrary); } /** diff --git a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java index cdb4b9d400c..f9b22295966 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/EventSerializer.java @@ -30,7 +30,7 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.SerializationException; import org.terasology.persistence.typeHandling.Serializer; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; import org.terasology.protobuf.EntityData; @@ -43,7 +43,7 @@ public class EventSerializer { private static final Logger logger = LoggerFactory.getLogger(ComponentSerializer.class); private EventLibrary eventLibrary; - private TypeSerializationLibrary typeSerializationLibrary; + private TypeHandlerLibrary typeHandlerLibrary; private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); private PersistedDataSerializer persistedDataSerializer; @@ -52,9 +52,9 @@ public class EventSerializer { * * @param eventLibrary The event library used to provide information on each event and its fields. */ - public EventSerializer(EventLibrary eventLibrary, TypeSerializationLibrary typeSerializationLibrary) { + public EventSerializer(EventLibrary eventLibrary, TypeHandlerLibrary typeHandlerLibrary) { this.eventLibrary = eventLibrary; - this.typeSerializationLibrary = typeSerializationLibrary; + this.typeHandlerLibrary = typeHandlerLibrary; this.persistedDataSerializer = new ProtobufPersistedDataSerializer(); } @@ -97,7 +97,7 @@ public Event deserialize(EntityData.Event eventData) { private Event deserializeOnto(Event targetEvent, EntityData.Event eventData, EventMetadata eventMetadata) { - Serializer serializer = typeSerializationLibrary.getSerializerFor(eventMetadata); + Serializer serializer = typeHandlerLibrary.getSerializerFor(eventMetadata); for (int i = 0; i < eventData.getFieldIds().size(); ++i) { byte fieldId = eventData.getFieldIds().byteAt(i); ReplicatedFieldMetadata fieldInfo = eventMetadata.getField(fieldId); @@ -129,7 +129,7 @@ public EntityData.Event serialize(Event event) { EntityData.Event.Builder eventData = EntityData.Event.newBuilder(); serializeEventType(event, eventData); - Serializer eventSerializer = typeSerializationLibrary.getSerializerFor(eventMetadata); + Serializer eventSerializer = typeHandlerLibrary.getSerializerFor(eventMetadata); ByteString.Output fieldIds = ByteString.newOutput(); for (ReplicatedFieldMetadata field : eventMetadata.getFields()) { if (field.isReplicated()) { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java index 55e6ead3454..87f473661d2 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/NetworkEntitySerializer.java @@ -36,7 +36,7 @@ import org.terasology.entitySystem.prefab.Prefab; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.Serializer; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; import org.terasology.protobuf.EntityData; @@ -52,14 +52,14 @@ public class NetworkEntitySerializer { private ComponentSerializeCheck componentSerializeCheck = ComponentSerializeCheck.NullCheck.create(); private EngineEntityManager entityManager; private ComponentLibrary componentLibrary; - private TypeSerializationLibrary typeSerializationLibrary; + private TypeHandlerLibrary typeHandlerLibrary; private ProtobufPersistedDataSerializer serializationContext; private BiMap, Integer> idTable = ImmutableBiMap., Integer>builder().build(); - public NetworkEntitySerializer(EngineEntityManager entityManager, ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { + public NetworkEntitySerializer(EngineEntityManager entityManager, ComponentLibrary componentLibrary, TypeHandlerLibrary typeHandlerLibrary) { this.entityManager = entityManager; this.componentLibrary = componentLibrary; - this.typeSerializationLibrary = typeSerializationLibrary; + this.typeHandlerLibrary = typeHandlerLibrary; this.serializationContext = new ProtobufPersistedDataSerializer(); } @@ -148,7 +148,7 @@ private void serializeComponentDelta(Component oldComponent, Component newCompon } byte fieldCount = 0; - Serializer serializer = typeSerializationLibrary.getSerializerFor(componentMetadata); + Serializer serializer = typeHandlerLibrary.getSerializerFor(componentMetadata); for (ReplicatedFieldMetadata field : componentMetadata.getFields()) { if (fieldCheck.shouldSerializeField(field, newComponent, componentInitial)) { Object oldValue = field.getValue(oldComponent); @@ -181,7 +181,7 @@ private void serializeComponentFull(Component component, boolean ignoreIfNoField return; } - Serializer serializer = typeSerializationLibrary.getSerializerFor(componentMetadata); + Serializer serializer = typeHandlerLibrary.getSerializerFor(componentMetadata); byte fieldCount = 0; for (ReplicatedFieldMetadata field : componentMetadata.getFields()) { if (fieldCheck.shouldSerializeField(field, component, componentInitial)) { @@ -225,7 +225,7 @@ public void deserializeOnto(MutableComponentContainer entity, EntityData.PackedE createdNewComponent = true; component = metadata.newInstance(); } - Serializer serializer = typeSerializationLibrary.getSerializerFor(metadata); + Serializer serializer = typeHandlerLibrary.getSerializerFor(metadata); for (int fieldIndex = 0; fieldIndex < UnsignedBytes.toInt(entityData.getComponentFieldCounts().byteAt(componentIndex)); ++fieldIndex) { byte fieldId = entityData.getFieldIds().byteAt(fieldPos); ReplicatedFieldMetadata fieldMetadata = metadata.getField(fieldId); diff --git a/engine/src/main/java/org/terasology/persistence/serializers/PrefabSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/PrefabSerializer.java index 4b2dd113b73..4951f7c350c 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/PrefabSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/PrefabSerializer.java @@ -26,7 +26,7 @@ import org.terasology.entitySystem.prefab.PrefabData; import org.terasology.module.Module; import org.terasology.persistence.ModuleContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.protobuf.EntityData; import java.util.Collections; @@ -50,9 +50,9 @@ public class PrefabSerializer { private ComponentSerializer componentSerializer; private ComponentLibrary componentLibrary; - public PrefabSerializer(ComponentLibrary componentLibrary, TypeSerializationLibrary typeSerializationLibrary) { + public PrefabSerializer(ComponentLibrary componentLibrary, TypeHandlerLibrary typeHandlerLibrary) { this.componentLibrary = componentLibrary; - this.componentSerializer = new ComponentSerializer(componentLibrary, typeSerializationLibrary); + this.componentSerializer = new ComponentSerializer(componentLibrary, typeHandlerLibrary); } /** diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandler.java index ecb98678bd9..a3a7c15dfec 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandler.java @@ -25,7 +25,7 @@ /** * Marks a {@link TypeHandler} to be automatically registered at a - * {@link org.terasology.persistence.typeHandling.TypeSerializationLibrary TypeSerializationLibrary} on environment change. + * {@link TypeHandlerLibrary TypeHandlerLibrary} on environment change. * This can be used to (de)serialize custom components. *

    * By default, the TypeHandler must have an empty constructor. diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java index b91f0db8afb..1207fa756cc 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java @@ -28,28 +28,28 @@ * while staying within the sandbox rules if called from a module. */ public class TypeHandlerContext { - private TypeSerializationLibrary typeSerializationLibrary; + private TypeHandlerLibrary typeHandlerLibrary; private ClassLoader[] classLoaders; - public TypeHandlerContext(TypeSerializationLibrary typeSerializationLibrary, Class... classes) { + public TypeHandlerContext(TypeHandlerLibrary typeHandlerLibrary, Class... classes) { this( - typeSerializationLibrary, + typeHandlerLibrary, Arrays.stream(classes) .map(Class::getClassLoader) .toArray(ClassLoader[]::new) ); } - public TypeHandlerContext(TypeSerializationLibrary typeSerializationLibrary, ClassLoader... classLoaders) { - this.typeSerializationLibrary = typeSerializationLibrary; + public TypeHandlerContext(TypeHandlerLibrary typeHandlerLibrary, ClassLoader... classLoaders) { + this.typeHandlerLibrary = typeHandlerLibrary; this.classLoaders = classLoaders; } /** - * Returns the {@link TypeSerializationLibrary} that called the {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerContext)} method. + * Returns the {@link TypeHandlerLibrary} that called the {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerContext)} method. */ - public TypeSerializationLibrary getTypeSerializationLibrary() { - return typeSerializationLibrary; + public TypeHandlerLibrary getTypeHandlerLibrary() { + return typeHandlerLibrary; } /** @@ -67,20 +67,20 @@ public ClassLoader[] getClassLoaders() { * Retrieve the {@link TypeHandler} for the given type in the current context. */ public Optional> getTypeHandler(Type elementType) { - return typeSerializationLibrary.getTypeHandler(elementType, classLoaders); + return typeHandlerLibrary.getTypeHandler(elementType, classLoaders); } /** * Retrieve the {@link TypeHandler} for the given type in the current context. */ public Optional> getTypeHandler(Class elementType) { - return typeSerializationLibrary.getTypeHandler(elementType, classLoaders); + return typeHandlerLibrary.getTypeHandler(elementType, classLoaders); } /** * Retrieve the {@link TypeHandler} for the given type in the current context. */ public Optional> getTypeHandler(TypeInfo elementType) { - return typeSerializationLibrary.getTypeHandler(elementType, classLoaders); + return typeHandlerLibrary.getTypeHandler(elementType, classLoaders); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java index 6b95936dfb0..c266f369846 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerFactory.java @@ -35,7 +35,7 @@ public interface TypeHandlerFactory { * * @param The type for which a {@link TypeHandler} must be generated. * @param typeInfo The {@link TypeInfo} of the type for which a {@link TypeHandler} must be generated. - * @param context The {@link TypeSerializationLibrary} for which the {@link TypeHandler} + * @param context The {@link TypeHandlerLibrary} for which the {@link TypeHandler} * is being created. * @return An {@link Optional} wrapping the created {@link TypeHandler}, or {@link Optional#empty()} * if the type is not supported by this {@link TypeHandlerFactory}. diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java similarity index 97% rename from engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java rename to engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 08f1e2265c1..53e417f8ac8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeSerializationLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -60,7 +60,6 @@ import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2fTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2iTypeHandlerFactory; import org.terasology.reflection.TypeInfo; -import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.metadata.ClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; import org.terasology.reflection.reflect.ConstructorLibrary; @@ -79,8 +78,8 @@ * This library should be initialised by adding a number of base type handlers, describing how to serialize each supported type. * It will then produce serializers for classes (through their ClassMetadata) on request. */ -public class TypeSerializationLibrary { - private static final Logger logger = LoggerFactory.getLogger(TypeSerializationLibrary.class); +public class TypeHandlerLibrary { + private static final Logger logger = LoggerFactory.getLogger(TypeHandlerLibrary.class); private List typeHandlerFactories = Lists.newArrayList(); @@ -102,7 +101,7 @@ public class TypeSerializationLibrary { /** */ - public TypeSerializationLibrary() { + public TypeHandlerLibrary() { constructorLibrary = new ConstructorLibrary(instanceCreators); @@ -139,12 +138,12 @@ public TypeSerializationLibrary() { * * @param original The original type serialization library to copy. */ - public TypeSerializationLibrary(TypeSerializationLibrary original) { + public TypeHandlerLibrary(TypeHandlerLibrary original) { this.typeHandlerFactories.addAll(original.typeHandlerFactories); } - public static TypeSerializationLibrary createDefaultLibrary() { - TypeSerializationLibrary serializationLibrary = new TypeSerializationLibrary(); + public static TypeHandlerLibrary createDefaultLibrary() { + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); serializationLibrary.addTypeHandler(Color.class, new ColorTypeHandler()); serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 8afbc61260d..61232142b56 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -22,6 +22,7 @@ import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.reflection.reflect.ObjectConstructor; import java.lang.reflect.Field; @@ -31,7 +32,7 @@ /** * Serializes objects as a fieldName -> fieldValue map. It is used as the last resort while serializing an - * object through a {@link org.terasology.persistence.typeHandling.TypeSerializationLibrary}. + * object through a {@link TypeHandlerLibrary}. */ public class ObjectFieldMapTypeHandler extends TypeHandler { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 5794e32d71b..8e139a28ac3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -23,7 +23,7 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.reflection.TypeInfo; import org.terasology.utilities.ReflectionUtil; @@ -35,7 +35,7 @@ * Delegates serialization of a value to a handler of its runtime type if needed. It is used in * cases where a subclass instance can be referred to as its supertype. As such, it is meant * for internal use in another {@link TypeHandler} only, and is never directly registered - * in a {@link TypeSerializationLibrary}. + * in a {@link TypeHandlerLibrary}. * * @param The base type whose instances may be delegated to a subtype's {@link TypeHandler} at runtime. */ @@ -47,13 +47,13 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private TypeHandler delegateHandler; private TypeInfo typeInfo; - private TypeSerializationLibrary typeSerializationLibrary; + private TypeHandlerLibrary typeHandlerLibrary; private ClassLoader[] classLoaders; public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeHandlerContext context) { this.delegateHandler = delegateHandler; this.typeInfo = typeInfo; - this.typeSerializationLibrary = context.getTypeSerializationLibrary(); + this.typeHandlerLibrary = context.getTypeHandlerLibrary(); this.classLoaders = context.getClassLoaders(); } @@ -73,7 +73,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize Class runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { - Optional> runtimeTypeHandler = typeSerializationLibrary.getTypeHandler((Type) runtimeClass, classLoaders); + Optional> runtimeTypeHandler = typeHandlerLibrary.getTypeHandler((Type) runtimeClass, classLoaders); chosenHandler = (TypeHandler) runtimeTypeHandler .map(typeHandler -> { @@ -165,7 +165,7 @@ public Optional deserialize(PersistedData data) { return Optional.empty(); } - TypeHandler runtimeTypeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(typeToDeserializeAs.get(), classLoaders) + TypeHandler runtimeTypeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(typeToDeserializeAs.get(), classLoaders) // To avoid compile errors in the orElseGet .map(typeHandler -> (TypeHandler) typeHandler) .orElseGet(() -> { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonBuilderFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonBuilderFactory.java index 864619de5fc..b6ced8e5d54 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonBuilderFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonBuilderFactory.java @@ -15,10 +15,9 @@ */ package org.terasology.persistence.typeHandling.gson; -import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.TypeAdapterFactory; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; /** * Class containing static factory methods for generating {@link GsonBuilder} objects that follow Terasology @@ -35,14 +34,14 @@ public static GsonBuilder createDefaultGsonBuilder() { /** * Create a {@link GsonBuilder} which uses type handlers loaded from the given - * {@link TypeSerializationLibrary} and complies with Terasology JSON serialization rules. + * {@link TypeHandlerLibrary} and complies with Terasology JSON serialization rules. * - * @param typeSerializationLibrary The {@link TypeSerializationLibrary} to load type handler + * @param typeHandlerLibrary The {@link TypeHandlerLibrary} to load type handler * definitions from */ - public static GsonBuilder createGsonBuilderWithTypeSerializationLibrary(TypeSerializationLibrary typeSerializationLibrary) { + public static GsonBuilder createGsonBuilderWithTypeSerializationLibrary(TypeHandlerLibrary typeHandlerLibrary) { TypeAdapterFactory typeAdapterFactory = - new GsonTypeSerializationLibraryAdapterFactory(typeSerializationLibrary); + new GsonTypeSerializationLibraryAdapterFactory(typeHandlerLibrary); return createDefaultGsonBuilder() .registerTypeAdapterFactory(typeAdapterFactory); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java index 8d3ad0ef7ad..53b7f02d666 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java @@ -20,21 +20,21 @@ import com.google.gson.TypeAdapterFactory; import com.google.gson.reflect.TypeToken; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; import java.lang.reflect.Type; /** * A Gson {@link TypeAdapterFactory} that dynamically looks up the {@link TypeHandler} from a - * {@link TypeSerializationLibrary} for each type encountered, and creates a {@link GsonTypeHandlerAdapter} with + * {@link TypeHandlerLibrary} for each type encountered, and creates a {@link GsonTypeHandlerAdapter} with * the retrieved {@link TypeHandler}. */ public class GsonTypeSerializationLibraryAdapterFactory implements TypeAdapterFactory { - private final TypeSerializationLibrary typeSerializationLibrary; + private final TypeHandlerLibrary typeHandlerLibrary; - public GsonTypeSerializationLibraryAdapterFactory(TypeSerializationLibrary typeSerializationLibrary) { - this.typeSerializationLibrary = typeSerializationLibrary; + public GsonTypeSerializationLibraryAdapterFactory(TypeHandlerLibrary typeHandlerLibrary) { + this.typeHandlerLibrary = typeHandlerLibrary; } @SuppressWarnings("unchecked") @@ -42,7 +42,7 @@ public GsonTypeSerializationLibraryAdapterFactory(TypeSerializationLibrary typeS public TypeAdapter create(Gson gson, TypeToken type) { Type rawType = type.getType(); - TypeHandler typeHandler = (TypeHandler) typeSerializationLibrary.getTypeHandler(rawType, + TypeHandler typeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(rawType, GsonTypeSerializationLibraryAdapterFactory.class).orElse(null); if (typeHandler == null || typeHandler instanceof ObjectFieldMapTypeHandler) { diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 4cdfc7b7a21..daba4d0a7e1 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -24,7 +24,7 @@ import org.terasology.persistence.serializers.GsonSerializer; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.copy.CopyStrategyLibrary; @@ -51,12 +51,12 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - TypeSerializationLibrary typeSerializationLibrary = TypeSerializationLibrary.createDefaultLibrary(); - typeSerializationLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + typeHandlerLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); ClassLoader[] classLoaders = ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment); - this.recordedEventListTypeHandler = typeSerializationLibrary.getTypeHandler( + this.recordedEventListTypeHandler = typeHandlerLibrary.getTypeHandler( new TypeInfo>() {}, classLoaders).get(); } diff --git a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java index a85e1782ed1..e2277de8e6d 100644 --- a/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java +++ b/engine/src/main/java/org/terasology/rendering/nui/asset/UIFormat.java @@ -35,7 +35,7 @@ import org.terasology.assets.module.annotations.RegisterAssetFileFormat; import org.terasology.i18n.TranslationSystem; import org.terasology.persistence.ModuleContext; -import org.terasology.persistence.typeHandling.TypeSerializationLibrary; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.AssetTypeHandler; import org.terasology.persistence.typeHandling.gson.GsonTypeSerializationLibraryAdapterFactory; import org.terasology.reflection.metadata.ClassMetadata; @@ -94,10 +94,10 @@ public UIData load(JsonElement element) throws IOException { 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)); + TypeHandlerLibrary library = new TypeHandlerLibrary(CoreRegistry.get(TypeHandlerLibrary.class)); library.addTypeHandler(UISkin.class, new AssetTypeHandler<>(UISkin.class)); - // TODO: Rewrite to use TypeSerializationLibrary + // TODO: Rewrite to use TypeHandlerLibrary GsonBuilder gsonBuilder = new GsonBuilder() .registerTypeAdapterFactory(new GsonTypeSerializationLibraryAdapterFactory(library)) From 6e3b8af9cc5a06fd964630863b3511f2a1c6684b Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 26 Jun 2019 19:15:32 +0530 Subject: [PATCH 097/141] Add TypeHandlerLibrary documentation --- .../typeHandling/TypeHandlerLibrary.java | 123 +++++++++++++++++- .../org/terasology/reflection/TypeInfo.java | 2 +- 2 files changed, 120 insertions(+), 5 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 53e417f8ac8..7fa0d340368 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -100,6 +100,7 @@ public class TypeHandlerLibrary { private Map, Serializer> serializerMap = Maps.newHashMap(); /** + * */ public TypeHandlerLibrary() { @@ -184,14 +185,37 @@ public Serializer getSerializerFor(ClassMetadata type) { return serializer; } + /** + * Adds a new {@link TypeHandlerFactory} to the {@link TypeHandlerLibrary}. Factories + * added later are given a higher priority during {@link TypeHandler} generation. + */ public void addTypeHandlerFactory(TypeHandlerFactory typeHandlerFactory) { typeHandlerFactories.add(typeHandlerFactory); } + /** + * Adds a {@link TypeHandler} for the specified type to this {@link TypeHandlerLibrary} by + * adding to the library a new {@link TypeHandlerFactory} that returns the {@link TypeHandler} + * whenever the {@link TypeHandler} for the specified type is requested. + * + * @param typeClass The {@link Class} of the type handled by the {@link TypeHandler}. + * @param typeHandler The {@link TypeHandler} to add to the library. + * @param The type handled by the {@link TypeHandler}. + */ public void addTypeHandler(Class typeClass, TypeHandler typeHandler) { addTypeHandler(TypeInfo.of(typeClass), typeHandler); } + /** + * Adds a {@link TypeHandler} for the specified type to this {@link TypeHandlerLibrary} by + * adding to the library a new {@link TypeHandlerFactory} that returns the {@link TypeHandler} + * whenever the {@link TypeHandler} for the specified type is requested. + * + * @param type The {@link TypeInfo} of the type handled by the {@link TypeHandler}. + * @param typeHandler The {@link TypeHandler} to add to the library. + * @param The type handled by the {@link TypeHandler}. + */ + public void addTypeHandler(TypeInfo type, TypeHandler typeHandler) { TypeHandlerFactory factory = new TypeHandlerFactory() { @SuppressWarnings("unchecked") @@ -204,21 +228,54 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont addTypeHandlerFactory(factory); } + /** + * Adds an {@link InstanceCreator} to the {@link TypeHandlerLibrary} for the specified type. + */ public void addInstanceCreator(Class typeClass, InstanceCreator instanceCreator) { addInstanceCreator(TypeInfo.of(typeClass), instanceCreator); } + /** + * Adds an {@link InstanceCreator} to the {@link TypeHandlerLibrary} for the specified type. + */ public void addInstanceCreator(TypeInfo typeInfo, InstanceCreator instanceCreator) { instanceCreators.put(typeInfo.getType(), instanceCreator); } + /** + * Retrieves the {@link TypeHandler} for the specified type, if available. + *

    + * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested + * to generate a {@link TypeHandler} for the given type. Most recently added factories are + * requested first, hence a {@link TypeHandlerFactory} can override one that was added + * before it. + * + * @param type The {@link Type} describing the type for which to + * retrieve the {@link TypeHandler}. + * @param contextClasses The {@link Class}(es) that the caller has access to. Used to obtain + * {@link ClassLoader}(s) that the caller has access to. + * @return The {@link TypeHandler} for the specified type, if available. + */ @SuppressWarnings({"unchecked"}) - public Optional> getTypeHandler(Type type, Class... classes) { - return getTypeHandler(type, Arrays.stream(classes) + public Optional> getTypeHandler(Type type, Class... contextClasses) { + return getTypeHandler(type, Arrays.stream(contextClasses) .map(Class::getClassLoader) .toArray(ClassLoader[]::new)); } + /** + * Retrieves the {@link TypeHandler} for the specified type, if available. + *

    + * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested + * to generate a {@link TypeHandler} for the given type. Most recently added factories are + * requested first, hence a {@link TypeHandlerFactory} can override one that was added + * before it. + * + * @param type The {@link Type} describing the type for which to + * retrieve the {@link TypeHandler}. + * @param contextClassLoaders The {@link ClassLoader}(s) that the caller has access to. + * @return The {@link TypeHandler} for the specified type, if available. + */ @SuppressWarnings({"unchecked"}) public Optional> getTypeHandler(Type type, ClassLoader... contextClassLoaders) { TypeInfo typeInfo = TypeInfo.of(type); @@ -226,16 +283,60 @@ public Optional> getTypeHandler(Type type, ClassLoader... context } - public Optional> getTypeHandler(Class typeClass, Class... classes) { - return getTypeHandler(typeClass, Arrays.stream(classes) + /** + * Retrieves the {@link TypeHandler} for the specified type, if available. + *

    + * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested + * to generate a {@link TypeHandler} for the given type. Most recently added factories are + * requested first, hence a {@link TypeHandlerFactory} can override one that was added + * before it. + * + * @param typeClass The {@link Class} of the type for which to + * retrieve the {@link TypeHandler}. + * @param contextClasses The {@link Class}(es) that the caller has access to. Used to obtain + * {@link ClassLoader}(s) that the caller has access to. + * @param The type for which to retrieve the {@link TypeHandler}. + * @return The {@link TypeHandler} for the specified type, if available. + */ + public Optional> getTypeHandler(Class typeClass, Class... contextClasses) { + return getTypeHandler(typeClass, Arrays.stream(contextClasses) .map(Class::getClassLoader) .toArray(ClassLoader[]::new)); } + /** + * Retrieves the {@link TypeHandler} for the specified type, if available. + *

    + * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested + * to generate a {@link TypeHandler} for the given type. Most recently added factories are + * requested first, hence a {@link TypeHandlerFactory} can override one that was added + * before it. + * + * @param typeClass The {@link Class} of the type for which to + * retrieve the {@link TypeHandler}. + * @param contextClassLoaders The {@link ClassLoader}(s) that the caller has access to. + * @param The type for which to retrieve the {@link TypeHandler}. + * @return The {@link TypeHandler} for the specified type, if available. + */ public Optional> getTypeHandler(Class typeClass, ClassLoader... contextClassLoaders) { return getTypeHandler(TypeInfo.of(typeClass), contextClassLoaders); } + /** + * Retrieves the {@link TypeHandler} for the specified type, if available. + *

    + * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested + * to generate a {@link TypeHandler} for the given type. Most recently added factories are + * requested first, hence a {@link TypeHandlerFactory} can override one that was added + * before it. + * + * @param type The {@link TypeInfo} describing the type for which to + * retrieve the {@link TypeHandler}. + * @param contextClasses The {@link Class}(es) that the caller has access to. Used to obtain + * {@link ClassLoader}(s) that the caller has access to. + * @param The type for which to retrieve the {@link TypeHandler}. + * @return The {@link TypeHandler} for the specified type, if available. + */ @SuppressWarnings("unchecked") public Optional> getTypeHandler(TypeInfo type, Class... contextClasses) { return getTypeHandler(type, Arrays.stream(contextClasses) @@ -243,6 +344,20 @@ public Optional> getTypeHandler(TypeInfo type, Class... .toArray(ClassLoader[]::new)); } + /** + * Retrieves the {@link TypeHandler} for the specified type, if available. + *

    + * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested + * to generate a {@link TypeHandler} for the given type. Most recently added factories are + * requested first, hence a {@link TypeHandlerFactory} can override one that was added + * before it. + * + * @param type The {@link TypeInfo} describing the type for which to + * retrieve the {@link TypeHandler}. + * @param contextClassLoaders The {@link ClassLoader}(s) that the caller has access to. + * @param The type for which to retrieve the {@link TypeHandler}. + * @return The {@link TypeHandler} for the specified type, if available. + */ @SuppressWarnings("unchecked") public Optional> getTypeHandler(TypeInfo type, ClassLoader... contextClassLoaders) { TypeHandlerContext context = new TypeHandlerContext(this, contextClassLoaders); diff --git a/engine/src/main/java/org/terasology/reflection/TypeInfo.java b/engine/src/main/java/org/terasology/reflection/TypeInfo.java index 7d06a130b77..6b4e42418bb 100644 --- a/engine/src/main/java/org/terasology/reflection/TypeInfo.java +++ b/engine/src/main/java/org/terasology/reflection/TypeInfo.java @@ -21,7 +21,7 @@ /** * Represents the type {@link T}. The type information generated is more comprehensive than {@link Class}, - * and {@link #type} correctly represents {@link T} whether it is generic or a wildcard type. + * and {@link #type} correctly represents {@link T} regardless of whether it is generic or a wildcard type. * *

    * Clients must create a subclass so that the proper {@link Type} can be retrieved at run-time: From feb21109b25598e0df88d04af41a2940dec305ec Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 26 Jun 2019 20:11:05 +0530 Subject: [PATCH 098/141] Add concrete Type implementations in ReflectionUtil --- .../terasology/utilities/ReflectionUtil.java | 230 +++++++++++++++--- 1 file changed, 195 insertions(+), 35 deletions(-) diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index f98d385b63c..d5488d77140 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -33,6 +33,7 @@ import java.util.Arrays; import java.util.List; import java.util.Locale; +import java.util.Objects; import java.util.Optional; import java.util.Set; @@ -290,7 +291,7 @@ private static Type getTypeParameterForSuperInterface(Type target, Class * will be thrown. * * @param contextType The {@link Type} which contains all type parameter definitions used in {@code type}. - * @param type The {@link Type} whose {@link TypeVariable}s are to be resolved. + * @param type The {@link Type} whose {@link TypeVariable}s are to be resolved. * @return A copy of {@code type} with all {@link TypeVariable}s resolved. */ public static Type resolveType(Type contextType, Type type) { @@ -335,22 +336,7 @@ public static Type resolveType(Type contextType, Type type) { final Type rawType = parameterizedType.getRawType(); - return new ParameterizedType() { - @Override - public Type[] getActualTypeArguments() { - return resolvedTypeArguments; - } - - @Override - public Type getRawType() { - return rawType; - } - - @Override - public Type getOwnerType() { - return resolvedOwnerType; - } - }; + return new ParameterizedTypeImpl(rawType, resolvedTypeArguments, resolvedOwnerType); } // T[] field || List[] field; @@ -363,13 +349,7 @@ public Type getOwnerType() { if (resolvedComponentType == componentType) { return type; } else { - return new GenericArrayType() { - final Type genericComponentType = resolvedComponentType; - @Override - public Type getGenericComponentType() { - return genericComponentType; - } - }; + return new GenericArrayTypeImpl(resolvedComponentType); } } @@ -392,17 +372,7 @@ public Type getGenericComponentType() { return wildcardType; } - return new WildcardType() { - @Override - public Type[] getUpperBounds() { - return resolvedUpperBounds; - } - - @Override - public Type[] getLowerBounds() { - return resolvedLowerBounds; - } - }; + return new WildcardTypeImpl(resolvedUpperBounds, resolvedLowerBounds); } return type; @@ -488,4 +458,194 @@ public static ClassLoader[] getComprehensiveEngineClassLoaders(ModuleEnvironment (ClassLoader) readField(moduleEnvironment, "finalClassLoader") }; } + + private static class WildcardTypeImpl implements WildcardType { + private final Type[] upperBounds; + private final Type[] lowerBounds; + + public WildcardTypeImpl(Type[] upperBounds, Type[] lowerBounds) { + this.upperBounds = upperBounds; + this.lowerBounds = lowerBounds; + } + + @Override + public Type[] getUpperBounds() { + return upperBounds; + } + + @Override + public Type[] getLowerBounds() { + return lowerBounds; + } + + public String toString() { + Type[] lowerBounds = this.getLowerBounds(); + Type[] bounds = lowerBounds; + + StringBuilder stringBuilder = new StringBuilder(); + + if (lowerBounds.length > 0) { + stringBuilder.append("? super "); + } else { + Type[] upperBounds = this.getUpperBounds(); + if (upperBounds.length <= 0 || upperBounds[0].equals(Object.class)) { + return "?"; + } + + bounds = upperBounds; + stringBuilder.append("? extends "); + } + + boolean isFirstBound = true; + + for (Type bound : bounds) { + if (!isFirstBound) { + stringBuilder.append(" & "); + } + + isFirstBound = false; + stringBuilder.append(bound.getTypeName()); + } + + return stringBuilder.toString(); + } + + public boolean equals(Object var1) { + if (!(var1 instanceof WildcardType)) { + return false; + } else { + WildcardType var2 = (WildcardType) var1; + return Arrays.equals(this.getLowerBounds(), var2.getLowerBounds()) && Arrays.equals(this.getUpperBounds(), var2.getUpperBounds()); + } + } + + public int hashCode() { + Type[] var1 = this.getLowerBounds(); + Type[] var2 = this.getUpperBounds(); + return Arrays.hashCode(var1) ^ Arrays.hashCode(var2); + } + } + + private static class GenericArrayTypeImpl implements GenericArrayType { + private final Type genericComponentType; + + private GenericArrayTypeImpl(Type genericComponentType) { + this.genericComponentType = genericComponentType; + } + + public Type getGenericComponentType() { + return this.genericComponentType; + } + + public String toString() { + Type genericComponentType = this.getGenericComponentType(); + StringBuilder stringBuilder = new StringBuilder(); + if (genericComponentType instanceof Class) { + stringBuilder.append(((Class) genericComponentType).getName()); + } else { + stringBuilder.append(genericComponentType.toString()); + } + + stringBuilder.append("[]"); + return stringBuilder.toString(); + } + + public boolean equals(Object var1) { + if (var1 instanceof GenericArrayType) { + GenericArrayType var2 = (GenericArrayType) var1; + return Objects.equals(this.genericComponentType, var2.getGenericComponentType()); + } else { + return false; + } + } + + public int hashCode() { + return Objects.hashCode(this.genericComponentType); + } + } + + private static class ParameterizedTypeImpl implements ParameterizedType { + private final Type[] actualTypeArguments; + private final Class rawType; + private final Type ownerType; + + private ParameterizedTypeImpl(Type rawType, Type[] actualTypeArguments, Type ownerType) { + this.actualTypeArguments = actualTypeArguments; + this.rawType = (Class) rawType; + this.ownerType = ownerType != null ? ownerType : this.rawType.getDeclaringClass(); + } + + public Type[] getActualTypeArguments() { + return this.actualTypeArguments.clone(); + } + + public Class getRawType() { + return this.rawType; + } + + public Type getOwnerType() { + return this.ownerType; + } + + public boolean equals(Object other) { + if (!(other instanceof ParameterizedType)) { + return false; + } + + ParameterizedType otherParameterizedType = (ParameterizedType) other; + + if (this == otherParameterizedType) { + return true; + } + + return Objects.equals(this.ownerType, otherParameterizedType.getOwnerType()) && + Objects.equals(this.rawType, otherParameterizedType.getRawType()) && + Arrays.equals(this.actualTypeArguments, otherParameterizedType.getActualTypeArguments()); + } + + public int hashCode() { + return Arrays.hashCode(this.actualTypeArguments) ^ Objects.hashCode(this.ownerType) ^ Objects.hashCode(this.rawType); + } + + public String toString() { + StringBuilder var1 = new StringBuilder(); + if (this.ownerType != null) { + if (this.ownerType instanceof Class) { + var1.append(((Class) this.ownerType).getName()); + } else { + var1.append(this.ownerType.toString()); + } + + var1.append("$"); + if (this.ownerType instanceof ParameterizedTypeImpl) { + var1.append(this.rawType.getName().replace(((ParameterizedTypeImpl) this.ownerType).rawType.getName() + "$", "")); + } else { + var1.append(this.rawType.getSimpleName()); + } + } else { + var1.append(this.rawType.getName()); + } + + if (this.actualTypeArguments != null && this.actualTypeArguments.length > 0) { + var1.append("<"); + boolean var2 = true; + Type[] var3 = this.actualTypeArguments; + int var4 = var3.length; + + for (int var5 = 0; var5 < var4; ++var5) { + Type var6 = var3[var5]; + if (!var2) { + var1.append(", "); + } + + var1.append(var6.getTypeName()); + var2 = false; + } + + var1.append(">"); + } + + return var1.toString(); + } + } } From 97506c3fbfd846b9181f2cdb7bc2bedf07ea01f5 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 26 Jun 2019 20:11:19 +0530 Subject: [PATCH 099/141] Add FutureTypeHandlerTest --- .../typeHandling/FutureTypeHandlerTest.java | 85 +++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java new file mode 100644 index 00000000000..8508fffe2ab --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java @@ -0,0 +1,85 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + +import com.google.common.collect.Lists; +import org.junit.Test; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.terasology.reflection.TypeInfo; + +import java.util.List; +import java.util.Optional; + +import static org.hamcrest.CoreMatchers.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.*; + +public class FutureTypeHandlerTest { + private final TypeHandlerLibrary typeHandlerLibrary = spy(TypeHandlerLibrary.createDefaultLibrary()); + + private static class RecursiveType { + final T data; + final List> children; + + @SafeVarargs + private RecursiveType(T data, RecursiveType... children) { + this.data = data; + this.children = Lists.newArrayList(children); + } + } + + private class ResultCaptor implements Answer { + private T result = null; + public T getResult() { + return result; + } + + @Override + public T answer(InvocationOnMock invocationOnMock) throws Throwable { + result = (T) invocationOnMock.callRealMethod(); + return result; + } + } + + @Test + public void testRecursiveType() { + ResultCaptor>>> resultCaptor = new ResultCaptor<>(); + + doAnswer(resultCaptor).when(typeHandlerLibrary).getTypeHandler( + eq(new TypeInfo>() {}.getType()), (ClassLoader) any() + ); + + TypeHandler> typeHandler = + typeHandlerLibrary.getTypeHandler( + new TypeInfo>() {}, + FutureTypeHandlerTest.class + ).get(); + + verify(typeHandlerLibrary, times(1)).getTypeHandler( + eq(new TypeInfo>() {}.getType()), (ClassLoader) any() + ); + + assertThat(resultCaptor.getResult().get(), + both(notNullValue()).and(instanceOf(FutureTypeHandler.class))); + + FutureTypeHandler> future = + (FutureTypeHandler>) resultCaptor.getResult().get(); + + assertEquals(typeHandler, future.typeHandler); + } +} \ No newline at end of file From 17da5d703de990b6ca29c682650963d4136ea03d Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Thu, 27 Jun 2019 15:38:25 +0530 Subject: [PATCH 100/141] Remove redundant TypeHandlerLibrary initialization --- .../src/main/java/org/terasology/engine/TerasologyEngine.java | 2 +- .../terasology/engine/bootstrap/EnvironmentSwitchHandler.java | 4 +--- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java index 6797cfce865..8fee04e1c22 100644 --- a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java +++ b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java @@ -315,7 +315,7 @@ private void initManagers() { CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); rootContext.put(CopyStrategyLibrary.class, copyStrategyLibrary); - rootContext.put(TypeHandlerLibrary.class, new TypeHandlerLibrary()); + rootContext.put(TypeHandlerLibrary.class, TypeHandlerLibrary.createDefaultLibrary()); changeStatus(TerasologyEngineStatus.INITIALIZING_ASSET_TYPES); assetTypeManager = new ModuleAwareAssetTypeManager(); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java index 944cb9cf795..b5805eba8d6 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java @@ -78,10 +78,8 @@ public void handleSwitchToGameEnvironment(Context context) { } } - ReflectFactory reflectFactory = context.get(ReflectFactory.class); - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + TypeHandlerLibrary typeHandlerLibrary = context.get(TypeHandlerLibrary.class); typeHandlerLibrary.addTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler(context.get(CollisionGroupManager.class))); - context.put(TypeHandlerLibrary.class, typeHandlerLibrary); // Entity System Library EntitySystemLibrary library = new EntitySystemLibrary(context, typeHandlerLibrary); From 1b4e9f8ca5e265ae504cc576a1b3df46c951ef8b Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 28 Jun 2019 14:59:00 +0530 Subject: [PATCH 101/141] Add Reflections field to TypeHandlerLibrary --- .../entitySystem/PojoEventSystemTests.java | 8 ++++- .../entitySystem/PojoPrefabManagerTest.java | 10 ++++++- .../metadata/ComponentMetadataTest.java | 12 ++++++-- .../persistence/ComponentSerializerTest.java | 8 ++++- .../serializers/TypeSerializerTest.java | 15 ++++++++-- .../typeHandling/FutureTypeHandlerTest.java | 9 +++++- .../typeHandling/TypeHandlerLibraryTest.java | 7 ++++- ...nTypeHandlerLibraryAdapterFactoryTest.java | 10 +++++-- .../recording/EventSystemReplayImplTest.java | 9 +++++- .../terasology/engine/TerasologyEngine.java | 5 +++- .../bootstrap/EntitySystemSetupUtil.java | 5 +++- .../typeHandling/TypeHandlerLibrary.java | 29 +++++++++++++++---- .../recording/RecordedEventSerializer.java | 2 +- 13 files changed, 108 insertions(+), 21 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java index 391aec8907a..9136cba7c3d 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java @@ -18,6 +18,8 @@ import com.google.common.collect.Lists; import org.junit.Before; import org.junit.Test; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.context.internal.ContextImpl; import org.terasology.engine.SimpleUri; import org.terasology.entitySystem.entity.EntityRef; @@ -61,7 +63,11 @@ public class PojoEventSystemTests { public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); + + ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + Reflections reflections = new Reflections(configurationBuilder); + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); compLibrary = entitySystemLibrary.getComponentLibrary(); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java index b799815a19e..b3d491fcf62 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java @@ -17,6 +17,8 @@ import org.junit.Before; import org.junit.Test; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.assets.AssetFactory; import org.terasology.assets.ResourceUrn; import org.terasology.assets.management.AssetManager; @@ -57,9 +59,15 @@ public void setup() throws Exception { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); ModuleManager moduleManager = ModuleManagerFactory.create(); - TypeHandlerLibrary lib = new TypeHandlerLibrary(); + + ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + Reflections reflections = new Reflections(configurationBuilder); + TypeHandlerLibrary lib = new TypeHandlerLibrary(reflections); + lib.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); lib.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); + entitySystemLibrary = new EntitySystemLibrary(context, lib); componentLibrary = entitySystemLibrary.getComponentLibrary(); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java index 2ebad16bf95..c390ef6210b 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java @@ -18,6 +18,8 @@ import org.junit.Before; import org.junit.Test; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.context.Context; import org.terasology.context.internal.ContextImpl; import org.terasology.engine.SimpleUri; @@ -48,7 +50,10 @@ public void prepare() { @Test public void testStaticFieldsIgnored() { - EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary()); + ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + Reflections reflections = new Reflections(configurationBuilder); + EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary(reflections)); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:string"), StringComponent.class); ComponentMetadata metadata = lib.getMetadata(StringComponent.class); @@ -57,7 +62,10 @@ public void testStaticFieldsIgnored() { @Test public void testOwnsReferencesPopulated() { - EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary()); + ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + Reflections reflections = new Reflections(configurationBuilder); + EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary(reflections)); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:owner"), OwnerComponent.class); ComponentMetadata metadata = lib.getMetadata(OwnerComponent.class); diff --git a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java index ac8137a1731..a04fcad6184 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java @@ -19,6 +19,8 @@ import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.context.Context; import org.terasology.context.internal.ContextImpl; import org.terasology.engine.SimpleUri; @@ -66,7 +68,11 @@ public void setup() { context.put(ModuleManager.class, moduleManager); CoreRegistry.setContext(context); - TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); + ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + Reflections reflections = new Reflections(configurationBuilder); + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); + serializationLibrary.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 29df232b1ce..4e2886824e4 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -20,6 +20,8 @@ import org.junit.Test; import org.junit.experimental.runners.Enclosed; import org.junit.runner.RunWith; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.math.geom.Vector3f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; @@ -49,7 +51,12 @@ public class TypeSerializerTest { public static class Json { private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; - private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + final Reflections reflections = new Reflections(configurationBuilder); + + private final TypeHandlerLibrary typeHandlerLibrary = + TypeHandlerLibrary.withDefaultHandlers(reflections); @Test public void testJsonSerialize() { @@ -74,8 +81,12 @@ public void testDeserialize() { } public static class Protobuf { - private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + final Reflections reflections = new Reflections(configurationBuilder); + private final TypeHandlerLibrary typeHandlerLibrary = + TypeHandlerLibrary.withDefaultHandlers(reflections); @Test public void testSerializeDeserialize() throws IOException { TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java index 8508fffe2ab..b0b71ebcd0a 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java @@ -19,6 +19,8 @@ import org.junit.Test; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.reflection.TypeInfo; import java.util.List; @@ -30,7 +32,12 @@ import static org.mockito.Mockito.*; public class FutureTypeHandlerTest { - private final TypeHandlerLibrary typeHandlerLibrary = spy(TypeHandlerLibrary.createDefaultLibrary()); + private final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + private final Reflections reflections = new Reflections(configurationBuilder); + + private final TypeHandlerLibrary typeHandlerLibrary = + spy(TypeHandlerLibrary.withDefaultHandlers(reflections)); private static class RecursiveType { final T data; diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java index 6c2eb5f72c7..634b01d43b8 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java @@ -16,6 +16,8 @@ package org.terasology.persistence.typeHandling; import org.junit.Test; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; @@ -33,7 +35,10 @@ import static org.junit.Assert.assertTrue; public class TypeHandlerLibraryTest { - private final TypeHandlerLibrary typeHandlerLibrary = new TypeHandlerLibrary(); + private final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + private final Reflections reflections = new Reflections(configurationBuilder); + private final TypeHandlerLibrary typeHandlerLibrary = new TypeHandlerLibrary(reflections); private enum AnEnum {} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java index d47d3fe8a93..8284ddfc38d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java @@ -20,6 +20,8 @@ import com.google.gson.Gson; import org.junit.Assert; import org.junit.Test; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector4f; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; @@ -46,10 +48,12 @@ public class GsonTypeHandlerLibraryAdapterFactoryTest { private static final String OBJECT_JSON = "{\"color\":[222,173,190,239],\"vector4fs\":[[0.0,0.0,0.0,0.0]," + "[1.0,1.0,1.0,1.0]],\"rect2iMap\":{\"someRect\":{\"min\":[-3,-3],\"size\":[10,10]}},\"i\":-912559}"; - private final ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); - private final CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); + private final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + private final Reflections reflections = new Reflections(configurationBuilder); + private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.createDefaultLibrary(); + TypeHandlerLibrary.withDefaultHandlers(reflections); private final Gson gson = GsonBuilderFactory.createGsonBuilderWithTypeSerializationLibrary(typeHandlerLibrary) diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 1b43f5fc854..6627a962afd 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -19,6 +19,8 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.context.internal.ContextImpl; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.PojoEntityManager; @@ -57,7 +59,12 @@ public class EventSystemReplayImplTest { public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); + + ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() + .addClassLoader(getClass().getClassLoader()); + Reflections reflections = new Reflections(configurationBuilder); + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); + EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); PojoEntityManager entityManager = new PojoEntityManager(); entityManager.setComponentLibrary(entitySystemLibrary.getComponentLibrary()); diff --git a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java index 8fee04e1c22..14cc9b23196 100644 --- a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java +++ b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java @@ -52,6 +52,7 @@ import org.terasology.input.InputSystem; import org.terasology.logic.behavior.asset.BehaviorTree; import org.terasology.logic.behavior.asset.BehaviorTreeData; +import org.terasology.module.ModuleEnvironment; import org.terasology.monitoring.Activity; import org.terasology.monitoring.PerformanceMonitor; import org.terasology.network.NetworkSystem; @@ -315,7 +316,9 @@ private void initManagers() { CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); rootContext.put(CopyStrategyLibrary.class, copyStrategyLibrary); - rootContext.put(TypeHandlerLibrary.class, TypeHandlerLibrary.createDefaultLibrary()); + + ModuleEnvironment environment = moduleManager.getEnvironment(); + rootContext.put(TypeHandlerLibrary.class, TypeHandlerLibrary.forModuleEnvironment(environment)); changeStatus(TerasologyEngineStatus.INITIALIZING_ASSET_TYPES); assetTypeManager = new ModuleAwareAssetTypeManager(); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java index a1d92b9796c..d94db5ccb39 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java @@ -74,8 +74,11 @@ public static void addReflectionBasedLibraries(Context context) { context.put(ReflectFactory.class, reflectFactory); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); context.put(CopyStrategyLibrary.class, copyStrategyLibrary); - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + + ModuleEnvironment moduleEnvironment = context.get(ModuleManager.class).getEnvironment(); + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleEnvironment); context.put(TypeHandlerLibrary.class, typeHandlerLibrary); + EntitySystemLibrary library = new EntitySystemLibrary(context, typeHandlerLibrary); context.put(EntitySystemLibrary.class, library); context.put(ComponentLibrary.class, library.getComponentLibrary()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 7fa0d340368..49e705b2108 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -18,6 +18,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import org.reflections.Reflections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.entitySystem.prefab.Prefab; @@ -28,6 +29,7 @@ import org.terasology.math.geom.Vector3f; import org.terasology.math.geom.Vector3i; import org.terasology.math.geom.Vector4f; +import org.terasology.module.ModuleEnvironment; import org.terasology.naming.Name; import org.terasology.persistence.typeHandling.coreTypes.BooleanTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ByteArrayTypeHandler; @@ -65,6 +67,7 @@ import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.rendering.assets.texture.TextureRegion; import org.terasology.rendering.nui.Color; +import org.terasology.utilities.ReflectionUtil; import java.lang.reflect.Type; import java.util.Arrays; @@ -81,6 +84,8 @@ public class TypeHandlerLibrary { private static final Logger logger = LoggerFactory.getLogger(TypeHandlerLibrary.class); + private Reflections reflections; + private List typeHandlerFactories = Lists.newArrayList(); private Map, TypeHandler> typeHandlerCache = Maps.newHashMap(); @@ -101,8 +106,10 @@ public class TypeHandlerLibrary { /** * + * @param reflections */ - public TypeHandlerLibrary() { + public TypeHandlerLibrary(Reflections reflections) { + this.reflections = reflections; constructorLibrary = new ConstructorLibrary(instanceCreators); @@ -141,11 +148,25 @@ public TypeHandlerLibrary() { */ public TypeHandlerLibrary(TypeHandlerLibrary original) { this.typeHandlerFactories.addAll(original.typeHandlerFactories); + this.instanceCreators.putAll(original.instanceCreators); + this.reflections = original.reflections; } - public static TypeHandlerLibrary createDefaultLibrary() { - TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(); + public static TypeHandlerLibrary withDefaultHandlers(Reflections reflections) { + TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); + + populateWithDefaultHandlers(serializationLibrary); + + return serializationLibrary; + } + public static TypeHandlerLibrary forModuleEnvironment(ModuleEnvironment moduleEnvironment) { + // TODO: Reflection - may break with updates to gestalt-module + Reflections reflections = (Reflections) ReflectionUtil.readField(moduleEnvironment, "fullReflections"); + return withDefaultHandlers(reflections); + } + + private static void populateWithDefaultHandlers(TypeHandlerLibrary serializationLibrary) { serializationLibrary.addTypeHandler(Color.class, new ColorTypeHandler()); serializationLibrary.addTypeHandler(Quat4f.class, new Quat4fTypeHandler()); @@ -165,8 +186,6 @@ public static TypeHandlerLibrary createDefaultLibrary() { serializationLibrary.addTypeHandlerFactory(new Rect2fTypeHandlerFactory()); serializationLibrary.addTypeHandler(Prefab.class, new PrefabTypeHandler()); serializationLibrary.addTypeHandler(IntegerRange.class, new IntegerRangeHandler()); - - return serializationLibrary; } /** diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index daba4d0a7e1..55643aef681 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -51,7 +51,7 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.createDefaultLibrary(); + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleEnvironment); typeHandlerLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); ClassLoader[] classLoaders = ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment); From a525594d988cad141c6eda98f13c796ee4d2747a Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 28 Jun 2019 18:54:32 +0530 Subject: [PATCH 102/141] Use Reflections instead of ClassLoaders in serialization --- .../entitySystem/PojoEventSystemTests.java | 5 +- .../entitySystem/PojoPrefabManagerTest.java | 5 +- .../metadata/ComponentMetadataTest.java | 9 +- .../persistence/ComponentSerializerTest.java | 9 +- .../serializers/TypeSerializerTest.java | 15 +- .../typeHandling/FutureTypeHandlerTest.java | 22 +- .../typeHandling/TypeHandlerLibraryTest.java | 19 +- ...ntimeDelegatingTypeHandlerSandboxTest.java | 224 ------------------ .../RuntimeDelegatingTypeHandlerTest.java | 24 +- .../ArrayTypeHandlerFactoryTest.java | 7 +- .../CollectionTypeHandlerFactoryTest.java | 11 +- .../ObjectFieldMapTypeHandlerFactoryTest.java | 11 +- .../StringMapTypeHandlerFactoryTest.java | 7 +- ...nTypeHandlerLibraryAdapterFactoryTest.java | 7 +- .../recording/EventSystemReplayImplTest.java | 5 +- .../typeHandling/TypeHandlerContext.java | 47 +--- .../typeHandling/TypeHandlerLibrary.java | 99 ++------ .../RuntimeDelegatingTypeHandler.java | 25 +- .../factories/ArrayTypeHandlerFactory.java | 3 +- .../CollectionTypeHandlerFactory.java | 3 +- .../ObjectFieldMapTypeHandlerFactory.java | 3 +- .../StringMapTypeHandlerFactory.java | 3 +- ...ypeSerializationLibraryAdapterFactory.java | 3 +- .../factories/Rect2fTypeHandlerFactory.java | 3 +- .../factories/Rect2iTypeHandlerFactory.java | 7 +- .../recording/RecordedEventSerializer.java | 2 +- .../terasology/utilities/ReflectionUtil.java | 11 - 27 files changed, 122 insertions(+), 467 deletions(-) delete mode 100644 engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java index 9136cba7c3d..2ee9cd05857 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoEventSystemTests.java @@ -19,7 +19,6 @@ import org.junit.Before; import org.junit.Test; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.context.internal.ContextImpl; import org.terasology.engine.SimpleUri; import org.terasology.entitySystem.entity.EntityRef; @@ -64,9 +63,7 @@ public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - Reflections reflections = new Reflections(configurationBuilder); + Reflections reflections = new Reflections(getClass().getClassLoader()); TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java index b3d491fcf62..1cf6bd8dff6 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/PojoPrefabManagerTest.java @@ -18,7 +18,6 @@ import org.junit.Before; import org.junit.Test; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.assets.AssetFactory; import org.terasology.assets.ResourceUrn; import org.terasology.assets.management.AssetManager; @@ -60,9 +59,7 @@ public void setup() throws Exception { CoreRegistry.setContext(context); ModuleManager moduleManager = ModuleManagerFactory.create(); - ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - Reflections reflections = new Reflections(configurationBuilder); + Reflections reflections = new Reflections(getClass().getClassLoader()); TypeHandlerLibrary lib = new TypeHandlerLibrary(reflections); lib.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); diff --git a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java index c390ef6210b..c800dd70f4a 100644 --- a/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java +++ b/engine-tests/src/test/java/org/terasology/entitySystem/metadata/ComponentMetadataTest.java @@ -19,7 +19,6 @@ import org.junit.Before; import org.junit.Test; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.context.Context; import org.terasology.context.internal.ContextImpl; import org.terasology.engine.SimpleUri; @@ -50,9 +49,7 @@ public void prepare() { @Test public void testStaticFieldsIgnored() { - ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - Reflections reflections = new Reflections(configurationBuilder); + Reflections reflections = new Reflections(getClass().getClassLoader()); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary(reflections)); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:string"), StringComponent.class); @@ -62,9 +59,7 @@ public void testStaticFieldsIgnored() { @Test public void testOwnsReferencesPopulated() { - ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - Reflections reflections = new Reflections(configurationBuilder); + Reflections reflections = new Reflections(getClass().getClassLoader()); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, new TypeHandlerLibrary(reflections)); ComponentLibrary lib = entitySystemLibrary.getComponentLibrary(); lib.register(new SimpleUri("unittest:owner"), OwnerComponent.class); diff --git a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java index a04fcad6184..77548c62d12 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/ComponentSerializerTest.java @@ -20,7 +20,6 @@ import org.junit.BeforeClass; import org.junit.Test; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.context.Context; import org.terasology.context.internal.ContextImpl; import org.terasology.engine.SimpleUri; @@ -44,9 +43,7 @@ import org.terasology.registry.CoreRegistry; import org.terasology.testUtil.ModuleManagerFactory; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.Assert.*; import static org.mockito.Mockito.mock; /** @@ -68,9 +65,7 @@ public void setup() { context.put(ModuleManager.class, moduleManager); CoreRegistry.setContext(context); - ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - Reflections reflections = new Reflections(configurationBuilder); + Reflections reflections = new Reflections(getClass().getClassLoader()); TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); serializationLibrary.addTypeHandler(Vector3f.class, new Vector3fTypeHandler()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 4e2886824e4..8c60285804e 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -21,7 +21,6 @@ import org.junit.experimental.runners.Enclosed; import org.junit.runner.RunWith; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.math.geom.Vector3f; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.TypeHandler; @@ -51,9 +50,7 @@ public class TypeSerializerTest { public static class Json { private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; - final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - final Reflections reflections = new Reflections(configurationBuilder); + final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.withDefaultHandlers(reflections); @@ -62,7 +59,7 @@ public static class Json { public void testJsonSerialize() { GsonSerializer gsonSerializer = new GsonSerializer(); - TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, TypeSerializerTest.class).get(); + TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertEquals(INSTANCE_JSON, gsonSerializer.toJson(INSTANCE, typeHandler)); } @@ -72,7 +69,7 @@ public void testDeserialize() { GsonSerializer gsonSerializer = new GsonSerializer(); PersistedData persistedData = gsonSerializer.persistedDataFromJson(INSTANCE_JSON); - TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); @@ -81,15 +78,13 @@ public void testDeserialize() { } public static class Protobuf { - final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - final Reflections reflections = new Reflections(configurationBuilder); + final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.withDefaultHandlers(reflections); @Test public void testSerializeDeserialize() throws IOException { - TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); ProtobufSerializer protobufSerializer = new ProtobufSerializer(); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java index b0b71ebcd0a..2cd09bdbdf4 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java @@ -20,21 +20,24 @@ import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.reflection.TypeInfo; import java.util.List; import java.util.Optional; -import static org.hamcrest.CoreMatchers.*; +import static org.hamcrest.CoreMatchers.both; +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.hamcrest.CoreMatchers.notNullValue; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; public class FutureTypeHandlerTest { - private final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - private final Reflections reflections = new Reflections(configurationBuilder); + private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = spy(TypeHandlerLibrary.withDefaultHandlers(reflections)); @@ -68,17 +71,16 @@ public void testRecursiveType() { ResultCaptor>>> resultCaptor = new ResultCaptor<>(); doAnswer(resultCaptor).when(typeHandlerLibrary).getTypeHandler( - eq(new TypeInfo>() {}.getType()), (ClassLoader) any() + eq(new TypeInfo>() {}.getType()) ); TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler( - new TypeInfo>() {}, - FutureTypeHandlerTest.class + new TypeInfo>() {} ).get(); verify(typeHandlerLibrary, times(1)).getTypeHandler( - eq(new TypeInfo>() {}.getType()), (ClassLoader) any() + eq(new TypeInfo>() {}.getType()) ); assertThat(resultCaptor.getResult().get(), diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java index 634b01d43b8..439820e56ed 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java @@ -17,7 +17,6 @@ import org.junit.Test; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; @@ -35,9 +34,7 @@ import static org.junit.Assert.assertTrue; public class TypeHandlerLibraryTest { - private final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - private final Reflections reflections = new Reflections(configurationBuilder); + private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = new TypeHandlerLibrary(reflections); private enum AnEnum {} @@ -47,14 +44,14 @@ private static class AMappedContainer {} @Test public void testEnumHandler() { - TypeHandler handler = typeHandlerLibrary.getTypeHandler(AnEnum.class, getClass().getClassLoader()).get(); + TypeHandler handler = typeHandlerLibrary.getTypeHandler(AnEnum.class).get(); assertTrue(handler instanceof EnumTypeHandler); } @Test public void testMappedContainerHandler() { - TypeHandler handler = typeHandlerLibrary.getTypeHandler(AMappedContainer.class, getClass().getClassLoader()).get(); + TypeHandler handler = typeHandlerLibrary.getTypeHandler(AMappedContainer.class).get(); assertTrue(handler instanceof ObjectFieldMapTypeHandler); } @@ -62,17 +59,17 @@ public void testMappedContainerHandler() { @Test public void testCollectionHandler() { TypeHandler> setHandler = - typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(setHandler instanceof CollectionTypeHandler); TypeHandler> listHandler = - typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(listHandler instanceof CollectionTypeHandler); TypeHandler> queueHandler = - typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(queueHandler instanceof CollectionTypeHandler); } @@ -80,7 +77,7 @@ public void testCollectionHandler() { @Test public void testStringMapHandler() { TypeHandler> handler = - typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()).get(); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); assertTrue(handler instanceof StringMapTypeHandler); } @@ -88,7 +85,7 @@ public void testStringMapHandler() { @Test public void testInvalidTypeHandler() { Optional>> handler = - typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}, getClass().getClassLoader()); + typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}); assertFalse(handler.isPresent()); } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java deleted file mode 100644 index acf81434582..00000000000 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerSandboxTest.java +++ /dev/null @@ -1,224 +0,0 @@ -/* - * Copyright 2018 MovingBlocks - * - * 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 org.terasology.persistence.typeHandling.coreTypes; - -import com.google.common.collect.ImmutableMap; -import org.junit.Before; -import org.junit.Test; -import org.terasology.math.AABB; -import org.terasology.math.Region3i; -import org.terasology.module.DependencyResolver; -import org.terasology.module.ModuleEnvironment; -import org.terasology.module.ModulePathScanner; -import org.terasology.module.ModuleRegistry; -import org.terasology.module.TableModuleRegistry; -import org.terasology.module.sandbox.ModuleSecurityManager; -import org.terasology.module.sandbox.ModuleSecurityPolicy; -import org.terasology.module.sandbox.PermissionSet; -import org.terasology.module.sandbox.StandardPermissionProviderFactory; -import org.terasology.naming.Name; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.TypeHandler; -import org.terasology.persistence.typeHandling.TypeHandlerContext; -import org.terasology.persistence.typeHandling.TypeHandlerLibrary; -import org.terasology.persistence.typeHandling.inMemory.PersistedInteger; -import org.terasology.persistence.typeHandling.inMemory.PersistedMap; -import org.terasology.persistence.typeHandling.inMemory.PersistedString; -import org.terasology.reflection.TypeInfo; -import org.terasology.utilities.ReflectionUtil; - -import java.io.FilePermission; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.security.Policy; -import java.util.Collections; -import java.util.Iterator; -import java.util.Optional; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assume.assumeTrue; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.*; - -public class RuntimeDelegatingTypeHandlerSandboxTest { - private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); - private final Class apiClass = AABB.class; - private final Class nonApiClass = Region3i.class; - - private ModuleEnvironment moduleEnvironment; - private Class moduleClass; - - private TypeHandler baseTypeHandlerMock; - private TypeHandler moduleClassHandlerMock; - private TypeHandler apiClassHandlerMock; - - @Before - public void setup() { - ModuleRegistry registry = new TableModuleRegistry(); - Path modulesPath = Paths.get("").toAbsolutePath(); - if (!modulesPath.endsWith("engine-tests")){ - modulesPath = modulesPath.resolve("engine-tests"); - } - modulesPath = modulesPath.resolve("test-modules"); - new ModulePathScanner().scan(registry, modulesPath); - - StandardPermissionProviderFactory permissionProviderFactory = new StandardPermissionProviderFactory(); - permissionProviderFactory.getBasePermissionSet().addAPIPackage("sun.reflect"); - permissionProviderFactory.getBasePermissionSet().addAPIPackage("java.lang"); - permissionProviderFactory.getBasePermissionSet().addAPIPackage("java.util"); - permissionProviderFactory.getBasePermissionSet().addAPIClass(apiClass); - PermissionSet ioPermissionSet = new PermissionSet(); - ioPermissionSet.addAPIPackage("java.io"); - ioPermissionSet.addAPIPackage("java.nio.file"); - ioPermissionSet.addAPIPackage("java.nio.file.attribute"); - ioPermissionSet.grantPermission(FilePermission.class); - permissionProviderFactory.addPermissionSet("io", ioPermissionSet); - - Policy.setPolicy(new ModuleSecurityPolicy()); - System.setSecurityManager(new ModuleSecurityManager()); - - DependencyResolver resolver = new DependencyResolver(registry); - moduleEnvironment = new ModuleEnvironment(resolver.resolve(new Name("EmptyClassModule")).getModules(), permissionProviderFactory, Collections.emptyList()); - - Iterator> moduleClasses = - moduleEnvironment.getSubtypesOf(AutoCloseable.class).iterator(); - - assumeTrue(moduleClasses.hasNext()); - - moduleClass = moduleClasses.next(); - - baseTypeHandlerMock = mock(TypeHandler.class); - moduleClassHandlerMock = mock(TypeHandler.class); - apiClassHandlerMock = mock(TypeHandler.class); - - when(baseTypeHandlerMock.deserialize(any())) - .thenReturn(Optional.of(new PersistedInteger(0))); - - when(moduleClassHandlerMock.deserialize(any())) - .thenReturn(Optional.of(new PersistedInteger(0))); - - when(apiClassHandlerMock.deserialize(any())) - .thenReturn(Optional.of(new PersistedInteger(0))); - - when(typeHandlerLibrary.getTypeHandler(eq(Object.class), (ClassLoader) any())) - .thenReturn(Optional.of(baseTypeHandlerMock)); - - when(typeHandlerLibrary.getTypeHandler(eq(moduleClass), (ClassLoader) any())) - .thenReturn(Optional.of(moduleClassHandlerMock)); - - when(typeHandlerLibrary.getTypeHandler(eq(apiClass), (ClassLoader) any())) - .thenReturn(Optional.of(apiClassHandlerMock)); - } - - @Test - public void testAccessModuleClassFromEngine() { - TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, - ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment)); - - RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); - - PersistedData persistedModuleClassInstance = new PersistedMap( - ImmutableMap.of( - RuntimeDelegatingTypeHandler.TYPE_FIELD, - new PersistedString(moduleClass.getName()), - RuntimeDelegatingTypeHandler.VALUE_FIELD, - new PersistedMap(ImmutableMap.of()) - ) - ); - - assertTrue(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); - - verify(baseTypeHandlerMock, times(0)).deserialize(any()); - verify(moduleClassHandlerMock, times(1)).deserialize(any()); - } - - @Test - public void testCannotAccessModuleClassFromEngineWithoutClassLoader() { - TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, - ReflectionUtil.class.getClassLoader()); - - RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(AutoCloseable.class), context); - - PersistedData persistedModuleClassInstance = new PersistedMap( - ImmutableMap.of( - RuntimeDelegatingTypeHandler.TYPE_FIELD, - new PersistedString(moduleClass.getName()), - RuntimeDelegatingTypeHandler.VALUE_FIELD, - new PersistedMap(ImmutableMap.of()) - ) - ); - - assertFalse(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); - - verify(baseTypeHandlerMock, times(0)).deserialize(any()); - verify(moduleClassHandlerMock, times(0)).deserialize(any()); - } - - @Test - public void testAccessApiClassFromModule() { - testCanAccessClassFromModule(apiClass, apiClassHandlerMock); - } - - @Test - public void testAccessModuleClassFromModule() { - testCanAccessClassFromModule(moduleClass, moduleClassHandlerMock); - } - - private void testCanAccessClassFromModule(Class testClass, TypeHandler testClassHandlerMock) { - TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, - moduleClass); - - RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); - - PersistedData persistedModuleClassInstance = new PersistedMap( - ImmutableMap.of( - RuntimeDelegatingTypeHandler.TYPE_FIELD, - new PersistedString(testClass.getName()), - RuntimeDelegatingTypeHandler.VALUE_FIELD, - new PersistedMap(ImmutableMap.of()) - ) - ); - - assertTrue(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); - - verify(baseTypeHandlerMock, times(0)).deserialize(any()); - verify(testClassHandlerMock, times(1)).deserialize(any()); - } - - @Test - public void testCannotAccessNonApiClassFromModule() { - TypeHandlerContext context = new TypeHandlerContext(typeHandlerLibrary, - moduleClass); - - RuntimeDelegatingTypeHandler typeHandler = new RuntimeDelegatingTypeHandler<>(mock(TypeHandler.class), TypeInfo.of(Object.class), context); - - PersistedData persistedModuleClassInstance = new PersistedMap( - ImmutableMap.of( - RuntimeDelegatingTypeHandler.TYPE_FIELD, - new PersistedString(nonApiClass.getName()), - RuntimeDelegatingTypeHandler.VALUE_FIELD, - new PersistedMap(ImmutableMap.of()) - ) - ); - - assertFalse(typeHandler.deserialize(persistedModuleClassInstance).isPresent()); - - verify(baseTypeHandlerMock, times(0)).deserialize(any()); - verify(apiClassHandlerMock, times(0)).deserialize(any()); - } -} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 849046b0ba4..2d16818db9e 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -20,6 +20,8 @@ import com.google.common.collect.Maps; import org.junit.Test; import org.mockito.ArgumentMatcher; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; import org.terasology.persistence.typeHandling.*; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; @@ -46,7 +48,7 @@ public class RuntimeDelegatingTypeHandlerTest { private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, new Reflections(getClass().getClassLoader())); private static class Base { int x; @@ -70,10 +72,10 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeHandlerLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(baseType))) .thenReturn(Optional.of(baseTypeHandler)); - when(typeHandlerLibrary.getTypeHandler(eq((Type) subType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq((Type) subType))) .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = @@ -82,15 +84,17 @@ abstract class SubHandler extends TypeHandler {} ArrayList bases = Lists.newArrayList(new Sub(), new Base(), new Sub(), new Base(), new Sub()); listTypeHandler.serialize(bases, serializer); - verify(typeHandlerLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); - verify(typeHandlerLibrary, times(3)).getTypeHandler(eq((Type) subType), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(baseType)); + verify(typeHandlerLibrary, times(3)).getTypeHandler(eq((Type) subType)); verify(baseTypeHandler, times(2)).serialize(any(), any()); verify(subTypeHandler, times(3)).serialize(any(), any()); verify(serializer, times(3)).serialize( argThat((ArgumentMatcher>) argument -> - argument.get(RuntimeDelegatingTypeHandler.TYPE_FIELD).getAsString().equals(subType.getName()) && + argument.get(RuntimeDelegatingTypeHandler.TYPE_FIELD) + .getAsString() + .equals(subType.getName()) && argument.containsKey(RuntimeDelegatingTypeHandler.VALUE_FIELD)) ); } @@ -105,10 +109,10 @@ abstract class SubHandler extends TypeHandler {} TypeHandler baseTypeHandler = mock(TypeHandler.class); TypeHandler subTypeHandler = mock(SubHandler.class); - when(typeHandlerLibrary.getTypeHandler(eq(baseType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(baseType))) .thenReturn(Optional.of(baseTypeHandler)); - when(typeHandlerLibrary.getTypeHandler(eq(subType), (ClassLoader) any())) + when(typeHandlerLibrary.getTypeHandler(eq(subType))) .thenReturn(Optional.of(subTypeHandler)); TypeHandler> listTypeHandler = collectionHandlerFactory.create( @@ -135,8 +139,8 @@ abstract class SubHandler extends TypeHandler {} listTypeHandler.deserialize(persistedBases); - verify(typeHandlerLibrary).getTypeHandler(eq(baseType), (ClassLoader) any()); - verify(typeHandlerLibrary, times(3)).getTypeHandler(eq(subType), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(baseType)); + verify(typeHandlerLibrary, times(3)).getTypeHandler(eq(subType)); verify(baseTypeHandler, times(2)).deserialize(any()); verify(subTypeHandler, times(3)).deserialize(any()); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java index 3324148f82b..b683c4493e2 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java @@ -16,6 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes.factories; import org.junit.Test; +import org.reflections.Reflections; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; @@ -36,7 +37,7 @@ public class ArrayTypeHandlerFactoryTest { private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final ArrayTypeHandlerFactory typeHandlerFactory = new ArrayTypeHandlerFactory(); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); @Test public void testArray() { @@ -49,7 +50,7 @@ public void testArray() { assertTrue(typeHandler.get() instanceof ArrayTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(int.class).getType())); } @Test @@ -63,7 +64,7 @@ public void testGenericArray() { assertTrue(typeHandler.get() instanceof ArrayTypeHandler); // Verify that the List TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType())); } @Test diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index e07e888aabe..17a39486524 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -17,6 +17,7 @@ import com.google.common.collect.Maps; import org.junit.Test; +import org.reflections.Reflections; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; @@ -41,7 +42,7 @@ public class CollectionTypeHandlerFactoryTest { private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap())); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); @Test public void testList() { @@ -54,7 +55,7 @@ public void testList() { assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType())); } @Test @@ -68,7 +69,7 @@ public void testSet() { assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType())); } @Test @@ -82,7 +83,7 @@ public void testQueue() { assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType())); } @Test @@ -96,6 +97,6 @@ class IntList extends ArrayList {} assertTrue(typeHandler.get() instanceof CollectionTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType())); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index 7c71c78488d..4f5d7ea4ffa 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -17,6 +17,7 @@ import com.google.common.collect.Maps; import org.junit.Test; +import org.reflections.Reflections; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; @@ -41,7 +42,7 @@ public class ObjectFieldMapTypeHandlerFactoryTest { constructorLibrary); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); private static class SomeClass { private T t; @@ -57,12 +58,8 @@ public void testObject() { assertTrue(typeHandler.get() instanceof ObjectFieldMapTypeHandler); // Verify that the Integer and List TypeHandlers were loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler( - eq(TypeInfo.of(Integer.class).getType()), - (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(TypeInfo.of(Integer.class).getType())); - verify(typeHandlerLibrary).getTypeHandler( - eq(new TypeInfo>() {}.getType()), - (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(eq(new TypeInfo>() {}.getType())); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java index cc2d23c0411..403f8d37efc 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -17,6 +17,7 @@ import org.junit.Test; import org.mockito.ArgumentMatchers; +import org.reflections.Reflections; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; @@ -38,7 +39,7 @@ public class StringMapTypeHandlerFactoryTest { private final StringMapTypeHandlerFactory typeHandlerFactory = new StringMapTypeHandlerFactory(); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, getClass().getClassLoader()); + new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); @Test public void testStringMap() { @@ -51,7 +52,7 @@ public void testStringMap() { assertTrue(typeHandler.get() instanceof StringMapTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); } @Test @@ -75,6 +76,6 @@ class IntMap extends HashMap {} assertTrue(typeHandler.get() instanceof StringMapTypeHandler); // Verify that the Integer TypeHandler was loaded from the TypeHandlerLibrary - verify(typeHandlerLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType()), (ClassLoader) any()); + verify(typeHandlerLibrary).getTypeHandler(ArgumentMatchers.eq(TypeInfo.of(Integer.class).getType())); } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java index 8284ddfc38d..c4c9a22b873 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java @@ -21,12 +21,9 @@ import org.junit.Assert; import org.junit.Test; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.math.geom.Rect2i; import org.terasology.math.geom.Vector4f; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.rendering.nui.Color; import java.util.Map; @@ -48,9 +45,7 @@ public class GsonTypeHandlerLibraryAdapterFactoryTest { private static final String OBJECT_JSON = "{\"color\":[222,173,190,239],\"vector4fs\":[[0.0,0.0,0.0,0.0]," + "[1.0,1.0,1.0,1.0]],\"rect2iMap\":{\"someRect\":{\"min\":[-3,-3],\"size\":[10,10]}},\"i\":-912559}"; - private final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - private final Reflections reflections = new Reflections(configurationBuilder); + private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.withDefaultHandlers(reflections); diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 6627a962afd..78b9b627f27 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -20,7 +20,6 @@ import org.junit.Before; import org.junit.Test; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.context.internal.ContextImpl; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.PojoEntityManager; @@ -60,9 +59,7 @@ public void setup() { ContextImpl context = new ContextImpl(); CoreRegistry.setContext(context); - ConfigurationBuilder configurationBuilder = new ConfigurationBuilder() - .addClassLoader(getClass().getClassLoader()); - Reflections reflections = new Reflections(configurationBuilder); + Reflections reflections = new Reflections(getClass().getClassLoader()); TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); EntitySystemLibrary entitySystemLibrary = new EntitySystemLibrary(context, serializationLibrary); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java index 1207fa756cc..60a26d353c9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java @@ -15,10 +15,10 @@ */ package org.terasology.persistence.typeHandling; +import org.reflections.Reflections; import org.terasology.reflection.TypeInfo; import java.lang.reflect.Type; -import java.util.Arrays; import java.util.Optional; /** @@ -29,20 +29,11 @@ */ public class TypeHandlerContext { private TypeHandlerLibrary typeHandlerLibrary; - private ClassLoader[] classLoaders; + private Reflections reflections; - public TypeHandlerContext(TypeHandlerLibrary typeHandlerLibrary, Class... classes) { - this( - typeHandlerLibrary, - Arrays.stream(classes) - .map(Class::getClassLoader) - .toArray(ClassLoader[]::new) - ); - } - - public TypeHandlerContext(TypeHandlerLibrary typeHandlerLibrary, ClassLoader... classLoaders) { + public TypeHandlerContext(TypeHandlerLibrary typeHandlerLibrary, Reflections reflections) { this.typeHandlerLibrary = typeHandlerLibrary; - this.classLoaders = classLoaders; + this.reflections = reflections; } /** @@ -53,34 +44,10 @@ public TypeHandlerLibrary getTypeHandlerLibrary() { } /** - * Returns the {@link ClassLoader}s to use to load classes in the + * Returns the {@link Reflections} to use to load classes in the * {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerContext)} method. - *

    - * If classes are loaded manually using a method like {@link Class#forName(String)}, these - * {@link ClassLoader}s must be used so that modules remain sandboxed. - */ - public ClassLoader[] getClassLoaders() { - return classLoaders; - } - - /** - * Retrieve the {@link TypeHandler} for the given type in the current context. - */ - public Optional> getTypeHandler(Type elementType) { - return typeHandlerLibrary.getTypeHandler(elementType, classLoaders); - } - - /** - * Retrieve the {@link TypeHandler} for the given type in the current context. - */ - public Optional> getTypeHandler(Class elementType) { - return typeHandlerLibrary.getTypeHandler(elementType, classLoaders); - } - - /** - * Retrieve the {@link TypeHandler} for the given type in the current context. */ - public Optional> getTypeHandler(TypeInfo elementType) { - return typeHandlerLibrary.getTypeHandler(elementType, classLoaders); + public Reflections getReflections() { + return reflections; } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 49e705b2108..24bed68483d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -105,7 +105,6 @@ public class TypeHandlerLibrary { private Map, Serializer> serializerMap = Maps.newHashMap(); /** - * * @param reflections */ public TypeHandlerLibrary(Reflections reflections) { @@ -269,76 +268,14 @@ public void addInstanceCreator(TypeInfo typeInfo, InstanceCreator inst * requested first, hence a {@link TypeHandlerFactory} can override one that was added * before it. * - * @param type The {@link Type} describing the type for which to - * retrieve the {@link TypeHandler}. - * @param contextClasses The {@link Class}(es) that the caller has access to. Used to obtain - * {@link ClassLoader}(s) that the caller has access to. - * @return The {@link TypeHandler} for the specified type, if available. - */ - @SuppressWarnings({"unchecked"}) - public Optional> getTypeHandler(Type type, Class... contextClasses) { - return getTypeHandler(type, Arrays.stream(contextClasses) - .map(Class::getClassLoader) - .toArray(ClassLoader[]::new)); - } - - /** - * Retrieves the {@link TypeHandler} for the specified type, if available. - *

    - * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested - * to generate a {@link TypeHandler} for the given type. Most recently added factories are - * requested first, hence a {@link TypeHandlerFactory} can override one that was added - * before it. - * - * @param type The {@link Type} describing the type for which to - * retrieve the {@link TypeHandler}. - * @param contextClassLoaders The {@link ClassLoader}(s) that the caller has access to. + * @param type The {@link Type} describing the type for which to + * retrieve the {@link TypeHandler}. * @return The {@link TypeHandler} for the specified type, if available. */ @SuppressWarnings({"unchecked"}) - public Optional> getTypeHandler(Type type, ClassLoader... contextClassLoaders) { + public Optional> getTypeHandler(Type type) { TypeInfo typeInfo = TypeInfo.of(type); - return (Optional>) getTypeHandler(typeInfo, contextClassLoaders); - } - - - /** - * Retrieves the {@link TypeHandler} for the specified type, if available. - *

    - * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested - * to generate a {@link TypeHandler} for the given type. Most recently added factories are - * requested first, hence a {@link TypeHandlerFactory} can override one that was added - * before it. - * - * @param typeClass The {@link Class} of the type for which to - * retrieve the {@link TypeHandler}. - * @param contextClasses The {@link Class}(es) that the caller has access to. Used to obtain - * {@link ClassLoader}(s) that the caller has access to. - * @param The type for which to retrieve the {@link TypeHandler}. - * @return The {@link TypeHandler} for the specified type, if available. - */ - public Optional> getTypeHandler(Class typeClass, Class... contextClasses) { - return getTypeHandler(typeClass, Arrays.stream(contextClasses) - .map(Class::getClassLoader) - .toArray(ClassLoader[]::new)); - } - - /** - * Retrieves the {@link TypeHandler} for the specified type, if available. - *

    - * Each {@link TypeHandlerFactory} added to this {@link TypeHandlerLibrary} is requested - * to generate a {@link TypeHandler} for the given type. Most recently added factories are - * requested first, hence a {@link TypeHandlerFactory} can override one that was added - * before it. - * - * @param typeClass The {@link Class} of the type for which to - * retrieve the {@link TypeHandler}. - * @param contextClassLoaders The {@link ClassLoader}(s) that the caller has access to. - * @param The type for which to retrieve the {@link TypeHandler}. - * @return The {@link TypeHandler} for the specified type, if available. - */ - public Optional> getTypeHandler(Class typeClass, ClassLoader... contextClassLoaders) { - return getTypeHandler(TypeInfo.of(typeClass), contextClassLoaders); + return (Optional>) getTypeHandler(typeInfo); } /** @@ -349,18 +286,13 @@ public Optional> getTypeHandler(Class typeClass, ClassLoad * requested first, hence a {@link TypeHandlerFactory} can override one that was added * before it. * - * @param type The {@link TypeInfo} describing the type for which to - * retrieve the {@link TypeHandler}. - * @param contextClasses The {@link Class}(es) that the caller has access to. Used to obtain - * {@link ClassLoader}(s) that the caller has access to. - * @param The type for which to retrieve the {@link TypeHandler}. + * @param typeClass The {@link Class} of the type for which to + * retrieve the {@link TypeHandler}. + * @param The type for which to retrieve the {@link TypeHandler}. * @return The {@link TypeHandler} for the specified type, if available. */ - @SuppressWarnings("unchecked") - public Optional> getTypeHandler(TypeInfo type, Class... contextClasses) { - return getTypeHandler(type, Arrays.stream(contextClasses) - .map(Class::getClassLoader) - .toArray(ClassLoader[]::new)); + public Optional> getTypeHandler(Class typeClass) { + return getTypeHandler(TypeInfo.of(typeClass)); } /** @@ -371,15 +303,14 @@ public Optional> getTypeHandler(TypeInfo type, Class... * requested first, hence a {@link TypeHandlerFactory} can override one that was added * before it. * - * @param type The {@link TypeInfo} describing the type for which to - * retrieve the {@link TypeHandler}. - * @param contextClassLoaders The {@link ClassLoader}(s) that the caller has access to. - * @param The type for which to retrieve the {@link TypeHandler}. + * @param type The {@link TypeInfo} describing the type for which to + * retrieve the {@link TypeHandler}. + * @param The type for which to retrieve the {@link TypeHandler}. * @return The {@link TypeHandler} for the specified type, if available. */ @SuppressWarnings("unchecked") - public Optional> getTypeHandler(TypeInfo type, ClassLoader... contextClassLoaders) { - TypeHandlerContext context = new TypeHandlerContext(this, contextClassLoaders); + public Optional> getTypeHandler(TypeInfo type) { + TypeHandlerContext context = new TypeHandlerContext(this, reflections); if (typeHandlerCache.containsKey(type)) { return Optional.of((TypeHandler) typeHandlerCache.get(type)); @@ -432,7 +363,7 @@ public Optional> getTypeHandler(TypeInfo type, ClassLoader private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type) { Map, TypeHandler> handlerMap = Maps.newHashMap(); for (FieldMetadata field : type.getFields()) { - Optional> handler = getTypeHandler(field.getField().getGenericType(), getClass()); + Optional> handler = getTypeHandler(field.getField().getGenericType()); if (handler.isPresent()) { handlerMap.put(field, handler.get()); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 8e139a28ac3..8c569d39ffc 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -16,6 +16,7 @@ package org.terasology.persistence.typeHandling.coreTypes; import com.google.common.collect.Maps; +import org.reflections.Reflections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.PersistedData; @@ -48,13 +49,13 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private TypeHandler delegateHandler; private TypeInfo typeInfo; private TypeHandlerLibrary typeHandlerLibrary; - private ClassLoader[] classLoaders; + private Reflections reflections; public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeHandlerContext context) { this.delegateHandler = delegateHandler; this.typeInfo = typeInfo; this.typeHandlerLibrary = context.getTypeHandlerLibrary(); - this.classLoaders = context.getClassLoaders(); + this.reflections = context.getReflections(); } @Override @@ -73,7 +74,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize Class runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { - Optional> runtimeTypeHandler = typeHandlerLibrary.getTypeHandler((Type) runtimeClass, classLoaders); + Optional> runtimeTypeHandler = typeHandlerLibrary.getTypeHandler((Type) runtimeClass); chosenHandler = (TypeHandler) runtimeTypeHandler .map(typeHandler -> { @@ -153,7 +154,7 @@ public Optional deserialize(PersistedData data) { String runtimeTypeName = valueMap.getAsString(TYPE_FIELD); - Optional> typeToDeserializeAs = ReflectionUtil.findClassInClassLoaders(runtimeTypeName, classLoaders); + Optional> typeToDeserializeAs = findSubtypeWithName(runtimeTypeName); if (!typeToDeserializeAs.isPresent()) { LOGGER.error("Cannot find class to deserialize {}", runtimeTypeName); @@ -161,11 +162,12 @@ public Optional deserialize(PersistedData data) { } if (!typeInfo.getRawType().isAssignableFrom(typeToDeserializeAs.get())) { - LOGGER.error("Given type {} is not a sub-type of expected type {}", typeToDeserializeAs.get(), typeInfo.getType()); + LOGGER.error("Given type {} is not a sub-type of expected type {}", + typeToDeserializeAs.get(), typeInfo.getType()); return Optional.empty(); } - TypeHandler runtimeTypeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(typeToDeserializeAs.get(), classLoaders) + TypeHandler runtimeTypeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(typeToDeserializeAs.get()) // To avoid compile errors in the orElseGet .map(typeHandler -> (TypeHandler) typeHandler) .orElseGet(() -> { @@ -181,4 +183,15 @@ public Optional deserialize(PersistedData data) { } + private Optional> findSubtypeWithName(String runtimeTypeName) { + for (Class clazz : reflections.getSubTypesOf(typeInfo.getRawType())) { + if (runtimeTypeName.equals(clazz.getSimpleName()) || + runtimeTypeName.equals(clazz.getName())) { + return Optional.of(clazz); + } + } + + return Optional.empty(); + } + } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java index 65cfb9cc25e..15ccaf3a95e 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactory.java @@ -45,7 +45,8 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = context.getTypeHandler(elementType); + Optional> declaredElementTypeHandler = + context.getTypeHandlerLibrary().getTypeHandler(elementType); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java index 3a367272d6c..b2da254ae54 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactory.java @@ -60,7 +60,8 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont TypeInfo elementTypeInfo = TypeInfo.of(elementType); - Optional> declaredElementTypeHandler = context.getTypeHandler(elementType); + Optional> declaredElementTypeHandler = + context.getTypeHandlerLibrary().getTypeHandler(elementType); @SuppressWarnings({"unchecked"}) TypeHandler elementTypeHandler = new RuntimeDelegatingTypeHandler( diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java index 5a331ef7be7..e65c0328ebf 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactory.java @@ -54,7 +54,8 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont getResolvedFields(typeInfo).forEach( (field, fieldType) -> { - Optional> declaredFieldTypeHandler = context.getTypeHandler(fieldType); + Optional> declaredFieldTypeHandler = + context.getTypeHandlerLibrary().getTypeHandler(fieldType); TypeInfo fieldTypeInfo = TypeInfo.of(fieldType); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java index 49ca59e77ea..7b214620d96 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactory.java @@ -51,7 +51,8 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont return Optional.empty(); } - Optional> declaredValueTypeHandler = context.getTypeHandler(valueType); + Optional> declaredValueTypeHandler = + context.getTypeHandlerLibrary().getTypeHandler(valueType); TypeInfo valueTypeInfo = TypeInfo.of(valueType); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java index 53b7f02d666..78236af5e17 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonTypeSerializationLibraryAdapterFactory.java @@ -42,8 +42,7 @@ public GsonTypeSerializationLibraryAdapterFactory(TypeHandlerLibrary typeHandler public TypeAdapter create(Gson gson, TypeToken type) { Type rawType = type.getType(); - TypeHandler typeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(rawType, - GsonTypeSerializationLibraryAdapterFactory.class).orElse(null); + TypeHandler typeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(rawType).orElse(null); if (typeHandler == null || typeHandler instanceof ObjectFieldMapTypeHandler) { return null; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java index f2c80fe6919..84525ea2283 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2fTypeHandlerFactory.java @@ -36,7 +36,8 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont return Optional.empty(); } - Optional> vector2fTypeHandler = context.getTypeHandler(Vector2f.class); + Optional> vector2fTypeHandler = + context.getTypeHandlerLibrary().getTypeHandler(Vector2f.class); if (!vector2fTypeHandler.isPresent()) { LOGGER.error("No Vector2f type handler found"); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java index 1e6018a54d9..61d101e9cc3 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/mathTypes/factories/Rect2iTypeHandlerFactory.java @@ -36,17 +36,18 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont return Optional.empty(); } - Optional> vector2iTypeHandler = context.getTypeHandler(Vector2i.class); + Optional> vector2iTypeHandler = + context.getTypeHandlerLibrary().getTypeHandler(Vector2i.class); if (!vector2iTypeHandler.isPresent()) { LOGGER.error("No Vector2i type handler found"); return Optional.empty(); } - Rect2iTypeHandler rect2fTypeHandler = + Rect2iTypeHandler rect2iTypeHandler = new Rect2iTypeHandler(vector2iTypeHandler.get()); - return Optional.of((TypeHandler) rect2fTypeHandler); + return Optional.of((TypeHandler) rect2iTypeHandler); } } diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 55643aef681..dff051e0d93 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -57,7 +57,7 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo ClassLoader[] classLoaders = ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment); this.recordedEventListTypeHandler = typeHandlerLibrary.getTypeHandler( - new TypeInfo>() {}, classLoaders).get(); + new TypeInfo>() {}).get(); } /** diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index d5488d77140..a02a482e748 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -434,17 +434,6 @@ public static Object readField(Object object, String fieldName) { "Cannot find field " + cls.getName() + "." + fieldName); } - public static Optional> findClassInClassLoaders(String className, ClassLoader... classLoaders) { - for (ClassLoader classLoader : classLoaders) { - try { - return Optional.of(Class.forName(className, true, classLoader)); - } catch (ClassNotFoundException ignored) { - } - } - - return Optional.empty(); - } - /** * Returns a list of {@link ClassLoader}s which have access to all engine and loaded module * classes. This function must NOT be accessible to modules. From 004eb9383228dfe1be72889b13f25d2e010439af Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 09:55:20 +0530 Subject: [PATCH 103/141] Use runtime type if declared type handler is missing during serialization --- .../coreTypes/RuntimeDelegatingTypeHandler.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 8c569d39ffc..6efad5713b6 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -71,7 +71,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize } TypeHandler chosenHandler = delegateHandler; - Class runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); + Class runtimeClass = getRuntimeTypeIfMoreSpecific(value); if (!typeInfo.getRawType().equals(runtimeClass)) { Optional> runtimeTypeHandler = typeHandlerLibrary.getTypeHandler((Type) runtimeClass); @@ -120,7 +120,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize return serializer.serialize(typeValuePersistedDataMap); } - private static Class getRuntimeTypeIfMoreSpecific(TypeInfo typeInfo, T value) { + private Class getRuntimeTypeIfMoreSpecific(T value) { if (value == null) { return typeInfo.getRawType(); } @@ -133,6 +133,9 @@ private static Class getRuntimeTypeIfMoreSpecific(TypeInfo typeInfo, T } else if (typeInfo.getType() instanceof Class) { // If given type is a simple class, use more specific runtime type return runtimeClass; + } else if (delegateHandler == null) { + // If we can't find a handler for the declared type, use the runtime type + return runtimeClass; } // Given type has more information than runtime type, use that From 908d67c10eecca61a0157c78791d5142cac1a772 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 10:15:24 +0530 Subject: [PATCH 104/141] Revert "Add RuntimeDelegatingTypeHandlerSandboxTest + test module" This reverts commit 6d3ac7ba50f1271a9c6e5b7f970c50e8ff27cc58. --- engine-tests/test-modules/.gitignore | 1 - .../module-with-empty-class/build.gradle | 34 ------------------- .../module-with-empty-class/module.info | 6 ---- .../emptyClassModule/EmptyClass.java | 23 ------------- 4 files changed, 64 deletions(-) delete mode 100644 engine-tests/test-modules/.gitignore delete mode 100644 engine-tests/test-modules/module-with-empty-class/build.gradle delete mode 100644 engine-tests/test-modules/module-with-empty-class/module.info delete mode 100644 engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java diff --git a/engine-tests/test-modules/.gitignore b/engine-tests/test-modules/.gitignore deleted file mode 100644 index 08a55c09bdf..00000000000 --- a/engine-tests/test-modules/.gitignore +++ /dev/null @@ -1 +0,0 @@ -.gradle diff --git a/engine-tests/test-modules/module-with-empty-class/build.gradle b/engine-tests/test-modules/module-with-empty-class/build.gradle deleted file mode 100644 index d7fef2c9de2..00000000000 --- a/engine-tests/test-modules/module-with-empty-class/build.gradle +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright 2015 MovingBlocks - * - * 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. - */ - -/* - * This is a Gradle build file: - * - Gradle Homepage: http://gradle.org/ - * - Gradle Documentation: http://gradle.org/documentation - * - View tasks for this project: $ gradlew tasks - */ - -apply plugin: 'java' - -println this.getGradle().gradleUserHomeDir - -sourceSets { - main { - java { - output.classesDir 'build/classes' - } - } -} diff --git a/engine-tests/test-modules/module-with-empty-class/module.info b/engine-tests/test-modules/module-with-empty-class/module.info deleted file mode 100644 index c81e3ec7541..00000000000 --- a/engine-tests/test-modules/module-with-empty-class/module.info +++ /dev/null @@ -1,6 +0,0 @@ -{ - "id" : "EmptyClassModule", - "version" : "1.0.0", - "displayName" : "Empty Class Module", - "description" : "This module contains an empty class" -} diff --git a/engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java b/engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java deleted file mode 100644 index 10c5c8d9ace..00000000000 --- a/engine-tests/test-modules/module-with-empty-class/src/main/java/org/terasology/emptyClassModule/EmptyClass.java +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright 2018 MovingBlocks - * - * 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 org.terasology.emptyClassModule; - -public class EmptyClass implements AutoCloseable { - public void close() { - - } -} From 0cad6f612fcec13683b0531c9f4c7b6c8b261019 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 10:17:07 +0530 Subject: [PATCH 105/141] Revert "Add test-modules to engine-tests build config" This reverts commit 89a09400027543ad3cfbfbde22538bad6e88b24f. --- engine-tests/subprojects.gradle | 32 -------------------------------- 1 file changed, 32 deletions(-) delete mode 100644 engine-tests/subprojects.gradle diff --git a/engine-tests/subprojects.gradle b/engine-tests/subprojects.gradle deleted file mode 100644 index 95ffa79df9a..00000000000 --- a/engine-tests/subprojects.gradle +++ /dev/null @@ -1,32 +0,0 @@ -import java.nio.file.Paths - -/* - * Copyright 2018 MovingBlocks - * - * 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. - */ - -new File(rootDir, Paths.get('engine-tests', 'test-modules').toString()).eachDir { testModuleDir -> - def testModuleName = 'testModules:' + testModuleDir.name - //println "Gradle is reviewing module $testModuleName for inclusion as a sub-project" - File buildFile = new File(testModuleDir, "build.gradle") - if (buildFile.exists()) { - println "Test module $testModuleName has a build file so counting it complete and including it" - include testModuleName - def testModulePath = ':' + testModuleName - def testModuleProject = project(testModulePath) - testModuleProject.projectDir = testModuleDir - } else { - println "***** WARNING: Found a test module without a build.gradle, corrupt dir? NOT including $testModuleName *****" - } -} From 2aa587aad7e36b904a3354ce87fdadbef08329dc Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 12:40:23 +0530 Subject: [PATCH 106/141] Add AbstractSerializer and extend GsonSerializer --- .../serializers/TypeSerializerTest.java | 55 +++++--- .../serializers/AbstractSerializer.java | 42 ++++++ .../serializers/GsonSerializer.java | 120 ++++++++++-------- .../recording/RecordedEventSerializer.java | 12 +- .../org/terasology/reflection/TypeInfo.java | 5 + 5 files changed, 159 insertions(+), 75 deletions(-) create mode 100644 engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 8c60285804e..73e3026f988 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -50,24 +50,22 @@ public class TypeSerializerTest { public static class Json { private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; - final Reflections reflections = new Reflections(getClass().getClassLoader()); + private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.withDefaultHandlers(reflections); + private final GsonSerializer serializer = new GsonSerializer(typeHandlerLibrary); + @Test public void testJsonSerialize() { - GsonSerializer gsonSerializer = new GsonSerializer(); - - TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); - - assertEquals(INSTANCE_JSON, gsonSerializer.toJson(INSTANCE, typeHandler)); + String serializedJson = serializer.toJson(INSTANCE, new TypeInfo>() {}); + assertEquals(INSTANCE_JSON, serializedJson); } @Test public void testDeserialize() { - GsonSerializer gsonSerializer = new GsonSerializer(); - PersistedData persistedData = gsonSerializer.persistedDataFromJson(INSTANCE_JSON); + PersistedData persistedData = serializer.persistedDataFromJson(INSTANCE_JSON); TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); @@ -82,6 +80,7 @@ public static class Protobuf { private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.withDefaultHandlers(reflections); + @Test public void testSerializeDeserialize() throws IOException { TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); @@ -109,8 +108,12 @@ private SomeClass(T data) { @Override public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } SomeClass someClass = (SomeClass) o; return Objects.equals(data, someClass.data) && Objects.equals(list, someClass.list) && @@ -141,8 +144,12 @@ private Animal(String name) { @Override public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } Animal animal = (Animal) o; return Objects.equals(name, animal.name); } @@ -163,9 +170,15 @@ private Dog(Vector3f tailPosition) { @Override public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - if (!super.equals(o)) return false; + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + if (!super.equals(o)) { + return false; + } Dog dog = (Dog) o; return Objects.equals(tailPosition, dog.tailPosition); } @@ -194,9 +207,15 @@ private Cheetah(Color spotColor) { @Override public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - if (!super.equals(o)) return false; + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + if (!super.equals(o)) { + return false; + } Cheetah cheetah = (Cheetah) o; return Objects.equals(spotColor, cheetah.spotColor); } diff --git a/engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java new file mode 100644 index 00000000000..f9f6be1ecac --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java @@ -0,0 +1,42 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.persistence.serializers; + +import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.PersistedDataSerializer; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; +import org.terasology.reflection.TypeInfo; + +import java.util.Optional; + +public abstract class AbstractSerializer { + protected final TypeHandlerLibrary typeHandlerLibrary; + protected final PersistedDataSerializer persistedDataSerializer; + + protected AbstractSerializer(TypeHandlerLibrary typeHandlerLibrary, PersistedDataSerializer persistedDataSerializer) { + this.typeHandlerLibrary = typeHandlerLibrary; + this.persistedDataSerializer = persistedDataSerializer; + } + + public Optional serialize(T object, TypeInfo typeInfo) { + return typeHandlerLibrary.getTypeHandler(typeInfo) + .map(typeHandler -> typeHandler.serialize(object, persistedDataSerializer)); + } + + public Optional deserialize(PersistedData data, TypeInfo typeInfo) { + return typeHandlerLibrary.getTypeHandler(typeInfo).flatMap(typeHandler -> typeHandler.deserialize(data)); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 545112ba8a2..36476957af3 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -17,10 +17,13 @@ import com.google.gson.Gson; import com.google.gson.JsonElement; +import com.google.gson.JsonIOException; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.SerializationException; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.gson.GsonPersistedData; import org.terasology.persistence.typeHandling.gson.GsonPersistedDataSerializer; +import org.terasology.reflection.TypeInfo; import java.io.BufferedWriter; import java.io.File; @@ -35,6 +38,7 @@ import java.io.StringReader; import java.io.StringWriter; import java.io.Writer; +import java.util.Optional; /** * GsonSerializer provides the ability to serialize and deserialize objects to and from JSON @@ -42,97 +46,113 @@ * Serialized JSON can be forwarded/written to various output types
    *
    * Various input types can be deserialized and returned as PersistedData types - * */ -public class GsonSerializer { +public class GsonSerializer extends AbstractSerializer { private Gson gson; /** * Constructs a new GsonSerializer object */ - public GsonSerializer() { + public GsonSerializer(TypeHandlerLibrary typeHandlerLibrary) { + super(typeHandlerLibrary, new GsonPersistedDataSerializer()); + this.gson = new Gson(); } /** - * Writes the serialized persisted data as a JSON to {@link Writer} and returns the JSON as a string. - * - * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized + * Writes the serialized persisted data as a JSON to {@link Writer} and returns the + * JSON as a string. + * + * @param object the object to be serialized + * @param typeInfo contains how the object will be serialized * @return contents of the JSON as a string + * @throws SerializationException Thrown if serialization fails. + * @see #writeJson(Object, TypeInfo, Writer) */ - public String toJson(T object, TypeHandler typeHandler) { + public String toJson(T object, TypeInfo typeInfo) throws SerializationException { StringWriter writer = new StringWriter(); - writeJson(object, typeHandler, writer); + writeJson(object, typeInfo, writer); return writer.toString(); } /** - * Writes an object's serialized persisted data to the {@link Writer} as JSON. - * - * @see #writeJson(Object, TypeHandler, OutputStream) - * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized - * @param writer The writer in which the JSON will be written to + * Writes an object's serialized persisted data to the {@link Writer} as JSON. + * + * @param object the object to be serialized + * @param typeInfo contains how the object will be serialized + * @param writer The writer in which the JSON will be written to + * @throws SerializationException Thrown when serialization fails. + * @see #writeJson(Object, TypeInfo, OutputStream) */ - public void writeJson(T object, TypeHandler typeHandler, Writer writer) { - GsonPersistedData persistedData = (GsonPersistedData) typeHandler.serialize(object, - new GsonPersistedDataSerializer()); + public void writeJson(T object, TypeInfo typeInfo, Writer writer) throws SerializationException { + Optional serialized = this.serialize(object, typeInfo); + + if (!serialized.isPresent()) { + throw new SerializationException("Could not find a TypeHandler for the type " + typeInfo); + } - gson.toJson(persistedData.getElement(), writer); + GsonPersistedData persistedData = (GsonPersistedData) serialized.get(); + + try { + gson.toJson(persistedData.getElement(), writer); + } catch (JsonIOException e) { + throw new SerializationException("Could not write JSON to writer", e); + } } /** * Writes an object's serialized persisted data to the {@link OutputStream} as JSON. - * - * @see #writeJson(Object, TypeHandler, Writer) - * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized - * @param stream stream that the data will be written to - * @throws IOException will be thrown if there is an error writing to the stream + * + * @param object the object to be serialized + * @param typeInfo contains how the object will be serialized + * @param stream stream that the data will be written to + * @throws IOException will be thrown if there is an error writing to the stream + * @throws SerializationException Thrown when serialization fails. + * @see #writeJson(Object, TypeInfo, Writer) */ - public void writeJson(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { + public void writeJson(T object, TypeInfo typeInfo, OutputStream stream) throws IOException, SerializationException { try (Writer writer = new BufferedWriter(new OutputStreamWriter(stream))) { - writeJson(object, typeHandler, writer); + writeJson(object, typeInfo, writer); } } /** * Writes the object's persisted data to the {@link File} as JSON. - * - * @see #writeJson(Object, TypeHandler, String) - * @param object the file to be serialized - * @param typeHandler contains how the object will be serialized - * @param file file that the bytes will be written to - * @throws IOException gets thrown if there is an issue writing to the file + * + * @param object the file to be serialized + * @param typeInfo contains how the object will be serialized + * @param file file that the bytes will be written to + * @throws IOException gets thrown if there is an issue writing to the file. + * @throws SerializationException Thrown when serialization fails. + * @see #writeJson(Object, TypeInfo, Writer) */ - public void writeJson(T object, TypeHandler typeHandler, File file) throws IOException { + public void writeJson(T object, TypeInfo typeInfo, File file) throws IOException, SerializationException { try (Writer writer = new BufferedWriter(new FileWriter(file))) { - writeJson(object, typeHandler, writer); + writeJson(object, typeInfo, writer); } } /** * Writes an object's persisted data to {@link File} of a specified file name as JSON - * - * @see #writeJson(Object, TypeHandler, String) - * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized + * + * @param object the object to be serialized + * @param typeInfo contains how the object will be serialized * @param fileName the file name where the JSON will be written * @throws IOException gets thrown if there is an error writing to the file at the specified location + * @see #writeJson(Object, TypeInfo, File) */ - public void writeJson(T object, TypeHandler typeHandler, String fileName) throws IOException { - writeJson(object, typeHandler, new File(fileName)); + public void writeJson(T object, TypeInfo typeInfo, String fileName) throws IOException { + writeJson(object, typeInfo, new File(fileName)); } /** * Gets the PersistedData from the {@link Reader}'s contents. - * - * @see #persistedDataFromJson(InputStream) + * * @param reader Reader object that contains the contents that will be deserialized * @return deserialized GsonPersistedData object + * @see #persistedDataFromJson(InputStream) */ public PersistedData persistedDataFromJson(Reader reader) { JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); @@ -142,11 +162,11 @@ public PersistedData persistedDataFromJson(Reader reader) { /** * Gets the PersistedData from an {@link InputStream}'s contents. - * - * @see #persistedDataFromJson(Reader) + * * @param stream Contents of the InputStream will be serialized * @return deserialized GsonPersistedData object * @throws IOException if there is an issue parsing the stream + * @see #persistedDataFromJson(Reader) */ public PersistedData persistedDataFromJson(InputStream stream) throws IOException { try (Reader reader = new InputStreamReader(stream)) { @@ -156,11 +176,11 @@ public PersistedData persistedDataFromJson(InputStream stream) throws IOExceptio /** * Gets the PersistedData from a {@link File} object's contents. - * - * @see #persistedDataFromJson(String) + * * @param file File object containing the JSON that will be deserialized * @return deserialized GsonPersistedData object * @throws IOException gets thrown if there is an issue reading the File object + * @see #persistedDataFromJson(String) */ public PersistedData persistedDataFromJson(File file) throws IOException { try (Reader reader = new FileReader(file)) { @@ -170,10 +190,10 @@ public PersistedData persistedDataFromJson(File file) throws IOException { /** * Gets the PersistedData from a {@link String}'s contents. - * - * @see #persistedDataFromJson(Reader) + * * @param json the String that will be deserialized * @return deserialized GsonPersistedData Object + * @see #persistedDataFromJson(Reader) */ public PersistedData persistedDataFromJson(String json) { try (StringReader reader = new StringReader(json)) { diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index dff051e0d93..5868af72b9a 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -23,6 +23,7 @@ import org.terasology.module.ModuleEnvironment; import org.terasology.persistence.serializers.GsonSerializer; import org.terasology.persistence.typeHandling.PersistedData; +import org.terasology.persistence.typeHandling.SerializationException; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; @@ -44,17 +45,14 @@ class RecordedEventSerializer { private static final Logger logger = LoggerFactory.getLogger(RecordedEventSerializer.class); - private GsonSerializer gsonSerializer = new GsonSerializer(); + private GsonSerializer gsonSerializer; private TypeHandler> recordedEventListTypeHandler; public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment moduleEnvironment) { - ReflectionReflectFactory reflectFactory = new ReflectionReflectFactory(); - CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleEnvironment); typeHandlerLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); - ClassLoader[] classLoaders = ReflectionUtil.getComprehensiveEngineClassLoaders(moduleEnvironment); + gsonSerializer = new GsonSerializer(typeHandlerLibrary); this.recordedEventListTypeHandler = typeHandlerLibrary.getTypeHandler( new TypeInfo>() {}).get(); @@ -68,8 +66,8 @@ public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment mo */ public void serializeRecordedEvents(List events, String filePath) { try { - gsonSerializer.writeJson(events, recordedEventListTypeHandler, filePath); - } catch (IOException e) { + gsonSerializer.writeJson(events, new TypeInfo>() {}, filePath); + } catch (IOException | SerializationException e) { logger.error("Error while serializing recorded events", e); } } diff --git a/engine/src/main/java/org/terasology/reflection/TypeInfo.java b/engine/src/main/java/org/terasology/reflection/TypeInfo.java index 6b4e42418bb..a9d4cb2bb88 100644 --- a/engine/src/main/java/org/terasology/reflection/TypeInfo.java +++ b/engine/src/main/java/org/terasology/reflection/TypeInfo.java @@ -102,4 +102,9 @@ public boolean equals(Object o) { return o instanceof TypeInfo && ReflectionUtil.typeEquals(type, ((TypeInfo) o).type); } + + @Override + public String toString() { + return type.toString(); + } } From 6623336b1f74b8f3521cb57b5e16f1e39098b32e Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 12:41:06 +0530 Subject: [PATCH 107/141] Remove ReflectionUtil.getComprehensiveEngineClassloaders --- .../org/terasology/utilities/ReflectionUtil.java | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index a02a482e748..23da26cefb8 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -434,20 +434,6 @@ public static Object readField(Object object, String fieldName) { "Cannot find field " + cls.getName() + "." + fieldName); } - /** - * Returns a list of {@link ClassLoader}s which have access to all engine and loaded module - * classes. This function must NOT be accessible to modules. - * - * @param moduleEnvironment The {@link ModuleEnvironment} managing all loaded modules. - */ - public static ClassLoader[] getComprehensiveEngineClassLoaders(ModuleEnvironment moduleEnvironment) { - return new ClassLoader[]{ - ReflectionUtil.class.getClassLoader(), - // TODO: Reflection - can break with updates to gestalt - (ClassLoader) readField(moduleEnvironment, "finalClassLoader") - }; - } - private static class WildcardTypeImpl implements WildcardType { private final Type[] upperBounds; private final Type[] lowerBounds; From 47128fa17f84aa84adfd933e0f000b5b11187554 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 13:02:45 +0530 Subject: [PATCH 108/141] Add GsonSerializer.fromJson implementations --- .../serializers/TypeSerializerTest.java | 9 ++-- .../serializers/GsonSerializer.java | 44 +++++++++++++------ .../recording/RecordedEventSerializer.java | 20 ++------- 3 files changed, 38 insertions(+), 35 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 73e3026f988..3cb5d0bba94 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -65,13 +65,10 @@ public void testJsonSerialize() { @Test public void testDeserialize() { - PersistedData persistedData = serializer.persistedDataFromJson(INSTANCE_JSON); + SomeClass deserialized = + serializer.fromJson(INSTANCE_JSON, new TypeInfo>() {}); - TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); - - SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); - - assertEquals(INSTANCE, deserializedInstance); + assertEquals(INSTANCE, deserialized); } } diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 36476957af3..9cb83a3f889 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -18,6 +18,7 @@ import com.google.gson.Gson; import com.google.gson.JsonElement; import com.google.gson.JsonIOException; +import com.google.gson.JsonSyntaxException; import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationException; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; @@ -151,26 +152,41 @@ public void writeJson(T object, TypeInfo typeInfo, String fileName) throw * Gets the PersistedData from the {@link Reader}'s contents. * * @param reader Reader object that contains the contents that will be deserialized + * @param typeInfo * @return deserialized GsonPersistedData object - * @see #persistedDataFromJson(InputStream) + * @see #fromJson(InputStream, TypeInfo) + * @throws SerializationException Thrown if the deserialization fails. */ - public PersistedData persistedDataFromJson(Reader reader) { - JsonElement jsonElement = gson.fromJson(reader, JsonElement.class); + public T fromJson(Reader reader, TypeInfo typeInfo) throws SerializationException { + JsonElement jsonElement; - return new GsonPersistedData(jsonElement); + try { + jsonElement = gson.fromJson(reader, JsonElement.class); + } catch (JsonIOException | JsonSyntaxException e) { + throw new SerializationException("Could not read JSON from reader", e); + } + + Optional deserialized = deserialize(new GsonPersistedData(jsonElement), typeInfo); + + if (!deserialized.isPresent()) { + throw new SerializationException("Could not deserialize object of type " + typeInfo); + } + + return deserialized.get(); } /** * Gets the PersistedData from an {@link InputStream}'s contents. * * @param stream Contents of the InputStream will be serialized + * @param typeInfo * @return deserialized GsonPersistedData object * @throws IOException if there is an issue parsing the stream - * @see #persistedDataFromJson(Reader) + * @see #fromJson(Reader, TypeInfo) */ - public PersistedData persistedDataFromJson(InputStream stream) throws IOException { + public T fromJson(InputStream stream, TypeInfo typeInfo) throws IOException, SerializationException { try (Reader reader = new InputStreamReader(stream)) { - return persistedDataFromJson(reader); + return fromJson(reader, typeInfo); } } @@ -178,13 +194,14 @@ public PersistedData persistedDataFromJson(InputStream stream) throws IOExceptio * Gets the PersistedData from a {@link File} object's contents. * * @param file File object containing the JSON that will be deserialized + * @param typeInfo * @return deserialized GsonPersistedData object * @throws IOException gets thrown if there is an issue reading the File object - * @see #persistedDataFromJson(String) + * @see #fromJson(String, TypeInfo) */ - public PersistedData persistedDataFromJson(File file) throws IOException { + public T fromJson(File file, TypeInfo typeInfo) throws IOException, SerializationException { try (Reader reader = new FileReader(file)) { - return persistedDataFromJson(reader); + return fromJson(reader, typeInfo); } } @@ -192,12 +209,13 @@ public PersistedData persistedDataFromJson(File file) throws IOException { * Gets the PersistedData from a {@link String}'s contents. * * @param json the String that will be deserialized + * @param typeInfo * @return deserialized GsonPersistedData Object - * @see #persistedDataFromJson(Reader) + * @see #fromJson(Reader, TypeInfo) */ - public PersistedData persistedDataFromJson(String json) { + public T fromJson(String json, TypeInfo typeInfo) throws SerializationException { try (StringReader reader = new StringReader(json)) { - return persistedDataFromJson(reader); + return fromJson(reader, typeInfo); } } } diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 5868af72b9a..5e4d9190fe3 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -28,9 +28,6 @@ import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; import org.terasology.reflection.TypeInfo; -import org.terasology.reflection.copy.CopyStrategyLibrary; -import org.terasology.reflection.reflect.ReflectionReflectFactory; -import org.terasology.utilities.ReflectionUtil; import java.io.File; import java.io.IOException; @@ -46,16 +43,12 @@ class RecordedEventSerializer { private static final Logger logger = LoggerFactory.getLogger(RecordedEventSerializer.class); private GsonSerializer gsonSerializer; - private TypeHandler> recordedEventListTypeHandler; public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment moduleEnvironment) { TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleEnvironment); typeHandlerLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); gsonSerializer = new GsonSerializer(typeHandlerLibrary); - - this.recordedEventListTypeHandler = typeHandlerLibrary.getTypeHandler( - new TypeInfo>() {}).get(); } /** @@ -81,15 +74,10 @@ public List deserializeRecordedEvents(String filePath) { List events = new ArrayList<>(); try { - PersistedData persistedData = gsonSerializer.persistedDataFromJson(new File(filePath)); - - Optional> recordedEvents = recordedEventListTypeHandler.deserialize(persistedData); - recordedEvents.ifPresent(events::addAll); - - if (!recordedEvents.isPresent()) { - logger.error("Some problem occurred during deserialization, no recorded events was found"); - } - } catch (IOException e) { + List recordedEvents = + gsonSerializer.fromJson(new File(filePath), new TypeInfo>() {}); + events.addAll(recordedEvents); + } catch (SerializationException | IOException e) { logger.error("Error while serializing recorded events", e); } From 503065242294bca5b5a8fc5dda80455328bc85a9 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 13:16:12 +0530 Subject: [PATCH 109/141] Make ProtobufSerializer extend AbstractSerializer --- .../serializers/TypeSerializerTest.java | 17 +-- .../serializers/ProtobufSerializer.java | 111 +++++++++++------- 2 files changed, 76 insertions(+), 52 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 3cb5d0bba94..427333da1c3 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -22,8 +22,6 @@ import org.junit.runner.RunWith; import org.reflections.Reflections; import org.terasology.math.geom.Vector3f; -import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.reflection.TypeInfo; import org.terasology.rendering.nui.Color; @@ -73,22 +71,19 @@ public void testDeserialize() { } public static class Protobuf { - final Reflections reflections = new Reflections(getClass().getClassLoader()); + private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.withDefaultHandlers(reflections); + private final ProtobufSerializer serializer = new ProtobufSerializer(typeHandlerLibrary); + @Test public void testSerializeDeserialize() throws IOException { - TypeHandler> typeHandler = typeHandlerLibrary.getTypeHandler(new TypeInfo>() {}).get(); - - ProtobufSerializer protobufSerializer = new ProtobufSerializer(); - - byte[] bytes = protobufSerializer.toBytes(INSTANCE, typeHandler); - - PersistedData persistedData = protobufSerializer.persistedDatafromBytes(bytes); + byte[] bytes = serializer.toBytes(INSTANCE, new TypeInfo>() {}); - SomeClass deserializedInstance = typeHandler.deserialize(persistedData).get(); + SomeClass deserializedInstance = + serializer.fromBytes(bytes, new TypeInfo>() {}); assertEquals(INSTANCE, deserializedInstance); } diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java index b1a60b68c62..570fc2d3d40 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java @@ -16,10 +16,12 @@ package org.terasology.persistence.serializers; import org.terasology.persistence.typeHandling.PersistedData; -import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.SerializationException; +import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedData; import org.terasology.persistence.typeHandling.protobuf.ProtobufPersistedDataSerializer; import org.terasology.protobuf.EntityData; +import org.terasology.reflection.TypeInfo; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; @@ -29,113 +31,140 @@ import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; +import java.util.Optional; /** * ProtobufSerializer provides the ability to serialize and deserialize between objects and bytes - *

    + *

    * Serialized bytes can be forwarded/written to various output types - *

    + *

    * Various input types of serialized bytes can be deserialized and returned as PersistedData objects - * */ -public class ProtobufSerializer { +public class ProtobufSerializer extends AbstractSerializer { + public ProtobufSerializer(TypeHandlerLibrary typeHandlerLibrary) { + super(typeHandlerLibrary, new ProtobufPersistedDataSerializer()); + } /** - * Converts the object into an array of bytes and forwards it to {@link #writeBytes(Object, TypeHandler, OutputStream)} - * + * Converts the object into an array of bytes and forwards it to {@link #writeBytes(Object, TypeInfo, OutputStream)} + * * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized + * @param typeInfo contains how the object will be serialized * @return the byte array of the object * @throws IOException throws if there is an error writing to the stream */ - public byte[] toBytes(T object, TypeHandler typeHandler) throws IOException { + public byte[] toBytes(T object, TypeInfo typeInfo) throws IOException { try (ByteArrayOutputStream stream = new ByteArrayOutputStream()) { - writeBytes(object, typeHandler, stream); + writeBytes(object, typeInfo, stream); return stream.toByteArray(); } } /** * Takes a string path of a file and writes the serialized bytes into that file - * - * @see #writeBytes(Object, TypeHandler, File) + * * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized + * @param typeInfo contains how the object will be serialized * @param fileName the path of the file in which it is being written to * @throws IOException gets thrown if there is an error writing to the file + * @see #writeBytes(Object, TypeInfo, File) */ - public void writeBytes(T object, TypeHandler typeHandler, String fileName) throws IOException { - writeBytes(object, typeHandler, new File(fileName)); + public void writeBytes(T object, TypeInfo typeInfo, String fileName) + throws SerializationException, IOException { + writeBytes(object, typeInfo, new File(fileName)); } /** * Writes an object's bytes to a file. - * - * @see #writeBytes(Object, TypeHandler, OutputStream) + * * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized + * @param typeInfo contains how the object will be serialized * @param file file that the bytes will be written to * @throws IOException gets thrown if there is an error writing to the file + * @see #writeBytes(Object, TypeInfo, OutputStream) */ - public void writeBytes(T object, TypeHandler typeHandler, File file) throws IOException { - writeBytes(object, typeHandler, new FileOutputStream(file)); + public void writeBytes(T object, TypeInfo typeInfo, File file) + throws SerializationException, IOException { + try (FileOutputStream stream = new FileOutputStream(file)) { + writeBytes(object, typeInfo, stream); + } } /** * Writes a given object to an OutputStream using protobuf and TypeHandler * serialization - * + * * @param object the object to be serialized - * @param typeHandler contains how the object will be serialized + * @param typeInfo contains how the object will be serialized * @param stream stream that the bytes will be written to - * @throws IOException will be thrown if there is an error writing to the stream */ - public void writeBytes(T object, TypeHandler typeHandler, OutputStream stream) throws IOException { - ProtobufPersistedData persistedData = (ProtobufPersistedData) typeHandler.serialize(object, - new ProtobufPersistedDataSerializer()); + public void writeBytes(T object, TypeInfo typeInfo, OutputStream stream) + throws SerializationException { + Optional serialized = this.serialize(object, typeInfo); + + if (!serialized.isPresent()) { + throw new SerializationException("Could not find a TypeHandler for the type " + typeInfo); + } + + ProtobufPersistedData persistedData = (ProtobufPersistedData) serialized.get(); - persistedData.getValue().writeDelimitedTo(stream); + try { + persistedData.getValue().writeDelimitedTo(stream); + } catch (IOException e) { + throw new SerializationException("Could not write bytes to stream", e); + } } /** * Gets the PersistedData from a byte stream (InputStream). - * - * @see #persistedDatafromBytes(File) + * * @param stream InputStream that will be deserialized * @return deserialized ProtobufPersistedData object - * @throws IOException if there is an issue parsing the stream + * @throws SerializationException if there is an issue parsing the stream */ - public PersistedData persistedDatafromBytes(InputStream stream) throws IOException { - EntityData.Value value = EntityData.Value.parseDelimitedFrom(stream); + public T fromBytes(InputStream stream, TypeInfo typeInfo) throws SerializationException { + EntityData.Value value; + + try { + value = EntityData.Value.parseDelimitedFrom(stream); + } catch (IOException e) { + throw new SerializationException("Could not parse bytes from Stream", e); + } + + Optional deserialized = this.deserialize(new ProtobufPersistedData(value), typeInfo); + + if (!deserialized.isPresent()) { + throw new SerializationException("Could not deserialize object of type " + typeInfo); + } - return new ProtobufPersistedData(value); + return deserialized.get(); } /** * Gets the PersistedData from a File. - * - * @see #persistedDatafromBytes(InputStream) + * * @param file contains the bytes that will be deserialized * @return deserialized ProtobufPersistedData object * @throws IOException gets thrown if there is an issue reading the file + * @see #fromBytes(InputStream, TypeInfo) */ - public PersistedData persistedDatafromBytes(File file) throws IOException { + public T fromBytes(File file, TypeInfo typeInfo) throws IOException, SerializationException { try (InputStream stream = new FileInputStream(file)) { - return persistedDatafromBytes(stream); + return fromBytes(stream, typeInfo); } } /** * Gets the PersistedData from an array of bytes. - * - * @see #persistedDatafromBytes(InputStream) + * * @param bytes array of bytes to be deserialized * @return deserialized ProtobufData object * @throws IOException gets thrown if there is an issue creating the InputStream + * @see #fromBytes(InputStream, TypeInfo) */ - public PersistedData persistedDatafromBytes(byte[] bytes) throws IOException { + public T fromBytes(byte[] bytes, TypeInfo typeInfo) throws IOException { try (InputStream reader = new ByteArrayInputStream(bytes)) { - return persistedDatafromBytes(reader); + return fromBytes(reader, typeInfo); } } } From b9d9dfb67fc138d7d09dfe38857d0de01686fa8d Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 13:53:49 +0530 Subject: [PATCH 110/141] Document Serializers --- .../serializers/AbstractSerializer.java | 36 +++++ .../serializers/GsonSerializer.java | 124 ++++++++++-------- .../serializers/ProtobufSerializer.java | 99 ++++++++------ 3 files changed, 164 insertions(+), 95 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java index f9f6be1ecac..256f3c3cbec 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/AbstractSerializer.java @@ -22,6 +22,15 @@ import java.util.Optional; +/** + * The abstract class that all serializers derive from. It by default provides the ability to + * serialize/deserialize an object to/from a {@link PersistedData} using the given + * {@link PersistedDataSerializer}. + *

    + * Implementors simply need to specify the type of {@link PersistedDataSerializer} to use + * and can provide convenience methods that use {@link #serialize(Object, TypeInfo)} and + * {@link #deserialize(PersistedData, TypeInfo)}. + */ public abstract class AbstractSerializer { protected final TypeHandlerLibrary typeHandlerLibrary; protected final PersistedDataSerializer persistedDataSerializer; @@ -31,11 +40,38 @@ protected AbstractSerializer(TypeHandlerLibrary typeHandlerLibrary, PersistedDat this.persistedDataSerializer = persistedDataSerializer; } + /** + * Serializes the given object to a {@link PersistedData} using the stored + * {@link #persistedDataSerializer} by loading a + * {@link org.terasology.persistence.typeHandling.TypeHandler TypeHandler} from the + * {@link #typeHandlerLibrary}. + * + * @param object The object to serialize. + * @param typeInfo A {@link TypeInfo} specifying the type of the object to serialize. + * @param The type of the object to serialize. + * @return A {@link PersistedData}, if the serialization was successful. Serialization + * usually fails only because an appropriate type handler could not be found for the + * given type. + */ public Optional serialize(T object, TypeInfo typeInfo) { return typeHandlerLibrary.getTypeHandler(typeInfo) .map(typeHandler -> typeHandler.serialize(object, persistedDataSerializer)); } + /** + * Deserializes an object of the given type from a {@link PersistedData} using the stored + * {@link #persistedDataSerializer} by loading a + * {@link org.terasology.persistence.typeHandling.TypeHandler TypeHandler} from the + * {@link #typeHandlerLibrary}. + * + * @param data The {@link PersistedData} containing the serialized representation of the object. + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}, if the deserialization was successful. + * Deserialization usually fails when an appropriate type handler could not be found for the + * type {@link T} or if the serialized object representation in {@code data} does + * not represent an object of type {@link T}. + */ public Optional deserialize(PersistedData data, TypeInfo typeInfo) { return typeHandlerLibrary.getTypeHandler(typeInfo).flatMap(typeHandler -> typeHandler.deserialize(data)); } diff --git a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java index 9cb83a3f889..49079bb83a2 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/GsonSerializer.java @@ -42,17 +42,13 @@ import java.util.Optional; /** - * GsonSerializer provides the ability to serialize and deserialize objects to and from JSON - *
    - * Serialized JSON can be forwarded/written to various output types
    - *
    - * Various input types can be deserialized and returned as PersistedData types + * {@link GsonSerializer} provides the ability to serialize and deserialize objects to and from JSON. */ public class GsonSerializer extends AbstractSerializer { private Gson gson; /** - * Constructs a new GsonSerializer object + * Constructs a new {@link GsonSerializer} object with the given {@link TypeHandlerLibrary}. */ public GsonSerializer(TypeHandlerLibrary typeHandlerLibrary) { super(typeHandlerLibrary, new GsonPersistedDataSerializer()); @@ -61,13 +57,13 @@ public GsonSerializer(TypeHandlerLibrary typeHandlerLibrary) { } /** - * Writes the serialized persisted data as a JSON to {@link Writer} and returns the - * JSON as a string. + * Serializes the given object to JSON and returns the serialized JSON as a {@link String}. * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @return contents of the JSON as a string - * @throws SerializationException Thrown if serialization fails. + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param The type of the object to be serialized. + * @return The serialized JSON as a {@link String}. + * @throws SerializationException Thrown when serialization fails. * @see #writeJson(Object, TypeInfo, Writer) */ public String toJson(T object, TypeInfo typeInfo) throws SerializationException { @@ -79,13 +75,14 @@ public String toJson(T object, TypeInfo typeInfo) throws SerializationExc } /** - * Writes an object's serialized persisted data to the {@link Writer} as JSON. + * Serializes the given object to JSON and writes the serialized JSON object to the + * {@link Writer}. * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @param writer The writer in which the JSON will be written to + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param writer The {@link Writer} to which the JSON will be written. + * @param The type of the object to be serialized. * @throws SerializationException Thrown when serialization fails. - * @see #writeJson(Object, TypeInfo, OutputStream) */ public void writeJson(T object, TypeInfo typeInfo, Writer writer) throws SerializationException { Optional serialized = this.serialize(object, typeInfo); @@ -104,57 +101,68 @@ public void writeJson(T object, TypeInfo typeInfo, Writer writer) throws } /** - * Writes an object's serialized persisted data to the {@link OutputStream} as JSON. + * Serializes the given object to JSON and writes the serialized JSON object to the + * {@link OutputStream}. * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @param stream stream that the data will be written to - * @throws IOException will be thrown if there is an error writing to the stream + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param stream The {@link OutputStream} to which the JSON will be written. + * @param The type of the object to be serialized. * @throws SerializationException Thrown when serialization fails. + * @throws IOException Thrown if there is an error in writing to the + * {@link OutputStream}. * @see #writeJson(Object, TypeInfo, Writer) */ - public void writeJson(T object, TypeInfo typeInfo, OutputStream stream) throws IOException, SerializationException { + public void writeJson(T object, TypeInfo typeInfo, OutputStream stream) + throws IOException, SerializationException { try (Writer writer = new BufferedWriter(new OutputStreamWriter(stream))) { writeJson(object, typeInfo, writer); } } /** - * Writes the object's persisted data to the {@link File} as JSON. + * Serializes the given object to JSON and writes the serialized JSON object to the + * {@link File}. * - * @param object the file to be serialized - * @param typeInfo contains how the object will be serialized - * @param file file that the bytes will be written to - * @throws IOException gets thrown if there is an issue writing to the file. + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param file The {@link File} that the JSON will be written to. + * @param The type of the object to be serialized. + * @throws IOException Thrown if there is an issue writing to the file. * @throws SerializationException Thrown when serialization fails. * @see #writeJson(Object, TypeInfo, Writer) */ - public void writeJson(T object, TypeInfo typeInfo, File file) throws IOException, SerializationException { + public void writeJson(T object, TypeInfo typeInfo, File file) + throws IOException, SerializationException { try (Writer writer = new BufferedWriter(new FileWriter(file))) { writeJson(object, typeInfo, writer); } } /** - * Writes an object's persisted data to {@link File} of a specified file name as JSON + * Serializes the given object to JSON and writes the serialized JSON object to the + * file with the given file name. * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @param fileName the file name where the JSON will be written - * @throws IOException gets thrown if there is an error writing to the file at the specified location + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param fileName The name of the file that the JSON will be written to. + * @param The type of the object to be serialized. + * @throws IOException Thrown if there is an issue writing to the file. + * @throws SerializationException Thrown when serialization fails. * @see #writeJson(Object, TypeInfo, File) */ - public void writeJson(T object, TypeInfo typeInfo, String fileName) throws IOException { + public void writeJson(T object, TypeInfo typeInfo, String fileName) + throws IOException, SerializationException { writeJson(object, typeInfo, new File(fileName)); } /** - * Gets the PersistedData from the {@link Reader}'s contents. + * Deserializes an object of type {@link T} from the JSON in the {@link Reader}. * - * @param reader Reader object that contains the contents that will be deserialized - * @param typeInfo - * @return deserialized GsonPersistedData object - * @see #fromJson(InputStream, TypeInfo) + * @param reader The {@link Reader} that contains the JSON to be deserialized. + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}. * @throws SerializationException Thrown if the deserialization fails. */ public T fromJson(Reader reader, TypeInfo typeInfo) throws SerializationException { @@ -176,12 +184,14 @@ public T fromJson(Reader reader, TypeInfo typeInfo) throws SerializationE } /** - * Gets the PersistedData from an {@link InputStream}'s contents. + * Deserializes an object of type {@link T} from the JSON in the {@link InputStream}. * - * @param stream Contents of the InputStream will be serialized - * @param typeInfo - * @return deserialized GsonPersistedData object - * @throws IOException if there is an issue parsing the stream + * @param stream The {@link InputStream} containing the serialized JSON. + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}. + * @throws IOException Thrown if there is an issue reading from the {@link InputStream}. + * @throws SerializationException Thrown if the deserialization fails. * @see #fromJson(Reader, TypeInfo) */ public T fromJson(InputStream stream, TypeInfo typeInfo) throws IOException, SerializationException { @@ -191,13 +201,15 @@ public T fromJson(InputStream stream, TypeInfo typeInfo) throws IOExcepti } /** - * Gets the PersistedData from a {@link File} object's contents. + * Deserializes an object of type {@link T} from the JSON in the {@link File}. * - * @param file File object containing the JSON that will be deserialized - * @param typeInfo - * @return deserialized GsonPersistedData object - * @throws IOException gets thrown if there is an issue reading the File object - * @see #fromJson(String, TypeInfo) + * @param file The file containing the JSON to be deserialized. + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}. + * @throws IOException Thrown if there is an issue reading from the {@link File}. + * @throws SerializationException Thrown if the deserialization fails. + * @see #fromJson(Reader, TypeInfo) */ public T fromJson(File file, TypeInfo typeInfo) throws IOException, SerializationException { try (Reader reader = new FileReader(file)) { @@ -206,11 +218,13 @@ public T fromJson(File file, TypeInfo typeInfo) throws IOException, Seria } /** - * Gets the PersistedData from a {@link String}'s contents. + * Deserializes an object of type {@link T} from the JSON in the {@link File}. * - * @param json the String that will be deserialized - * @param typeInfo - * @return deserialized GsonPersistedData Object + * @param json The JSON to be deserialized + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}. + * @throws SerializationException Thrown if the deserialization fails. * @see #fromJson(Reader, TypeInfo) */ public T fromJson(String json, TypeInfo typeInfo) throws SerializationException { diff --git a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java index 570fc2d3d40..5a689d62b3c 100644 --- a/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java +++ b/engine/src/main/java/org/terasology/persistence/serializers/ProtobufSerializer.java @@ -34,26 +34,31 @@ import java.util.Optional; /** - * ProtobufSerializer provides the ability to serialize and deserialize between objects and bytes - *

    - * Serialized bytes can be forwarded/written to various output types - *

    - * Various input types of serialized bytes can be deserialized and returned as PersistedData objects + * {@link ProtobufSerializer} provides the ability to serialize and deserialize objects to and + * from a binary format using Protobuf. */ public class ProtobufSerializer extends AbstractSerializer { + /** + * Constructs a new {@link ProtobufSerializer} using the given {@link TypeHandlerLibrary}. + */ public ProtobufSerializer(TypeHandlerLibrary typeHandlerLibrary) { super(typeHandlerLibrary, new ProtobufPersistedDataSerializer()); } /** - * Converts the object into an array of bytes and forwards it to {@link #writeBytes(Object, TypeInfo, OutputStream)} + * Serializes the given object to bytes and returns the serialized byte array. * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @return the byte array of the object - * @throws IOException throws if there is an error writing to the stream + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param The type of the object to be serialized. + * @return The serialized byte array. + * @throws SerializationException Thrown when serialization fails. + * @throws IOException Thrown if there was an error creating the + * {@link ByteArrayOutputStream}. + * @see #writeBytes(Object, TypeInfo, OutputStream) */ - public byte[] toBytes(T object, TypeInfo typeInfo) throws IOException { + public byte[] toBytes(T object, TypeInfo typeInfo) + throws SerializationException, IOException { try (ByteArrayOutputStream stream = new ByteArrayOutputStream()) { writeBytes(object, typeInfo, stream); return stream.toByteArray(); @@ -61,12 +66,14 @@ public byte[] toBytes(T object, TypeInfo typeInfo) throws IOException { } /** - * Takes a string path of a file and writes the serialized bytes into that file + * Serializes the given object to bytes and writes the bytes to the file with the given name. * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @param fileName the path of the file in which it is being written to - * @throws IOException gets thrown if there is an error writing to the file + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param fileName The name of the file to write the serialized bytes to. + * @param The type of the object to be serialized. + * @throws SerializationException Thrown when serialization fails. + * @throws IOException Thrown if there was an error writing the bytes to the file. * @see #writeBytes(Object, TypeInfo, File) */ public void writeBytes(T object, TypeInfo typeInfo, String fileName) @@ -75,13 +82,15 @@ public void writeBytes(T object, TypeInfo typeInfo, String fileName) } /** - * Writes an object's bytes to a file. + * Serializes the given object to bytes and writes the bytes to the {@link File} * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @param file file that the bytes will be written to - * @throws IOException gets thrown if there is an error writing to the file - * @see #writeBytes(Object, TypeInfo, OutputStream) + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param file The {@link File} to write the serialized bytes to. + * @param The type of the object to be serialized. + * @throws SerializationException Thrown when serialization fails. + * @throws IOException Thrown if there was an error writing the bytes to the file. + * @see #writeBytes(Object, TypeInfo, File) */ public void writeBytes(T object, TypeInfo typeInfo, File file) throws SerializationException, IOException { @@ -91,12 +100,14 @@ public void writeBytes(T object, TypeInfo typeInfo, File file) } /** - * Writes a given object to an OutputStream using protobuf and TypeHandler - * serialization + * Serializes the given object to bytes and writes the bytes to the {@link OutputStream}. * - * @param object the object to be serialized - * @param typeInfo contains how the object will be serialized - * @param stream stream that the bytes will be written to + * @param object The object to be serialized. + * @param typeInfo The {@link TypeInfo} specifying the type of the object to be serialized. + * @param stream The {@link OutputStream} to write the serialized bytes to. + * @param The type of the object to be serialized. + * @throws SerializationException Thrown when serialization fails. + * @see #writeBytes(Object, TypeInfo, File) */ public void writeBytes(T object, TypeInfo typeInfo, OutputStream stream) throws SerializationException { @@ -116,11 +127,13 @@ public void writeBytes(T object, TypeInfo typeInfo, OutputStream stream) } /** - * Gets the PersistedData from a byte stream (InputStream). + * Deserializes an object of type {@link T} from the bytes in the {@link InputStream}. * - * @param stream InputStream that will be deserialized - * @return deserialized ProtobufPersistedData object - * @throws SerializationException if there is an issue parsing the stream + * @param stream The {@link InputStream} that contains the bytes to be deserialized. + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}. + * @throws SerializationException Thrown if the deserialization fails. */ public T fromBytes(InputStream stream, TypeInfo typeInfo) throws SerializationException { EntityData.Value value; @@ -141,11 +154,14 @@ public T fromBytes(InputStream stream, TypeInfo typeInfo) throws Serializ } /** - * Gets the PersistedData from a File. + * Deserializes an object of type {@link T} from the bytes in the {@link File}. * - * @param file contains the bytes that will be deserialized - * @return deserialized ProtobufPersistedData object - * @throws IOException gets thrown if there is an issue reading the file + * @param file The {@link File} that contains the bytes to be deserialized. + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}. + * @throws IOException Thrown if there was an error reading from the file. + * @throws SerializationException Thrown if the deserialization fails. * @see #fromBytes(InputStream, TypeInfo) */ public T fromBytes(File file, TypeInfo typeInfo) throws IOException, SerializationException { @@ -155,14 +171,17 @@ public T fromBytes(File file, TypeInfo typeInfo) throws IOException, Seri } /** - * Gets the PersistedData from an array of bytes. + * Deserializes an object of type {@link T} from the given bytes. * - * @param bytes array of bytes to be deserialized - * @return deserialized ProtobufData object - * @throws IOException gets thrown if there is an issue creating the InputStream + * @param bytes The bytes to be deserialized. + * @param typeInfo The {@link TypeInfo} specifying the type to deserialize the object as. + * @param The type to deserialize the object as. + * @return The deserialized object of type {@link T}. + * @throws IOException Thrown if there was an error creating a {@link ByteArrayInputStream}. + * @throws SerializationException Thrown if the deserialization fails. * @see #fromBytes(InputStream, TypeInfo) */ - public T fromBytes(byte[] bytes, TypeInfo typeInfo) throws IOException { + public T fromBytes(byte[] bytes, TypeInfo typeInfo) throws IOException, SerializationException { try (InputStream reader = new ByteArrayInputStream(bytes)) { return fromBytes(reader, typeInfo); } From 3a4f2f77653502ff096dead8e30684120a66c268 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 29 Jun 2019 15:04:08 +0530 Subject: [PATCH 111/141] Add @SerializedName annotation --- .../serializers/TypeSerializerTest.java | 4 ++- .../annotations/SerializedName.java | 34 +++++++++++++++++++ .../coreTypes/ObjectFieldMapTypeHandler.java | 15 ++++++-- 3 files changed, 50 insertions(+), 3 deletions(-) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/annotations/SerializedName.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 427333da1c3..5a7ca267e2c 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -23,6 +23,7 @@ import org.reflections.Reflections; import org.terasology.math.geom.Vector3f; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; +import org.terasology.persistence.typeHandling.annotations.SerializedName; import org.terasology.reflection.TypeInfo; import org.terasology.rendering.nui.Color; @@ -46,7 +47,7 @@ public class TypeSerializerTest { } public static class Json { - private static final String INSTANCE_JSON = "{\"data\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; + private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; private final Reflections reflections = new Reflections(getClass().getClassLoader()); @@ -90,6 +91,7 @@ public void testSerializeDeserialize() throws IOException { } private static class SomeClass { + @SerializedName("generic-t") private T data; private List list = Lists.newArrayList(); private Set animals = Sets.newHashSet(); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/annotations/SerializedName.java b/engine/src/main/java/org/terasology/persistence/typeHandling/annotations/SerializedName.java new file mode 100644 index 00000000000..71775885abc --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/annotations/SerializedName.java @@ -0,0 +1,34 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * An annotation that indicates that the decorated field should be serialized with + * the provided name value as its field name. + */ +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.FIELD}) +public @interface SerializedName { + /** + * @return the desired name of the field when it is serialized or deserialized. + */ + String value(); +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java index 61232142b56..2ae9261e872 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ObjectFieldMapTypeHandler.java @@ -23,6 +23,7 @@ import org.terasology.persistence.typeHandling.PersistedDataSerializer; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; +import org.terasology.persistence.typeHandling.annotations.SerializedName; import org.terasology.reflection.reflect.ObjectConstructor; import java.lang.reflect.Field; @@ -46,7 +47,7 @@ public ObjectFieldMapTypeHandler(ObjectConstructor constructor, Map deserialize(PersistedData data) { if (!data.isValueMap()) { From 54c0d97d41a709da643f7d306e02fcad63a0cb2a Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sun, 30 Jun 2019 11:59:05 +0530 Subject: [PATCH 112/141] Add inherited type parameter resolution in ReflectionUtil --- .../serializers/TypeSerializerTest.java | 64 ++++---- .../utilities/ReflectionUtilsTest.java | 55 ++++++- .../behavior/nui/BehaviorNodeFactory.java | 2 +- .../RuntimeDelegatingTypeHandler.java | 42 ++--- .../gson/GsonMapExclusionStrategy.java | 3 +- .../org/terasology/reflection/TypeInfo.java | 4 +- .../reflection/copy/CopyStrategyLibrary.java | 2 +- .../terasology/utilities/ReflectionUtil.java | 143 +++++++++++++----- 8 files changed, 219 insertions(+), 96 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 5a7ca267e2c..22a77ed6ec5 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -41,18 +41,18 @@ public class TypeSerializerTest { static { INSTANCE.list.addAll(Lists.newArrayList(50, 51, -52, -53)); - INSTANCE.animals.add(new Dog(new Vector3f(3.15f, 54.51f, -0.001f))); + INSTANCE.animals.add(new Dog<>(1, new Vector3f(3.15f, 54.51f, -0.001f))); - INSTANCE.animals.add(new Cheetah(Color.MAGENTA)); + INSTANCE.animals.add(new Cheetah<>(2, Color.MAGENTA)); } public static class Json { - private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"name\":\"Dog\"}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"name\":\"Cheetah\"}}]}"; + private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"data\":1}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"data\":2}}]}"; private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.withDefaultHandlers(reflections); + TypeHandlerLibrary.withDefaultHandlers(reflections); private final GsonSerializer serializer = new GsonSerializer(typeHandlerLibrary); @@ -65,7 +65,7 @@ public void testJsonSerialize() { @Test public void testDeserialize() { SomeClass deserialized = - serializer.fromJson(INSTANCE_JSON, new TypeInfo>() {}); + serializer.fromJson(INSTANCE_JSON, new TypeInfo>() {}); assertEquals(INSTANCE, deserialized); } @@ -75,7 +75,7 @@ public static class Protobuf { private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.withDefaultHandlers(reflections); + TypeHandlerLibrary.withDefaultHandlers(reflections); private final ProtobufSerializer serializer = new ProtobufSerializer(typeHandlerLibrary); @@ -84,7 +84,7 @@ public void testSerializeDeserialize() throws IOException { byte[] bytes = serializer.toBytes(INSTANCE, new TypeInfo>() {}); SomeClass deserializedInstance = - serializer.fromBytes(bytes, new TypeInfo>() {}); + serializer.fromBytes(bytes, new TypeInfo>() {}); assertEquals(INSTANCE, deserializedInstance); } @@ -94,7 +94,7 @@ private static class SomeClass { @SerializedName("generic-t") private T data; private List list = Lists.newArrayList(); - private Set animals = Sets.newHashSet(); + private Set> animals = Sets.newHashSet(); private SomeClass(T data) { this.data = data; @@ -110,8 +110,8 @@ public boolean equals(Object o) { } SomeClass someClass = (SomeClass) o; return Objects.equals(data, someClass.data) && - Objects.equals(list, someClass.list) && - Objects.equals(animals, someClass.animals); + Objects.equals(list, someClass.list) && + Objects.equals(animals, someClass.animals); } @Override @@ -122,18 +122,18 @@ public int hashCode() { @Override public String toString() { return "SomeClass{" + - "data=" + data + - ", list=" + list + - ", animals=" + animals + - '}'; + "data=" + data + + ", list=" + list + + ", animals=" + animals + + '}'; } } - private static abstract class Animal { - protected final String name; + private static abstract class Animal { + protected final T data; - private Animal(String name) { - this.name = name; + private Animal(T data) { + this.data = data; } @Override @@ -145,20 +145,20 @@ public boolean equals(Object o) { return false; } Animal animal = (Animal) o; - return Objects.equals(name, animal.name); + return Objects.equals(data, animal.data); } @Override public int hashCode() { - return Objects.hash(name); + return Objects.hash(data); } } - private static class Dog extends Animal { + private static class Dog extends Animal { private final Vector3f tailPosition; - private Dog(Vector3f tailPosition) { - super("Dog"); + private Dog(T data, Vector3f tailPosition) { + super(data); this.tailPosition = tailPosition; } @@ -180,9 +180,9 @@ public boolean equals(Object o) { @Override public String toString() { return "Dog{" + - "name='" + name + '\'' + - ", tailPosition=" + tailPosition + - '}'; + "name='" + data + '\'' + + ", tailPosition=" + tailPosition + + '}'; } @Override @@ -191,11 +191,11 @@ public int hashCode() { } } - private static class Cheetah extends Animal { + private static class Cheetah extends Animal { private final Color spotColor; - private Cheetah(Color spotColor) { - super("Cheetah"); + private Cheetah(T data, Color spotColor) { + super(data); this.spotColor = spotColor; } @@ -217,9 +217,9 @@ public boolean equals(Object o) { @Override public String toString() { return "Cheetah{" + - "name='" + name + '\'' + - ", spotColor=" + spotColor + - '}'; + "name='" + data + '\'' + + ", spotColor=" + spotColor + + '}'; } @Override diff --git a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java index 3b5e8182887..41c188ccc9b 100644 --- a/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java +++ b/engine-tests/src/test/java/org/terasology/utilities/ReflectionUtilsTest.java @@ -24,8 +24,8 @@ import java.lang.reflect.GenericArrayType; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; -import java.lang.reflect.TypeVariable; import java.lang.reflect.WildcardType; +import java.sql.Struct; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -40,7 +40,7 @@ class C {} ParameterizedType cType = (ParameterizedType) new TypeInfo>() {}.getType(); Type wildcardType = cType.getActualTypeArguments()[0]; - assertEquals(Object.class, ReflectionUtil.getClassOfType(wildcardType)); + assertEquals(Object.class, ReflectionUtil.getRawType(wildcardType)); } @Test @@ -217,6 +217,57 @@ class SomeClass { assertEquals(Integer.class, resolvedWildcardType.getLowerBounds()[0]); } + @Test + public void testResolveThroughGenericSupertypes() { + class B implements MarkerB, MarkerA {} + + ParameterizedType resolvedTypeForB = (ParameterizedType) ReflectionUtil.resolveType( + new TypeInfo>() {}.getType(), + ReflectionUtil.parameterizeRawType(B.class) + ); + + // Could not resolve S + assertEquals(Object.class, resolvedTypeForB.getActualTypeArguments()[0]); + // Could resolve T + assertEquals(String.class, resolvedTypeForB.getActualTypeArguments()[1]); + } + + @Test + public void testResolveThroughInheritanceTree() { + class A implements MarkerA, MarkerC {} + class B extends A implements MarkerB, MarkerC {} + class C extends B {} + + final Type typeToResolve = ReflectionUtil.parameterizeRawType(C.class); + + ParameterizedType resolvedThroughMarkerA = (ParameterizedType) ReflectionUtil.resolveType( + new TypeInfo>() {}.getType(), + typeToResolve + ); + + assertEquals(String.class, resolvedThroughMarkerA.getActualTypeArguments()[0]); + + ParameterizedType resolvedThroughMarkerB = (ParameterizedType) ReflectionUtil.resolveType( + new TypeInfo>() {}.getType(), + typeToResolve + ); + + assertEquals(String.class, resolvedThroughMarkerB.getActualTypeArguments()[0]); + + + ParameterizedType resolvedThroughAWithIncorrectFirstType = + (ParameterizedType) ReflectionUtil.resolveType( + new TypeInfo>() {}.getType(), + typeToResolve + ); + + assertEquals(String.class, resolvedThroughAWithIncorrectFirstType.getActualTypeArguments()[0]); + } + + interface MarkerA {} + interface MarkerB {} + interface MarkerC {} + interface GenericInterfaceSubInterface extends CopyStrategy {} class SubInterfaceImplementor implements GenericInterfaceSubInterface { diff --git a/engine/src/main/java/org/terasology/logic/behavior/nui/BehaviorNodeFactory.java b/engine/src/main/java/org/terasology/logic/behavior/nui/BehaviorNodeFactory.java index 5d22b353ea2..bfe26da57e3 100644 --- a/engine/src/main/java/org/terasology/logic/behavior/nui/BehaviorNodeFactory.java +++ b/engine/src/main/java/org/terasology/logic/behavior/nui/BehaviorNodeFactory.java @@ -137,7 +137,7 @@ private List determineAnimationPoolUris() { ParameterizedType parameterizedType = (ParameterizedType) fieldType; Type[] typeArguments = parameterizedType.getActualTypeArguments(); if (typeArguments.length == 1) { - Class typeClass = ReflectionUtil.getClassOfType(typeArguments[0]); + Class typeClass = ReflectionUtil.getRawType(typeArguments[0]); if (typeClass.isAssignableFrom(MeshAnimation.class)) { animationSetUris.add(new ComponentFieldUri(uri, fieldMetadata.getName())); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 6efad5713b6..7811dff089b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -58,6 +58,7 @@ public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo this.reflections = context.getReflections(); } + @SuppressWarnings({"unchecked"}) @Override public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { // If primitive, don't go looking for the runtime type, serialize as is @@ -71,10 +72,10 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize } TypeHandler chosenHandler = delegateHandler; - Class runtimeClass = getRuntimeTypeIfMoreSpecific(value); + Type runtimeType = getRuntimeTypeIfMoreSpecific(value); - if (!typeInfo.getRawType().equals(runtimeClass)) { - Optional> runtimeTypeHandler = typeHandlerLibrary.getTypeHandler((Type) runtimeClass); + if (!typeInfo.getRawType().equals(runtimeType)) { + Optional> runtimeTypeHandler = typeHandlerLibrary.getTypeHandler(runtimeType); chosenHandler = (TypeHandler) runtimeTypeHandler .map(typeHandler -> { @@ -97,7 +98,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize } if (chosenHandler == null) { - LOGGER.error("Could not find appropriate TypeHandler for runtime type {}", runtimeClass); + LOGGER.error("Could not find appropriate TypeHandler for runtime type {}", runtimeType); return serializer.serializeNull(); } @@ -109,7 +110,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize typeValuePersistedDataMap.put( TYPE_FIELD, - serializer.serialize(runtimeClass.getName()) + serializer.serialize(ReflectionUtil.getRawType(runtimeType).getName()) ); typeValuePersistedDataMap.put( @@ -120,26 +121,27 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize return serializer.serialize(typeValuePersistedDataMap); } - private Class getRuntimeTypeIfMoreSpecific(T value) { + private Type getRuntimeTypeIfMoreSpecific(T value) { if (value == null) { return typeInfo.getRawType(); } - Class runtimeClass = value.getClass(); + Type runtimeType = + ReflectionUtil.parameterizeandResolveRawType(typeInfo.getType(), value.getClass()); if (typeInfo.getRawType().isInterface()) { // Given type is interface, use runtime type which will be a class and will have data - return runtimeClass; + return runtimeType; } else if (typeInfo.getType() instanceof Class) { // If given type is a simple class, use more specific runtime type - return runtimeClass; + return runtimeType; } else if (delegateHandler == null) { // If we can't find a handler for the declared type, use the runtime type - return runtimeClass; + return runtimeType; } // Given type has more information than runtime type, use that - return typeInfo.getRawType(); + return typeInfo.getType(); } @SuppressWarnings({"unchecked"}) @@ -157,19 +159,13 @@ public Optional deserialize(PersistedData data) { String runtimeTypeName = valueMap.getAsString(TYPE_FIELD); - Optional> typeToDeserializeAs = findSubtypeWithName(runtimeTypeName); + Optional typeToDeserializeAs = findSubtypeWithName(runtimeTypeName); if (!typeToDeserializeAs.isPresent()) { LOGGER.error("Cannot find class to deserialize {}", runtimeTypeName); return Optional.empty(); } - if (!typeInfo.getRawType().isAssignableFrom(typeToDeserializeAs.get())) { - LOGGER.error("Given type {} is not a sub-type of expected type {}", - typeToDeserializeAs.get(), typeInfo.getType()); - return Optional.empty(); - } - TypeHandler runtimeTypeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(typeToDeserializeAs.get()) // To avoid compile errors in the orElseGet .map(typeHandler -> (TypeHandler) typeHandler) @@ -186,7 +182,14 @@ public Optional deserialize(PersistedData data) { } - private Optional> findSubtypeWithName(String runtimeTypeName) { + private Optional findSubtypeWithName(String runtimeTypeName) { + return findSubclassWithName(runtimeTypeName) + .map(runtimeClass -> + ReflectionUtil.parameterizeandResolveRawType(typeInfo.getType(), runtimeClass) + ); + } + + private Optional> findSubclassWithName(String runtimeTypeName) { for (Class clazz : reflections.getSubTypesOf(typeInfo.getRawType())) { if (runtimeTypeName.equals(clazz.getSimpleName()) || runtimeTypeName.equals(clazz.getName())) { @@ -196,5 +199,4 @@ private Optional> findSubtypeWithName(String runtimeTypeName) { return Optional.empty(); } - } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonMapExclusionStrategy.java b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonMapExclusionStrategy.java index 6b35deedfff..b78ca8f15e8 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonMapExclusionStrategy.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/gson/GsonMapExclusionStrategy.java @@ -19,7 +19,6 @@ import com.google.gson.FieldAttributes; import org.terasology.utilities.ReflectionUtil; -import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.Map; @@ -27,7 +26,7 @@ public class GsonMapExclusionStrategy implements ExclusionStrategy { @Override public boolean shouldSkipField(FieldAttributes f) { Type fieldType = f.getDeclaredType(); - Class fieldClass = ReflectionUtil.getClassOfType(fieldType); + Class fieldClass = ReflectionUtil.getRawType(fieldType); if (Map.class.isAssignableFrom(fieldClass)) { Type mapKeyType = ReflectionUtil.getTypeParameter(fieldType, 0); diff --git a/engine/src/main/java/org/terasology/reflection/TypeInfo.java b/engine/src/main/java/org/terasology/reflection/TypeInfo.java index a9d4cb2bb88..78c44092d25 100644 --- a/engine/src/main/java/org/terasology/reflection/TypeInfo.java +++ b/engine/src/main/java/org/terasology/reflection/TypeInfo.java @@ -55,7 +55,7 @@ public class TypeInfo { @SuppressWarnings("unchecked") protected TypeInfo() { this.type = ReflectionUtil.getTypeParameterForSuper(getClass(), TypeInfo.class, 0); - this.rawType = (Class) ReflectionUtil.getClassOfType(type); + this.rawType = (Class) ReflectionUtil.getRawType(type); this.hashCode = type.hashCode(); } @@ -65,7 +65,7 @@ protected TypeInfo() { @SuppressWarnings("unchecked") protected TypeInfo(Type type) { this.type = type; - this.rawType = (Class) ReflectionUtil.getClassOfType(type); + this.rawType = (Class) ReflectionUtil.getRawType(type); this.hashCode = type.hashCode(); } diff --git a/engine/src/main/java/org/terasology/reflection/copy/CopyStrategyLibrary.java b/engine/src/main/java/org/terasology/reflection/copy/CopyStrategyLibrary.java index ef550a3d6d9..0da5ab050a0 100644 --- a/engine/src/main/java/org/terasology/reflection/copy/CopyStrategyLibrary.java +++ b/engine/src/main/java/org/terasology/reflection/copy/CopyStrategyLibrary.java @@ -84,7 +84,7 @@ public void clear() { // TODO: Consider CopyStrategyFactory system for Collections and similar public CopyStrategy getStrategy(Type genericType) { - Class typeClass = ReflectionUtil.getClassOfType(genericType); + Class typeClass = ReflectionUtil.getRawType(genericType); if (typeClass == null) { logger.error("Cannot obtain class for type {}, using default strategy", genericType); return defaultStrategy; diff --git a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java index 23da26cefb8..915adeac8eb 100644 --- a/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java +++ b/engine/src/main/java/org/terasology/utilities/ReflectionUtil.java @@ -19,7 +19,6 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import com.google.common.collect.Sets; -import org.terasology.module.ModuleEnvironment; import org.terasology.rendering.nui.UIWidget; import java.lang.reflect.Array; @@ -30,12 +29,14 @@ import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; import java.lang.reflect.WildcardType; +import java.util.AbstractMap; import java.util.Arrays; import java.util.List; import java.util.Locale; +import java.util.Map; import java.util.Objects; -import java.util.Optional; import java.util.Set; +import java.util.stream.Stream; /** * @@ -111,8 +112,6 @@ public static boolean typeEquals(Type a, Type b) { * Attempts to return the type of a parameter of a parameterised field. This uses compile-time information only - the * type should be obtained from a field with a the generic types bound. * - * @param type - * @param index * @return The type of the generic parameter at index for the given type, or null if it cannot be obtained. */ // TODO - Improve parameter lookup to go up the inheritance tree more @@ -127,17 +126,17 @@ public static Type getTypeParameter(Type type, int index) { return parameterizedType.getActualTypeArguments()[index]; } - public static Class getClassOfType(Type type) { + public static Class getRawType(Type type) { if (type instanceof Class) { return (Class) type; } else if (type instanceof ParameterizedType) { return (Class) ((ParameterizedType) type).getRawType(); } else if (type instanceof GenericArrayType) { GenericArrayType genericArrayType = (GenericArrayType) type; - return Array.newInstance(getClassOfType(genericArrayType.getGenericComponentType()), 0).getClass(); + return Array.newInstance(getRawType(genericArrayType.getGenericComponentType()), 0).getClass(); } else if (type instanceof WildcardType) { WildcardType wildcardType = (WildcardType) type; - return getClassOfType(wildcardType.getUpperBounds()[0]); + return getRawType(wildcardType.getUpperBounds()[0]); } return Object.class; } @@ -194,8 +193,6 @@ public static Method findMethod(Class targetType, String methodName, Class * Returns an ordered list of super classes and interfaces for the given class, that have a common base class. * The set is ordered with the deepest interface first, through all the interfaces, and then all the super classes. * - * @param forClass - * @param baseClass * @return an ordered list of super classes and interfaces for the given class, that have a common base class. */ public static List> getInheritanceTree(Class forClass, Class baseClass) { @@ -231,7 +228,7 @@ private static void addInterfaceToInheritanceTree(Class interfa } public static Type getTypeParameterForSuper(Type target, Class superClass, int index) { - Class targetClass = getClassOfType(target); + Class targetClass = getRawType(target); Preconditions.checkArgument(superClass.isAssignableFrom(targetClass), "Target must be a child of superClass"); if (superClass.isInterface()) { @@ -242,10 +239,10 @@ public static Type getTypeParameterForSuper(Type target, Class superClass } private static Type getTypeParameterForSuperClass(Type target, Class superClass, int index) { - for (Class targetClass = getClassOfType(target); + for (Class targetClass = getRawType(target); !Object.class.equals(targetClass); target = resolveType(target, targetClass.getGenericSuperclass()), - targetClass = getClassOfType(target)) { + targetClass = getRawType(target)) { if (superClass.equals(targetClass)) { return getTypeParameter(target, index); } @@ -255,7 +252,7 @@ private static Type getTypeParameterForSuperClass(Type target, Class supe } private static Type getTypeParameterForSuperInterface(Type target, Class superClass, int index) { - Class targetClass = getClassOfType(target); + Class targetClass = getRawType(target); if (Object.class.equals(targetClass)) { return null; @@ -287,15 +284,15 @@ private static Type getTypeParameterForSuperInterface(Type target, Class /** * Resolves all {@link TypeVariable}s in {@code type} to concrete types as per the type * parameter definitions in {@code contextType}. All {@link TypeVariable}s in {@code type} - * should have been declared in {@code contextType} or one of its supertypes, otherwise an error - * will be thrown. + * should have been declared in {@code contextType} or one of its supertypes, otherwise those + * variables will be resolved to {@link Object Object.class}. * * @param contextType The {@link Type} which contains all type parameter definitions used in {@code type}. * @param type The {@link Type} whose {@link TypeVariable}s are to be resolved. * @return A copy of {@code type} with all {@link TypeVariable}s resolved. */ public static Type resolveType(Type contextType, Type type) { - Class contextClass = getClassOfType(contextType); + Class contextClass = getRawType(contextType); // T field; if (type instanceof TypeVariable) { @@ -336,7 +333,7 @@ public static Type resolveType(Type contextType, Type type) { final Type rawType = parameterizedType.getRawType(); - return new ParameterizedTypeImpl(rawType, resolvedTypeArguments, resolvedOwnerType); + return parameterizedTypeOf(resolvedOwnerType, resolvedTypeArguments, rawType); } // T[] field || List[] field; @@ -379,22 +376,13 @@ public static Type resolveType(Type contextType, Type type) { } private static Type[] resolveTypes(Type contextType, Type[] types) { - boolean changed = false; + Type[] resolvedTypes = new Type[types.length]; for (int i = 0; i < types.length; i++) { - Type resolvedTypeArgument = resolveType(contextType, types[i]); - - if (resolvedTypeArgument != types[i]) { - if (!changed) { - types = types.clone(); - changed = true; - } - - types[i] = resolvedTypeArgument; - } + resolvedTypes[i] = resolveType(contextType, types[i]); } - return types; + return resolvedTypes; } private static Type resolveTypeVariable(Type contextType, TypeVariable typeVariable, Class contextClass) { @@ -403,17 +391,64 @@ private static Type resolveTypeVariable(Type contextType, TypeVariable typeVa return typeVariable; } - Class declaringClass = (Class) typeVariable.getGenericDeclaration(); + return getCascadedGenericDeclaration(typeVariable) + .filter(declaration -> + declaration.getKey().isAssignableFrom(contextClass)) + .findAny() + .map(declaration -> + getTypeParameterForSuper(contextType, + declaration.getKey(), + declaration.getValue()) + ) + // If we couldn't find a declaration in the context, we will not be + // able to resolve this type variable, resort to Object.class + .orElse(Object.class); + } + + public static Stream getGenericSupertypes(Class clazz) { + return Stream.concat(Stream.of(clazz.getGenericSuperclass()), Stream.of(clazz.getGenericInterfaces())); + } + + /** + * Cascades the declaration of the type variable up the inheritance tree and returns the + * cascaded declaration classes and the corresponding index of the type variable for that + * declaration class. + */ + private static Stream, Integer>> getCascadedGenericDeclaration(TypeVariable typeVariable) { + assert typeVariable.getGenericDeclaration() instanceof Class; - Preconditions.checkArgument(declaringClass.isAssignableFrom(contextClass), - "Type variable was not declared in context class " + contextClass); + Class genericDeclaration = (Class) typeVariable.getGenericDeclaration(); - List> typeParameters = - Arrays.asList(declaringClass.getTypeParameters()); + int typeVariableIndex = Arrays.asList(genericDeclaration.getTypeParameters()) + .indexOf(typeVariable); - int typeParameterIndex = typeParameters.indexOf(typeVariable); + return cascadeTypeVariableDeclarationToSupertypes(typeVariableIndex, genericDeclaration); + } - return getTypeParameterForSuper(contextType, declaringClass, typeParameterIndex); + private static Stream, Integer>> cascadeTypeVariableDeclarationToSupertypes( + int typeVariableIndex, Class declaration) { + TypeVariable typeVariable = declaration.getTypeParameters()[typeVariableIndex]; + + return Stream.concat( + Stream.of(new AbstractMap.SimpleEntry<>(declaration, typeVariableIndex)), + getGenericSupertypes(declaration) + .filter(supertype -> supertype instanceof ParameterizedType) + .map(supertype -> (ParameterizedType) supertype) + .flatMap(supertype -> { + int superTypeVariableIndex = + Arrays.asList(supertype.getActualTypeArguments()).indexOf(typeVariable); + + if (superTypeVariableIndex == -1) { + return Stream.empty(); + } + + return cascadeTypeVariableDeclarationToSupertypes( + superTypeVariableIndex, + getRawType(supertype) + ); + } + ) + ); } public static Object readField(Object object, String fieldName) { @@ -434,6 +469,42 @@ public static Object readField(Object object, String fieldName) { "Cannot find field " + cls.getName() + "." + fieldName); } + public static ParameterizedTypeImpl parameterizedTypeOf(Type ownerType, Type[] actualTypeArguments, Type rawType) { + return new ParameterizedTypeImpl(rawType, actualTypeArguments, ownerType); + } + + /** + * Returns a parameterized version of the given raw type, if it has generic type parameters. + * If it has no generic type parameters, the raw type itself is returned. + */ + public static Type parameterizeRawType(Class rawType) { + if (rawType == null) { + return null; + } + + TypeVariable[] typeParameters = rawType.getTypeParameters(); + + if (typeParameters.length == 0) { + return rawType; + } + + return parameterizedTypeOf( + parameterizeRawType(rawType.getEnclosingClass()), + typeParameters, + rawType + ); + } + + /** + * Returns a parameterized version of the given raw type that has been resolved with the given + * context type, if it has generic type parameters. If it has no generic type parameters, + * the raw type itself is returned. + */ + public static Type parameterizeandResolveRawType(Type contextType, Class rawType) { + Type parameterizedType = parameterizeRawType(rawType); + return resolveType(contextType, parameterizedType); + } + private static class WildcardTypeImpl implements WildcardType { private final Type[] upperBounds; private final Type[] lowerBounds; From 76213edd6d720957c1c536c7192e786a5c71f17c Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sun, 30 Jun 2019 12:38:01 +0530 Subject: [PATCH 113/141] Fix RuntimeDelegatingTypeHandler test --- .../coreTypes/RuntimeDelegatingTypeHandlerTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 2d16818db9e..41ba18d7785 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -101,7 +101,7 @@ abstract class SubHandler extends TypeHandler {} @Test public void testDeserialize() { - Class subType = Sub.class; + Type subType = Sub.class; Type baseType = TypeInfo.of(Base.class).getType(); abstract class SubHandler extends TypeHandler {} @@ -124,7 +124,7 @@ abstract class SubHandler extends TypeHandler {} PersistedData persistedSub = new PersistedMap( ImmutableMap.of( RuntimeDelegatingTypeHandler.TYPE_FIELD, - new PersistedString(subType.getName()), + new PersistedString(((Class) subType).getName()), RuntimeDelegatingTypeHandler.VALUE_FIELD, new PersistedMap(ImmutableMap.of()) ) From 0dcfb6432d262f38b5bc4966f3b89b3a9d8a8a53 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 10 Jul 2019 10:49:40 +0530 Subject: [PATCH 114/141] Flatten RuntimeDelegatingTypeHandler serialized format --- .../serializers/TypeSerializerTest.java | 4 +- .../RuntimeDelegatingTypeHandlerTest.java | 22 +++++- .../RuntimeDelegatingTypeHandler.java | 69 ++++++++++++------- 3 files changed, 67 insertions(+), 28 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 22a77ed6ec5..6ce7b4160a0 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -47,7 +47,7 @@ public class TypeSerializerTest { } public static class Json { - private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"content\":{\"tailPosition\":[3.15,54.51,-0.001],\"data\":1}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"content\":{\"spotColor\":[255,0,255,255],\"data\":2}}]}"; + private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"tailPosition\":[3.15,54.51,-0.001],\"data\":1},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"spotColor\":[255,0,255,255],\"data\":2}]}"; private final Reflections reflections = new Reflections(getClass().getClassLoader()); @@ -129,7 +129,7 @@ public String toString() { } } - private static abstract class Animal { + private static class Animal { protected final T data; private Animal(T data) { diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 41ba18d7785..9575ca1e3af 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -25,6 +25,7 @@ import org.terasology.persistence.typeHandling.*; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; +import org.terasology.persistence.typeHandling.inMemory.AbstractPersistedData; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; import org.terasology.persistence.typeHandling.inMemory.PersistedString; import org.terasology.reflection.TypeInfo; @@ -69,8 +70,8 @@ public void testSerialize() { abstract class SubHandler extends TypeHandler {} - TypeHandler baseTypeHandler = mock(TypeHandler.class); - TypeHandler subTypeHandler = mock(SubHandler.class); + TypeHandler baseTypeHandler = mockTypeHandler(); + TypeHandler subTypeHandler = mockTypeHandler(SubHandler.class); when(typeHandlerLibrary.getTypeHandler(eq(baseType))) .thenReturn(Optional.of(baseTypeHandler)); @@ -99,6 +100,23 @@ abstract class SubHandler extends TypeHandler {} ); } + private static TypeHandler mockTypeHandler(Class subHandlerClass) { + TypeHandler mocked = mock(subHandlerClass); + + when(mocked.serialize(any(), any())).thenReturn(new AbstractPersistedData() { + @Override + public boolean isNull() { + return true; + } + }); + + return mocked; + } + + private static TypeHandler mockTypeHandler() { + return mockTypeHandler(TypeHandler.class); + } + @Test public void testDeserialize() { Type subType = Sub.class; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 7811dff089b..f728bdfe36a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -25,12 +25,14 @@ import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; +import org.terasology.persistence.typeHandling.inMemory.PersistedMap; import org.terasology.reflection.TypeInfo; import org.terasology.utilities.ReflectionUtil; import java.lang.reflect.Type; import java.util.Map; import java.util.Optional; +import java.util.Set; /** * Delegates serialization of a value to a handler of its runtime type if needed. It is used in @@ -81,10 +83,12 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize .map(typeHandler -> { if (delegateHandler == null) { return typeHandler; - } else if (typeHandler.getClass().equals(delegateHandler.getClass())) { - // Both handlers are of same type, use delegateHandler - return delegateHandler; } else if (!(typeHandler instanceof ObjectFieldMapTypeHandler)) { + if (typeHandler.getClass().equals(delegateHandler.getClass())) { + // Both handlers are of same type, use delegateHandler + return delegateHandler; + } + // Custom handler for runtime type return typeHandler; } else if (!(delegateHandler instanceof ObjectFieldMapTypeHandler)) { @@ -113,10 +117,20 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize serializer.serialize(ReflectionUtil.getRawType(runtimeType).getName()) ); - typeValuePersistedDataMap.put( + PersistedData serialized = chosenHandler.serialize(value, serializer); + + // If the serialized representation is a Map, flatten it to include the class variable + if (serialized.isValueMap()) { + for (Map.Entry entry : serialized.getAsValueMap().entrySet()) { + typeValuePersistedDataMap.put(entry.getKey(), entry.getValue()); + } + } + else { + typeValuePersistedDataMap.put( VALUE_FIELD, - chosenHandler.serialize(value, serializer) - ); + serialized + ); + } return serializer.serialize(typeValuePersistedDataMap); } @@ -126,22 +140,7 @@ private Type getRuntimeTypeIfMoreSpecific(T value) { return typeInfo.getRawType(); } - Type runtimeType = - ReflectionUtil.parameterizeandResolveRawType(typeInfo.getType(), value.getClass()); - - if (typeInfo.getRawType().isInterface()) { - // Given type is interface, use runtime type which will be a class and will have data - return runtimeType; - } else if (typeInfo.getType() instanceof Class) { - // If given type is a simple class, use more specific runtime type - return runtimeType; - } else if (delegateHandler == null) { - // If we can't find a handler for the declared type, use the runtime type - return runtimeType; - } - - // Given type has more information than runtime type, use that - return typeInfo.getType(); + return ReflectionUtil.parameterizeandResolveRawType(typeInfo.getType(), value.getClass()); } @SuppressWarnings({"unchecked"}) @@ -153,7 +152,7 @@ public Optional deserialize(PersistedData data) { PersistedDataMap valueMap = data.getAsValueMap(); - if (!valueMap.has(TYPE_FIELD) || !valueMap.has(VALUE_FIELD)) { + if (!valueMap.has(TYPE_FIELD)) { return delegateHandler.deserialize(data); } @@ -176,7 +175,29 @@ public Optional deserialize(PersistedData data) { return delegateHandler; }); - PersistedData valueData = valueMap.get(VALUE_FIELD); + PersistedData valueData; + + Set> valueEntries = valueMap.entrySet(); + + if (valueEntries.size() == 2 && valueMap.has(VALUE_FIELD)) { + // The runtime value was stored in a separate field only if the two fields stored + // are TYPE_FIELD and VALUE_FIELD + + valueData = valueMap.get(VALUE_FIELD); + } else { + // The value was flattened and stored, every field except TYPE_FIELD describes the + // serialized value + + Map valueFields = Maps.newLinkedHashMap(); + + for (Map.Entry entry : valueEntries) { + valueFields.put(entry.getKey(), entry.getValue()); + } + + valueFields.remove(TYPE_FIELD); + + valueData = new PersistedMap(valueFields); + } return runtimeTypeHandler.deserialize(valueData); From 2dd88947fb0dcc24e029d738d523fbe9afd39c0f Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 10 Jul 2019 19:37:52 +0530 Subject: [PATCH 115/141] Change TypeInfo.rawType to Class --- .../src/main/java/org/terasology/reflection/TypeInfo.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/engine/src/main/java/org/terasology/reflection/TypeInfo.java b/engine/src/main/java/org/terasology/reflection/TypeInfo.java index 78c44092d25..6103984ad78 100644 --- a/engine/src/main/java/org/terasology/reflection/TypeInfo.java +++ b/engine/src/main/java/org/terasology/reflection/TypeInfo.java @@ -45,7 +45,7 @@ * @param The type for which type information is to be generated. */ public class TypeInfo { - private final Class rawType; + private final Class rawType; private final Type type; private final int hashCode; @@ -55,7 +55,7 @@ public class TypeInfo { @SuppressWarnings("unchecked") protected TypeInfo() { this.type = ReflectionUtil.getTypeParameterForSuper(getClass(), TypeInfo.class, 0); - this.rawType = (Class) ReflectionUtil.getRawType(type); + this.rawType = (Class) ReflectionUtil.getRawType(type); this.hashCode = type.hashCode(); } @@ -65,7 +65,7 @@ protected TypeInfo() { @SuppressWarnings("unchecked") protected TypeInfo(Type type) { this.type = type; - this.rawType = (Class) ReflectionUtil.getRawType(type); + this.rawType = (Class) ReflectionUtil.getRawType(type); this.hashCode = type.hashCode(); } @@ -83,7 +83,7 @@ public static TypeInfo of(Class type) { return new TypeInfo<>(type); } - public Class getRawType() { + public Class getRawType() { return rawType; } From 4c2ac42a8db2fdd1c2c2506fe08878ae8d4b3534 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 20 Jul 2019 10:28:17 +0530 Subject: [PATCH 116/141] Add SerializationSandbox and implementations --- .../RuntimeDelegatingTypeHandlerTest.java | 3 +- .../ArrayTypeHandlerFactoryTest.java | 3 +- .../CollectionTypeHandlerFactoryTest.java | 3 +- .../ObjectFieldMapTypeHandlerFactoryTest.java | 3 +- .../StringMapTypeHandlerFactoryTest.java | 3 +- .../typeHandling/TypeHandlerContext.java | 16 ++- .../typeHandling/TypeHandlerLibrary.java | 33 ++++-- .../RuntimeDelegatingTypeHandler.java | 29 ++--- .../reflection/ModuleEnvironmentSandbox.java | 106 ++++++++++++++++++ .../reflection/ReflectionsSandbox.java | 48 ++++++++ .../reflection/SerializationSandbox.java | 31 +++++ 11 files changed, 236 insertions(+), 42 deletions(-) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 9575ca1e3af..24d6b1db712 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -28,6 +28,7 @@ import org.terasology.persistence.typeHandling.inMemory.AbstractPersistedData; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; import org.terasology.persistence.typeHandling.inMemory.PersistedString; +import org.terasology.persistence.typeHandling.reflection.ReflectionsSandbox; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; @@ -49,7 +50,7 @@ public class RuntimeDelegatingTypeHandlerTest { private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, new Reflections(getClass().getClassLoader())); + new TypeHandlerContext(typeHandlerLibrary, new ReflectionsSandbox(new Reflections(getClass().getClassLoader()))); private static class Base { int x; diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java index b683c4493e2..9bfa3a4b3a1 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ArrayTypeHandlerFactoryTest.java @@ -21,6 +21,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.ArrayTypeHandler; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; import java.util.List; @@ -37,7 +38,7 @@ public class ArrayTypeHandlerFactoryTest { private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final ArrayTypeHandlerFactory typeHandlerFactory = new ArrayTypeHandlerFactory(); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); + new TypeHandlerContext(typeHandlerLibrary, mock(SerializationSandbox.class)); @Test public void testArray() { diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java index 17a39486524..6603de02c2d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/CollectionTypeHandlerFactoryTest.java @@ -22,6 +22,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; @@ -42,7 +43,7 @@ public class CollectionTypeHandlerFactoryTest { private final CollectionTypeHandlerFactory typeHandlerFactory = new CollectionTypeHandlerFactory(new ConstructorLibrary(Maps.newHashMap())); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); + new TypeHandlerContext(typeHandlerLibrary, mock(SerializationSandbox.class)); @Test public void testList() { diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java index 4f5d7ea4ffa..accdff8aac4 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/ObjectFieldMapTypeHandlerFactoryTest.java @@ -22,6 +22,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.reflect.ConstructorLibrary; @@ -42,7 +43,7 @@ public class ObjectFieldMapTypeHandlerFactoryTest { constructorLibrary); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); + new TypeHandlerContext(typeHandlerLibrary, mock(SerializationSandbox.class)); private static class SomeClass { private T t; diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java index 403f8d37efc..f2c6b421b0d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/factories/StringMapTypeHandlerFactoryTest.java @@ -22,6 +22,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; import java.util.HashMap; @@ -39,7 +40,7 @@ public class StringMapTypeHandlerFactoryTest { private final StringMapTypeHandlerFactory typeHandlerFactory = new StringMapTypeHandlerFactory(); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, mock(Reflections.class)); + new TypeHandlerContext(typeHandlerLibrary, mock(SerializationSandbox.class)); @Test public void testStringMap() { diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java index 60a26d353c9..7d3c1a635b0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerContext.java @@ -16,11 +16,9 @@ package org.terasology.persistence.typeHandling; import org.reflections.Reflections; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; -import java.lang.reflect.Type; -import java.util.Optional; - /** * Represents the context in which a {@link TypeHandlerFactory} creates {@link TypeHandler} instances. *

    @@ -29,11 +27,11 @@ */ public class TypeHandlerContext { private TypeHandlerLibrary typeHandlerLibrary; - private Reflections reflections; + private SerializationSandbox sandbox; - public TypeHandlerContext(TypeHandlerLibrary typeHandlerLibrary, Reflections reflections) { + public TypeHandlerContext(TypeHandlerLibrary typeHandlerLibrary, SerializationSandbox sandbox) { this.typeHandlerLibrary = typeHandlerLibrary; - this.reflections = reflections; + this.sandbox = sandbox; } /** @@ -44,10 +42,10 @@ public TypeHandlerLibrary getTypeHandlerLibrary() { } /** - * Returns the {@link Reflections} to use to load classes in the + * Returns the {@link SerializationSandbox} to use to load classes in the * {@link TypeHandlerFactory#create(TypeInfo, TypeHandlerContext)} method. */ - public Reflections getReflections() { - return reflections; + public SerializationSandbox getSandbox() { + return sandbox; } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 24bed68483d..1193dbbf2e7 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -61,6 +61,9 @@ import org.terasology.persistence.typeHandling.mathTypes.Vector4fTypeHandler; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2fTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2iTypeHandlerFactory; +import org.terasology.persistence.typeHandling.reflection.ModuleEnvironmentSandbox; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; +import org.terasology.persistence.typeHandling.reflection.ReflectionsSandbox; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.metadata.ClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; @@ -70,7 +73,6 @@ import org.terasology.utilities.ReflectionUtil; import java.lang.reflect.Type; -import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -84,7 +86,7 @@ public class TypeHandlerLibrary { private static final Logger logger = LoggerFactory.getLogger(TypeHandlerLibrary.class); - private Reflections reflections; + private SerializationSandbox sandbox; private List typeHandlerFactories = Lists.newArrayList(); @@ -104,12 +106,7 @@ public class TypeHandlerLibrary { private Map, Serializer> serializerMap = Maps.newHashMap(); - /** - * @param reflections - */ - public TypeHandlerLibrary(Reflections reflections) { - this.reflections = reflections; - + private TypeHandlerLibrary() { constructorLibrary = new ConstructorLibrary(instanceCreators); addTypeHandlerFactory(new ObjectFieldMapTypeHandlerFactory(constructorLibrary)); @@ -137,6 +134,22 @@ public TypeHandlerLibrary(Reflections reflections) { addTypeHandlerFactory(new EnumTypeHandlerFactory()); addTypeHandlerFactory(new CollectionTypeHandlerFactory(constructorLibrary)); addTypeHandlerFactory(new StringMapTypeHandlerFactory()); + + } + + /** + * @param reflections + */ + public TypeHandlerLibrary(Reflections reflections) { + this(); + + this.sandbox = new ReflectionsSandbox(reflections); + } + + public TypeHandlerLibrary(ModuleEnvironment moduleEnvironment) { + this(); + + this.sandbox = new ModuleEnvironmentSandbox(moduleEnvironment); } /** @@ -148,7 +161,7 @@ public TypeHandlerLibrary(Reflections reflections) { public TypeHandlerLibrary(TypeHandlerLibrary original) { this.typeHandlerFactories.addAll(original.typeHandlerFactories); this.instanceCreators.putAll(original.instanceCreators); - this.reflections = original.reflections; + this.sandbox = original.sandbox; } public static TypeHandlerLibrary withDefaultHandlers(Reflections reflections) { @@ -310,7 +323,7 @@ public Optional> getTypeHandler(Class typeClass) { */ @SuppressWarnings("unchecked") public Optional> getTypeHandler(TypeInfo type) { - TypeHandlerContext context = new TypeHandlerContext(this, reflections); + TypeHandlerContext context = new TypeHandlerContext(this, sandbox); if (typeHandlerCache.containsKey(type)) { return Optional.of((TypeHandler) typeHandlerCache.get(type)); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index f728bdfe36a..4a4e10c8205 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.coreTypes; import com.google.common.collect.Maps; -import org.reflections.Reflections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.terasology.persistence.typeHandling.PersistedData; @@ -26,6 +25,7 @@ import org.terasology.persistence.typeHandling.TypeHandlerContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; import org.terasology.utilities.ReflectionUtil; @@ -51,13 +51,13 @@ public class RuntimeDelegatingTypeHandler extends TypeHandler { private TypeHandler delegateHandler; private TypeInfo typeInfo; private TypeHandlerLibrary typeHandlerLibrary; - private Reflections reflections; + private SerializationSandbox sandbox; public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo typeInfo, TypeHandlerContext context) { this.delegateHandler = delegateHandler; this.typeInfo = typeInfo; this.typeHandlerLibrary = context.getTypeHandlerLibrary(); - this.reflections = context.getReflections(); + this.sandbox = context.getSandbox(); } @SuppressWarnings({"unchecked"}) @@ -76,7 +76,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize TypeHandler chosenHandler = delegateHandler; Type runtimeType = getRuntimeTypeIfMoreSpecific(value); - if (!typeInfo.getRawType().equals(runtimeType)) { + if (!typeInfo.getType().equals(runtimeType)) { Optional> runtimeTypeHandler = typeHandlerLibrary.getTypeHandler(runtimeType); chosenHandler = (TypeHandler) runtimeTypeHandler @@ -112,9 +112,12 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize Map typeValuePersistedDataMap = Maps.newLinkedHashMap(); + Class subType = (Class) ReflectionUtil.getRawType(runtimeType); + String subTypeIdentifier = sandbox.getSubTypeIdentifier(subType, typeInfo.getRawType()); + typeValuePersistedDataMap.put( TYPE_FIELD, - serializer.serialize(ReflectionUtil.getRawType(runtimeType).getName()) + serializer.serialize(subTypeIdentifier) ); PersistedData serialized = chosenHandler.serialize(value, serializer); @@ -137,7 +140,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize private Type getRuntimeTypeIfMoreSpecific(T value) { if (value == null) { - return typeInfo.getRawType(); + return typeInfo.getType(); } return ReflectionUtil.parameterizeandResolveRawType(typeInfo.getType(), value.getClass()); @@ -204,20 +207,10 @@ public Optional deserialize(PersistedData data) { } private Optional findSubtypeWithName(String runtimeTypeName) { - return findSubclassWithName(runtimeTypeName) + return sandbox.findSubTypeOf(runtimeTypeName, typeInfo.getRawType()) .map(runtimeClass -> - ReflectionUtil.parameterizeandResolveRawType(typeInfo.getType(), runtimeClass) + ReflectionUtil.parameterizeandResolveRawType(typeInfo.getType(), runtimeClass) ); } - private Optional> findSubclassWithName(String runtimeTypeName) { - for (Class clazz : reflections.getSubTypesOf(typeInfo.getRawType())) { - if (runtimeTypeName.equals(clazz.getSimpleName()) || - runtimeTypeName.equals(clazz.getName())) { - return Optional.of(clazz); - } - } - - return Optional.empty(); - } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java new file mode 100644 index 00000000000..9eb37e99d9b --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -0,0 +1,106 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.reflection; + +import com.google.common.base.Preconditions; +import com.google.common.collect.Iterables; +import com.google.common.collect.Streams; +import org.terasology.engine.SimpleUri; +import org.terasology.module.ModuleEnvironment; +import org.terasology.naming.Name; + +import java.util.Iterator; +import java.util.Optional; + +import static com.google.common.collect.Streams.stream; + +public class ModuleEnvironmentSandbox implements SerializationSandbox { + private final ModuleEnvironment moduleEnvironment; + + public ModuleEnvironmentSandbox(ModuleEnvironment moduleEnvironment) { + this.moduleEnvironment = moduleEnvironment; + } + + @Override + public Optional> findSubTypeOf(String subTypeIdentifier, Class clazz) { + + Iterator> possibilities = + moduleEnvironment + .getSubtypesOf(clazz, subclass -> doesSubclassMatch(subclass, subTypeIdentifier)) + .iterator(); + + if (possibilities.hasNext()) { + Class possibility = possibilities.next(); + + // Multiple possibilities + if (possibilities.hasNext()) { + return Optional.empty(); + } + + return Optional.of(possibility); + } + + // No possibility + return Optional.empty(); + } + + private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { + if (subclass == null) { + return false; + } + + SimpleUri subTypeUri = new SimpleUri(subTypeIdentifier); + Name subTypeName = subTypeUri.isValid() ? subTypeUri.getObjectName() : new Name(subTypeIdentifier); + + Name providingModule = moduleEnvironment.getModuleProviding(subclass); + + + if (subTypeUri.isValid()) { + if (!subTypeUri.getModuleName().equals(providingModule)) { + return false; + } + } + + return subTypeName.toString().equals((subclass.getName())) || subTypeName.toString().equals((subclass.getSimpleName())); + } + + @Override + public String getSubTypeIdentifier(Class subType, Class baseType) { + SimpleUri subTypeUri = getTypeSimpleUri(subType); + + long subTypesWithSameUri = Streams.stream(moduleEnvironment.getSubtypesOf(baseType)) + .map(this::getTypeSimpleUri) + .filter(subTypeUri::equals) + .count(); + + Preconditions.checkArgument(subTypesWithSameUri > 0, + "Subtype was not found in the module environment"); + + if (subTypesWithSameUri > 1) { + // More than one subType with same SimpleUri, use fully qualified name + return subType.getName(); + } + + return subTypeUri.toString(); + } + + private SimpleUri getTypeSimpleUri(Class type) { + Name moduleProvidingType = moduleEnvironment.getModuleProviding(type); + String typeSimpleName = type.getSimpleName(); + + return new SimpleUri(moduleProvidingType, typeSimpleName); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java new file mode 100644 index 00000000000..5e75328096c --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java @@ -0,0 +1,48 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.reflection; + +import org.reflections.Reflections; + +import java.util.Optional; +import java.util.Set; + +public class ReflectionsSandbox implements SerializationSandbox { + private final Reflections reflections; + + public ReflectionsSandbox(Reflections reflections) { + this.reflections = reflections; + } + + @Override + public Optional> findSubTypeOf(String subTypeIdentifier, Class clazz) { + Set> subTypes = reflections.getSubTypesOf(clazz); + + subTypes.removeIf(subType -> !subTypeIdentifier.equals(subType.getName())); + + if (subTypes.size() == 1) { + return Optional.ofNullable(subTypes.iterator().next()); + } + + // If there are multiple/no possibilities, return empty Optional + return Optional.empty(); + } + + @Override + public String getSubTypeIdentifier(Class subType, Class baseType) { + return subType.getName(); + } +} diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java new file mode 100644 index 00000000000..6f9caa9eea5 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java @@ -0,0 +1,31 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling.reflection; + +import java.util.Optional; + +public interface SerializationSandbox { + /** + * + * @param subTypeIdentifier + * @param clazz + * @param + * @return + */ + Optional> findSubTypeOf(String subTypeIdentifier, Class clazz); + + String getSubTypeIdentifier(Class subType, Class baseType); +} From af0ddb8fa0e14269ed379798d9b6edc02a67b4ff Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 22 Jul 2019 15:03:42 +0530 Subject: [PATCH 117/141] Sandbox TypeHandler addition --- .../typeHandling/TypeHandlerLibrary.java | 39 ++++++++++++------- .../reflection/ModuleEnvironmentSandbox.java | 12 ++++++ .../reflection/ReflectionsSandbox.java | 7 ++++ .../reflection/SerializationSandbox.java | 5 +++ 4 files changed, 50 insertions(+), 13 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 1193dbbf2e7..0f5e503a596 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -62,8 +62,8 @@ import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2fTypeHandlerFactory; import org.terasology.persistence.typeHandling.mathTypes.factories.Rect2iTypeHandlerFactory; import org.terasology.persistence.typeHandling.reflection.ModuleEnvironmentSandbox; -import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.persistence.typeHandling.reflection.ReflectionsSandbox; +import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; import org.terasology.reflection.metadata.ClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; @@ -106,7 +106,9 @@ public class TypeHandlerLibrary { private Map, Serializer> serializerMap = Maps.newHashMap(); - private TypeHandlerLibrary() { + private TypeHandlerLibrary(SerializationSandbox sandbox) { + this.sandbox = sandbox; + constructorLibrary = new ConstructorLibrary(instanceCreators); addTypeHandlerFactory(new ObjectFieldMapTypeHandlerFactory(constructorLibrary)); @@ -138,18 +140,14 @@ private TypeHandlerLibrary() { } /** - * @param reflections + * */ public TypeHandlerLibrary(Reflections reflections) { - this(); - - this.sandbox = new ReflectionsSandbox(reflections); + this(new ReflectionsSandbox(reflections)); } public TypeHandlerLibrary(ModuleEnvironment moduleEnvironment) { - this(); - - this.sandbox = new ModuleEnvironmentSandbox(moduleEnvironment); + this(new ModuleEnvironmentSandbox(moduleEnvironment)); } /** @@ -228,26 +226,39 @@ public void addTypeHandlerFactory(TypeHandlerFactory typeHandlerFactory) { * Adds a {@link TypeHandler} for the specified type to this {@link TypeHandlerLibrary} by * adding to the library a new {@link TypeHandlerFactory} that returns the {@link TypeHandler} * whenever the {@link TypeHandler} for the specified type is requested. + *

    + * If the specified {@link SerializationSandbox} does not allow the addition of the given + * {@link TypeHandler} for the given type, the {@link TypeHandler} is not added to the + * library and false is returned. * * @param typeClass The {@link Class} of the type handled by the {@link TypeHandler}. * @param typeHandler The {@link TypeHandler} to add to the library. * @param The type handled by the {@link TypeHandler}. + * @return True if the {@link TypeHandler} was successfully added, false otherwise. */ - public void addTypeHandler(Class typeClass, TypeHandler typeHandler) { - addTypeHandler(TypeInfo.of(typeClass), typeHandler); + public boolean addTypeHandler(Class typeClass, TypeHandler typeHandler) { + return addTypeHandler(TypeInfo.of(typeClass), typeHandler); } /** * Adds a {@link TypeHandler} for the specified type to this {@link TypeHandlerLibrary} by * adding to the library a new {@link TypeHandlerFactory} that returns the {@link TypeHandler} * whenever the {@link TypeHandler} for the specified type is requested. + *

    + * If the specified {@link SerializationSandbox} does not allow the addition of the given + * {@link TypeHandler} for the given type, the {@link TypeHandler} is not added to the + * library and false is returned. * + * @param The type handled by the {@link TypeHandler}. * @param type The {@link TypeInfo} of the type handled by the {@link TypeHandler}. * @param typeHandler The {@link TypeHandler} to add to the library. - * @param The type handled by the {@link TypeHandler}. + * @return True if the {@link TypeHandler} was successfully added, false otherwise. */ + public boolean addTypeHandler(TypeInfo type, TypeHandler typeHandler) { + if (!sandbox.isValidTypeHandlerDeclaration(type, typeHandler)) { + return false; + } - public void addTypeHandler(TypeInfo type, TypeHandler typeHandler) { TypeHandlerFactory factory = new TypeHandlerFactory() { @SuppressWarnings("unchecked") @Override @@ -257,6 +268,8 @@ public Optional> create(TypeInfo typeInfo, TypeHandlerCont }; addTypeHandlerFactory(factory); + + return true; } /** diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 9eb37e99d9b..7830effb541 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -21,8 +21,11 @@ import org.terasology.engine.SimpleUri; import org.terasology.module.ModuleEnvironment; import org.terasology.naming.Name; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.reflection.TypeInfo; import java.util.Iterator; +import java.util.Objects; import java.util.Optional; import static com.google.common.collect.Streams.stream; @@ -97,6 +100,15 @@ public String getSubTypeIdentifier(Class subType, Class base return subTypeUri.toString(); } + @Override + public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler) { + Name moduleDeclaringType = moduleEnvironment.getModuleProviding(type.getRawType()); + Name moduleDeclaringHandler = moduleEnvironment.getModuleProviding(typeHandler.getClass()); + + // Both the type and the handler must come from the same module + return Objects.equals(moduleDeclaringType, moduleDeclaringHandler); + } + private SimpleUri getTypeSimpleUri(Class type) { Name moduleProvidingType = moduleEnvironment.getModuleProviding(type); String typeSimpleName = type.getSimpleName(); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java index 5e75328096c..05324baffca 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ReflectionsSandbox.java @@ -16,6 +16,8 @@ package org.terasology.persistence.typeHandling.reflection; import org.reflections.Reflections; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.reflection.TypeInfo; import java.util.Optional; import java.util.Set; @@ -45,4 +47,9 @@ public Optional> findSubTypeOf(String subTypeIdentifier, public String getSubTypeIdentifier(Class subType, Class baseType) { return subType.getName(); } + + @Override + public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler) { + return true; + } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java index 6f9caa9eea5..b631acd0d8f 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java @@ -15,6 +15,9 @@ */ package org.terasology.persistence.typeHandling.reflection; +import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.reflection.TypeInfo; + import java.util.Optional; public interface SerializationSandbox { @@ -28,4 +31,6 @@ public interface SerializationSandbox { Optional> findSubTypeOf(String subTypeIdentifier, Class clazz); String getSubTypeIdentifier(Class subType, Class baseType); + + boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler); } From 3197ec61f7d91f8081210a19fec5fa21f8f760d7 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 22 Jul 2019 15:08:53 +0530 Subject: [PATCH 118/141] Update TypeHandlerLibrary static factory methods for sandbox --- .../serializers/TypeSerializerTest.java | 4 ++-- .../typeHandling/FutureTypeHandlerTest.java | 4 ++-- ...GsonTypeHandlerLibraryAdapterFactoryTest.java | 2 +- .../typeHandling/TypeHandlerLibrary.java | 16 +++++++++------- 4 files changed, 14 insertions(+), 12 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 6ce7b4160a0..1a283fc150d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -52,7 +52,7 @@ public static class Json { private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.withDefaultHandlers(reflections); + TypeHandlerLibrary.withReflections(reflections); private final GsonSerializer serializer = new GsonSerializer(typeHandlerLibrary); @@ -75,7 +75,7 @@ public static class Protobuf { private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.withDefaultHandlers(reflections); + TypeHandlerLibrary.withReflections(reflections); private final ProtobufSerializer serializer = new ProtobufSerializer(typeHandlerLibrary); diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java index 2cd09bdbdf4..0385875f1d8 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/FutureTypeHandlerTest.java @@ -40,7 +40,7 @@ public class FutureTypeHandlerTest { private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = - spy(TypeHandlerLibrary.withDefaultHandlers(reflections)); + spy(TypeHandlerLibrary.withReflections(reflections)); private static class RecursiveType { final T data; @@ -91,4 +91,4 @@ public void testRecursiveType() { assertEquals(typeHandler, future.typeHandler); } -} \ No newline at end of file +} diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java index c4c9a22b873..fca00044a8d 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/gson/GsonTypeHandlerLibraryAdapterFactoryTest.java @@ -48,7 +48,7 @@ public class GsonTypeHandlerLibraryAdapterFactoryTest { private final Reflections reflections = new Reflections(getClass().getClassLoader()); private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.withDefaultHandlers(reflections); + TypeHandlerLibrary.withReflections(reflections); private final Gson gson = GsonBuilderFactory.createGsonBuilderWithTypeSerializationLibrary(typeHandlerLibrary) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 0f5e503a596..c116212a4e0 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -162,18 +162,20 @@ public TypeHandlerLibrary(TypeHandlerLibrary original) { this.sandbox = original.sandbox; } - public static TypeHandlerLibrary withDefaultHandlers(Reflections reflections) { - TypeHandlerLibrary serializationLibrary = new TypeHandlerLibrary(reflections); + public static TypeHandlerLibrary withReflections(Reflections reflections) { + TypeHandlerLibrary library = new TypeHandlerLibrary(reflections); - populateWithDefaultHandlers(serializationLibrary); + populateWithDefaultHandlers(library); - return serializationLibrary; + return library; } public static TypeHandlerLibrary forModuleEnvironment(ModuleEnvironment moduleEnvironment) { - // TODO: Reflection - may break with updates to gestalt-module - Reflections reflections = (Reflections) ReflectionUtil.readField(moduleEnvironment, "fullReflections"); - return withDefaultHandlers(reflections); + TypeHandlerLibrary library = new TypeHandlerLibrary(moduleEnvironment); + + populateWithDefaultHandlers(library); + + return library; } private static void populateWithDefaultHandlers(TypeHandlerLibrary serializationLibrary) { From cad41d839adaba9cab901d6f005f5ba51aa1f83e Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Mon, 22 Jul 2019 17:49:31 +0530 Subject: [PATCH 119/141] Add TypeHandlerLibrary.getBaseTypeHandler --- .../typeHandling/TypeHandlerLibraryTest.java | 8 + .../RuntimeDelegatingTypeHandlerTest.java | 180 +++++++++++------- .../typeHandling/TypeHandlerLibrary.java | 15 ++ 3 files changed, 132 insertions(+), 71 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java index 439820e56ed..06bcd243e6e 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/TypeHandlerLibraryTest.java @@ -20,6 +20,7 @@ import org.terasology.persistence.typeHandling.coreTypes.CollectionTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.EnumTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ObjectFieldMapTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringMapTypeHandler; import org.terasology.reflection.MappedContainer; import org.terasology.reflection.TypeInfo; @@ -89,4 +90,11 @@ public void testInvalidTypeHandler() { assertFalse(handler.isPresent()); } + + @Test + public void testGetBaseTypeHandler() { + TypeHandler handler = typeHandlerLibrary.getBaseTypeHandler(TypeInfo.of(Integer.class)); + + assertTrue(handler instanceof RuntimeDelegatingTypeHandler); + } } diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 24d6b1db712..91be78dc305 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -17,20 +17,17 @@ import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; +import org.junit.Assert; import org.junit.Test; import org.mockito.ArgumentMatcher; import org.reflections.Reflections; -import org.reflections.util.ConfigurationBuilder; import org.terasology.persistence.typeHandling.*; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; -import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; import org.terasology.persistence.typeHandling.inMemory.AbstractPersistedData; import org.terasology.persistence.typeHandling.inMemory.PersistedMap; import org.terasology.persistence.typeHandling.inMemory.PersistedString; import org.terasology.persistence.typeHandling.reflection.ReflectionsSandbox; import org.terasology.reflection.TypeInfo; -import org.terasology.reflection.reflect.ConstructorLibrary; import java.lang.reflect.Type; import java.util.ArrayList; @@ -41,16 +38,16 @@ import static org.mockito.Mockito.*; public class RuntimeDelegatingTypeHandlerTest { - private final ConstructorLibrary constructorLibrary = - new ConstructorLibrary(Maps.newHashMap()); - - private final CollectionTypeHandlerFactory collectionHandlerFactory = - new CollectionTypeHandlerFactory(constructorLibrary); - private final TypeHandlerLibrary typeHandlerLibrary = mock(TypeHandlerLibrary.class); private final TypeHandlerContext context = - new TypeHandlerContext(typeHandlerLibrary, new ReflectionsSandbox(new Reflections(getClass().getClassLoader()))); + new TypeHandlerContext(typeHandlerLibrary, new ReflectionsSandbox(new Reflections(getClass().getClassLoader()))); + + private TypeHandler baseTypeHandler; + private TypeHandler subTypeHandler; + private Class subType; + private Type baseType; + private RuntimeDelegatingTypeHandler runtimeDelegatingTypeHandler; private static class Base { int x; @@ -60,45 +57,22 @@ private static class Sub extends Base { float y; } - @Test - public void testSerialize() { - PersistedDataSerializer serializer = mock(PersistedDataSerializer.class); - when(serializer.serialize(any(String.class))) - .then(invocation -> new PersistedString((String) invocation.getArguments()[0])); - - Class subType = Sub.class; - Type baseType = TypeInfo.of(Base.class).getType(); + private void setupHandlers() { + subType = Sub.class; + baseType = TypeInfo.of(Base.class).getType(); abstract class SubHandler extends TypeHandler {} - TypeHandler baseTypeHandler = mockTypeHandler(); - TypeHandler subTypeHandler = mockTypeHandler(SubHandler.class); + baseTypeHandler = mockTypeHandler(); + subTypeHandler = mockTypeHandler(SubHandler.class); when(typeHandlerLibrary.getTypeHandler(eq(baseType))) - .thenReturn(Optional.of(baseTypeHandler)); + .thenReturn(Optional.of(baseTypeHandler)); when(typeHandlerLibrary.getTypeHandler(eq((Type) subType))) - .thenReturn(Optional.of(subTypeHandler)); - - TypeHandler> listTypeHandler = - collectionHandlerFactory.create(new TypeInfo>() {}, context).get(); - - ArrayList bases = Lists.newArrayList(new Sub(), new Base(), new Sub(), new Base(), new Sub()); - listTypeHandler.serialize(bases, serializer); - - verify(typeHandlerLibrary).getTypeHandler(eq(baseType)); - verify(typeHandlerLibrary, times(3)).getTypeHandler(eq((Type) subType)); - - verify(baseTypeHandler, times(2)).serialize(any(), any()); - verify(subTypeHandler, times(3)).serialize(any(), any()); + .thenReturn(Optional.of(subTypeHandler)); - verify(serializer, times(3)).serialize( - argThat((ArgumentMatcher>) argument -> - argument.get(RuntimeDelegatingTypeHandler.TYPE_FIELD) - .getAsString() - .equals(subType.getName()) && - argument.containsKey(RuntimeDelegatingTypeHandler.VALUE_FIELD)) - ); + runtimeDelegatingTypeHandler = new RuntimeDelegatingTypeHandler(baseTypeHandler, TypeInfo.of(Base.class), context); } private static TypeHandler mockTypeHandler(Class subHandlerClass) { @@ -119,49 +93,113 @@ private static TypeHandler mockTypeHandler() { } @Test - public void testDeserialize() { - Type subType = Sub.class; - Type baseType = TypeInfo.of(Base.class).getType(); + public void testSerializeBase() { + PersistedDataSerializer serializer = mock(PersistedDataSerializer.class); + when(serializer.serialize(any(String.class))) + .then(invocation -> new PersistedString((String) invocation.getArguments()[0])); - abstract class SubHandler extends TypeHandler {} + setupHandlers(); - TypeHandler baseTypeHandler = mock(TypeHandler.class); - TypeHandler subTypeHandler = mock(SubHandler.class); + Base base = new Base(); + runtimeDelegatingTypeHandler.serialize(base, serializer); - when(typeHandlerLibrary.getTypeHandler(eq(baseType))) - .thenReturn(Optional.of(baseTypeHandler)); + verify(typeHandlerLibrary, never()).getTypeHandler(eq((Type) subType)); - when(typeHandlerLibrary.getTypeHandler(eq(subType))) - .thenReturn(Optional.of(subTypeHandler)); + verify(baseTypeHandler).serialize(any(), any()); + verify(subTypeHandler, never()).serialize(any(), any()); - TypeHandler> listTypeHandler = collectionHandlerFactory.create( - new TypeInfo>() {}, context - ).get(); + verify(serializer, never()).serialize( + argThat((ArgumentMatcher>) argument -> { + return argument.containsKey(RuntimeDelegatingTypeHandler.TYPE_FIELD); + }) + ); + } + + @Test + public void testSerializeSub() { + PersistedDataSerializer serializer = mock(PersistedDataSerializer.class); + when(serializer.serialize(any(String.class))) + .then(invocation -> new PersistedString((String) invocation.getArguments()[0])); + + setupHandlers(); + + Base sub = new Sub(); + runtimeDelegatingTypeHandler.serialize(sub, serializer); + + verify(typeHandlerLibrary, never()).getTypeHandler(eq(baseType)); + verify(typeHandlerLibrary).getTypeHandler(eq((Type) subType)); + + verify(baseTypeHandler, never()).serialize(any(), any()); + verify(subTypeHandler).serialize(any(), any()); + + verify(serializer).serialize( + argThat((ArgumentMatcher>) argument -> { + return argument.get(RuntimeDelegatingTypeHandler.TYPE_FIELD) + .getAsString() + .equals(subType.getName()) && + argument.containsKey(RuntimeDelegatingTypeHandler.VALUE_FIELD); + }) + ); + } + + @Test + public void testDeserializeBase() { + setupHandlers(); PersistedData persistedBase = new PersistedMap(ImmutableMap.of()); + runtimeDelegatingTypeHandler.deserialize(persistedBase); + + verify(typeHandlerLibrary, never()).getTypeHandler(eq((Type) subType)); + + verify(baseTypeHandler).deserialize(any()); + verify(subTypeHandler, never()).deserialize(any()); + } + + @Test + public void testDeserializeSub() { + setupHandlers(); + PersistedData persistedSub = new PersistedMap( - ImmutableMap.of( - RuntimeDelegatingTypeHandler.TYPE_FIELD, - new PersistedString(((Class) subType).getName()), - RuntimeDelegatingTypeHandler.VALUE_FIELD, - new PersistedMap(ImmutableMap.of()) - ) + ImmutableMap.of( + RuntimeDelegatingTypeHandler.TYPE_FIELD, + new PersistedString(((Class) subType).getName()), + RuntimeDelegatingTypeHandler.VALUE_FIELD, + new PersistedMap(ImmutableMap.of()) + ) ); - PersistedDataArray persistedBases = mock(PersistedDataArray.class); - when(persistedBases.isArray()).thenReturn(true); - when(persistedBases.getAsArray()).thenReturn(persistedBases); - when(persistedBases.iterator()).thenReturn( - Lists.newArrayList(persistedSub, persistedBase, persistedSub, persistedBase, persistedSub).iterator() + runtimeDelegatingTypeHandler.deserialize(persistedSub); + + verify(typeHandlerLibrary, never()).getTypeHandler(eq(baseType)); + verify(typeHandlerLibrary).getTypeHandler(eq((Type) subType)); + + verify(baseTypeHandler, never()).deserialize(any()); + verify(subTypeHandler).deserialize(any()); + } + + @Test + public void testDeserializeNonSub() { + setupHandlers(); + + PersistedData persistedData = new PersistedMap( + ImmutableMap.of( + RuntimeDelegatingTypeHandler.TYPE_FIELD, + new PersistedString(Integer.class.getName()), + RuntimeDelegatingTypeHandler.VALUE_FIELD, + new PersistedMap(ImmutableMap.of()) + ) ); - listTypeHandler.deserialize(persistedBases); + Optional deserialized = runtimeDelegatingTypeHandler.deserialize(persistedData); + + Assert.assertFalse(deserialized.isPresent()); - verify(typeHandlerLibrary).getTypeHandler(eq(baseType)); - verify(typeHandlerLibrary, times(3)).getTypeHandler(eq(subType)); + verify(typeHandlerLibrary, never()).getTypeHandler(eq(baseType)); + verify(typeHandlerLibrary, never()).getTypeHandler(eq((Type) subType)); + verify(typeHandlerLibrary, never()).getTypeHandler(eq((Type) Integer.class)); - verify(baseTypeHandler, times(2)).deserialize(any()); - verify(subTypeHandler, times(3)).deserialize(any()); + verify(baseTypeHandler, never()).deserialize(any()); + verify(subTypeHandler, never()).deserialize(any()); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index c116212a4e0..42551e66431 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -40,6 +40,7 @@ import org.terasology.persistence.typeHandling.coreTypes.IntTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.LongTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.NumberTypeHandler; +import org.terasology.persistence.typeHandling.coreTypes.RuntimeDelegatingTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.StringTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.factories.ArrayTypeHandlerFactory; import org.terasology.persistence.typeHandling.coreTypes.factories.CollectionTypeHandlerFactory; @@ -388,6 +389,20 @@ public Optional> getTypeHandler(TypeInfo type) { } } + /** + * Returns a {@link TypeHandler} that can handle all types deriving from {@link T}. + * + * @param typeInfo The {@link TypeInfo} describing the base type for which to return a + * {@link TypeHandler}. + * @param The base type for which to return a {@link TypeHandler}. + */ + public TypeHandler getBaseTypeHandler(TypeInfo typeInfo) { + TypeHandler delegateHandler = getTypeHandler(typeInfo).orElse(null); + + TypeHandlerContext context = new TypeHandlerContext(this, sandbox); + return new RuntimeDelegatingTypeHandler<>(delegateHandler, typeInfo, context); + } + private Map, TypeHandler> getFieldHandlerMap(ClassMetadata type) { Map, TypeHandler> handlerMap = Maps.newHashMap(); for (FieldMetadata field : type.getFields()) { From a88959688e14c87bc3fb6ddc1e9c7213288af87e Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 23 Jul 2019 15:28:01 +0530 Subject: [PATCH 120/141] Handle builtin types in ModuleEnvironmentSandbox.isValidHandlerDeclaration --- .../typeHandling/reflection/ModuleEnvironmentSandbox.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 7830effb541..76a4a834f26 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -102,9 +102,15 @@ public String getSubTypeIdentifier(Class subType, Class base @Override public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler) { - Name moduleDeclaringType = moduleEnvironment.getModuleProviding(type.getRawType()); Name moduleDeclaringHandler = moduleEnvironment.getModuleProviding(typeHandler.getClass()); + if (type.getRawType().getClassLoader() == null) { + // Modules cannot specify handlers for builtin classes + return moduleDeclaringHandler == null; + } + + Name moduleDeclaringType = moduleEnvironment.getModuleProviding(type.getRawType()); + // Both the type and the handler must come from the same module return Objects.equals(moduleDeclaringType, moduleDeclaringHandler); } From f2172041b98599067176fefd1585523ec351336a Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 23 Jul 2019 22:01:01 +0530 Subject: [PATCH 121/141] Fix ModuleEnvSandbox.isValidHandler method --- .../typeHandling/reflection/ModuleEnvironmentSandbox.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 76a4a834f26..624638ab48c 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -106,7 +106,7 @@ public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler Date: Wed, 24 Jul 2019 13:22:12 +0530 Subject: [PATCH 122/141] Document sandbox, Check factory generated handlers for validity --- .../typeHandling/TypeHandlerLibrary.java | 4 +++ .../reflection/SerializationSandbox.java | 34 ++++++++++++++++--- 2 files changed, 34 insertions(+), 4 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 42551e66431..c868d87f08d 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -372,6 +372,10 @@ public Optional> getTypeHandler(TypeInfo type) { if (typeHandler.isPresent()) { TypeHandler handler = typeHandler.get(); + if (!sandbox.isValidTypeHandlerDeclaration(type, handler)) { + continue; + } + typeHandlerCache.put(type, handler); future.typeHandler = handler; diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java index b631acd0d8f..a6f2aed8a03 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/SerializationSandbox.java @@ -20,17 +20,43 @@ import java.util.Optional; +/** + * Provides an interface to the sandboxed environment that serialization may be performed in. + * This allows serialization to load types according to the rules specified in the sandbox it + * is being executed in. + */ public interface SerializationSandbox { /** + * Finds a subtype of {@link T} with the given identifier. If zero or more than one + * subtypes are identified by the given identifier, {@link Optional#empty()} is returned. * - * @param subTypeIdentifier - * @param clazz - * @param - * @return + * @param subTypeIdentifier The identifier of the subtype to look up + * @param clazz The {@link Class} of the base type whose subtype is to be found. + * @param The base type whose subtype is to be found. + * @return An {@link Optional} containing the unique subtype of {@link T}, if found. */ Optional> findSubTypeOf(String subTypeIdentifier, Class clazz); + /** + * Returns a unique identifier of the given subtype of the given base type. This method is + * guaranteed to not return the same identifier for any other subtype of the given base type. + * + * @param subType The {@link Class} specifying the subtype which is to be identified. + * @param baseType The {@link Class} specifying the base type. + * @param The base type whose subtype needs to be identified. + * @return The unique identifier for {@code subType}. + */ String getSubTypeIdentifier(Class subType, Class baseType); + /** + * Checks whether the given {@link TypeHandler} should be allowed to handle instances of + * the given type according to the rules in the sandbox. + * + * @param type The {@link TypeInfo} describing {@link T}. + * @param typeHandler An instance of the {@link TypeHandler} implementation that handles + * instances of type {@link T}. + * @param The type being handled by the {@link TypeHandler}. + * @return True if the sandbox allows this handler implementation, false otherwise. + */ boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler); } From 0352f8efa1a24d230d9ae702c1ca6c12a454e569 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 24 Jul 2019 21:25:14 +0530 Subject: [PATCH 123/141] Allow non-module handlers by default in serialization sandbox --- .../reflection/ModuleEnvironmentSandbox.java | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 624638ab48c..3b13cdf09d9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -104,9 +104,17 @@ public String getSubTypeIdentifier(Class subType, Class base public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler) { Name moduleDeclaringHandler = moduleEnvironment.getModuleProviding(typeHandler.getClass()); + // If handler was declared outside of a module (engine or somewhere else), we allow it + // TODO: Possibly find better way to refer to engine module + if (moduleDeclaringHandler == null || moduleDeclaringHandler.equals(new Name("engine"))) { + return true; + } + + // Handler has been declared in a module, proceed accordingly + if (type.getRawType().getClassLoader() == null) { // Modules cannot specify handlers for builtin classes - return moduleDeclaringHandler == null || moduleDeclaringHandler.equals(new Name("engine")); + return false; } Name moduleDeclaringType = moduleEnvironment.getModuleProviding(type.getRawType()); From d1e4537fa763dc142716c9b297cf5d297e0144c4 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Jul 2019 10:50:34 +0530 Subject: [PATCH 124/141] Better error handling in RuntimeDelegatingTypeHandler --- .../RuntimeDelegatingTypeHandler.java | 46 ++++++++++++++----- 1 file changed, 35 insertions(+), 11 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 4a4e10c8205..617a7316338 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -69,7 +69,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize return delegateHandler.serialize(value, serializer); } - LOGGER.error("Primitive {} does not have a TypeHandler", typeInfo.getRawType().getName()); + LOGGER.error("Primitive '{}' does not have a TypeHandler", typeInfo); return serializer.serializeNull(); } @@ -102,12 +102,13 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize } if (chosenHandler == null) { - LOGGER.error("Could not find appropriate TypeHandler for runtime type {}", runtimeType); - return serializer.serializeNull(); + LOGGER.warn("Could not find appropriate TypeHandler for runtime type '{}', " + + "serializing as base type '{}'", runtimeType, typeInfo); + return serializeViaDelegate(value, serializer); } if (chosenHandler == delegateHandler) { - return delegateHandler.serialize(value, serializer); + return serializeViaDelegate(value, serializer); } Map typeValuePersistedDataMap = Maps.newLinkedHashMap(); @@ -138,6 +139,15 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize return serializer.serialize(typeValuePersistedDataMap); } + private PersistedData serializeViaDelegate(T value, PersistedDataSerializer serializer) { + if (delegateHandler == null) { + LOGGER.error("Base type '{}' does not have a handler", typeInfo); + return serializer.serializeNull(); + } + + return delegateHandler.serialize(value, serializer); + } + private Type getRuntimeTypeIfMoreSpecific(T value) { if (value == null) { return typeInfo.getType(); @@ -150,13 +160,13 @@ private Type getRuntimeTypeIfMoreSpecific(T value) { @Override public Optional deserialize(PersistedData data) { if (!data.isValueMap()) { - return delegateHandler.deserialize(data); + return deserializeViaDelegate(data); } PersistedDataMap valueMap = data.getAsValueMap(); if (!valueMap.has(TYPE_FIELD)) { - return delegateHandler.deserialize(data); + return deserializeViaDelegate(data); } String runtimeTypeName = valueMap.getAsString(TYPE_FIELD); @@ -164,17 +174,21 @@ public Optional deserialize(PersistedData data) { Optional typeToDeserializeAs = findSubtypeWithName(runtimeTypeName); if (!typeToDeserializeAs.isPresent()) { - LOGGER.error("Cannot find class to deserialize {}", runtimeTypeName); - return Optional.empty(); + LOGGER.warn("Cannot find subtype '{}' to deserialize as, " + + "deserializing as base type '{}'", + runtimeTypeName, + typeInfo + ); + return deserializeViaDelegate(data); } TypeHandler runtimeTypeHandler = (TypeHandler) typeHandlerLibrary.getTypeHandler(typeToDeserializeAs.get()) // To avoid compile errors in the orElseGet .map(typeHandler -> (TypeHandler) typeHandler) .orElseGet(() -> { - LOGGER.warn("Cannot find TypeHandler for runtime class {}, " + - "deserializing as base class {}", - runtimeTypeName, typeInfo.getRawType().getName()); + LOGGER.warn("Cannot find TypeHandler for runtime type '{}', " + + "deserializing as base type '{}'", + runtimeTypeName, typeInfo); return delegateHandler; }); @@ -206,6 +220,16 @@ public Optional deserialize(PersistedData data) { } + private Optional deserializeViaDelegate(PersistedData data) { + if (delegateHandler == null) { + LOGGER.error("Base type '{}' does not have a handler and no subtype information " + + "was found in the serialized form {}", typeInfo, data); + return Optional.empty(); + } + + return delegateHandler.deserialize(data); + } + private Optional findSubtypeWithName(String runtimeTypeName) { return sandbox.findSubTypeOf(runtimeTypeName, typeInfo.getRawType()) .map(runtimeClass -> From ff59080ef820c869e29b949a9ce983864068bbe5 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Jul 2019 10:59:03 +0530 Subject: [PATCH 125/141] Use ModuleContext in ModuleEnvironmentSandbox --- .../reflection/ModuleEnvironmentSandbox.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 3b13cdf09d9..92713f1f3d1 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -21,6 +21,7 @@ import org.terasology.engine.SimpleUri; import org.terasology.module.ModuleEnvironment; import org.terasology.naming.Name; +import org.terasology.persistence.ModuleContext; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.reflection.TypeInfo; @@ -77,7 +78,15 @@ private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { } } - return subTypeName.toString().equals((subclass.getName())) || subTypeName.toString().equals((subclass.getSimpleName())); + boolean fullNameEquals = subTypeName.toString().equals((subclass.getName())); + + if (fullNameEquals) { + return true; + } + + // Assume that the requested subtype is in the context module + Name contextModule = ModuleContext.getContext() != null ? ModuleContext.getContext().getId() : null; + return Objects.equals(contextModule, providingModule) && subTypeName.toString().equals(subclass.getSimpleName()); } @Override From d0a033a967836b003be2a54dfbe5b89ba35b9986 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Jul 2019 12:19:18 +0530 Subject: [PATCH 126/141] Fix RuntimeDelegatingTypeHandler non-sub deserialization test --- .../coreTypes/RuntimeDelegatingTypeHandlerTest.java | 3 ++- .../coreTypes/RuntimeDelegatingTypeHandler.java | 7 +++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java index 91be78dc305..23993bed5c9 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandlerTest.java @@ -199,7 +199,8 @@ public void testDeserializeNonSub() { verify(typeHandlerLibrary, never()).getTypeHandler(eq((Type) subType)); verify(typeHandlerLibrary, never()).getTypeHandler(eq((Type) Integer.class)); - verify(baseTypeHandler, never()).deserialize(any()); verify(subTypeHandler, never()).deserialize(any()); + // Serializes using base type handler + verify(baseTypeHandler).deserialize(any()); } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 617a7316338..18850dadb43 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -222,8 +222,11 @@ public Optional deserialize(PersistedData data) { private Optional deserializeViaDelegate(PersistedData data) { if (delegateHandler == null) { - LOGGER.error("Base type '{}' does not have a handler and no subtype information " + - "was found in the serialized form {}", typeInfo, data); + LOGGER.error("Base type '{}' does not have a handler and no \"{}\" field " + + "was found in the serialized form {}", + typeInfo, + TYPE_FIELD, + data); return Optional.empty(); } From 644fcff2892b5d09739b08422b81f64070255596 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Jul 2019 18:14:33 +0530 Subject: [PATCH 127/141] Add RegisterTypeHandlerFactory annotation --- .../bootstrap/EnvironmentSwitchHandler.java | 12 ++++++ .../RegisterTypeHandlerFactory.java | 38 +++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandlerFactory.java diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java index b5805eba8d6..6dcc3400091 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EnvironmentSwitchHandler.java @@ -35,7 +35,9 @@ import org.terasology.entitySystem.systems.internal.DoNotAutoRegister; import org.terasology.module.ModuleEnvironment; import org.terasology.persistence.typeHandling.RegisterTypeHandler; +import org.terasology.persistence.typeHandling.RegisterTypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeHandler; +import org.terasology.persistence.typeHandling.TypeHandlerFactory; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.CollisionGroupTypeHandler; import org.terasology.physics.CollisionGroup; @@ -188,5 +190,15 @@ private static void registerTypeHandlers(Context context, TypeHandlerLibrary lib } } } + + for (Class clazz : environment.getSubtypesOf(TypeHandlerFactory.class)) { + if (!clazz.isAnnotationPresent(RegisterTypeHandlerFactory.class)) { + continue; + } + + TypeHandlerFactory instance = InjectionHelper.createWithConstructorInjection(clazz, context); + InjectionHelper.inject(instance, context); + library.addTypeHandlerFactory(instance); + } } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandlerFactory.java b/engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandlerFactory.java new file mode 100644 index 00000000000..9dc866e21c3 --- /dev/null +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/RegisterTypeHandlerFactory.java @@ -0,0 +1,38 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.persistence.typeHandling; + + +import org.terasology.module.sandbox.API; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Marks a {@link TypeHandlerFactory} to be automatically registered to the + * {@link TypeHandlerLibrary} on environment change. + * This can be used to (de)serialize custom components. + *

    + * The {@link org.terasology.registry.In} annotation can be used to access objects + * in the parent {@link org.terasology.context.Context}. + */ +@API +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +public @interface RegisterTypeHandlerFactory { +} From b4acfaa949ed8bf59f5dc2c4ef58db92467e7736 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Jul 2019 21:08:56 +0530 Subject: [PATCH 128/141] Use ModuleManager instead of environment in ModEnvSandbox --- .../TerasologyTestingEnvironment.java | 2 +- .../internal/StorageManagerTest.java | 7 +++++- .../recording/EventSystemReplayImplTest.java | 5 ++-- .../terasology/engine/TerasologyEngine.java | 3 +-- .../bootstrap/EntitySystemSetupUtil.java | 9 ++++---- .../typeHandling/TypeHandlerLibrary.java | 9 ++++---- .../reflection/ModuleEnvironmentSandbox.java | 23 +++++++++++-------- .../recording/RecordAndReplaySerializer.java | 5 ++-- .../recording/RecordedEventSerializer.java | 5 ++-- 9 files changed, 41 insertions(+), 27 deletions(-) diff --git a/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java b/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java index 0a4aaaaa748..56698402563 100644 --- a/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java +++ b/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java @@ -104,7 +104,7 @@ public void setup() throws Exception { context.put(CharacterStateEventPositionMap.class, characterStateEventPositionMap); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = new DirectionAndOriginPosRecorderList(); context.put(DirectionAndOriginPosRecorderList.class, directionAndOriginPosRecorderList); - RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(engineEntityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager.getEnvironment()); + RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(engineEntityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); context.put(RecordAndReplaySerializer.class, recordAndReplaySerializer); Path savePath = PathManager.getInstance().getSavePath("world1"); diff --git a/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java b/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java index 74e26a39f42..fc5a27855a4 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java @@ -28,6 +28,7 @@ import org.terasology.assets.ResourceUrn; import org.terasology.assets.management.AssetManager; import org.terasology.engine.bootstrap.EntitySystemSetupUtil; +import org.terasology.engine.module.ModuleManager; import org.terasology.engine.paths.PathManager; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.EngineEntityManager; @@ -112,11 +113,15 @@ public void setup() throws Exception { blockManager = context.get(BlockManager.class); extraDataManager = context.get(ExtraBlockDataManager.class); + ModuleManager moduleManager = mock(ModuleManager.class); + + when(moduleManager.getEnvironment()).thenReturn(moduleEnvironment); + RecordedEventStore recordedEventStore = new RecordedEventStore(); recordAndReplayUtils = new RecordAndReplayUtils(); CharacterStateEventPositionMap characterStateEventPositionMap = new CharacterStateEventPositionMap(); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = new DirectionAndOriginPosRecorderList(); - recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleEnvironment); + recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); recordAndReplayCurrentStatus = context.get(RecordAndReplayCurrentStatus.class); diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 78b9b627f27..59e92cddcbc 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -21,6 +21,7 @@ import org.junit.Test; import org.reflections.Reflections; import org.terasology.context.internal.ContextImpl; +import org.terasology.engine.module.ModuleManager; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.PojoEntityManager; import org.terasology.entitySystem.event.AbstractConsumableEvent; @@ -73,9 +74,9 @@ public void setup() { RecordAndReplayUtils recordAndReplayUtils = new RecordAndReplayUtils(); CharacterStateEventPositionMap characterStateEventPositionMap = new CharacterStateEventPositionMap(); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = new DirectionAndOriginPosRecorderList(); - ModuleEnvironment moduleEnvironment = mock(ModuleEnvironment.class); + ModuleManager moduleManager = mock(ModuleManager.class); RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, eventStore, - recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleEnvironment); + recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); recordAndReplayCurrentStatus.setStatus(RecordAndReplayStatus.REPLAYING); entity = entityManager.create(); Long id = entity.getId(); diff --git a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java index 14cc9b23196..6a28a66172c 100644 --- a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java +++ b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java @@ -317,8 +317,7 @@ private void initManagers() { CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); rootContext.put(CopyStrategyLibrary.class, copyStrategyLibrary); - ModuleEnvironment environment = moduleManager.getEnvironment(); - rootContext.put(TypeHandlerLibrary.class, TypeHandlerLibrary.forModuleEnvironment(environment)); + rootContext.put(TypeHandlerLibrary.class, TypeHandlerLibrary.forModuleEnvironment(moduleManager)); changeStatus(TerasologyEngineStatus.INITIALIZING_ASSET_TYPES); assetTypeManager = new ModuleAwareAssetTypeManager(); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java index d94db5ccb39..77ba5011923 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java @@ -75,8 +75,8 @@ public static void addReflectionBasedLibraries(Context context) { CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); context.put(CopyStrategyLibrary.class, copyStrategyLibrary); - ModuleEnvironment moduleEnvironment = context.get(ModuleManager.class).getEnvironment(); - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleEnvironment); + ModuleManager moduleManager = context.get(ModuleManager.class); + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager); context.put(TypeHandlerLibrary.class, typeHandlerLibrary); EntitySystemLibrary library = new EntitySystemLibrary(context, typeHandlerLibrary); @@ -106,7 +106,8 @@ public static void addReflectionBasedLibraries(Context context) { * */ public static void addEntityManagementRelatedClasses(Context context) { - ModuleEnvironment environment = context.get(ModuleManager.class).getEnvironment(); + ModuleManager moduleManager = context.get(ModuleManager.class); + ModuleEnvironment environment = moduleManager.getEnvironment(); NetworkSystem networkSystem = context.get(NetworkSystem.class); // Entity Manager @@ -133,7 +134,7 @@ public static void addEntityManagementRelatedClasses(Context context) { CharacterStateEventPositionMap characterStateEventPositionMap = context.get(CharacterStateEventPositionMap.class); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = context.get(DirectionAndOriginPosRecorderList.class); RecordedEventStore recordedEventStore = new RecordedEventStore(); - RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, environment); + RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); context.put(RecordAndReplaySerializer.class, recordAndReplaySerializer); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index c868d87f08d..962b463090b 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -21,6 +21,7 @@ import org.reflections.Reflections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.terasology.engine.module.ModuleManager; import org.terasology.entitySystem.prefab.Prefab; import org.terasology.math.IntegerRange; import org.terasology.math.geom.Quat4f; @@ -147,8 +148,8 @@ public TypeHandlerLibrary(Reflections reflections) { this(new ReflectionsSandbox(reflections)); } - public TypeHandlerLibrary(ModuleEnvironment moduleEnvironment) { - this(new ModuleEnvironmentSandbox(moduleEnvironment)); + public TypeHandlerLibrary(ModuleManager moduleManager) { + this(new ModuleEnvironmentSandbox(moduleManager)); } /** @@ -171,8 +172,8 @@ public static TypeHandlerLibrary withReflections(Reflections reflections) { return library; } - public static TypeHandlerLibrary forModuleEnvironment(ModuleEnvironment moduleEnvironment) { - TypeHandlerLibrary library = new TypeHandlerLibrary(moduleEnvironment); + public static TypeHandlerLibrary forModuleEnvironment(ModuleManager moduleManager) { + TypeHandlerLibrary library = new TypeHandlerLibrary(moduleManager); populateWithDefaultHandlers(library); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 92713f1f3d1..b4058114b92 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -19,6 +19,7 @@ import com.google.common.collect.Iterables; import com.google.common.collect.Streams; import org.terasology.engine.SimpleUri; +import org.terasology.engine.module.ModuleManager; import org.terasology.module.ModuleEnvironment; import org.terasology.naming.Name; import org.terasology.persistence.ModuleContext; @@ -32,17 +33,21 @@ import static com.google.common.collect.Streams.stream; public class ModuleEnvironmentSandbox implements SerializationSandbox { - private final ModuleEnvironment moduleEnvironment; + private final ModuleManager moduleManager; - public ModuleEnvironmentSandbox(ModuleEnvironment moduleEnvironment) { - this.moduleEnvironment = moduleEnvironment; + public ModuleEnvironmentSandbox(ModuleManager moduleManager) { + this.moduleManager = moduleManager; + } + + private ModuleEnvironment getModuleEnvironment() { + return moduleManager.getEnvironment(); } @Override public Optional> findSubTypeOf(String subTypeIdentifier, Class clazz) { Iterator> possibilities = - moduleEnvironment + getModuleEnvironment() .getSubtypesOf(clazz, subclass -> doesSubclassMatch(subclass, subTypeIdentifier)) .iterator(); @@ -69,7 +74,7 @@ private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { SimpleUri subTypeUri = new SimpleUri(subTypeIdentifier); Name subTypeName = subTypeUri.isValid() ? subTypeUri.getObjectName() : new Name(subTypeIdentifier); - Name providingModule = moduleEnvironment.getModuleProviding(subclass); + Name providingModule = getModuleEnvironment().getModuleProviding(subclass); if (subTypeUri.isValid()) { @@ -93,7 +98,7 @@ private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { public String getSubTypeIdentifier(Class subType, Class baseType) { SimpleUri subTypeUri = getTypeSimpleUri(subType); - long subTypesWithSameUri = Streams.stream(moduleEnvironment.getSubtypesOf(baseType)) + long subTypesWithSameUri = Streams.stream(getModuleEnvironment().getSubtypesOf(baseType)) .map(this::getTypeSimpleUri) .filter(subTypeUri::equals) .count(); @@ -111,7 +116,7 @@ public String getSubTypeIdentifier(Class subType, Class base @Override public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler) { - Name moduleDeclaringHandler = moduleEnvironment.getModuleProviding(typeHandler.getClass()); + Name moduleDeclaringHandler = getModuleEnvironment().getModuleProviding(typeHandler.getClass()); // If handler was declared outside of a module (engine or somewhere else), we allow it // TODO: Possibly find better way to refer to engine module @@ -126,14 +131,14 @@ public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler type) { - Name moduleProvidingType = moduleEnvironment.getModuleProviding(type); + Name moduleProvidingType = getModuleEnvironment().getModuleProviding(type); String typeSimpleName = type.getSimpleName(); return new SimpleUri(moduleProvidingType, typeSimpleName); diff --git a/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java b/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java index 8ce81097d07..806dc42d6a1 100644 --- a/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java @@ -23,6 +23,7 @@ import com.google.gson.stream.JsonWriter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.terasology.engine.module.ModuleManager; import org.terasology.engine.paths.PathManager; import org.terasology.entitySystem.entity.EntityManager; import org.terasology.math.geom.Vector3f; @@ -55,12 +56,12 @@ public final class RecordAndReplaySerializer { public RecordAndReplaySerializer(EntityManager manager, RecordedEventStore store, RecordAndReplayUtils recordAndReplayUtils, CharacterStateEventPositionMap characterStateEventPositionMap, - DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList, ModuleEnvironment moduleEnvironment) { + DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList, ModuleManager moduleManager) { this.recordedEventStore = store; this.recordAndReplayUtils = recordAndReplayUtils; this.characterStateEventPositionMap = characterStateEventPositionMap; this.directionAndOriginPosRecorderList = directionAndOriginPosRecorderList; - this.recordedEventSerializer = new RecordedEventSerializer(manager, moduleEnvironment); + this.recordedEventSerializer = new RecordedEventSerializer(manager, moduleManager); } /** diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 5e4d9190fe3..14fe420e4db 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -17,6 +17,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.terasology.engine.module.ModuleManager; import org.terasology.entitySystem.entity.EntityManager; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.EngineEntityManager; @@ -44,8 +45,8 @@ class RecordedEventSerializer { private GsonSerializer gsonSerializer; - public RecordedEventSerializer(EntityManager entityManager, ModuleEnvironment moduleEnvironment) { - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleEnvironment); + public RecordedEventSerializer(EntityManager entityManager, ModuleManager moduleManager) { + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager); typeHandlerLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); gsonSerializer = new GsonSerializer(typeHandlerLibrary); From b08d52a40940fc9a389c459e303398ad46bc3a77 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Jul 2019 21:38:13 +0530 Subject: [PATCH 129/141] Fix ModuleEnvironmentSandbox.doesSubclassMatch --- .../reflection/ModuleEnvironmentSandbox.java | 25 ++++++++++--------- 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index b4058114b92..17d77d387e2 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -74,24 +74,25 @@ private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { SimpleUri subTypeUri = new SimpleUri(subTypeIdentifier); Name subTypeName = subTypeUri.isValid() ? subTypeUri.getObjectName() : new Name(subTypeIdentifier); - Name providingModule = getModuleEnvironment().getModuleProviding(subclass); - - - if (subTypeUri.isValid()) { - if (!subTypeUri.getModuleName().equals(providingModule)) { - return false; - } - } - + // First check full name boolean fullNameEquals = subTypeName.toString().equals((subclass.getName())); if (fullNameEquals) { return true; } - // Assume that the requested subtype is in the context module - Name contextModule = ModuleContext.getContext() != null ? ModuleContext.getContext().getId() : null; - return Objects.equals(contextModule, providingModule) && subTypeName.toString().equals(subclass.getSimpleName()); + // Now check through module and simple name + Name providingModule = getModuleEnvironment().getModuleProviding(subclass); + Name givenModuleName; + + if (subTypeUri.isValid()) { + givenModuleName = subTypeUri.getModuleName(); + } else { + // Assume that the requested subtype is in the context module + givenModuleName = ModuleContext.getContext() != null ? ModuleContext.getContext().getId() : null; + } + + return Objects.equals(givenModuleName, providingModule) && subTypeName.toString().equals(subclass.getSimpleName()); } @Override From b362b2e39e60b10dd3c978891498282d0bdd3c13 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Tue, 30 Jul 2019 23:43:17 +0530 Subject: [PATCH 130/141] Fix NPE in ModuleEnvironmentSandbox --- .../coreTypes/RuntimeDelegatingTypeHandler.java | 2 +- .../reflection/ModuleEnvironmentSandbox.java | 15 +++++++++------ 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 18850dadb43..b6213f3c467 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -64,7 +64,7 @@ public RuntimeDelegatingTypeHandler(TypeHandler delegateHandler, TypeInfo @Override public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { // If primitive, don't go looking for the runtime type, serialize as is - if (typeInfo.getRawType().isPrimitive()) { + if (typeInfo.getRawType().isPrimitive() || Number.class.isAssignableFrom(typeInfo.getRawType())) { if (delegateHandler != null) { return delegateHandler.serialize(value, serializer); } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 17d77d387e2..00f35c31a44 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.reflection; import com.google.common.base.Preconditions; -import com.google.common.collect.Iterables; import com.google.common.collect.Streams; import org.terasology.engine.SimpleUri; import org.terasology.engine.module.ModuleManager; @@ -97,15 +96,15 @@ private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { @Override public String getSubTypeIdentifier(Class subType, Class baseType) { - SimpleUri subTypeUri = getTypeSimpleUri(subType); + String subTypeUri = getTypeUri(subType); long subTypesWithSameUri = Streams.stream(getModuleEnvironment().getSubtypesOf(baseType)) - .map(this::getTypeSimpleUri) + .map(this::getTypeUri) .filter(subTypeUri::equals) .count(); Preconditions.checkArgument(subTypesWithSameUri > 0, - "Subtype was not found in the module environment"); + "Subtype " + subType + " was not found in the module environment"); if (subTypesWithSameUri > 1) { // More than one subType with same SimpleUri, use fully qualified name @@ -138,10 +137,14 @@ public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler type) { + private String getTypeUri(Class type) { + if (type.getClassLoader() == null) { + return type.getName(); + } + Name moduleProvidingType = getModuleEnvironment().getModuleProviding(type); String typeSimpleName = type.getSimpleName(); - return new SimpleUri(moduleProvidingType, typeSimpleName); + return new SimpleUri(moduleProvidingType, typeSimpleName).toString(); } } From ac9e33f75ee2f3d2ecabd80feb4e498a188fcd65 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 31 Jul 2019 09:38:37 +0530 Subject: [PATCH 131/141] Fix EventSystemReplay tests, Fix some static analysis warnings --- .../recording/EventSystemReplayImplTest.java | 1 + .../coreTypes/ByteArrayTypeHandler.java | 24 +++++++++---------- .../RuntimeDelegatingTypeHandler.java | 3 +-- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 59e92cddcbc..7a6b41459ad 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -75,6 +75,7 @@ public void setup() { CharacterStateEventPositionMap characterStateEventPositionMap = new CharacterStateEventPositionMap(); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = new DirectionAndOriginPosRecorderList(); ModuleManager moduleManager = mock(ModuleManager.class); + when(moduleManager.getEnvironment()).thenReturn(mock(ModuleEnvironment.class)); RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, eventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); recordAndReplayCurrentStatus.setStatus(RecordAndReplayStatus.REPLAYING); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java index c6ae45e720f..0c04a6f39ff 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/ByteArrayTypeHandler.java @@ -21,17 +21,17 @@ import java.util.Optional; public class ByteArrayTypeHandler extends org.terasology.persistence.typeHandling.TypeHandler { - @Override - public PersistedData serializeNonNull(byte[] value, PersistedDataSerializer serializer) { - return serializer.serialize(value); - } + @Override + public PersistedData serializeNonNull(byte[] value, PersistedDataSerializer serializer) { + return serializer.serialize(value); + } - @Override - public Optional deserialize(PersistedData data) { - if (data.isBytes()) { - return Optional.of(data.getAsBytes()); - } else { - return Optional.empty(); - } - } + @Override + public Optional deserialize(PersistedData data) { + if (data.isBytes()) { + return Optional.of(data.getAsBytes()); + } else { + return Optional.empty(); + } + } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index b6213f3c467..624e891cec9 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -128,8 +128,7 @@ public PersistedData serializeNonNull(T value, PersistedDataSerializer serialize for (Map.Entry entry : serialized.getAsValueMap().entrySet()) { typeValuePersistedDataMap.put(entry.getKey(), entry.getValue()); } - } - else { + } else { typeValuePersistedDataMap.put( VALUE_FIELD, serialized From 7822f5ed2209ab534704226973b0c16a552b82fd Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 7 Aug 2019 11:09:54 +0530 Subject: [PATCH 132/141] Make TypeInfo @API --- engine/src/main/java/org/terasology/reflection/TypeInfo.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/engine/src/main/java/org/terasology/reflection/TypeInfo.java b/engine/src/main/java/org/terasology/reflection/TypeInfo.java index 6103984ad78..7192b7ba62c 100644 --- a/engine/src/main/java/org/terasology/reflection/TypeInfo.java +++ b/engine/src/main/java/org/terasology/reflection/TypeInfo.java @@ -15,6 +15,7 @@ */ package org.terasology.reflection; +import org.terasology.module.sandbox.API; import org.terasology.utilities.ReflectionUtil; import java.lang.reflect.Type; @@ -44,6 +45,7 @@ * * @param The type for which type information is to be generated. */ +@API public class TypeInfo { private final Class rawType; private final Type type; From 3391b62768983fd8f4928eadf7f9daba4ce740e7 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Wed, 7 Aug 2019 13:50:58 +0530 Subject: [PATCH 133/141] Add TypeRegistry --- .../testUtil/ModuleManagerFactory.java | 4 +- .../internal/TypeRegistryImplTest.java | 33 ++++++++++ .../terasology/engine/TerasologyEngine.java | 8 ++- .../engine/module/ModuleManagerImpl.java | 18 +++--- .../terasology/reflection/TypeRegistry.java | 25 ++++++++ .../reflection/internal/TypeRegistryImpl.java | 60 +++++++++++++++++++ 6 files changed, 138 insertions(+), 10 deletions(-) create mode 100644 engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java create mode 100644 engine/src/main/java/org/terasology/reflection/TypeRegistry.java create mode 100644 engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java diff --git a/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java b/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java index 69f7e55fab8..f2434b94d63 100644 --- a/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java +++ b/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java @@ -16,6 +16,7 @@ package org.terasology.testUtil; import com.google.common.collect.Sets; +import org.mockito.Mockito; import org.terasology.engine.TerasologyConstants; import org.terasology.engine.module.ModuleManager; import org.terasology.engine.module.ModuleManagerImpl; @@ -23,6 +24,7 @@ import org.terasology.module.ModuleMetadata; import org.terasology.module.ModuleMetadataReader; import org.terasology.naming.Name; +import org.terasology.reflection.internal.TypeRegistryImpl; import java.io.InputStreamReader; import java.io.Reader; @@ -34,7 +36,7 @@ private ModuleManagerFactory() { } public static ModuleManager create() throws Exception { - ModuleManager moduleManager = new ModuleManagerImpl(""); + ModuleManager moduleManager = new ModuleManagerImpl("", Mockito.mock(TypeRegistryImpl.class)); try (Reader reader = new InputStreamReader(ModuleManagerFactory.class.getResourceAsStream("/module.txt"), TerasologyConstants.CHARSET)) { ModuleMetadata metadata = new ModuleMetadataReader().read(reader); moduleManager.getRegistry().add(ClasspathModule.create(metadata, ModuleManagerFactory.class)); diff --git a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java new file mode 100644 index 00000000000..f5f013e500b --- /dev/null +++ b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java @@ -0,0 +1,33 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.reflection.internal; + +import org.junit.Test; + +import java.util.Set; +import java.util.TreeSet; + +import static org.junit.Assert.assertTrue; + +public class TypeRegistryImplTest { + private TypeRegistryImpl typeRegistry = new TypeRegistryImpl(); + + @Test + public void testRegistry() { + assertTrue(typeRegistry.getSubtypesOf(Object.class).size() > 0); + assertTrue(typeRegistry.getSubtypesOf(Set.class).contains(TreeSet.class)); + } +} diff --git a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java index 6a28a66172c..ee79fda938c 100644 --- a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java +++ b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java @@ -52,7 +52,6 @@ import org.terasology.input.InputSystem; import org.terasology.logic.behavior.asset.BehaviorTree; import org.terasology.logic.behavior.asset.BehaviorTreeData; -import org.terasology.module.ModuleEnvironment; import org.terasology.monitoring.Activity; import org.terasology.monitoring.PerformanceMonitor; import org.terasology.network.NetworkSystem; @@ -61,7 +60,9 @@ import org.terasology.recording.DirectionAndOriginPosRecorderList; import org.terasology.recording.RecordAndReplayCurrentStatus; import org.terasology.recording.RecordAndReplayUtils; +import org.terasology.reflection.TypeRegistry; import org.terasology.reflection.copy.CopyStrategyLibrary; +import org.terasology.reflection.internal.TypeRegistryImpl; import org.terasology.reflection.reflect.ReflectFactory; import org.terasology.reflection.reflect.ReflectionReflectFactory; import org.terasology.registry.CoreRegistry; @@ -307,7 +308,10 @@ private void verifyRequiredSystemIsRegistered(Class clazz) { private void initManagers() { changeStatus(TerasologyEngineStatus.INITIALIZING_MODULE_MANAGER); - ModuleManager moduleManager = new ModuleManagerImpl(rootContext.get(Config.class), classesOnClasspathsToAddToEngine); + TypeRegistryImpl typeRegistry = new TypeRegistryImpl(); + rootContext.put(TypeRegistry.class, typeRegistry); + + ModuleManager moduleManager = new ModuleManagerImpl(rootContext.get(Config.class), classesOnClasspathsToAddToEngine, typeRegistry); rootContext.put(ModuleManager.class, moduleManager); changeStatus(TerasologyEngineStatus.INITIALIZING_LOWLEVEL_OBJECT_MANIPULATION); diff --git a/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java b/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java index df77cde67a1..a63375d57d9 100644 --- a/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java +++ b/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java @@ -41,6 +41,7 @@ import org.terasology.module.sandbox.StandardPermissionProviderFactory; import org.terasology.module.sandbox.WarnOnlyProviderFactory; import org.terasology.naming.Name; +import org.terasology.reflection.internal.TypeRegistryImpl; import java.io.IOException; import java.io.InputStreamReader; @@ -70,11 +71,14 @@ public class ModuleManagerImpl implements ModuleManager { private ModuleMetadataJsonAdapter metadataReader; private ModuleInstallManager installManager; - public ModuleManagerImpl(String masterServerAddress) { - this(masterServerAddress, Collections.emptyList()); + private final TypeRegistryImpl typeRegistry; + + public ModuleManagerImpl(String masterServerAddress, TypeRegistryImpl typeRegistry) { + this(masterServerAddress, Collections.emptyList(), typeRegistry); } - public ModuleManagerImpl(String masterServerAddress, List> classesOnClasspathsToAddToEngine) { + public ModuleManagerImpl(String masterServerAddress, List> classesOnClasspathsToAddToEngine, TypeRegistryImpl typeRegistry) { + this.typeRegistry = typeRegistry; metadataReader = new ModuleMetadataJsonAdapter(); for (ModuleExtension ext : StandardModuleExtension.values()) { metadataReader.registerExtension(ext.getKey(), ext.getValueType()); @@ -119,12 +123,12 @@ public ModuleManagerImpl(String masterServerAddress, List> classesOnCla installManager = new ModuleInstallManager(this, masterServerAddress); } - public ModuleManagerImpl(Config config) { - this(config, Collections.emptyList()); + public ModuleManagerImpl(Config config, TypeRegistryImpl typeRegistry) { + this(config, Collections.emptyList(), typeRegistry); } - public ModuleManagerImpl(Config config, List> classesOnClasspathsToAddToEngine) { - this(config.getNetwork().getMasterServer(), classesOnClasspathsToAddToEngine); + public ModuleManagerImpl(Config config, List> classesOnClasspathsToAddToEngine, TypeRegistryImpl typeRegistry) { + this(config.getNetwork().getMasterServer(), classesOnClasspathsToAddToEngine, typeRegistry); } /** diff --git a/engine/src/main/java/org/terasology/reflection/TypeRegistry.java b/engine/src/main/java/org/terasology/reflection/TypeRegistry.java new file mode 100644 index 00000000000..7a2fa30851d --- /dev/null +++ b/engine/src/main/java/org/terasology/reflection/TypeRegistry.java @@ -0,0 +1,25 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.reflection; + +import java.lang.annotation.Annotation; +import java.util.Set; + +public interface TypeRegistry { + Set> getSubtypesOf(Class type); + + Set> getTypesAnnotatedWith(Class annotationType); +} diff --git a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java new file mode 100644 index 00000000000..8ec67bb596f --- /dev/null +++ b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java @@ -0,0 +1,60 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology.reflection.internal; + +import org.reflections.Reflections; +import org.reflections.scanners.SubTypesScanner; +import org.reflections.scanners.TypeAnnotationsScanner; +import org.terasology.module.Module; +import org.terasology.module.ModuleEnvironment; +import org.terasology.reflection.TypeRegistry; + +import java.lang.annotation.Annotation; +import java.util.Set; + +public class TypeRegistryImpl implements TypeRegistry { + private Reflections reflections; + + public TypeRegistryImpl() { + initializeReflections(); + } + + public void reload(ModuleEnvironment environment) { + initializeReflections(); + + for (Module module : environment.getModulesOrderedByDependencies()) { + reflections.merge(module.getReflectionsFragment()); + } + } + + private void initializeReflections() { + reflections = new Reflections( + TypeRegistryImpl.class.getClassLoader(), + new SubTypesScanner(false), + new TypeAnnotationsScanner() + ); + } + + @Override + public Set> getSubtypesOf(Class type) { + return reflections.getSubTypesOf(type); + } + + @Override + public Set> getTypesAnnotatedWith(Class annotationType) { + return reflections.getTypesAnnotatedWith(annotationType); + } +} From 6e1de25b4660108d141f31c23c3e826f724cb3b3 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 9 Aug 2019 19:26:21 +0530 Subject: [PATCH 134/141] Make TypeInfo abstract for more IDE/compiler enforcement --- .../java/org/terasology/reflection/TypeInfo.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/engine/src/main/java/org/terasology/reflection/TypeInfo.java b/engine/src/main/java/org/terasology/reflection/TypeInfo.java index 7192b7ba62c..d5ed07e3bda 100644 --- a/engine/src/main/java/org/terasology/reflection/TypeInfo.java +++ b/engine/src/main/java/org/terasology/reflection/TypeInfo.java @@ -46,7 +46,7 @@ * @param The type for which type information is to be generated. */ @API -public class TypeInfo { +public abstract class TypeInfo { private final Class rawType; private final Type type; private final int hashCode; @@ -75,21 +75,21 @@ protected TypeInfo(Type type) { * Creates a {@link TypeInfo} for the given type. */ public static TypeInfo of(Type type) { - return new TypeInfo(type); + return new TypeInfo(type) {}; } /** * Creates a {@link TypeInfo} for the given {@link Class}. */ public static TypeInfo of(Class type) { - return new TypeInfo<>(type); + return new TypeInfo(type) {}; } - public Class getRawType() { + public final Class getRawType() { return rawType; } - public Type getType() { + public final Type getType() { return type; } @@ -99,14 +99,14 @@ public final int hashCode() { } @Override - public boolean equals(Object o) { + public final boolean equals(Object o) { if (this == o) return true; return o instanceof TypeInfo && ReflectionUtil.typeEquals(type, ((TypeInfo) o).type); } @Override - public String toString() { + public final String toString() { return type.toString(); } } From 4e8e17356a31d89e73515cda85b4839c8f053bc1 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 9 Aug 2019 21:55:26 +0530 Subject: [PATCH 135/141] Use ClassLoaders to populate TypeRegistryImpl Reflections --- .../serializers/TypeSerializerTest.java | 113 +++++++++++------- .../internal/TypeRegistryImplTest.java | 11 +- .../engine/module/ModuleManagerImpl.java | 1 + .../reflection/ModuleEnvironmentSandbox.java | 7 ++ .../reflection/internal/TypeRegistryImpl.java | 25 ++-- 5 files changed, 100 insertions(+), 57 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 1a283fc150d..4d7ea8a068c 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -17,26 +17,37 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.nio.file.ShrinkWrapFileSystems; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.junit.Before; import org.junit.Test; -import org.junit.experimental.runners.Enclosed; -import org.junit.runner.RunWith; -import org.reflections.Reflections; +import org.terasology.engine.module.ModuleManager; +import org.terasology.engine.paths.PathManager; import org.terasology.math.geom.Vector3f; +import org.terasology.module.DependencyResolver; +import org.terasology.module.ModuleEnvironment; +import org.terasology.module.ResolutionResult; +import org.terasology.naming.Name; +import org.terasology.persistence.ModuleContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.annotations.SerializedName; import org.terasology.reflection.TypeInfo; import org.terasology.rendering.nui.Color; +import org.terasology.testUtil.ModuleManagerFactory; import java.io.IOException; +import java.nio.file.FileSystem; import java.util.List; import java.util.Objects; import java.util.Set; import static org.junit.Assert.assertEquals; +import static org.junit.Assume.assumeTrue; -@RunWith(Enclosed.class) public class TypeSerializerTest { private static final SomeClass INSTANCE = new SomeClass<>(0xdeadbeef); + private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"tailPosition\":[3.15,54.51,-0.001],\"data\":1},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"spotColor\":[255,0,255,255],\"data\":2}]}"; static { INSTANCE.list.addAll(Lists.newArrayList(50, 51, -52, -53)); @@ -46,55 +57,65 @@ public class TypeSerializerTest { INSTANCE.animals.add(new Cheetah<>(2, Color.MAGENTA)); } - public static class Json { - private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"tailPosition\":[3.15,54.51,-0.001],\"data\":1},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"spotColor\":[255,0,255,255],\"data\":2}]}"; + private TypeHandlerLibrary typeHandlerLibrary; + private ProtobufSerializer protobufSerializer; + private GsonSerializer gsonSerializer; - private final Reflections reflections = new Reflections(getClass().getClassLoader()); + @Before + public void setup() throws Exception { + final JavaArchive homeArchive = ShrinkWrap.create(JavaArchive.class); + final FileSystem vfs = ShrinkWrapFileSystems.newFileSystem(homeArchive); + PathManager.getInstance().useOverrideHomePath(vfs.getPath("")); - private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.withReflections(reflections); + ModuleManager moduleManager = ModuleManagerFactory.create(); - private final GsonSerializer serializer = new GsonSerializer(typeHandlerLibrary); + DependencyResolver resolver = new DependencyResolver(moduleManager.getRegistry()); + ResolutionResult result = resolver.resolve(moduleManager.getRegistry().getModuleIds()); - @Test - public void testJsonSerialize() { - String serializedJson = serializer.toJson(INSTANCE, new TypeInfo>() {}); - assertEquals(INSTANCE_JSON, serializedJson); - } + assumeTrue(result.isSuccess()); - @Test - public void testDeserialize() { - SomeClass deserialized = - serializer.fromJson(INSTANCE_JSON, new TypeInfo>() {}); + ModuleEnvironment environment = moduleManager.loadEnvironment(result.getModules(), true); + ModuleContext.setContext(environment.get(new Name("unittest"))); - assertEquals(INSTANCE, deserialized); - } + typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager); + + protobufSerializer = new ProtobufSerializer(typeHandlerLibrary); + gsonSerializer = new GsonSerializer(typeHandlerLibrary); } - public static class Protobuf { - private final Reflections reflections = new Reflections(getClass().getClassLoader()); + @Test + public void testJsonSerialize() { + String serializedJson = gsonSerializer.toJson(INSTANCE, new TypeInfo>() { + }); + assertEquals(INSTANCE_JSON, serializedJson); + } - private final TypeHandlerLibrary typeHandlerLibrary = - TypeHandlerLibrary.withReflections(reflections); + @Test + public void testDeserialize() { + SomeClass deserialized = + gsonSerializer.fromJson(INSTANCE_JSON, new TypeInfo>() { + }); - private final ProtobufSerializer serializer = new ProtobufSerializer(typeHandlerLibrary); + assertEquals(INSTANCE, deserialized); + } - @Test - public void testSerializeDeserialize() throws IOException { - byte[] bytes = serializer.toBytes(INSTANCE, new TypeInfo>() {}); + @Test + public void testSerializeDeserialize() throws IOException { + byte[] bytes = protobufSerializer.toBytes(INSTANCE, new TypeInfo>() { + }); - SomeClass deserializedInstance = - serializer.fromBytes(bytes, new TypeInfo>() {}); + SomeClass deserializedInstance = + protobufSerializer.fromBytes(bytes, new TypeInfo>() { + }); - assertEquals(INSTANCE, deserializedInstance); - } + assertEquals(INSTANCE, deserializedInstance); } private static class SomeClass { @SerializedName("generic-t") private T data; private List list = Lists.newArrayList(); - private Set> animals = Sets.newHashSet(); + private Set> animals = Sets.newHashSet(); private SomeClass(T data) { this.data = data; @@ -110,8 +131,8 @@ public boolean equals(Object o) { } SomeClass someClass = (SomeClass) o; return Objects.equals(data, someClass.data) && - Objects.equals(list, someClass.list) && - Objects.equals(animals, someClass.animals); + Objects.equals(list, someClass.list) && + Objects.equals(animals, someClass.animals); } @Override @@ -122,10 +143,10 @@ public int hashCode() { @Override public String toString() { return "SomeClass{" + - "data=" + data + - ", list=" + list + - ", animals=" + animals + - '}'; + "data=" + data + + ", list=" + list + + ", animals=" + animals + + '}'; } } @@ -180,9 +201,9 @@ public boolean equals(Object o) { @Override public String toString() { return "Dog{" + - "name='" + data + '\'' + - ", tailPosition=" + tailPosition + - '}'; + "name='" + data + '\'' + + ", tailPosition=" + tailPosition + + '}'; } @Override @@ -217,9 +238,9 @@ public boolean equals(Object o) { @Override public String toString() { return "Cheetah{" + - "name='" + data + '\'' + - ", spotColor=" + spotColor + - '}'; + "name='" + data + '\'' + + ", spotColor=" + spotColor + + '}'; } @Override diff --git a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java index f5f013e500b..7ec58c7a0d7 100644 --- a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java +++ b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java @@ -15,8 +15,11 @@ */ package org.terasology.reflection.internal; +import org.junit.Before; import org.junit.Test; +import org.reflections.Reflections; +import java.util.Collection; import java.util.Set; import java.util.TreeSet; @@ -25,9 +28,13 @@ public class TypeRegistryImplTest { private TypeRegistryImpl typeRegistry = new TypeRegistryImpl(); + @Before + public void setup() { + Reflections.log = null; + } + @Test public void testRegistry() { - assertTrue(typeRegistry.getSubtypesOf(Object.class).size() > 0); - assertTrue(typeRegistry.getSubtypesOf(Set.class).contains(TreeSet.class)); + assertTrue(typeRegistry.getSubtypesOf(Collection.class).contains(TreeSet.class)); } } diff --git a/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java b/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java index a63375d57d9..606dc6845b8 100644 --- a/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java +++ b/engine/src/main/java/org/terasology/engine/module/ModuleManagerImpl.java @@ -229,6 +229,7 @@ public ModuleEnvironment loadEnvironment(Set modules, boolean asPrimary) } if (asPrimary) { environment = newEnvironment; + typeRegistry.reload(environment); } return newEnvironment; } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 00f35c31a44..6088953e30a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -32,6 +32,8 @@ import static com.google.common.collect.Streams.stream; public class ModuleEnvironmentSandbox implements SerializationSandbox { + // TODO: Use TypeRegistry + private final ModuleManager moduleManager; public ModuleEnvironmentSandbox(ModuleManager moduleManager) { @@ -143,6 +145,11 @@ private String getTypeUri(Class type) { } Name moduleProvidingType = getModuleEnvironment().getModuleProviding(type); + + if (moduleProvidingType == null || moduleProvidingType.isEmpty()) { + return type.getName(); + } + String typeSimpleName = type.getSimpleName(); return new SimpleUri(moduleProvidingType, typeSimpleName).toString(); diff --git a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java index 8ec67bb596f..46cc4c1512e 100644 --- a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java +++ b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java @@ -18,32 +18,39 @@ import org.reflections.Reflections; import org.reflections.scanners.SubTypesScanner; import org.reflections.scanners.TypeAnnotationsScanner; -import org.terasology.module.Module; import org.terasology.module.ModuleEnvironment; import org.terasology.reflection.TypeRegistry; +import org.terasology.utilities.ReflectionUtil; import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.List; import java.util.Set; public class TypeRegistryImpl implements TypeRegistry { private Reflections reflections; public TypeRegistryImpl() { - initializeReflections(); + initializeReflections(TypeRegistryImpl.class.getClassLoader()); } public void reload(ModuleEnvironment environment) { - initializeReflections(); + // FIXME: Reflection -- may break with updates to gestalt-module + initializeReflections((ClassLoader) ReflectionUtil.readField(environment,"finalClassLoader")); + } + + private void initializeReflections(ClassLoader classLoader) { + List allClassLoaders = new ArrayList<>(); - for (Module module : environment.getModulesOrderedByDependencies()) { - reflections.merge(module.getReflectionsFragment()); + while (classLoader != null) { + allClassLoaders.add(classLoader); + classLoader = classLoader.getParent(); } - } - private void initializeReflections() { reflections = new Reflections( - TypeRegistryImpl.class.getClassLoader(), - new SubTypesScanner(false), + allClassLoaders, + new SubTypesScanner(), + // TODO: Add string-based scanner that scans all objects (== getSubtypesOf(Object.class)) new TypeAnnotationsScanner() ); } From 1679be21c1681f2f74af96474f21b37d2d20cfb8 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 9 Aug 2019 22:54:03 +0530 Subject: [PATCH 136/141] Reverse ClassLoader list in TypeRegistryImpl.reload --- .../org/terasology/ModuleEnvironmentTest.java | 57 +++++++++++++++++++ .../testUtil/ModuleManagerFactory.java | 7 ++- .../internal/TypeRegistryImplTest.java | 27 +++++++-- .../reflection/internal/TypeRegistryImpl.java | 16 +++--- 4 files changed, 94 insertions(+), 13 deletions(-) create mode 100644 engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java diff --git a/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java b/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java new file mode 100644 index 00000000000..fe6d9e5fa3e --- /dev/null +++ b/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java @@ -0,0 +1,57 @@ +/* + * Copyright 2019 MovingBlocks + * + * 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 org.terasology; + +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.nio.file.ShrinkWrapFileSystems; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.junit.Before; +import org.mockito.Mockito; +import org.terasology.engine.module.ModuleManager; +import org.terasology.engine.paths.PathManager; +import org.terasology.module.DependencyResolver; +import org.terasology.module.ModuleEnvironment; +import org.terasology.module.ResolutionResult; +import org.terasology.reflection.internal.TypeRegistryImpl; +import org.terasology.testUtil.ModuleManagerFactory; + +import java.nio.file.FileSystem; + +import static org.junit.Assume.assumeTrue; + +public abstract class ModuleEnvironmentTest { + protected ModuleManager moduleManager; + + @Before + public void setup() throws Exception { + final JavaArchive homeArchive = ShrinkWrap.create(JavaArchive.class); + final FileSystem vfs = ShrinkWrapFileSystems.newFileSystem(homeArchive); + PathManager.getInstance().useOverrideHomePath(vfs.getPath("")); + + moduleManager = ModuleManagerFactory.create(getTypeRegistry()); + + DependencyResolver resolver = new DependencyResolver(moduleManager.getRegistry()); + ResolutionResult result = resolver.resolve(moduleManager.getRegistry().getModuleIds()); + + assumeTrue(result.isSuccess()); + + moduleManager.loadEnvironment(result.getModules(), true); + } + + protected TypeRegistryImpl getTypeRegistry() { + return Mockito.mock(TypeRegistryImpl.class); + } +} diff --git a/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java b/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java index f2434b94d63..8541005a7c0 100644 --- a/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java +++ b/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java @@ -24,6 +24,7 @@ import org.terasology.module.ModuleMetadata; import org.terasology.module.ModuleMetadataReader; import org.terasology.naming.Name; +import org.terasology.reflection.TypeRegistry; import org.terasology.reflection.internal.TypeRegistryImpl; import java.io.InputStreamReader; @@ -36,7 +37,11 @@ private ModuleManagerFactory() { } public static ModuleManager create() throws Exception { - ModuleManager moduleManager = new ModuleManagerImpl("", Mockito.mock(TypeRegistryImpl.class)); + return create(Mockito.mock(TypeRegistryImpl.class)); + } + + public static ModuleManager create(TypeRegistryImpl typeRegistry) throws Exception { + ModuleManager moduleManager = new ModuleManagerImpl("", typeRegistry); try (Reader reader = new InputStreamReader(ModuleManagerFactory.class.getResourceAsStream("/module.txt"), TerasologyConstants.CHARSET)) { ModuleMetadata metadata = new ModuleMetadataReader().read(reader); moduleManager.getRegistry().add(ClasspathModule.create(metadata, ModuleManagerFactory.class)); diff --git a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java index 7ec58c7a0d7..f6a2d3a6cdb 100644 --- a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java +++ b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java @@ -15,26 +15,43 @@ */ package org.terasology.reflection.internal; -import org.junit.Before; import org.junit.Test; import org.reflections.Reflections; +import org.terasology.ModuleEnvironmentTest; +import org.terasology.entitySystem.Component; +import org.terasology.naming.Name; import java.util.Collection; import java.util.Set; import java.util.TreeSet; +import java.util.stream.Collectors; import static org.junit.Assert.assertTrue; -public class TypeRegistryImplTest { +public class TypeRegistryImplTest extends ModuleEnvironmentTest { + static { + Reflections.log = null; + } + private TypeRegistryImpl typeRegistry = new TypeRegistryImpl(); - @Before - public void setup() { - Reflections.log = null; + @Override + protected TypeRegistryImpl getTypeRegistry() { + return typeRegistry; } @Test public void testRegistry() { assertTrue(typeRegistry.getSubtypesOf(Collection.class).contains(TreeSet.class)); + + Set modulesDeclaringComponents = + typeRegistry.getSubtypesOf(Component.class).stream() + .map(componentClass -> moduleManager.getEnvironment().getModuleProviding(componentClass)) + .collect(Collectors.toSet()); + + assertTrue(modulesDeclaringComponents.size() > 2); + + assertTrue(modulesDeclaringComponents.contains(new Name("engine"))); + assertTrue(modulesDeclaringComponents.contains(new Name("Core"))); } } diff --git a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java index 46cc4c1512e..8a15858a08a 100644 --- a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java +++ b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java @@ -15,6 +15,7 @@ */ package org.terasology.reflection.internal; +import com.google.common.collect.Lists; import org.reflections.Reflections; import org.reflections.scanners.SubTypesScanner; import org.reflections.scanners.TypeAnnotationsScanner; @@ -23,7 +24,6 @@ import org.terasology.utilities.ReflectionUtil; import java.lang.annotation.Annotation; -import java.util.ArrayList; import java.util.List; import java.util.Set; @@ -36,11 +36,11 @@ public TypeRegistryImpl() { public void reload(ModuleEnvironment environment) { // FIXME: Reflection -- may break with updates to gestalt-module - initializeReflections((ClassLoader) ReflectionUtil.readField(environment,"finalClassLoader")); + initializeReflections((ClassLoader) ReflectionUtil.readField(environment, "finalClassLoader")); } private void initializeReflections(ClassLoader classLoader) { - List allClassLoaders = new ArrayList<>(); + List allClassLoaders = Lists.newArrayList(); while (classLoader != null) { allClassLoaders.add(classLoader); @@ -48,10 +48,12 @@ private void initializeReflections(ClassLoader classLoader) { } reflections = new Reflections( - allClassLoaders, - new SubTypesScanner(), - // TODO: Add string-based scanner that scans all objects (== getSubtypesOf(Object.class)) - new TypeAnnotationsScanner() + // Reversed so that classes are loaded using the originally declaring/loading class loader, + // not a child class loader (like a ModuleClassLoader, for example) + Lists.reverse(allClassLoaders), + new SubTypesScanner(), + // TODO: Add string-based scanner that scans all objects (== getSubtypesOf(Object.class)) + new TypeAnnotationsScanner() ); } From ef8c8b4f8a03c56131230856cb8cc34e4f63ed16 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Fri, 9 Aug 2019 23:39:44 +0530 Subject: [PATCH 137/141] Add empty TypeRegistryImpl constructor --- .../java/org/terasology/ModuleEnvironmentTest.java | 1 - .../terasology/testUtil/ModuleManagerFactory.java | 12 +++++++++--- .../reflection/internal/TypeRegistryImpl.java | 10 ++++++++-- 3 files changed, 17 insertions(+), 6 deletions(-) diff --git a/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java b/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java index fe6d9e5fa3e..af92ca7eacc 100644 --- a/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java +++ b/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java @@ -23,7 +23,6 @@ import org.terasology.engine.module.ModuleManager; import org.terasology.engine.paths.PathManager; import org.terasology.module.DependencyResolver; -import org.terasology.module.ModuleEnvironment; import org.terasology.module.ResolutionResult; import org.terasology.reflection.internal.TypeRegistryImpl; import org.terasology.testUtil.ModuleManagerFactory; diff --git a/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java b/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java index 8541005a7c0..055199e4a7e 100644 --- a/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java +++ b/engine-tests/src/main/java/org/terasology/testUtil/ModuleManagerFactory.java @@ -24,11 +24,11 @@ import org.terasology.module.ModuleMetadata; import org.terasology.module.ModuleMetadataReader; import org.terasology.naming.Name; -import org.terasology.reflection.TypeRegistry; import org.terasology.reflection.internal.TypeRegistryImpl; import java.io.InputStreamReader; import java.io.Reader; +import java.util.Set; /** */ @@ -36,17 +36,23 @@ public final class ModuleManagerFactory { private ModuleManagerFactory() { } + // Named "create" for legacy reasons, but does more than create public static ModuleManager create() throws Exception { - return create(Mockito.mock(TypeRegistryImpl.class)); + ModuleManager manager = create(Mockito.mock(TypeRegistryImpl.class)); + manager.loadEnvironment(Sets.newHashSet(manager.getRegistry().getLatestModuleVersion(new Name("engine"))), true); + return manager; } + /** + * Creates a new {@link ModuleManager} instance, but does not + * {@link ModuleManager#loadEnvironment(Set, boolean) load it's environment}. + */ public static ModuleManager create(TypeRegistryImpl typeRegistry) throws Exception { ModuleManager moduleManager = new ModuleManagerImpl("", typeRegistry); try (Reader reader = new InputStreamReader(ModuleManagerFactory.class.getResourceAsStream("/module.txt"), TerasologyConstants.CHARSET)) { ModuleMetadata metadata = new ModuleMetadataReader().read(reader); moduleManager.getRegistry().add(ClasspathModule.create(metadata, ModuleManagerFactory.class)); } - moduleManager.loadEnvironment(Sets.newHashSet(moduleManager.getRegistry().getLatestModuleVersion(new Name("engine"))), true); return moduleManager; } } diff --git a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java index 8a15858a08a..9f55a765f08 100644 --- a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java +++ b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java @@ -30,8 +30,14 @@ public class TypeRegistryImpl implements TypeRegistry { private Reflections reflections; - public TypeRegistryImpl() { - initializeReflections(TypeRegistryImpl.class.getClassLoader()); + /** + * Creates an empty {@link TypeRegistryImpl}. No types are loaded when this constructor + * is called -- to populate the registry use one of the other parameterized constructors. + */ + public TypeRegistryImpl() {} + + public TypeRegistryImpl(ClassLoader classLoader) { + initializeReflections(classLoader); } public void reload(ModuleEnvironment environment) { From 66a9dcd67328d49c824d079be9cb9eff47b257cc Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 10 Aug 2019 14:58:29 +0530 Subject: [PATCH 138/141] Use TypeRegistry in ModuleEnvironmentSandbox --- .../org/terasology/HeadlessEnvironment.java | 7 ++- .../org/terasology/ModuleEnvironmentTest.java | 13 +++-- .../TerasologyTestingEnvironment.java | 3 +- .../internal/StorageManagerTest.java | 3 +- .../serializers/TypeSerializerTest.java | 35 +++---------- .../recording/EventSystemReplayImplTest.java | 3 +- .../internal/TypeRegistryImplTest.java | 7 --- .../terasology/engine/TerasologyEngine.java | 2 +- .../bootstrap/EntitySystemSetupUtil.java | 6 ++- .../typeHandling/TypeHandlerLibrary.java | 11 ++-- .../reflection/ModuleEnvironmentSandbox.java | 51 ++++++++++++------- .../recording/RecordAndReplaySerializer.java | 10 ++-- .../recording/RecordedEventSerializer.java | 9 ++-- .../terasology/reflection/TypeRegistry.java | 3 ++ .../reflection/internal/TypeRegistryImpl.java | 26 ++++++++-- 15 files changed, 104 insertions(+), 85 deletions(-) diff --git a/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java b/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java index 4e9bc1fe529..f83220a2118 100644 --- a/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java +++ b/engine-tests/src/main/java/org/terasology/HeadlessEnvironment.java @@ -64,6 +64,8 @@ import org.terasology.recording.RecordAndReplayCurrentStatus; import org.terasology.recording.RecordAndReplaySerializer; import org.terasology.recording.RecordAndReplayUtils; +import org.terasology.reflection.TypeRegistry; +import org.terasology.reflection.internal.TypeRegistryImpl; import org.terasology.rendering.assets.animation.MeshAnimation; import org.terasology.rendering.assets.animation.MeshAnimationImpl; import org.terasology.rendering.assets.atlas.Atlas; @@ -267,7 +269,10 @@ protected void setupConfig() { @Override protected void setupModuleManager(Set moduleNames) throws Exception { - ModuleManager moduleManager = ModuleManagerFactory.create(); + TypeRegistryImpl typeRegistry = new TypeRegistryImpl(); + context.put(TypeRegistry.class, typeRegistry); + + ModuleManager moduleManager = ModuleManagerFactory.create(typeRegistry); ModuleRegistry registry = moduleManager.getRegistry(); DependencyResolver resolver = new DependencyResolver(registry); diff --git a/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java b/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java index af92ca7eacc..cf746d0e7cc 100644 --- a/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java +++ b/engine-tests/src/main/java/org/terasology/ModuleEnvironmentTest.java @@ -24,6 +24,7 @@ import org.terasology.engine.paths.PathManager; import org.terasology.module.DependencyResolver; import org.terasology.module.ResolutionResult; +import org.terasology.reflection.TypeRegistry; import org.terasology.reflection.internal.TypeRegistryImpl; import org.terasology.testUtil.ModuleManagerFactory; @@ -33,14 +34,16 @@ public abstract class ModuleEnvironmentTest { protected ModuleManager moduleManager; + protected TypeRegistry typeRegistry; @Before - public void setup() throws Exception { + public void before() throws Exception { final JavaArchive homeArchive = ShrinkWrap.create(JavaArchive.class); final FileSystem vfs = ShrinkWrapFileSystems.newFileSystem(homeArchive); PathManager.getInstance().useOverrideHomePath(vfs.getPath("")); - moduleManager = ModuleManagerFactory.create(getTypeRegistry()); + typeRegistry = new TypeRegistryImpl(); + moduleManager = ModuleManagerFactory.create((TypeRegistryImpl) typeRegistry); DependencyResolver resolver = new DependencyResolver(moduleManager.getRegistry()); ResolutionResult result = resolver.resolve(moduleManager.getRegistry().getModuleIds()); @@ -48,9 +51,11 @@ public void setup() throws Exception { assumeTrue(result.isSuccess()); moduleManager.loadEnvironment(result.getModules(), true); + + setup(); } - protected TypeRegistryImpl getTypeRegistry() { - return Mockito.mock(TypeRegistryImpl.class); + protected void setup() { + } } diff --git a/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java b/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java index 56698402563..b9f57c196ba 100644 --- a/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java +++ b/engine-tests/src/main/java/org/terasology/TerasologyTestingEnvironment.java @@ -45,6 +45,7 @@ import org.terasology.recording.RecordAndReplaySerializer; import org.terasology.recording.RecordAndReplayUtils; import org.terasology.recording.RecordedEventStore; +import org.terasology.reflection.TypeRegistry; import org.terasology.world.block.BlockManager; import org.terasology.world.chunks.blockdata.ExtraBlockDataManager; @@ -104,7 +105,7 @@ public void setup() throws Exception { context.put(CharacterStateEventPositionMap.class, characterStateEventPositionMap); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = new DirectionAndOriginPosRecorderList(); context.put(DirectionAndOriginPosRecorderList.class, directionAndOriginPosRecorderList); - RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(engineEntityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); + RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(engineEntityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager, context.get(TypeRegistry.class)); context.put(RecordAndReplaySerializer.class, recordAndReplaySerializer); Path savePath = PathManager.getInstance().getSavePath("world1"); diff --git a/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java b/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java index fc5a27855a4..9405ccfbe41 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/internal/StorageManagerTest.java @@ -51,6 +51,7 @@ import org.terasology.recording.RecordAndReplaySerializer; import org.terasology.recording.RecordAndReplayUtils; import org.terasology.recording.RecordedEventStore; +import org.terasology.reflection.TypeRegistry; import org.terasology.registry.CoreRegistry; import org.terasology.world.WorldProvider; import org.terasology.world.block.Block; @@ -121,7 +122,7 @@ public void setup() throws Exception { recordAndReplayUtils = new RecordAndReplayUtils(); CharacterStateEventPositionMap characterStateEventPositionMap = new CharacterStateEventPositionMap(); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = new DirectionAndOriginPosRecorderList(); - recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); + recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager, mock(TypeRegistry.class)); recordAndReplayCurrentStatus = context.get(RecordAndReplayCurrentStatus.class); diff --git a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java index 4d7ea8a068c..23e3c4bf661 100644 --- a/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java +++ b/engine-tests/src/test/java/org/terasology/persistence/serializers/TypeSerializerTest.java @@ -17,27 +17,18 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; -import org.jboss.shrinkwrap.api.ShrinkWrap; -import org.jboss.shrinkwrap.api.nio.file.ShrinkWrapFileSystems; -import org.jboss.shrinkwrap.api.spec.JavaArchive; import org.junit.Before; import org.junit.Test; -import org.terasology.engine.module.ModuleManager; -import org.terasology.engine.paths.PathManager; +import org.terasology.ModuleEnvironmentTest; import org.terasology.math.geom.Vector3f; -import org.terasology.module.DependencyResolver; -import org.terasology.module.ModuleEnvironment; -import org.terasology.module.ResolutionResult; import org.terasology.naming.Name; import org.terasology.persistence.ModuleContext; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.annotations.SerializedName; import org.terasology.reflection.TypeInfo; import org.terasology.rendering.nui.Color; -import org.terasology.testUtil.ModuleManagerFactory; import java.io.IOException; -import java.nio.file.FileSystem; import java.util.List; import java.util.Objects; import java.util.Set; @@ -45,9 +36,9 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assume.assumeTrue; -public class TypeSerializerTest { +public class TypeSerializerTest extends ModuleEnvironmentTest { private static final SomeClass INSTANCE = new SomeClass<>(0xdeadbeef); - private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"tailPosition\":[3.15,54.51,-0.001],\"data\":1},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"spotColor\":[255,0,255,255],\"data\":2}]}"; + private static final String INSTANCE_JSON = "{\"generic-t\":-559038737,\"list\":[50,51,-52,-53],\"animals\":[{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Dog\",\"tailPosition\":[3.15,54.51,-0.001],\"data\":{\"class\":\"java.lang.Integer\",\"content\":1}},{\"class\":\"org.terasology.persistence.serializers.TypeSerializerTest$Cheetah\",\"spotColor\":[255,0,255,255],\"data\":{\"class\":\"java.lang.Integer\",\"content\":2}}]}"; static { INSTANCE.list.addAll(Lists.newArrayList(50, 51, -52, -53)); @@ -61,23 +52,11 @@ public class TypeSerializerTest { private ProtobufSerializer protobufSerializer; private GsonSerializer gsonSerializer; - @Before - public void setup() throws Exception { - final JavaArchive homeArchive = ShrinkWrap.create(JavaArchive.class); - final FileSystem vfs = ShrinkWrapFileSystems.newFileSystem(homeArchive); - PathManager.getInstance().useOverrideHomePath(vfs.getPath("")); + @Override + public void setup() { + ModuleContext.setContext(moduleManager.getEnvironment().get(new Name("unittest"))); - ModuleManager moduleManager = ModuleManagerFactory.create(); - - DependencyResolver resolver = new DependencyResolver(moduleManager.getRegistry()); - ResolutionResult result = resolver.resolve(moduleManager.getRegistry().getModuleIds()); - - assumeTrue(result.isSuccess()); - - ModuleEnvironment environment = moduleManager.loadEnvironment(result.getModules(), true); - ModuleContext.setContext(environment.get(new Name("unittest"))); - - typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager); + typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager, typeRegistry); protobufSerializer = new ProtobufSerializer(typeHandlerLibrary); gsonSerializer = new GsonSerializer(typeHandlerLibrary); diff --git a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java index 7a6b41459ad..7b86025035a 100644 --- a/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java +++ b/engine-tests/src/test/java/org/terasology/recording/EventSystemReplayImplTest.java @@ -37,6 +37,7 @@ import org.terasology.network.NetworkMode; import org.terasology.network.NetworkSystem; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; +import org.terasology.reflection.TypeRegistry; import org.terasology.registry.CoreRegistry; import java.util.ArrayList; @@ -77,7 +78,7 @@ public void setup() { ModuleManager moduleManager = mock(ModuleManager.class); when(moduleManager.getEnvironment()).thenReturn(mock(ModuleEnvironment.class)); RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, eventStore, - recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); + recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager, mock(TypeRegistry.class)); recordAndReplayCurrentStatus.setStatus(RecordAndReplayStatus.REPLAYING); entity = entityManager.create(); Long id = entity.getId(); diff --git a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java index f6a2d3a6cdb..370d199ce93 100644 --- a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java +++ b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java @@ -33,13 +33,6 @@ public class TypeRegistryImplTest extends ModuleEnvironmentTest { Reflections.log = null; } - private TypeRegistryImpl typeRegistry = new TypeRegistryImpl(); - - @Override - protected TypeRegistryImpl getTypeRegistry() { - return typeRegistry; - } - @Test public void testRegistry() { assertTrue(typeRegistry.getSubtypesOf(Collection.class).contains(TreeSet.class)); diff --git a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java index ee79fda938c..8da21ae3dd6 100644 --- a/engine/src/main/java/org/terasology/engine/TerasologyEngine.java +++ b/engine/src/main/java/org/terasology/engine/TerasologyEngine.java @@ -321,7 +321,7 @@ private void initManagers() { CopyStrategyLibrary copyStrategyLibrary = new CopyStrategyLibrary(reflectFactory); rootContext.put(CopyStrategyLibrary.class, copyStrategyLibrary); - rootContext.put(TypeHandlerLibrary.class, TypeHandlerLibrary.forModuleEnvironment(moduleManager)); + rootContext.put(TypeHandlerLibrary.class, TypeHandlerLibrary.forModuleEnvironment(moduleManager, typeRegistry)); changeStatus(TerasologyEngineStatus.INITIALIZING_ASSET_TYPES); assetTypeManager = new ModuleAwareAssetTypeManager(); diff --git a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java index 77ba5011923..f30800a5998 100644 --- a/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java +++ b/engine/src/main/java/org/terasology/engine/bootstrap/EntitySystemSetupUtil.java @@ -51,6 +51,7 @@ import org.terasology.recording.RecordAndReplayStatus; import org.terasology.recording.RecordAndReplayUtils; import org.terasology.recording.RecordedEventStore; +import org.terasology.reflection.TypeRegistry; import org.terasology.reflection.copy.CopyStrategyLibrary; import org.terasology.reflection.reflect.ReflectFactory; import org.terasology.reflection.reflect.ReflectionReflectFactory; @@ -76,7 +77,8 @@ public static void addReflectionBasedLibraries(Context context) { context.put(CopyStrategyLibrary.class, copyStrategyLibrary); ModuleManager moduleManager = context.get(ModuleManager.class); - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager); + TypeRegistry typeRegistry = context.get(TypeRegistry.class); + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager, typeRegistry); context.put(TypeHandlerLibrary.class, typeHandlerLibrary); EntitySystemLibrary library = new EntitySystemLibrary(context, typeHandlerLibrary); @@ -134,7 +136,7 @@ public static void addEntityManagementRelatedClasses(Context context) { CharacterStateEventPositionMap characterStateEventPositionMap = context.get(CharacterStateEventPositionMap.class); DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList = context.get(DirectionAndOriginPosRecorderList.class); RecordedEventStore recordedEventStore = new RecordedEventStore(); - RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager); + RecordAndReplaySerializer recordAndReplaySerializer = new RecordAndReplaySerializer(entityManager, recordedEventStore, recordAndReplayUtils, characterStateEventPositionMap, directionAndOriginPosRecorderList, moduleManager, context.get(TypeRegistry.class)); context.put(RecordAndReplaySerializer.class, recordAndReplaySerializer); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java index 962b463090b..f74f65787af 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/TypeHandlerLibrary.java @@ -30,7 +30,6 @@ import org.terasology.math.geom.Vector3f; import org.terasology.math.geom.Vector3i; import org.terasology.math.geom.Vector4f; -import org.terasology.module.ModuleEnvironment; import org.terasology.naming.Name; import org.terasology.persistence.typeHandling.coreTypes.BooleanTypeHandler; import org.terasology.persistence.typeHandling.coreTypes.ByteArrayTypeHandler; @@ -67,12 +66,12 @@ import org.terasology.persistence.typeHandling.reflection.ReflectionsSandbox; import org.terasology.persistence.typeHandling.reflection.SerializationSandbox; import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.TypeRegistry; import org.terasology.reflection.metadata.ClassMetadata; import org.terasology.reflection.metadata.FieldMetadata; import org.terasology.reflection.reflect.ConstructorLibrary; import org.terasology.rendering.assets.texture.TextureRegion; import org.terasology.rendering.nui.Color; -import org.terasology.utilities.ReflectionUtil; import java.lang.reflect.Type; import java.util.HashMap; @@ -148,8 +147,8 @@ public TypeHandlerLibrary(Reflections reflections) { this(new ReflectionsSandbox(reflections)); } - public TypeHandlerLibrary(ModuleManager moduleManager) { - this(new ModuleEnvironmentSandbox(moduleManager)); + public TypeHandlerLibrary(ModuleManager moduleManager, TypeRegistry typeRegistry) { + this(new ModuleEnvironmentSandbox(moduleManager, typeRegistry)); } /** @@ -172,8 +171,8 @@ public static TypeHandlerLibrary withReflections(Reflections reflections) { return library; } - public static TypeHandlerLibrary forModuleEnvironment(ModuleManager moduleManager) { - TypeHandlerLibrary library = new TypeHandlerLibrary(moduleManager); + public static TypeHandlerLibrary forModuleEnvironment(ModuleManager moduleManager, TypeRegistry typeRegistry) { + TypeHandlerLibrary library = new TypeHandlerLibrary(moduleManager, typeRegistry); populateWithDefaultHandlers(library); diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java index 6088953e30a..a1ef521706a 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/reflection/ModuleEnvironmentSandbox.java @@ -16,7 +16,6 @@ package org.terasology.persistence.typeHandling.reflection; import com.google.common.base.Preconditions; -import com.google.common.collect.Streams; import org.terasology.engine.SimpleUri; import org.terasology.engine.module.ModuleManager; import org.terasology.module.ModuleEnvironment; @@ -24,32 +23,40 @@ import org.terasology.persistence.ModuleContext; import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.TypeRegistry; import java.util.Iterator; import java.util.Objects; import java.util.Optional; -import static com.google.common.collect.Streams.stream; - public class ModuleEnvironmentSandbox implements SerializationSandbox { - // TODO: Use TypeRegistry - + private final TypeRegistry typeRegistry; private final ModuleManager moduleManager; - public ModuleEnvironmentSandbox(ModuleManager moduleManager) { + public ModuleEnvironmentSandbox(ModuleManager moduleManager, TypeRegistry typeRegistry) { this.moduleManager = moduleManager; + this.typeRegistry = typeRegistry; } - private ModuleEnvironment getModuleEnvironment() { + private ModuleEnvironment getEnvironment() { return moduleManager.getEnvironment(); } @Override public Optional> findSubTypeOf(String subTypeIdentifier, Class clazz) { + if (getModuleProviding(clazz) == null) { + // Assume that subTypeIdentifier is full name + return typeRegistry.load(subTypeIdentifier) + // If loaded class is not a subtype, return empty + .filter(clazz::isAssignableFrom) + .map(sub -> (Class) sub); + } Iterator> possibilities = - getModuleEnvironment() - .getSubtypesOf(clazz, subclass -> doesSubclassMatch(subclass, subTypeIdentifier)) + typeRegistry + .getSubtypesOf(clazz) + .stream() + .filter(subclass -> doesSubclassMatch(subclass, subTypeIdentifier)) .iterator(); if (possibilities.hasNext()) { @@ -83,7 +90,7 @@ private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { } // Now check through module and simple name - Name providingModule = getModuleEnvironment().getModuleProviding(subclass); + Name providingModule = getModuleProviding(subclass); Name givenModuleName; if (subTypeUri.isValid()) { @@ -100,7 +107,11 @@ private boolean doesSubclassMatch(Class subclass, String subTypeIdentifier) { public String getSubTypeIdentifier(Class subType, Class baseType) { String subTypeUri = getTypeUri(subType); - long subTypesWithSameUri = Streams.stream(getModuleEnvironment().getSubtypesOf(baseType)) + if (getModuleProviding(baseType) == null) { + return subType.getName(); + } + + long subTypesWithSameUri = typeRegistry.getSubtypesOf(baseType).stream() .map(this::getTypeUri) .filter(subTypeUri::equals) .count(); @@ -118,7 +129,7 @@ public String getSubTypeIdentifier(Class subType, Class base @Override public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler typeHandler) { - Name moduleDeclaringHandler = getModuleEnvironment().getModuleProviding(typeHandler.getClass()); + Name moduleDeclaringHandler = getModuleProviding(typeHandler.getClass()); // If handler was declared outside of a module (engine or somewhere else), we allow it // TODO: Possibly find better way to refer to engine module @@ -133,18 +144,14 @@ public boolean isValidTypeHandlerDeclaration(TypeInfo type, TypeHandler type) { - if (type.getClassLoader() == null) { - return type.getName(); - } - - Name moduleProvidingType = getModuleEnvironment().getModuleProviding(type); + Name moduleProvidingType = getModuleProviding(type); if (moduleProvidingType == null || moduleProvidingType.isEmpty()) { return type.getName(); @@ -154,4 +161,12 @@ private String getTypeUri(Class type) { return new SimpleUri(moduleProvidingType, typeSimpleName).toString(); } + + private Name getModuleProviding(Class type) { + if (type.getClassLoader() == null) { + return null; + } + + return getEnvironment().getModuleProviding(type); + } } diff --git a/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java b/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java index 806dc42d6a1..fe88443df8a 100644 --- a/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordAndReplaySerializer.java @@ -27,7 +27,7 @@ import org.terasology.engine.paths.PathManager; import org.terasology.entitySystem.entity.EntityManager; import org.terasology.math.geom.Vector3f; -import org.terasology.module.ModuleEnvironment; +import org.terasology.reflection.TypeRegistry; import java.io.FileWriter; import java.io.FileReader; @@ -55,13 +55,15 @@ public final class RecordAndReplaySerializer { private RecordedEventSerializer recordedEventSerializer; public RecordAndReplaySerializer(EntityManager manager, RecordedEventStore store, - RecordAndReplayUtils recordAndReplayUtils, CharacterStateEventPositionMap characterStateEventPositionMap, - DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList, ModuleManager moduleManager) { + RecordAndReplayUtils recordAndReplayUtils, + CharacterStateEventPositionMap characterStateEventPositionMap, + DirectionAndOriginPosRecorderList directionAndOriginPosRecorderList, + ModuleManager moduleManager, TypeRegistry typeRegistry) { this.recordedEventStore = store; this.recordAndReplayUtils = recordAndReplayUtils; this.characterStateEventPositionMap = characterStateEventPositionMap; this.directionAndOriginPosRecorderList = directionAndOriginPosRecorderList; - this.recordedEventSerializer = new RecordedEventSerializer(manager, moduleManager); + this.recordedEventSerializer = new RecordedEventSerializer(manager, moduleManager, typeRegistry); } /** diff --git a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java index 14fe420e4db..92fe46da2ca 100644 --- a/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java +++ b/engine/src/main/java/org/terasology/recording/RecordedEventSerializer.java @@ -21,20 +21,17 @@ import org.terasology.entitySystem.entity.EntityManager; import org.terasology.entitySystem.entity.EntityRef; import org.terasology.entitySystem.entity.internal.EngineEntityManager; -import org.terasology.module.ModuleEnvironment; import org.terasology.persistence.serializers.GsonSerializer; -import org.terasology.persistence.typeHandling.PersistedData; import org.terasology.persistence.typeHandling.SerializationException; -import org.terasology.persistence.typeHandling.TypeHandler; import org.terasology.persistence.typeHandling.TypeHandlerLibrary; import org.terasology.persistence.typeHandling.extensionTypes.EntityRefTypeHandler; import org.terasology.reflection.TypeInfo; +import org.terasology.reflection.TypeRegistry; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.List; -import java.util.Optional; /** * Serializes and deserializes RecordedEvents. @@ -45,8 +42,8 @@ class RecordedEventSerializer { private GsonSerializer gsonSerializer; - public RecordedEventSerializer(EntityManager entityManager, ModuleManager moduleManager) { - TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager); + public RecordedEventSerializer(EntityManager entityManager, ModuleManager moduleManager, TypeRegistry typeRegistry) { + TypeHandlerLibrary typeHandlerLibrary = TypeHandlerLibrary.forModuleEnvironment(moduleManager, typeRegistry); typeHandlerLibrary.addTypeHandler(EntityRef.class, new EntityRefTypeHandler((EngineEntityManager) entityManager)); gsonSerializer = new GsonSerializer(typeHandlerLibrary); diff --git a/engine/src/main/java/org/terasology/reflection/TypeRegistry.java b/engine/src/main/java/org/terasology/reflection/TypeRegistry.java index 7a2fa30851d..e20e957da01 100644 --- a/engine/src/main/java/org/terasology/reflection/TypeRegistry.java +++ b/engine/src/main/java/org/terasology/reflection/TypeRegistry.java @@ -16,10 +16,13 @@ package org.terasology.reflection; import java.lang.annotation.Annotation; +import java.util.Optional; import java.util.Set; public interface TypeRegistry { Set> getSubtypesOf(Class type); Set> getTypesAnnotatedWith(Class annotationType); + + Optional> load(String name); } diff --git a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java index 9f55a765f08..5e93b530f44 100644 --- a/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java +++ b/engine/src/main/java/org/terasology/reflection/internal/TypeRegistryImpl.java @@ -15,7 +15,9 @@ */ package org.terasology.reflection.internal; +import com.google.common.base.Preconditions; import com.google.common.collect.Lists; +import org.reflections.ReflectionUtils; import org.reflections.Reflections; import org.reflections.scanners.SubTypesScanner; import org.reflections.scanners.TypeAnnotationsScanner; @@ -24,11 +26,14 @@ import org.terasology.utilities.ReflectionUtil; import java.lang.annotation.Annotation; +import java.util.Collections; import java.util.List; +import java.util.Optional; import java.util.Set; public class TypeRegistryImpl implements TypeRegistry { private Reflections reflections; + private ClassLoader[] classLoaders; /** * Creates an empty {@link TypeRegistryImpl}. No types are loaded when this constructor @@ -53,18 +58,24 @@ private void initializeReflections(ClassLoader classLoader) { classLoader = classLoader.getParent(); } + // Here allClassLoaders contains child class loaders followed by their parent. The list is + // reversed so that classes are loaded using the originally declaring/loading class loader, + // not a child class loader (like a ModuleClassLoader, for example) + Collections.reverse(allClassLoaders); + + classLoaders = allClassLoaders.toArray(new ClassLoader[0]); + reflections = new Reflections( - // Reversed so that classes are loaded using the originally declaring/loading class loader, - // not a child class loader (like a ModuleClassLoader, for example) - Lists.reverse(allClassLoaders), - new SubTypesScanner(), - // TODO: Add string-based scanner that scans all objects (== getSubtypesOf(Object.class)) + allClassLoaders, + new SubTypesScanner(false), new TypeAnnotationsScanner() ); } @Override public Set> getSubtypesOf(Class type) { + Preconditions.checkArgument(!Object.class.equals(type)); + return reflections.getSubTypesOf(type); } @@ -72,4 +83,9 @@ public Set> getSubtypesOf(Class type) { public Set> getTypesAnnotatedWith(Class annotationType) { return reflections.getTypesAnnotatedWith(annotationType); } + + @Override + public Optional> load(String name) { + return Optional.ofNullable(ReflectionUtils.forName(name, classLoaders)); + } } From e16914f39aecef6ff0667ecef8fd9670a9a376a5 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 10 Aug 2019 19:04:06 +0530 Subject: [PATCH 139/141] Separate tests in TypeRegistryImplTest --- .../reflection/internal/TypeRegistryImplTest.java | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java index 370d199ce93..ba6bee8e206 100644 --- a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java +++ b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java @@ -22,11 +22,14 @@ import org.terasology.naming.Name; import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; import java.util.Set; import java.util.TreeSet; import java.util.stream.Collectors; import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeTrue; public class TypeRegistryImplTest extends ModuleEnvironmentTest { static { @@ -34,9 +37,14 @@ public class TypeRegistryImplTest extends ModuleEnvironmentTest { } @Test - public void testRegistry() { - assertTrue(typeRegistry.getSubtypesOf(Collection.class).contains(TreeSet.class)); + public void testNonModuleTypes() { + assumeTrue(typeRegistry.getSubtypesOf(Collection.class).contains(TreeSet.class)); + assertTrue(typeRegistry.getSubtypesOf(Map.class).contains(LinkedHashMap.class)); + } + + @Test + public void testModuleTypes() { Set modulesDeclaringComponents = typeRegistry.getSubtypesOf(Component.class).stream() .map(componentClass -> moduleManager.getEnvironment().getModuleProviding(componentClass)) From 715c929c4ec83bdc17ec2a2f9568942831bd3425 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sat, 10 Aug 2019 19:23:00 +0530 Subject: [PATCH 140/141] Test for unittest module instead of Core in TypeRegistryImplTest --- .../terasology/reflection/internal/TypeRegistryImplTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java index ba6bee8e206..dd5d784b349 100644 --- a/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java +++ b/engine-tests/src/test/java/org/terasology/reflection/internal/TypeRegistryImplTest.java @@ -50,9 +50,9 @@ public void testModuleTypes() { .map(componentClass -> moduleManager.getEnvironment().getModuleProviding(componentClass)) .collect(Collectors.toSet()); - assertTrue(modulesDeclaringComponents.size() > 2); + assertTrue(modulesDeclaringComponents.size() >= 2); assertTrue(modulesDeclaringComponents.contains(new Name("engine"))); - assertTrue(modulesDeclaringComponents.contains(new Name("Core"))); + assertTrue(modulesDeclaringComponents.contains(new Name("unittest"))); } } From 419b85a3ba483280c9128171be00a75759f1a649 Mon Sep 17 00:00:00 2001 From: Arav Singhal Date: Sun, 11 Aug 2019 00:57:43 +0530 Subject: [PATCH 141/141] Add PersistedDataMap.of --- .../persistence/typeHandling/PersistedDataMap.java | 5 +++++ .../typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataMap.java b/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataMap.java index 9e7206eeb30..c11077eebf5 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataMap.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/PersistedDataMap.java @@ -15,6 +15,8 @@ */ package org.terasology.persistence.typeHandling; +import org.terasology.persistence.typeHandling.inMemory.PersistedMap; + import java.util.Map; import java.util.Set; @@ -44,4 +46,7 @@ public interface PersistedDataMap extends PersistedData { Set> entrySet(); + static PersistedDataMap of(Map map) { + return new PersistedMap(map); + } } diff --git a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java index 624e891cec9..a01f9bb4849 100644 --- a/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java +++ b/engine/src/main/java/org/terasology/persistence/typeHandling/coreTypes/RuntimeDelegatingTypeHandler.java @@ -212,7 +212,7 @@ public Optional deserialize(PersistedData data) { valueFields.remove(TYPE_FIELD); - valueData = new PersistedMap(valueFields); + valueData = PersistedDataMap.of(valueFields); } return runtimeTypeHandler.deserialize(valueData);