bundles/org.simantics.modeling/src/org/simantics/modeling/services/ComponentNamingUtil.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.modeling.services;
  13
  14 import java.util.Collections;
  15 import java.util.List;
  16 import java.util.Set;
  17
  18 import org.simantics.databoard.Bindings;
  19 import org.simantics.databoard.util.URIStringUtils;
  20 import org.simantics.db.ReadGraph;
  21 import org.simantics.db.Resource;
  22 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied2;
  23 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
  24 import org.simantics.db.common.utils.NameUtils;
  25 import org.simantics.db.common.utils.Versions;
  26 import org.simantics.db.exception.DatabaseException;
  27 import org.simantics.layer0.Layer0;
  28 import org.simantics.operation.Layer0X;
  29 import org.simantics.project.IProject;
  30 import org.simantics.structural.stubs.StructuralResource2;
  31
  32 /**
  33  * @author Tuukka Lehtonen
  34  */
  35 public final class ComponentNamingUtil {
  36
  37     private final static boolean DEBUG = false;
  38
  39     public static final String validateInstanceName(ReadGraph graph, IProject project, Resource configurationRoot,
  40             Resource composite, Resource componentType, String proposition, boolean acceptProposition) throws DatabaseException, NamingException {
  41         if (DEBUG) {
  42             System.out.println("validateInstanceName(project=" + project + ", configurationRoot=" + configurationRoot
  43                     + ", composite=" + composite + ", componentType=" + componentType + ", proposition=" + proposition + ")");
  44             System.out.println("  INVOKED FROM: " + new Exception().getStackTrace()[1].toString());
  45         }
  46
  47         ComponentNamingStrategy strategy = findNamingStrategy(graph, project, composite);
  48         if (strategy != null) {
  49             proposition = strategy.validateInstanceName(graph, configurationRoot, composite, componentType, proposition, acceptProposition);
  50         }
  51
  52         // As a fallback method, try to deduce the name based on type properties.
  53         if (proposition == null) {
  54             proposition = fallbackNameGeneration(graph, composite, componentType);
  55         }
  56
  57         return proposition;
  58     }
  59
  60     public static final String validateInstanceName(ReadGraph graph, IProject project, Resource configurationRoot, Resource component, String proposition, boolean acceptProposition) throws DatabaseException, NamingException {
  61
  62         Layer0 L0 = Layer0.getInstance(graph);
  63         Resource composite = graph.getPossibleObject(component, L0.PartOf);
  64
  65         ComponentNamingStrategy strategy = findNamingStrategy(graph, project, composite);
  66         if (strategy != null) {
  67             return strategy.validateInstanceName(graph, configurationRoot, component, proposition, acceptProposition);
  68         } else {
  69                 return null;
  70         }
  71
  72     }
  73
  74     public static final String findFreshInstanceName(ReadGraph graph, IProject project, Resource configurationRoot,
  75             Resource composite, Resource componentType) throws DatabaseException, NamingException {
  76
  77         String proposition = null;
  78
  79         if (DEBUG) {
  80             System.out.println("findFreshInstanceName(project=" + project + ", configurationRoot=" + configurationRoot
  81                     + ", composite=" + composite + ", componentType=" + componentType + ")");
  82             System.out.println("  INVOKED FROM: " + new Exception().getStackTrace()[1].toString());
  83         }
  84
  85         ComponentNamingStrategy strategy = findNamingStrategy(graph, project, composite);
  86         if (strategy != null) {
  87             proposition = strategy.findFreshInstanceName(graph, configurationRoot, composite, componentType);
  88         }
  89
  90         // As a fallback method, try to deduce the name based on type properties.
  91         if (proposition == null) {
  92             proposition = fallbackNameGeneration(graph, composite, componentType);
  93         }
  94
  95         return proposition;
  96     }
  97
  98     public static final String findFreshEscapedInstanceName(ReadGraph graph, IProject project, Resource configurationRoot,
  99             Resource composite, Resource componentType) throws DatabaseException, NamingException {
 100         if (DEBUG) {
 101             System.out.println("findFreshEscapedInstanceName(project=" + project + ", configurationRoot=" + configurationRoot
 102                     + ", composite=" + composite + ", componentType=" + componentType + ")");
 103             new Exception("trace").printStackTrace();
 104         }
 105         String proposition = findFreshInstanceName(graph, project, configurationRoot, composite, componentType);
 106         proposition = URIStringUtils.escape(proposition);
 107         return proposition;
 108     }
 109
 110     /**
 111      * @param graph
 112      * @param project
 113      * @param configurationRoot
 114      * @param composite
 115      * @param componentType
 116      * @param externallyReserved
 117      * @return
 118      * @throws DatabaseException
 119      * @throws NamingException
 120      */
 121     public static final String validateInstanceName(
 122             ReadGraph graph,
 123             IProject project,
 124             Resource configurationRoot,
 125             Resource composite,
 126             Resource componentType,
 127             Set<String> externallyReserved)
 128                     throws DatabaseException, NamingException
 129     {
 130         if (DEBUG) {
 131             System.out.println("validateInstanceName(project=" + project + ", configurationRoot=" + configurationRoot
 132                     + ", composite=" + composite + ", componentType=" + componentType + ")");
 133             System.out.println("  INVOKED FROM: " + new Exception().getStackTrace()[1].toString());
 134         }
 135
 136         ComponentNamingStrategy strategy = findNamingStrategy(graph, project, composite);
 137         if (strategy == null)
 138             throw new NamingException("No naming strategy available, project=" + project + ", composite=" + composite + ", componentType=" + componentType);
 139
 140         String proposition = ComponentNamingUtil.generateProposition(graph, composite, componentType);
 141         List<String> validated = strategy.validateInstanceNames(graph, configurationRoot, Collections.singletonList(proposition), true, externallyReserved);
 142         proposition = validated.get(0);
 143
 144         return proposition;
 145     }
 146
 147     /**
 148      * @param graph
 149      * @param project
 150      * @param configurationRoot
 151      * @param propositions
 152      * @param externallyReserved
 153      * @return
 154      * @throws DatabaseException
 155      * @throws NamingException
 156      */
 157     public static final List<String> validateInstanceNames(
 158             ReadGraph graph,
 159             IProject project,
 160             Resource configurationRoot,
 161             List<String> propositions,
 162             boolean acceptProposition,
 163             Set<String> externallyReserved)
 164                     throws DatabaseException, NamingException
 165     {
 166         ComponentNamingStrategy strategy = findNamingStrategy(graph, project, configurationRoot);
 167         if (strategy == null)
 168             throw new NamingException("No naming strategy available, project=" + project);
 169         return strategy.validateInstanceNames(graph, configurationRoot, propositions, acceptProposition, externallyReserved);
 170     }
 171
 172     /**
 173      * This is a fallback name generation method that deduces propositions
 174      * container-locally based on component type prefixes or names.
 175      *
 176      * @param graph
 177      * @param composite
 178      * @param componentType
 179      * @return
 180      * @throws DatabaseException
 181      */
 182     private static String fallbackNameGeneration(ReadGraph graph, Resource container, Resource componentType)
 183             throws DatabaseException {
 184         return NameUtils.findFreshName(graph, generateProposition(graph, container, componentType), container);
 185     }
 186
 187     public static String generateProposition(ReadGraph graph, String containerGeneratedNamePrefix, Resource componentType) throws DatabaseException {
 188         Layer0X L0X = Layer0X.getInstance(graph);
 189         StringBuilder proposition = new StringBuilder();
 190         if (containerGeneratedNamePrefix != null)
 191             proposition.append(containerGeneratedNamePrefix);
 192         String componentPrefix = graph.getPossibleRelatedValue(componentType, L0X.HasGeneratedNamePrefix, Bindings.STRING);
 193         if (componentPrefix == null || "".equals(componentPrefix)) {
 194             Layer0 L0 = Layer0.getInstance(graph);
 195             String name = graph.getPossibleRelatedValue(componentType, L0.HasName);
 196             if (name == null)
 197                 componentPrefix = "Entity";
 198             else
 199                 componentPrefix = Versions.getBaseName(name);
 200         }
 201         proposition.append(componentPrefix);
 202         return proposition.toString();
 203     }
 204
 205     public static String generateProposition(ReadGraph graph, Resource container, Resource componentType) throws DatabaseException {
 206         Layer0X L0X = Layer0X.getInstance(graph);
 207         String containerPrefix = graph.getPossibleRelatedValue(container, L0X.HasGeneratedNamePrefix, Bindings.STRING);
 208         return generateProposition(graph, containerPrefix != null ? containerPrefix : "", componentType);
 209     }
 210
 211     public static final ComponentNamingStrategy findNamingStrategy(ReadGraph graph, IProject project, Resource composite) throws DatabaseException {
 212         // Primarily, use naming function from composite
 213         ComponentNamingStrategy strategy = graph.syncRequest(
 214                 new PossibleRelatedValueImplied2<ComponentNamingStrategy>(composite, StructuralResource2.getInstance(graph).Composite_namingFunction),
 215                 TransientCacheListener.<ComponentNamingStrategy>instance());
 216         if (strategy == null && project != null) {
 217             // If not available, try to find ComponentNamingStrategy for project
 218             strategy = project.getHint(ComponentNamingStrategy.PROJECT_KEY);
 219         }
 220         return strategy;
 221     }
 222
 223 }