statesystem/org.eclipse.tracecompass.statesystem.core/src/org/eclipse/tracecompass/internal/statesystem/core/AttributeTree.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2015 Ericsson
   3  * Copyright (c) 2010, 2011 École Polytechnique de Montréal
   4  * Copyright (c) 2010, 2011 Alexandre Montplaisir <alexandre.montplaisir@gmail.com>
   5  *
   6  * All rights reserved. This program and the accompanying materials are
   7  * made available under the terms of the Eclipse Public License v1.0 which
   8  * accompanies this distribution, and is available at
   9  * http://www.eclipse.org/legal/epl-v10.html
  10  *
  11  * Contributors:
  12  *   Alexandre Montplaisir - Initial API and implementation
  13  *   Patrick Tasse - Add message to exceptions
  14  *******************************************************************************/
  15
  16 package org.eclipse.tracecompass.internal.statesystem.core;
  17
  18 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  19
  20 import java.io.BufferedInputStream;
  21 import java.io.File;
  22 import java.io.FileInputStream;
  23 import java.io.FileOutputStream;
  24 import java.io.IOException;
  25 import java.io.ObjectInputStream;
  26 import java.io.ObjectOutputStream;
  27 import java.io.PrintWriter;
  28 import java.nio.channels.FileChannel;
  29 import java.util.ArrayList;
  30 import java.util.Arrays;
  31 import java.util.List;
  32
  33 import org.eclipse.jdt.annotation.NonNull;
  34 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  35
  36 /**
  37  * The Attribute Tree is the /proc-like filesystem used to organize attributes.
  38  * Each node of this tree is both like a file and a directory in the
  39  * "file system".
  40  *
  41  * @author alexmont
  42  *
  43  */
  44 public final class AttributeTree {
  45
  46     /* "Magic number" for attribute tree files or file sections */
  47     private static final int ATTRIB_TREE_MAGIC_NUMBER = 0x06EC3671;
  48
  49     private final StateSystem ss;
  50     private final List<Attribute> attributeList;
  51     private final Attribute attributeTreeRoot;
  52
  53     /**
  54      * Standard constructor, create a new empty Attribute Tree
  55      *
  56      * @param ss
  57      *            The StateSystem to which this AT is attached
  58      */
  59     public AttributeTree(StateSystem ss) {
  60         this.ss = ss;
  61         this.attributeList = new ArrayList<>();
  62         this.attributeTreeRoot = new Attribute(null, "root", -1); //$NON-NLS-1$
  63     }
  64
  65     /**
  66      * "Existing file" constructor. Builds an attribute tree from a
  67      * "mapping file" or mapping section previously saved somewhere.
  68      *
  69      * @param ss
  70      *            StateSystem to which this AT is attached
  71      * @param fis
  72      *            File stream where to read the AT information. Make sure it's
  73      *            sought at the right place!
  74      * @throws IOException
  75      *             If there is a problem reading from the file stream
  76      */
  77     public AttributeTree(StateSystem ss, FileInputStream fis) throws IOException {
  78         this(ss);
  79         ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(fis));
  80
  81         /* Read the header of the Attribute Tree file (or file section) */
  82         int res = ois.readInt(); /* Magic number */
  83         if (res != ATTRIB_TREE_MAGIC_NUMBER) {
  84             throw new IOException("The attribute tree file section is either invalid or corrupted."); //$NON-NLS-1$
  85         }
  86
  87
  88         ArrayList<String[]> attribList;
  89         try {
  90             @SuppressWarnings("unchecked")
  91             ArrayList<String[]> list = (ArrayList<String[]>) ois.readObject();
  92             attribList = list;
  93         } catch (ClassNotFoundException e) {
  94             throw new IOException("Unrecognizable attribute list"); //$NON-NLS-1$
  95         }
  96
  97         /*
  98          * Now we have 'list', the ArrayList of String arrays representing all
  99          * the attributes. Simply create attributes the normal way from them.
 100          */
 101         for (String[] attrib : attribList) {
 102             this.getQuarkAndAdd(-1, attrib);
 103         }
 104     }
 105
 106     /**
 107      * Tell the Attribute Tree to write itself somewhere in a file.
 108      *
 109      * @param file
 110      *            The file to write to
 111      * @param pos
 112      *            The position (in bytes) in the file where to write
 113      */
 114     public synchronized void writeSelf(File file, long pos) {
 115         try (FileOutputStream fos = new FileOutputStream(file, true);
 116                 FileChannel fc = fos.getChannel();) {
 117             fc.position(pos);
 118             try (ObjectOutputStream oos = new ObjectOutputStream(fos)) {
 119
 120                 /* Write the almost-magic number */
 121                 oos.writeInt(ATTRIB_TREE_MAGIC_NUMBER);
 122
 123                 /* Compute the serialized list of attributes and write it */
 124                 List<String[]> list = new ArrayList<>(attributeList.size());
 125                 for (Attribute entry : this.attributeList) {
 126                     list.add(entry.getFullAttribute());
 127                 }
 128                 oos.writeObject(list);
 129             }
 130         } catch (IOException e) {
 131             e.printStackTrace();
 132         }
 133
 134     }
 135
 136     /**
 137      * Return the number of attributes this system as seen so far. Note that
 138      * this also equals the integer value (quark) the next added attribute will
 139      * have.
 140      *
 141      * @return The current number of attributes in the tree
 142      */
 143     public synchronized int getNbAttributes() {
 144         return attributeList.size();
 145     }
 146
 147     /**
 148      * Get the quark for a given attribute path. No new attribute will be
 149      * created : if the specified path does not exist, throw an error.
 150      *
 151      * @param startingNodeQuark
 152      *            The quark of the attribute from which relative queries will
 153      *            start. Use '-1' to start at the root node.
 154      * @param subPath
 155      *            The path to the attribute, relative to the starting node.
 156      * @return The quark of the specified attribute
 157      * @throws AttributeNotFoundException
 158      *             If the specified path was not found
 159      */
 160     public synchronized int getQuarkDontAdd(int startingNodeQuark, String... subPath)
 161             throws AttributeNotFoundException {
 162         assert (startingNodeQuark >= -1);
 163
 164         Attribute prevNode;
 165
 166         /* If subPath is empty, simply return the starting quark */
 167         if (subPath == null || subPath.length == 0) {
 168             return startingNodeQuark;
 169         }
 170
 171         /* Get the "starting node" */
 172         if (startingNodeQuark == -1) {
 173             prevNode = attributeTreeRoot;
 174         } else {
 175             prevNode = attributeList.get(startingNodeQuark);
 176         }
 177
 178         int knownQuark = prevNode.getSubAttributeQuark(subPath);
 179         if (knownQuark == -1) {
 180             /*
 181              * The attribute doesn't exist, but we have been specified to NOT
 182              * add any new attributes.
 183              */
 184             throw new AttributeNotFoundException(ss.getSSID() + " Quark:" + startingNodeQuark + ", SubPath:" + Arrays.toString(subPath)); //$NON-NLS-1$ //$NON-NLS-2$
 185         }
 186         /*
 187          * The attribute was already existing, return the quark of that
 188          * attribute
 189          */
 190         return knownQuark;
 191     }
 192
 193     /**
 194      * Get the quark of a given attribute path. If that specified path does not
 195      * exist, it will be created (and the quark that was just created will be
 196      * returned).
 197      *
 198      * @param startingNodeQuark
 199      *            The quark of the attribute from which relative queries will
 200      *            start. Use '-1' to start at the root node.
 201      * @param subPath
 202      *            The path to the attribute, relative to the starting node.
 203      * @return The quark of the attribute represented by the path
 204      */
 205     public synchronized int getQuarkAndAdd(int startingNodeQuark, String... subPath) {
 206         // FIXME synchronized here is probably quite costly... maybe only locking
 207         // the "for" would be enough?
 208         assert (subPath != null && subPath.length > 0);
 209         assert (startingNodeQuark >= -1);
 210
 211         Attribute nextNode = null;
 212         Attribute prevNode;
 213
 214         /* Get the "starting node" */
 215         if (startingNodeQuark == -1) {
 216             prevNode = attributeTreeRoot;
 217         } else {
 218             prevNode = attributeList.get(startingNodeQuark);
 219         }
 220
 221         int knownQuark = prevNode.getSubAttributeQuark(subPath);
 222         if (knownQuark == -1) {
 223             /*
 224              * The attribute was not in the table previously, and we want to add
 225              * it
 226              */
 227             for (String curDirectory : subPath) {
 228                 nextNode = prevNode.getSubAttributeNode(curDirectory);
 229                 if (nextNode == null) {
 230                     /* This is where we need to start adding */
 231                     nextNode = new Attribute(prevNode, checkNotNull(curDirectory), attributeList.size());
 232                     prevNode.addSubAttribute(nextNode);
 233                     attributeList.add(nextNode);
 234                     ss.addEmptyAttribute();
 235                 }
 236                 prevNode = nextNode;
 237             }
 238             return attributeList.size() - 1;
 239         }
 240         /*
 241          * The attribute was already existing, return the quark of that
 242          * attribute
 243          */
 244         return knownQuark;
 245     }
 246
 247     /**
 248      * Returns the sub-attributes of the quark passed in parameter
 249      *
 250      * @param attributeQuark
 251      *            The quark of the attribute to print the sub-attributes of.
 252      * @param recursive
 253      *            Should the query be recursive or not? If false, only children
 254      *            one level deep will be returned. If true, all descendants will
 255      *            be returned (depth-first search)
 256      * @return The list of quarks representing the children attributes
 257      * @throws AttributeNotFoundException
 258      *             If 'attributeQuark' is invalid, or if there is no attrbiute
 259      *             associated to it.
 260      */
 261     public synchronized @NonNull List<@NonNull Integer> getSubAttributes(int attributeQuark, boolean recursive)
 262             throws AttributeNotFoundException {
 263         List<@NonNull Integer> listOfChildren = new ArrayList<>();
 264         Attribute startingAttribute;
 265
 266         /* Check if the quark is valid */
 267         if (attributeQuark < -1 || attributeQuark >= attributeList.size()) {
 268             throw new AttributeNotFoundException(ss.getSSID() + " Quark:" + attributeQuark); //$NON-NLS-1$
 269         }
 270
 271         /* Set up the node from which we'll start the search */
 272         if (attributeQuark == -1) {
 273             startingAttribute = attributeTreeRoot;
 274         } else {
 275             startingAttribute = attributeList.get(attributeQuark);
 276         }
 277
 278         /* Iterate through the sub-attributes and add them to the list */
 279         addSubAttributes(listOfChildren, startingAttribute, recursive);
 280
 281         return listOfChildren;
 282     }
 283
 284     /**
 285      * Returns the parent quark of the attribute. The root attribute has no
 286      * parent and will return <code>-1</code>
 287      *
 288      * @param quark
 289      *            The quark of the attribute
 290      * @return Quark of the parent attribute or <code>-1</code> for the root
 291      *         attribute
 292      */
 293     public synchronized int getParentAttributeQuark(int quark) {
 294         if (quark == -1) {
 295             return quark;
 296         }
 297         return attributeList.get(quark).getParentAttributeQuark();
 298     }
 299
 300     private void addSubAttributes(List<Integer> list, Attribute curAttribute,
 301             boolean recursive) {
 302         for (Attribute childNode : curAttribute.getSubAttributes()) {
 303             list.add(childNode.getQuark());
 304             if (recursive) {
 305                 addSubAttributes(list, childNode, true);
 306             }
 307         }
 308     }
 309
 310     /**
 311      * Get then base name of an attribute specified by a quark.
 312      *
 313      * @param quark
 314      *            The quark of the attribute
 315      * @return The (base) name of the attribute
 316      */
 317     public synchronized @NonNull String getAttributeName(int quark) {
 318         return attributeList.get(quark).getName();
 319     }
 320
 321     /**
 322      * Get the full path name of an attribute specified by a quark.
 323      *
 324      * @param quark
 325      *            The quark of the attribute
 326      * @return The full path name of the attribute
 327      */
 328     public synchronized @NonNull String getFullAttributeName(int quark) {
 329         return attributeList.get(quark).getFullAttributeName();
 330     }
 331
 332     /**
 333      * Get the full path name (as an array of path elements) of an attribute
 334      * specified by a quark.
 335      *
 336      * @param quark
 337      *            The quark of the attribute
 338      * @return The path elements of the full path
 339      */
 340     public synchronized String @NonNull [] getFullAttributePathArray(int quark) {
 341         return attributeList.get(quark).getFullAttribute();
 342     }
 343
 344     /**
 345      * Debug-print all the attributes in the tree.
 346      *
 347      * @param writer
 348      *            The writer where to print the output
 349      */
 350     public synchronized void debugPrint(PrintWriter writer) {
 351         attributeTreeRoot.debugPrint(writer);
 352     }
 353
 354 }