added support of getters and setters into mapping

Author: raydac

README.md

@@ -19,6 +19,7 @@ For instance I have been very actively using the framework in [the ZX-Poly emula
  - __reworked object mapping system, removed hacks to instantiate classes, now only mapping to objects allowed, support of private fields mapping is removed__
  - __minimal JDK version now 1.8+__
  - __minimal Android API now 3.0+__
+ - added support of getters and setters into mapping
  - added `Object newInstance(Class)` method support of mapped classes to generate instances for local classes 
  - added generating of `makeFIELD()` method for structure types in Java class converter
  - refactoring

changelog.txt

@@ -2,6 +2,7 @@
  - __reworked object mapping system, removed hacks to instantiate classes, now only mapping to objects allowed, support of private fields mapping is removed__
  - __minimal JDK version now 1.8+__
  - __minimal Android API now 3.0+__
+ - added support of getters and setters into mapping
  - added `Object newInstance(Class)` method support of mapped classes to generate instances for local classes
  - added generating of `makeFIELD()` method for structure types in Java class converter
  - refactoring

jbbp/src/main/java/com/igormaznitsa/jbbp/mapper/JBBPMapper.java

@@ -23,12 +23,15 @@
 import com.igormaznitsa.jbbp.model.JBBPFieldStruct;
 import com.igormaznitsa.jbbp.utils.Function;
 import com.igormaznitsa.jbbp.utils.JBBPUtils;
+import com.igormaznitsa.jbbp.utils.NullableTriple;
 import com.igormaznitsa.jbbp.utils.ReflectUtils;
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -339,7 +342,6 @@ public static List<MappedFieldRecord> findAffectedFields(final Object instance)
           if (fieldAnno == null) {
             if (Modifier.isTransient(fieldModifiers)
                 || Modifier.isStatic(fieldModifiers)
-                || Modifier.isPrivate(fieldModifiers)
                 || Modifier.isFinal(fieldModifiers)) {
               continue;
             }
@@ -349,8 +351,6 @@ public static List<MappedFieldRecord> findAffectedFields(final Object instance)
               disallowedModifier = "STATIC";
             } else if (Modifier.isFinal(fieldModifiers)) {
               disallowedModifier = "FINAL";
-            } else if (Modifier.isPrivate(fieldModifiers)) {
-              disallowedModifier = "PRIVATE";
             } else {
               disallowedModifier = null;
             }
@@ -359,12 +359,22 @@ public static List<MappedFieldRecord> findAffectedFields(final Object instance)
             }
           }
 
-          if (!ReflectUtils.isPotentiallyAccessibleField(mappingField)) {
+          final NullableTriple<Method, Method, Method> auxMethods = findAuxFieldMethods(processingClazz, mappingField);
+
+          final Method fieldGenerator = auxMethods.getA();
+          final Method fieldGetter = auxMethods.getB();
+          final Method fieldSetter = auxMethods.getC();
+
+          if (fieldSetter == null && Modifier.isPrivate(mappingField.getModifiers())) {
+            throw new JBBPMapperException("Detected private field, there must be provided setter for mapping", null, processingClazz, mappingField, null);
+          }
+
+          if (fieldGetter == null && !ReflectUtils.isPotentiallyAccessibleField(mappingField)) {
             mappingField = ReflectUtils.makeAccessible(mappingField);
           }
 
           try {
-            result.add(new MappedFieldRecord(mappingField, null, null, mappingClass, mappedAnno));
+            result.add(new MappedFieldRecord(mappingField, fieldGenerator, fieldSetter, fieldGetter, mappingClass, mappedAnno));
           } catch (IllegalStateException ex) {
             throw new JBBPMapperException(ex.getMessage(), null, mappingClass, mappingField, ex);
           }
@@ -379,4 +389,42 @@ public static List<MappedFieldRecord> findAffectedFields(final Object instance)
     return result;
   }
 
