bundles/org.simantics.mapping/src/org/simantics/mapping/pattern/MappingRule.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in 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.mapping.pattern;\r
  13 \r
  14 \r
  15 public class MappingRule {\r
  16         /*\r
  17         static final THashSet<Resource> EMPTY_SET = new THashSet<Resource>();\r
  18         \r
  19         THashMap<Resource, Resource> resourcesByDomains = new THashMap<Resource, Resource>();\r
  20         Collection<IConstraint> constraints = new ArrayList<IConstraint>();\r
  21         Collection<ConstraintGroup> constraintGroups = new ArrayList<ConstraintGroup>();\r
  22         \r
  23         static class ConstraintGroup {\r
  24                 Collection<IConstraint> constraints;\r
  25                 Collection<Resource> targets;\r
  26                 Collection<Resource> dependencies;\r
  27         }\r
  28         \r
  29         class DirectedRuleBuilder {\r
  30                 THashSet<Resource> sourceResources = new THashSet<Resource>();\r
  31                 THashSet<Resource> targetResources = new THashSet<Resource>();\r
  32                 THashSet<IConstraint> sourceConstraints = new THashSet<IConstraint>();\r
  33                 THashSet<IConstraint> targetConstraints = new THashSet<IConstraint>();\r
  34                 TObjectIntHashMap<Resource> boundResources;\r
  35                 int id;\r
  36                 \r
  37                 Instruction root = new DummyInstruction();\r
  38                 Instruction cur = root;\r
  39                 \r
  40                 public DirectedRuleBuilder(final THashSet<Resource> sourceDomains,\r
  41                                 TObjectIntHashMap<Resource> boundResources, int id) {\r
  42                         this.boundResources = boundResources;\r
  43                         this.id = id;\r
  44                         \r
  45                         // Classify resources\r
  46                         \r
  47                         resourcesByDomains.forEachEntry(new TObjectObjectProcedure<Resource, Resource>() {\r
  48 \r
  49                                 @Override\r
  50                                 public boolean execute(Resource domain, Resource resource) {\r
  51                                         if(sourceDomains.contains(domain))\r
  52                                                 sourceResources.add(resource);\r
  53                                         else\r
  54                                                 targetResources.add(resource);\r
  55                                         return true;\r
  56                                 }\r
  57                                 \r
  58                         });\r
  59                         \r
  60                         // Classify constraints                 \r
  61                         \r
  62                         for(IConstraint constraint : constraints) {\r
  63                                 if(sourceResources.containsAll(constraint.binds()))\r
  64                                         sourceConstraints.add(constraint);\r
  65                                 else\r
  66                                         targetConstraints.add(constraint);\r
  67                         }\r
  68                 }       \r
  69                 \r
  70                 int bestValue;\r
  71                 IConstraint bestConstraint;\r
  72                 \r
  73                 private void findBestConstraint(THashSet<IConstraint> constraints) {\r
  74                         bestValue = 0;\r
  75                         bestConstraint = null;\r
  76                         sourceConstraints.forEach(new TObjectProcedure<IConstraint>() {\r
  77                                 \r
  78                                 @Override\r
  79                                 public boolean execute(IConstraint constraint) {\r
  80                                         int temp = constraint.isApplicable(boundResources);\r
  81                                         if(temp>bestValue) {\r
  82                                                 bestValue = temp;\r
  83                                                 bestConstraint = constraint;\r
  84                                         }\r
  85                                         return true;\r
  86                                 }\r
  87                                 \r
  88                         });\r
  89                 }\r
  90                 \r
  91                 private void applyConstraint(THashSet<Resource> resources, IConstraint constraint) {\r
  92                         THashSet<Resource> unbounded = new THashSet<Resource>();\r
  93                         for(Resource r : constraint.binds())\r
  94                                 if(resources.remove(r)) {\r
  95                                         unbounded.add(r);\r
  96                                         boundResources.put(r, id++);\r
  97                                 }                                       \r
  98                         Instruction temp = constraint.createQueryInstruction(boundResources, unbounded);\r
  99                         cur.next = temp;\r
 100                         cur = temp;                     \r
 101                 }\r
 102                 \r
 103                 private void applyConstraints(THashSet<Resource> resources, THashSet<IConstraint> constraints) {\r
 104                         while(!constraints.isEmpty()) {\r
 105                                 findBestConstraint(constraints);                                \r
 106                                 if(bestConstraint != null) {\r
 107                                         applyConstraint(resources, bestConstraint);\r
 108                                         constraints.remove(bestConstraint);\r
 109                                 }\r
 110                                 else\r
 111                                         throw new RuntimeException("Cannot form a directed mapping.");\r
 112                         }\r
 113                 }\r
 114                 \r
 115                 public void orderSourceConstraints() {\r
 116                         applyConstraints(sourceResources, sourceConstraints);\r
 117                         if(!sourceResources.isEmpty())\r
 118                                 throw new RuntimeException("Couldn't bind all source resources");\r
 119                 }\r
 120                 \r
 121                 public void orderTargetConstraints() {\r
 122                         THashSet<ConstraintGroup> groups = new THashSet<ConstraintGroup>(constraintGroups);\r
 123                         while(!groups.isEmpty()) {\r
 124                                 \r
 125                                 // Find a suitable group\r
 126                                 \r
 127                                 final Ref<ConstraintGroup> possibleGroup = new Ref<ConstraintGroup>();\r
 128                                 final Collection<ConstraintGroup> removableGroups = new ArrayList<ConstraintGroup>();\r
 129                                 groups.forEach(new TObjectProcedure<ConstraintGroup>() {\r
 130 \r
 131                                         @Override\r
 132                                         public boolean execute(ConstraintGroup group) {\r
 133                                                 for(Resource target : group.targets)\r
 134                                                         if(boundResources.containsKey(target)) {\r
 135                                                                 removableGroups.add(group);\r
 136                                                                 return true;\r
 137                                                         }\r
 138                                                 for(Resource dep : group.dependencies)\r
 139                                                         if(!boundResources.containsKey(dep))\r
 140                                                                 return true;\r
 141                                                 possibleGroup.value = group;\r
 142                                                 return false;\r
 143                                         }\r
 144                                         \r
 145                                 });\r
 146                                 groups.removeAll(removableGroups);\r
 147                                 if(possibleGroup.value == null) {\r
 148                                         if(!groups.isEmpty())\r
 149                                                 throw new RuntimeException("Couldn't find a suitable group.");\r
 150                                         break;\r
 151                                 }\r
 152                                 groups.remove(possibleGroup.value);\r
 153                                 ConstraintGroup group = possibleGroup.value;\r
 154                                         \r
 155                                 // Order group constraints\r
 156                                 \r
 157                                 THashSet<IConstraint> groupConstraints = new THashSet<IConstraint>();\r
 158                                 for(IConstraint constraint : group.constraints)\r
 159                                         if(targetConstraints.remove(constraint))\r
 160                                                 groupConstraints.add(constraint);\r
 161                                 \r
 162                                 applyConstraints(targetResources, groupConstraints);\r
 163                                 \r
 164                                 // Apply other constraints\r
 165                                 \r
 166                                 final Collection<IConstraint> removableConstraints = new ArrayList<IConstraint>();\r
 167                                 targetConstraints.forEach(new TObjectProcedure<IConstraint>() {\r
 168 \r
 169                                         @Override\r
 170                                         public boolean execute(IConstraint constraint) {\r
 171                                                 for(Resource r : constraint.binds())\r
 172                                                         if(!boundResources.containsKey(r))\r
 173                                                                 return true;\r
 174                                                 \r
 175                                                 Instruction temp = constraint.createQueryInstruction(boundResources, EMPTY_SET);\r
 176                                                 cur.next = temp;\r
 177                                                 cur = temp;\r
 178                                                 \r
 179                                                 removableConstraints.add(constraint);\r
 180                                                 return true;\r
 181                                         }\r
 182                                         \r
 183                                 });\r
 184                                 targetConstraints.removeAll(removableConstraints);\r
 185                         }\r
 186                         if(!targetResources.isEmpty())\r
 187                                 throw new RuntimeException("Couldn't bind all target resources");\r
 188                 }\r
 189                 \r
 190         }\r
 191         */\r
 192 }\r