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

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