org.simantics.objmap2/src/org/simantics/objmap/graph/schema/MappingSchemas.java

   1 package org.simantics.objmap.graph.schema;\r
   2 \r
   3 import java.lang.annotation.Annotation;\r
   4 import java.lang.reflect.Field;\r
   5 import java.lang.reflect.Method;\r
   6 import java.util.ArrayList;\r
   7 import java.util.Collection;\r
   8 \r
   9 import org.simantics.db.ReadGraph;\r
  10 import org.simantics.db.Resource;\r
  11 import org.simantics.db.exception.DatabaseException;\r
  12 import org.simantics.objmap.bidirectional.IBidirectionalMappingRule;\r
  13 import org.simantics.objmap.graph.annotations.CompoundRelatedGetValue;\r
  14 import org.simantics.objmap.graph.annotations.DynamicGraphType;\r
  15 import org.simantics.objmap.graph.annotations.GraphType;\r
  16 import org.simantics.objmap.graph.annotations.HasCollectionAdder;\r
  17 import org.simantics.objmap.graph.annotations.HasCollectionRemover;\r
  18 import org.simantics.objmap.graph.annotations.HasSetter;\r
  19 import org.simantics.objmap.graph.annotations.OptionalRelatedElements;\r
  20 import org.simantics.objmap.graph.annotations.RelatedElements;\r
  21 import org.simantics.objmap.graph.annotations.RelatedElementsGet;\r
  22 import org.simantics.objmap.graph.annotations.RelatedGetObj;\r
  23 import org.simantics.objmap.graph.annotations.RelatedGetValue;\r
  24 import org.simantics.objmap.graph.annotations.RelatedOrderedSetElements;\r
  25 import org.simantics.objmap.graph.annotations.RelatedValue;\r
  26 import org.simantics.objmap.graph.annotations.UpdateMethod;\r
  27 import org.simantics.objmap.graph.annotations.factories.CompoundRelatedGetSetValueRuleFactory;\r
  28 import org.simantics.objmap.graph.annotations.factories.OptionalRelatedElementsRuleFactory;\r
  29 import org.simantics.objmap.graph.annotations.factories.RelatedElementsRuleFactory;\r
  30 import org.simantics.objmap.graph.annotations.factories.RelatedElementsRuleFactory2;\r
  31 import org.simantics.objmap.graph.annotations.factories.RelatedGetSetObjRuleFactory;\r
  32 import org.simantics.objmap.graph.annotations.factories.RelatedGetSetValueRuleFactory;\r
  33 import org.simantics.objmap.graph.annotations.factories.RelatedOrderedSetElementsRuleFactory;\r
  34 import org.simantics.objmap.graph.annotations.factories.RelatedValueRuleFactory;\r
  35 import org.simantics.objmap.graph.annotations.factories.UpdateMethodFactory;\r
  36 import org.simantics.objmap.graph.annotations.meta.IsClassRule;\r
  37 import org.simantics.objmap.graph.annotations.meta.IsCollectionRule;\r
  38 import org.simantics.objmap.graph.annotations.meta.IsFieldRule;\r
  39 import org.simantics.objmap.graph.annotations.meta.IsGetSetRule;\r
  40 import org.simantics.objmap.graph.annotations.meta.IsMethodRule;\r
  41 import org.simantics.objmap.graph.rules.factory.IClassRuleFactory;\r
  42 import org.simantics.objmap.graph.rules.factory.ICollectionRuleFactory;\r
  43 import org.simantics.objmap.graph.rules.factory.IFieldRuleFactory;\r
  44 import org.simantics.objmap.graph.rules.factory.IGetSetRuleFactory;\r
  45 import org.simantics.objmap.graph.rules.factory.IMethodRuleFactory;\r
  46 \r
  47 \r
  48 public class MappingSchemas {\r
  49         /**\r
  50      * Creates a new SimpleLinkType based on the annotations in the given class.\r
  51      * @throws IllegalAccessException \r
  52      * @throws InstantiationException \r
  53      * @see GraphType\r
  54      * @see RelatedValue\r
  55      */\r
  56         public static SimpleLinkType<Object> fromAnnotations(ReadGraph g, Class<?> clazz) throws DatabaseException, InstantiationException, IllegalAccessException {\r
  57             GraphType graphType = clazz.getAnnotation(GraphType.class);\r
  58             \r
  59             if (graphType != null) {\r
  60                     ArrayList<IBidirectionalMappingRule<Resource, Object>> rules = new ArrayList<IBidirectionalMappingRule<Resource, Object>>();\r
  61                     collectRulesFromAnnotations(g, clazz, rules);\r
  62                     \r
  63                     return new SimpleLinkType<Object>(g.getResource(graphType.value()), clazz, rules);  \r
  64             }\r
  65             DynamicGraphType dynamicType = clazz.getAnnotation(DynamicGraphType.class);\r
  66             if (dynamicType != null) {\r
  67                 ArrayList<IBidirectionalMappingRule<Resource, Object>> rules = new ArrayList<IBidirectionalMappingRule<Resource, Object>>();\r
  68                     collectRulesFromAnnotations(g, clazz, rules);\r
  69                     \r
  70                     return new DynamicSimpleLinkType<Object>(g.getResource(dynamicType.value()), clazz, rules);\r
  71             }\r
  72             throw new IllegalArgumentException("Class " + clazz.toString() + " does not contain annotations.");\r
  73         }\r
  74         \r
  75         public static void collectRulesFromAnnotations(ReadGraph g, Class<?> clazz, Collection<IBidirectionalMappingRule<Resource, Object>> rules) throws DatabaseException, InstantiationException, IllegalAccessException {\r
  76             Class<?> superclass = clazz.getSuperclass();\r
  77             if(superclass != null)\r
  78                 collectRulesFromAnnotations(g, superclass, rules);\r
  79                 \r
  80         for(Annotation annotation : clazz.getAnnotations()) {\r
  81 \r
  82                 IsClassRule tag = annotation.annotationType().getAnnotation(IsClassRule.class);\r
  83             if(tag!= null) {\r
  84                 rules.add(createClassRule(g, annotation, clazz).create(g, annotation, clazz));\r
  85             }\r
  86         }\r
  87 \r
  88         for(Field f : clazz.getDeclaredFields()) {\r
  89             f.setAccessible(true);\r
  90 \r
  91             for(Annotation annotation : f.getAnnotations()) {\r
  92 \r
  93                 IsFieldRule tag = annotation.annotationType().getAnnotation(IsFieldRule.class);\r
  94                 if(tag != null) {\r
  95                     rules.add(createFieldRule(g, annotation, f).create(g, annotation, f));\r
  96                 }\r
  97             }\r
  98         }\r
  99 \r
 100         for(Method m : clazz.getDeclaredMethods()) {\r
 101             m.setAccessible(true);\r
 102 \r
 103             for(Annotation annotation : m.getAnnotations()) {\r
 104                 IsMethodRule tag = \r
 105                         annotation.annotationType().getAnnotation(IsMethodRule.class);\r
 106                 if(tag != null) {\r
 107                         rules.add(createMethodRule(g, annotation, m).create(g, annotation, m));\r
 108                 }\r
 109             }\r
 110         }\r
 111         \r
 112         for (Method m : clazz.getDeclaredMethods()) {\r
 113                 m.setAccessible(true);\r
 114                 for (Annotation annotation : m.getAnnotations()) {\r
 115                         Class<? extends Annotation> annotationType = annotation.annotationType();\r
 116 \r
 117                          IsGetSetRule tag = \r
 118                          annotationType.getAnnotation(IsGetSetRule.class);\r
 119                          if (tag != null) {\r
 120                                  \r
 121                                  HasSetter setterAnnType = annotationType.getAnnotation(HasSetter.class);\r
 122                                  \r
 123                                  Class<? extends Annotation> setterAnn = setterAnnType.value();\r
 124                                  \r
 125                                  Method getter = m;\r
 126                                  \r
 127                                  IGetSetRuleFactory<Resource,Object> ruleFactory = createGetSetRuleFactory(g, annotation, getter);\r
 128                                  \r
 129                                  \r
 130                                  Method setter = null;\r
 131                                  \r
 132                                  for (Method m2 : clazz.getDeclaredMethods()) {\r
 133                                          Annotation set = m2.getAnnotation(setterAnn);\r
 134                                          if (set != null && ruleFactory.isSetter(annotation, set))\r
 135                                                  setter = m2;\r
 136                                  }\r
 137 \r
 138                                  rules.add(ruleFactory.create(g, annotation, getter, setter));\r
 139                          }\r
 140                 \r
 141                 }\r
 142         }\r
 143         \r
 144         for (Method m : clazz.getDeclaredMethods()) {\r
 145                 m.setAccessible(true);\r
 146                 for (Annotation annotation : m.getAnnotations()) {\r
 147                         Class<? extends Annotation> annotationType = annotation.annotationType();\r
 148 \r
 149                          IsCollectionRule tag = \r
 150                          annotationType.getAnnotation(IsCollectionRule.class);\r
 151                          if (tag != null) {\r
 152                                  \r
 153                                  HasCollectionAdder adderAnnType = annotationType.getAnnotation(HasCollectionAdder.class);\r
 154                                  HasCollectionRemover removerAnnType = annotationType.getAnnotation(HasCollectionRemover.class);\r
 155                 \r
 156                                  Class<? extends Annotation> adderAnn = adderAnnType.value();\r
 157                                  Class<? extends Annotation> removerAnn = removerAnnType.value();\r
 158                                  \r
 159                                  Method getter = m;\r
 160                                  \r
 161                                  ICollectionRuleFactory<Resource,Object> ruleFactory = createCollectionRuleFactory(g, annotation, getter);\r
 162                                  \r
 163                                  \r
 164                                  Method adder = null;\r
 165                                  Method remover = null;\r
 166                                  \r
 167                                  for (Method m2 : clazz.getDeclaredMethods()) {\r
 168                                          Annotation add = m2.getAnnotation(adderAnn);\r
 169                                          Annotation rem = m2.getAnnotation(removerAnn);\r
 170                                          if (add != null && ruleFactory.isAdder(annotation, add))\r
 171                                                  adder = m2;\r
 172                                          if (rem != null && ruleFactory.isRemover(annotation, rem))\r
 173                                                  remover = m2;\r
 174                                  }\r
 175                                  \r
 176                                  \r
 177                                  \r
 178                                  rules.add(ruleFactory.create(g, annotation, getter,adder,remover));\r
 179                          }\r
 180                 \r
 181                 }\r
 182         }\r
 183     }\r
 184         \r
 185         public static IClassRuleFactory<Resource, Object> createClassRule(ReadGraph g, Annotation annotation, Class<?> clazz) {\r
 186                 return null;\r
 187         }\r
 188         \r
 189         public static IFieldRuleFactory<Resource,Object> createFieldRule(ReadGraph g, Annotation annotation, Field field) {\r
 190                 if (annotation.annotationType().equals(RelatedElements.class))\r
 191                         return new RelatedElementsRuleFactory<Object>();\r
 192                 if (annotation.annotationType().equals(RelatedValue.class))\r
 193                         return new RelatedValueRuleFactory<Object>();\r
 194                 if (annotation.annotationType().equals(OptionalRelatedElements.class))\r
 195                         return new OptionalRelatedElementsRuleFactory<Object>();\r
 196                 if (annotation.annotationType().equals(RelatedOrderedSetElements.class))\r
 197                         return new RelatedOrderedSetElementsRuleFactory<Object>();\r
 198                 return null;\r
 199         }\r
 200         \r
 201         public static IMethodRuleFactory<Resource, Object> createMethodRule(ReadGraph g, Annotation annotation, Method m) {\r
 202                 if (annotation.annotationType().equals(UpdateMethod.class))\r
 203                         return new UpdateMethodFactory<Resource,Object>();\r
 204                 return null;\r
 205         }\r
 206         \r
 207         public static IGetSetRuleFactory<Resource,Object> createGetSetRuleFactory(ReadGraph g, Annotation annotation, Method getter) {\r
 208                 if (annotation.annotationType().equals(RelatedGetValue.class))\r
 209                         return new RelatedGetSetValueRuleFactory<Object>();\r
 210                 if (annotation.annotationType().equals(RelatedGetObj.class))\r
 211                         return new RelatedGetSetObjRuleFactory<Object>();\r
 212                 if (annotation.annotationType().equals(CompoundRelatedGetValue.class))\r
 213                         return new CompoundRelatedGetSetValueRuleFactory<Object>();\r
 214                 return null;\r
 215         }\r
 216         \r
 217         public static ICollectionRuleFactory<Resource,Object> createCollectionRuleFactory(ReadGraph g, Annotation annotation, Method getter) {\r
 218                 if (annotation.annotationType().equals(RelatedElementsGet.class))\r
 219                         return new RelatedElementsRuleFactory2<Object>();\r
 220                 return null;\r
 221         }\r
 222         \r
 223         /**\r
 224      * Creates a new SimpleLinkType based on the annotations in the given class.\r
 225      * @throws IllegalAccessException \r
 226      * @throws InstantiationException \r
 227      * @see GraphType\r
 228      * @see RelatedValue\r
 229      */\r
 230         \r
 231         public static AdaptedLinkType<Object> fromAdaptable(ReadGraph g, String type, Class<?> clazz) throws DatabaseException, InstantiationException, IllegalAccessException {\r
 232             \r
 233             \r
 234             return new AdaptedLinkType<Object>(g.getResource(type), clazz);    \r
 235         }\r
 236         \r
 237         \r
 238 }\r