Skip to content

Commit

Permalink
Merge pull request #18 from devjeonghwan/main
Browse files Browse the repository at this point in the history 
Rename `class` and `compile` words
  • Loading branch information
@devjeonghwan
devjeonghwan authored Dec 29, 2021
2 parents 866daaf + 3a254a2 commit c04cb0b
Show file tree
Hide file tree
Showing 20 changed files with 363 additions and 390 deletions.
2 changes: 1 addition & 1 deletion build.gradle
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ plugins {

group 'io.github.realtimetech-solution'
archivesBaseName = "opack"
version = "0.0.3"
version = "0.0.4"

compileJava.options.encoding = 'UTF-8'

Expand Down
149 changes: 74 additions & 75 deletions src/main/java/com/realtimetech/opack/Opacker.java
View file

Large diffs are not rendered by default.

22 changes: 11 additions & 11 deletions ...realtimetech/opack/compile/ClassInfo.java → ...om/realtimetech/opack/bake/BakedType.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,23 +20,23 @@
* limitations under the License.
*/

package com.realtimetech.opack.compile;
package com.realtimetech.opack.bake;

import com.realtimetech.opack.transformer.Transformer;
import org.jetbrains.annotations.NotNull;

import java.lang.reflect.Field;

public class ClassInfo {
public static class FieldInfo {
public class BakedType {
public static class Property {
final Field field;
final String name;
final Class<?> type;

final Transformer transformer;
final Class<?> explicitType;

public FieldInfo(@NotNull Field field, Transformer transformer, Class<?> explicitType) {
public Property(@NotNull Field field, Transformer transformer, Class<?> explicitType) {
this.field = field;
this.name = this.field.getName();
this.type = explicitType == null ? this.field.getType() : explicitType;
Expand Down Expand Up @@ -94,25 +94,25 @@ public Object get(Object object) throws IllegalAccessException {
}
}

final Class<?> targetClass;
final Class<?> type;
final Transformer[] transformers;
final FieldInfo[] fields;
final Property[] fields;

public ClassInfo(Class<?> targetClass, Transformer[] transformers, FieldInfo[] fields) {
this.targetClass = targetClass;
public BakedType(Class<?> type, Transformer[] transformers, Property[] fields) {
this.type = type;
this.transformers = transformers;
this.fields = fields;
}

public Class<?> getTargetClass() {
return targetClass;
public Class<?> getType() {
return type;
}

public Transformer[] getTransformers() {
return transformers;
}

public FieldInfo[] getFields() {
public Property[] getFields() {
return fields;
}
}
158 changes: 91 additions & 67 deletions ...ltimetech/opack/compile/InfoCompiler.java → ...om/realtimetech/opack/bake/TypeBaker.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,13 +20,13 @@
* limitations under the License.
*/

package com.realtimetech.opack.compile;
package com.realtimetech.opack.bake;

import com.realtimetech.opack.Opacker;
import com.realtimetech.opack.annotation.ExplicitType;
import com.realtimetech.opack.annotation.Ignore;
import com.realtimetech.opack.annotation.Transform;
import com.realtimetech.opack.exception.CompileException;
import com.realtimetech.opack.exception.BakeException;
import com.realtimetech.opack.transformer.Transformer;
import com.realtimetech.opack.transformer.TransformerFactory;
import com.realtimetech.opack.util.ReflectionUtil;
Expand All @@ -38,36 +38,60 @@
import java.util.LinkedList;
import java.util.List;

public class InfoCompiler {
public class TypeBaker {
static class PredefinedTransformer {
final Transformer transformer;
final boolean inheritable;

/**
* Constructs the PredefinedTransformer.
*
* @param transformer the transformer
* @param inheritable whether the transformer is inheritable
*/
public PredefinedTransformer(@NotNull Transformer transformer, boolean inheritable) {
this.transformer = transformer;
this.inheritable = inheritable;
}

public Transformer getTransformer() {
return transformer;
}

public boolean isInheritable() {
return inheritable;
}
}

final @NotNull Opacker opacker;

final @NotNull TransformerFactory transformerFactory;

final @NotNull HashMap<Class<?>, ClassInfo> classInfoMap;
final @NotNull HashMap<Class<?>, BakedType> backedTypeMap;
final @NotNull HashMap<Class<?>, List<PredefinedTransformer>> predefinedTransformerMap;

/**
* Constructs an InfoCompiler with the opacker.
* Constructs an TypeBaker with the opacker.
*
* @param opacker the opacker
*/
public InfoCompiler(@NotNull Opacker opacker) {
public TypeBaker(@NotNull Opacker opacker) {
this.opacker = opacker;

this.transformerFactory = new TransformerFactory(opacker);

this.classInfoMap = new HashMap<>();
this.backedTypeMap = new HashMap<>();
this.predefinedTransformerMap = new HashMap<>();
}

/**
* Returns predefined transformers targeting a specific class.
*
* @param typeClass the class to be the target
* @param type the class to be the target
* @return found predefined transformers
*/
public PredefinedTransformer[] getPredefinedTransformers(Class<?> typeClass) {
List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(typeClass);
public PredefinedTransformer[] getPredefinedTransformers(Class<?> type) {
List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(type);

if (predefinedTransformers == null) {
return new PredefinedTransformer[0];
Expand All @@ -77,40 +101,40 @@ public PredefinedTransformer[] getPredefinedTransformers(Class<?> typeClass) {
}

/**
* Calls {@code registerPredefinedTransformer(typeClass, transformerClass, false);}
* Calls {@code registerPredefinedTransformer(type, transformerClass, false);}
*
* @param typeClass the class to be the target
* @param transformerClass the predefined transformer class to register
* @param type the class to be the target
* @param transformerType the predefined transformer class to register
* @return whether the predefined transformer registration is successful
* @throws InstantiationException if transformer class object cannot be instantiated
*/
public boolean registerPredefinedTransformer(@NotNull Class<?> typeClass, @NotNull Class<? extends Transformer> transformerClass) throws InstantiationException {
return this.registerPredefinedTransformer(typeClass, transformerClass, false);
public boolean registerPredefinedTransformer(@NotNull Class<?> type, @NotNull Class<? extends Transformer> transformerType) throws InstantiationException {
return this.registerPredefinedTransformer(type, transformerType, false);
}

/**
* Register a predefined transformer targeting the specific class.
*
* @param typeClass the class to be the target
* @param transformerClass the predefined transformer to register
* @param type the class to be the target
* @param transformerType the predefined transformer to register
* @param inheritable whether transformer is inheritable
* @return whether the predefined transformer registration is successful
* @throws InstantiationException if transformer class object cannot be instantiated
*/
public synchronized boolean registerPredefinedTransformer(@NotNull Class<?> typeClass, @NotNull Class<? extends Transformer> transformerClass, boolean inheritable) throws InstantiationException {
if (!this.predefinedTransformerMap.containsKey(typeClass)) {
this.predefinedTransformerMap.put(typeClass, new LinkedList<>());
public synchronized boolean registerPredefinedTransformer(@NotNull Class<?> type, @NotNull Class<? extends Transformer> transformerType, boolean inheritable) throws InstantiationException {
if (!this.predefinedTransformerMap.containsKey(type)) {
this.predefinedTransformerMap.put(type, new LinkedList<>());
}

List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(typeClass);
List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(type);

for (PredefinedTransformer predefinedTransformer : predefinedTransformers) {
if (predefinedTransformer.getTransformer().getClass() == transformerClass) {
if (predefinedTransformer.getTransformer().getClass() == transformerType) {
return false;
}
}

Transformer transformer = this.transformerFactory.get(transformerClass);
Transformer transformer = this.transformerFactory.get(transformerType);
predefinedTransformers.add(new PredefinedTransformer(transformer, inheritable));

return true;
Expand All @@ -119,20 +143,20 @@ public synchronized boolean registerPredefinedTransformer(@NotNull Class<?> type
/**
* Unregister a predefined transformer targeting the specific class.
*
* @param typeClass the targeted type class
* @param transformerClass the predefined transformer to unregister
* @param type the targeted type class
* @param transformerType the predefined transformer to unregister
* @return whether the cancellation of predefined transformer registration is successful
*/
public synchronized boolean unregisterPredefinedTransformer(@NotNull Class<?> typeClass, @NotNull Class<? extends Transformer> transformerClass) {
List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(typeClass);
public synchronized boolean unregisterPredefinedTransformer(@NotNull Class<?> type, @NotNull Class<? extends Transformer> transformerType) {
List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(type);

if (predefinedTransformers == null) {
return false;
}

PredefinedTransformer targetPredefinedTransformer = null;
for (PredefinedTransformer predefinedTransformer : predefinedTransformers) {
if (predefinedTransformer.getTransformer().getClass() == transformerClass) {
if (predefinedTransformer.getTransformer().getClass() == transformerType) {
targetPredefinedTransformer = predefinedTransformer;
break;
}
Expand All @@ -153,27 +177,27 @@ public synchronized boolean unregisterPredefinedTransformer(@NotNull Class<?> ty
* @param transformers the transformer list to add
* @param annotatedElement the element to be targeted
* @param root whether the element is not super class (whether the element is the root)
* @throws CompileException if transformer class object cannot be instantiated
* @throws BakeException if transformer class object cannot be instantiated
*/
void addTransformer(List<Transformer> transformers, AnnotatedElement annotatedElement, boolean root) throws CompileException {
void addTransformer(List<Transformer> transformers, AnnotatedElement annotatedElement, boolean root) throws BakeException {
if (annotatedElement instanceof Class) {
Class<?> elementClass = (Class<?>) annotatedElement;
Class<?> superClass = elementClass.getSuperclass();
Class<?> elementType = (Class<?>) annotatedElement;
Class<?> superType = elementType.getSuperclass();

if (superClass != null && superClass != Object.class) {
this.addTransformer(transformers, superClass, false);
if (superType != null && superType != Object.class) {
this.addTransformer(transformers, superType, false);
}

for (Class<?> interfaceClass : elementClass.getInterfaces()) {
for (Class<?> interfaceClass : elementType.getInterfaces()) {
this.addTransformer(transformers, interfaceClass, false);
}
}

if (annotatedElement instanceof Class) {
Class<?> elementClass = (Class<?>) annotatedElement;
Class<?> elementType = (Class<?>) annotatedElement;

if (this.predefinedTransformerMap.containsKey(elementClass)) {
List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(elementClass);
if (this.predefinedTransformerMap.containsKey(elementType)) {
List<PredefinedTransformer> predefinedTransformers = this.predefinedTransformerMap.get(elementType);

if (predefinedTransformers != null) {
for (PredefinedTransformer predefinedTransformer : predefinedTransformers) {
Expand All @@ -189,12 +213,12 @@ void addTransformer(List<Transformer> transformers, AnnotatedElement annotatedEl
Transform transform = annotatedElement.getAnnotation(Transform.class);

if (root || transform.inheritable()) {
Class<Transformer> transformerInterfaceClass = (Class<Transformer>) transform.transformer();
Class<Transformer> transformerType = (Class<Transformer>) transform.transformer();

try {
transformers.add(this.transformerFactory.get(transformerInterfaceClass));
transformers.add(this.transformerFactory.get(transformerType));
} catch (InstantiationException e) {
throw new CompileException(e);
throw new BakeException(e);
}
}
}
Expand All @@ -205,9 +229,9 @@ void addTransformer(List<Transformer> transformers, AnnotatedElement annotatedEl
*
* @param annotatedElement the element that annotated {@link Transform Transform}
* @return transformers
* @throws CompileException if transformer class object cannot be instantiated
* @throws BakeException if transformer class object cannot be instantiated
*/
Transformer[] getTransformer(AnnotatedElement annotatedElement) throws CompileException {
Transformer[] getTransformer(AnnotatedElement annotatedElement) throws BakeException {
List<Transformer> transformers = new LinkedList<>();
this.addTransformer(transformers, annotatedElement, true);
return transformers.toArray(new Transformer[0]);
Expand All @@ -229,22 +253,22 @@ Class<?> getExplicitType(AnnotatedElement annotatedElement) {
}

/**
* Compile the class into {@link ClassInfo ClassInfo}.
* Compile the class into {@link BakedType BakedType}.
*
* @param compileClass the class to compile
* @return compiled class info
* @throws CompileException if a problem occurs during compiling a class into {@link ClassInfo ClassInfo}
* @param bakeType the type to bake
* @return baked type info
* @throws BakeException if a problem occurs during baking a class into {@link BakedType BakedType}
*/
@NotNull ClassInfo compile(@NotNull Class<?> compileClass) throws CompileException {
List<ClassInfo.FieldInfo> fieldInfos = new LinkedList<>();
@NotNull BakedType bake(@NotNull Class<?> bakeType) throws BakeException {
List<BakedType.Property> properties = new LinkedList<>();
Transformer[] transformers = new Transformer[0];

if (!compileClass.isArray() &&
compileClass != String.class &&
!ReflectionUtil.isPrimitiveClass(compileClass) &&
!ReflectionUtil.isWrapperClass(compileClass)) {
if (!bakeType.isArray() &&
bakeType != String.class &&
!ReflectionUtil.isPrimitiveType(bakeType) &&
!ReflectionUtil.isWrapperType(bakeType)) {

Field[] fields = ReflectionUtil.getAccessibleFields(compileClass);
Field[] fields = ReflectionUtil.getAccessibleFields(bakeType);
for (Field field : fields) {
if (field.isAnnotationPresent(Ignore.class)) {
continue;
Expand All @@ -253,33 +277,33 @@ Class<?> getExplicitType(AnnotatedElement annotatedElement) {
Transformer[] fieldTransformers = this.getTransformer(field);
Class<?> explicitType = this.getExplicitType(field);

fieldInfos.add(new ClassInfo.FieldInfo(field, fieldTransformers.length > 0 ? fieldTransformers[0] : null, explicitType));
properties.add(new BakedType.Property(field, fieldTransformers.length > 0 ? fieldTransformers[0] : null, explicitType));
}

transformers = this.getTransformer(compileClass);
transformers = this.getTransformer(bakeType);
}

return new ClassInfo(compileClass, transformers, fieldInfos.toArray(new ClassInfo.FieldInfo[0]));
return new BakedType(bakeType, transformers, properties.toArray(new BakedType.Property[0]));
}

/**
* Returns ClassInfo for target class.
* Returns BakedType for target class.
*
* @param compileClass the class to be targeted
* @param bakeType the class to be baked
* @return class info
* @throws CompileException if a problem occurs during compiling a class into class info
* @throws BakeException if a problem occurs during baking a class into class info
*/
public @NotNull ClassInfo get(@NotNull Class<?> compileClass) throws CompileException {
if (!this.classInfoMap.containsKey(compileClass)) {
synchronized (this.classInfoMap) {
if (!this.classInfoMap.containsKey(compileClass)) {
ClassInfo classInfo = this.compile(compileClass);
public @NotNull BakedType get(@NotNull Class<?> bakeType) throws BakeException {
if (!this.backedTypeMap.containsKey(bakeType)) {
synchronized (this.backedTypeMap) {
if (!this.backedTypeMap.containsKey(bakeType)) {
BakedType bakedType = this.bake(bakeType);

this.classInfoMap.put(compileClass, classInfo);
this.backedTypeMap.put(bakeType, bakedType);
}
}
}

return this.classInfoMap.get(compileClass);
return this.backedTypeMap.get(bakeType);
}
}
Loading

0 comments on commit c04cb0b

Please sign in to comment.