+  private static NullableTriple<Method, Method, Method> findAuxFieldMethods(final Class<?> klazz, final Field field) {
+    final String lowerCasedFieldName = field.getName().toLowerCase(Locale.ENGLISH);
+    final String generatorName = "make" + lowerCasedFieldName;
+    final String getterName = "get" + lowerCasedFieldName;
+    final String setterName = "set" + lowerCasedFieldName;
+
+    Method generator = null;
+    Method setter = null;
+    Method getter = null;
+
+    for (final Method m : klazz.getMethods()) {
+      final Class<?>[] args = m.getParameterTypes();
+      final String lcMethodName = m.getName().toLowerCase(Locale.ENGLISH);
+
+      if (!Modifier.isPublic(m.getModifiers()) || Modifier.isStatic(m.getModifiers())) {
+        continue;
+      }
+
+      if (args.length == 0) {
+        if (generator == null && lcMethodName.equals(generatorName)
+        ) {
+          generator = m;
+        }
+        if (getter == null && lcMethodName.equals(getterName)) {
+          getter = m;
+        }
+      }
+
+      if (args.length == 1 && setter == null && lcMethodName.equals(setterName) && field.getType().isAssignableFrom(args[0])) {
+        setter = m;
+      }
+
+      if (generator != null && setter != null && getter != null) {
+        break;
+      }
+    }
+    return new NullableTriple<>(generator, getter, setter);
+  }
 }

jbbp/src/main/java/com/igormaznitsa/jbbp/mapper/MappedFieldRecord.java

