ctf/org.eclipse.tracecompass.ctf.core/src/org/eclipse/tracecompass/ctf/core/event/types/StructDefinition.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011, 2014 Ericsson, Ecole Polytechnique de Montreal and others
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors: Matthew Khouzam - Initial API and implementation
  10  * Contributors: Simon Marchi - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.ctf.core.event.types;
  14
  15 import java.util.Collections;
  16 import java.util.LinkedList;
  17 import java.util.List;
  18 import java.util.Map;
  19
  20 import org.eclipse.jdt.annotation.NonNull;
  21 import org.eclipse.tracecompass.ctf.core.event.scope.IDefinitionScope;
  22 import org.eclipse.tracecompass.ctf.core.event.scope.ILexicalScope;
  23 import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration.InternalDef;
  24
  25 import com.google.common.base.Joiner;
  26 import com.google.common.collect.ImmutableList;
  27 import com.google.common.collect.ImmutableMap;
  28 import com.google.common.collect.ImmutableMap.Builder;
  29
  30 /**
  31  * A CTF structure definition (similar to a C structure).
  32  *
  33  * A structure is similar to a C structure, it is a compound data type that
  34  * contains other datatypes in fields. they are stored in an hashmap and indexed
  35  * by names which are strings.
  36  *
  37  * TODO: move me to internal
  38  *
  39  * @version 1.0
  40  * @author Matthew Khouzam
  41  * @author Simon Marchi
  42  */
  43 public final class StructDefinition extends ScopedDefinition implements ICompositeDefinition {
  44
  45     // ------------------------------------------------------------------------
  46     // Attributes
  47     // ------------------------------------------------------------------------
  48
  49     private final @NonNull List<@NonNull String> fFieldNames;
  50     private final Definition[] fDefinitions;
  51     private Map<String, Definition> fDefinitionsMap = null;
  52
  53     // ------------------------------------------------------------------------
  54     // Constructors
  55     // ------------------------------------------------------------------------
  56
  57     /**
  58      * Constructor
  59      *
  60      * @param declaration
  61      *            the parent declaration
  62      * @param definitionScope
  63      *            the parent scope
  64      * @param structFieldName
  65      *            the field name
  66      * @param definitions
  67      *            the definitions
  68      * @since 1.0
  69      */
  70     public StructDefinition(@NonNull StructDeclaration declaration,
  71             IDefinitionScope definitionScope,
  72             @NonNull String structFieldName,
  73             Definition[] definitions) {
  74         super(declaration, definitionScope, structFieldName);
  75         fFieldNames = ImmutableList.copyOf(declaration.getFieldsList());
  76         fDefinitions = definitions;
  77         if (fFieldNames.isEmpty()) {
  78             fDefinitionsMap = Collections.EMPTY_MAP;
  79         }
  80     }
  81
  82     /**
  83      * Constructor This one takes the scope and thus speeds up definition
  84      * creation
  85      *
  86      * @param declaration
  87      *            the parent declaration
  88      * @param definitionScope
  89      *            the parent scope
  90      * @param scope
  91      *            the scope of this variable
  92      * @param structFieldName
  93      *            the field name
  94      * @param fieldNames
  95      *            the list of fields
  96      * @param definitions
  97      *            the definitions
  98      * @since 1.0
  99      */
 100     public StructDefinition(@NonNull StructDeclaration declaration,
 101             IDefinitionScope definitionScope,
 102             @NonNull ILexicalScope scope,
 103             @NonNull String structFieldName,
 104             @NonNull Iterable<@NonNull String> fieldNames,
 105             Definition[] definitions) {
 106         super(declaration, definitionScope, structFieldName, scope);
 107         fFieldNames = ImmutableList.copyOf(fieldNames);
 108         fDefinitions = definitions;
 109         if (fFieldNames.isEmpty()) {
 110             fDefinitionsMap = Collections.EMPTY_MAP;
 111         }
 112     }
 113
 114     // ------------------------------------------------------------------------
 115     // Getters/Setters/Predicates
 116     // ------------------------------------------------------------------------
 117
 118     @Override
 119     public Definition getDefinition(String fieldName) {
 120         if (fDefinitionsMap == null) {
 121             /* Build the definitions map */
 122             Builder<String, Definition> mapBuilder = new ImmutableMap.Builder<>();
 123             for (int i = 0; i < fFieldNames.size(); i++) {
 124                 if (fDefinitions[i] != null) {
 125                     mapBuilder.put(fFieldNames.get(i), fDefinitions[i]);
 126                 }
 127             }
 128             fDefinitionsMap = mapBuilder.build();
 129         }
 130         return fDefinitionsMap.get(fieldName);
 131     }
 132
 133     @Override
 134     public @NonNull List<@NonNull String> getFieldNames() {
 135         return fFieldNames;
 136     }
 137
 138     @Override
 139     public StructDeclaration getDeclaration() {
 140         return (StructDeclaration) super.getDeclaration();
 141     }
 142
 143     // ------------------------------------------------------------------------
 144     // Operations
 145     // ------------------------------------------------------------------------
 146
 147     @Override
 148     public Definition lookupDefinition(String lookupPath) {
 149         return lookupDefinition(lookupPath, null);
 150     }
 151
 152     @Override
 153     public String toString() {
 154         StringBuilder builder = new StringBuilder();
 155
 156         builder.append("{ "); //$NON-NLS-1$
 157
 158         List<String> fields = new LinkedList<>();
 159         for (String field : fFieldNames) {
 160             String appendee = field + " = " + lookupDefinition(field).toString(); //$NON-NLS-1$
 161             fields.add(appendee);
 162         }
 163         Joiner joiner = Joiner.on(", ").skipNulls(); //$NON-NLS-1$
 164         builder.append(joiner.join(fields));
 165
 166         builder.append(" }"); //$NON-NLS-1$
 167
 168         return builder.toString();
 169     }
 170
 171     /**
 172      * Lookup definition while exclusing the caller
 173      *
 174      * @param lookupPath
 175      *            the path to lookup
 176      * @param defintionToExclude
 177      *            the definition to exclude, can be null
 178      * @return the definition or null
 179      * @since 1.1
 180      */
 181     public Definition lookupDefinition(String lookupPath, ScopedDefinition defintionToExclude) {
 182         /*
 183          * The fields are created in order of appearance, so if a variant or
 184          * sequence refers to a field that is after it, the field's definition
 185          * will not be there yet in the hashmap.
 186          */
 187         int val = fFieldNames.indexOf(lookupPath);
 188         if (val != -1) {
 189             return fDefinitions[val];
 190         }
 191         String lookupUnderscored = "_" + lookupPath; //$NON-NLS-1$
 192         val = fFieldNames.indexOf(lookupUnderscored);
 193         if (val != -1) {
 194             return fDefinitions[val];
 195         }
 196         for (IDefinition child : fDefinitions) {
 197             if (child instanceof ScopedDefinition) {
 198                 if (!child.equals(defintionToExclude)) {
 199                     IDefinition def = ((ScopedDefinition) child).lookupDefinition(lookupPath);
 200                     if (def instanceof Definition) {
 201                         return (Definition) def;
 202                     }
 203                 }
 204             }
 205         }
 206         if (getDefinitionScope() instanceof InternalDef) {
 207             return (Definition) ((InternalDef) getDefinitionScope()).lookupDefinitionBreakLoop(lookupPath);
 208         }
 209         return (Definition) getDefinitionScope().lookupDefinition(lookupPath);
 210     }
 211
 212 }