@@ -114,17 +114,25 @@ public final class MappedFieldRecord implements Comparable<MappedFieldRecord> {
       mapNumericField(instance, record.setter, record.mappingField, (JBBPNumericField) binField, record.binAnnotation.bitOrder() == JBBPBitOrder.MSB0);
     } else if (binField instanceof JBBPFieldString) {
       if (record.mappingField.getType().isPrimitive()) {
-        throw new JBBPMapperException("Can't map a string to a primitive mapping field", binField, record.mappingClass, record.mappingField, null);
+        throw new JBBPMapperException("Can't map string to a primitive mapping field", binField, record.mappingClass, record.mappingField, null);
       } else {
         setFieldValue(instance, record.setter, record.mappingField, binField, ((JBBPFieldString) binField).getAsString());
       }
     } else if (binField instanceof JBBPFieldStruct) {
       if (record.mappingField.getType().isPrimitive()) {
-        throw new JBBPMapperException("Can't map a structure to a primitive mapping field", binField, record.mappingClass, record.mappingField, null);
+        throw new JBBPMapperException("Can't map structure to a primitive mapping field", binField, record.mappingClass, record.mappingField, null);
       } else {
         final Object curValue = getFieldValue(instance, record.getter, record.mappingField);
         if (curValue == null) {
-          setFieldValue(instance, record.setter, record.mappingField, binField, JBBPMapper.map((JBBPFieldStruct) binField, tryMakeInstance(record.mappingField.getType(), binField, instance, record.mappingField, instantiators), customFieldProcessor));
+          if (record.classMemberGenerator == null) {
+            setFieldValue(instance, record.setter, record.mappingField, binField, JBBPMapper.map((JBBPFieldStruct) binField, tryMakeInstance(record.mappingField.getType(), binField, instance, record.mappingField, instantiators), customFieldProcessor));
+          } else {
+            try {
+              JBBPMapper.map((JBBPFieldStruct) binField, record.classMemberGenerator.invoke(instance));
+            } catch (Exception ex) {
+              throw new JBBPMapperException("Can't map field which member generatet by instance", binField, record.mappingClass, record.mappingField, ex);
+            }
+          }
         } else {
           setFieldValue(instance, record.setter, record.mappingField, binField, JBBPMapper.map((JBBPFieldStruct) binField, curValue, customFieldProcessor));
         }
@@ -148,6 +156,7 @@ public final class MappedFieldRecord implements Comparable<MappedFieldRecord> {
   public final Class<?> mappingClass;
   public final Method setter;
   public final Method getter;
+  public final Method classMemberGenerator;
   public final Bin binAnnotation;
   public final boolean bitWideField;
   public final String fieldName;
@@ -157,10 +166,12 @@ public final class MappedFieldRecord implements Comparable<MappedFieldRecord> {
   public final FieldProcessor proc;
 
   MappedFieldRecord(final Field mappingField,
+                    final Method classMemberGenerator,
                     final Method setter,
                     final Method getter,
                     final Class<?> mappingClass,
                     final Bin binAnnotation) {
+    this.classMemberGenerator = classMemberGenerator;
     this.setter = setter;
     this.getter = getter;
 
@@ -393,9 +404,9 @@ private static void mapNumericField(final Object mappingClassInstance, final Met
    */
   private static Object getFieldValue(final Object classInstance, final Method getter, final Field classField) {
     try {
-      if (getter == null)
+      if (getter == null) {
         return classField.get(classInstance);
-      else {
+      } else {
         return getter.invoke(classInstance);
       }
     } catch (IllegalArgumentException ex) {
@@ -412,17 +423,17 @@ private static Object getFieldValue(final Object classInstance, final Method get
    * fields!
    *
    * @param classInstance a class instance
-   * @param setter setter for the field, can be null
+   * @param setter        setter for the field, can be null
    * @param classField    a mapping class field which should be set by the value,
    *                      must not be null
    * @param binField      a parsed bin field which value will be set, can be null
    * @param value         a value to be set to the class field
    */
   static void setFieldValue(final Object classInstance, final Method setter, final Field classField, final JBBPAbstractField binField, final Object value) {
     try {
-      if (setter == null)
+      if (setter == null) {
         classField.set(classInstance, value);
-      else {
+      } else {
         setter.invoke(classInstance, value);
       }
     } catch (IllegalArgumentException ex) {

jbbp/src/main/java/com/igormaznitsa/jbbp/utils/NullableTriple.java

@@ -0,0 +1,34 @@
+package com.igormaznitsa.jbbp.utils;
+
+/**
+ * Auxiliary class to keep three values. Any value can be null.
+ *
+ * @param <A> first value type
+ * @param <B> second value type
+ * @param <C> third value type
+ * @since 2.0.0
+ */
+public final class NullableTriple<A, B, C> {
+  private final A a;
+  private final B b;
+  private final C c;
+
+  public NullableTriple(A a, B b, C c) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+  }
+
+  public A getA() {
+    return this.a;
+  }
+
+  public B getB() {
+    return this.b;
+  }
+
+  public C getC() {
+    return this.c;
+  }
+
+}

jbbp/src/test/java/com/igormaznitsa/jbbp/mapper/ClassWithPrivateFieldsAndSetterGetter.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2017 Igor Maznitsa.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.igormaznitsa.jbbp.mapper;
+
+class ClassWithPrivateFieldsAndSetterGetter {
+  @Bin
+  private int field;
+
+  public int getField() {
+    return this.field;
+  }
+
+  public void setField(int value) {
+    this.field = value;
+  }
+}

jbbp/src/test/java/com/igormaznitsa/jbbp/mapper/JBBPMapperTest.java

@@ -542,6 +542,12 @@ void testMap_privateFieldInPackagelevelClass() {
     assertThrows(JBBPMapperException.class, () -> JBBPParser.prepare("int field;").parse(new byte[] {1, 2, 3, 4}).mapTo(new ClassWithPrivateFields()));
   }
 
+  @Test
+  void testMap_privateFieldWithSetterInPackagelevelClass() throws Exception {
+    final ClassWithPrivateFieldsAndSetterGetter instance = JBBPParser.prepare("int field;").parse(new byte[] {1, 2, 3, 4}).mapTo(new ClassWithPrivateFieldsAndSetterGetter());
+    assertEquals(0x1020304, instance.getField());
+  }
+
   @Test
   void testMap_customMappingFields_Class() throws Exception {
     final class Mapped {