1 /*
   2  * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 package org.graalvm.graphio;
  26 
  27 import java.io.File;
  28 import java.io.IOException;
  29 import java.net.URI;
  30 import java.net.URISyntaxException;
  31 import java.nio.channels.WritableByteChannel;
  32 import java.util.Collection;
  33 import java.util.Map;
  34 
  35 final class ProtocolImpl<Graph, Node, NodeClass, Port, Block, ResolvedJavaMethod, ResolvedJavaField, Signature, NodeSourcePosition, Location>
  36                 extends GraphProtocol<Graph, Node, NodeClass, Port, Block, ResolvedJavaMethod, ResolvedJavaField, Signature, NodeSourcePosition, Location> {
  37     private final GraphStructure<Graph, Node, NodeClass, Port> structure;
  38     private final GraphTypes types;
  39     private final GraphBlocks<Graph, Block, Node> blocks;
  40     private final GraphElements<ResolvedJavaMethod, ResolvedJavaField, Signature, NodeSourcePosition> elements;
  41     private final GraphLocations<ResolvedJavaMethod, NodeSourcePosition, Location> locations;
  42 
  43     ProtocolImpl(int major, int minor, GraphStructure<Graph, Node, NodeClass, Port> structure, GraphTypes enums, GraphBlocks<Graph, Block, Node> blocks,
  44                     GraphElements<ResolvedJavaMethod, ResolvedJavaField, Signature, NodeSourcePosition> elements,
  45                     GraphLocations<ResolvedJavaMethod, NodeSourcePosition, Location> locs,
  46                     WritableByteChannel channel) throws IOException {
  47         super(channel, major, minor);
  48         this.structure = structure;
  49         this.types = enums;
  50         this.blocks = blocks;
  51         this.elements = elements;
  52         this.locations = locs;
  53     }
  54 
  55     ProtocolImpl(GraphProtocol<?, ?, ?, ?, ?, ?, ?, ?, ?, ?> parent, GraphStructure<Graph, Node, NodeClass, Port> structure, GraphTypes enums, GraphBlocks<Graph, Block, Node> blocks,
  56                     GraphElements<ResolvedJavaMethod, ResolvedJavaField, Signature, NodeSourcePosition> elements,
  57                     GraphLocations<ResolvedJavaMethod, NodeSourcePosition, Location> locs) {
  58         super(parent);
  59         this.structure = structure;
  60         this.types = enums;
  61         this.blocks = blocks;
  62         this.elements = elements;
  63         this.locations = locs;
  64     }
  65 
  66     @Override
  67     protected Graph findGraph(Graph current, Object obj) {
  68         return structure.graph(current, obj);
  69     }
  70 
  71     @Override
  72     protected Node findNode(Object obj) {
  73         return structure.node(obj);
  74     }
  75 
  76     @Override
  77     protected NodeClass findNodeClass(Object obj) {
  78         return structure.nodeClass(obj);
  79     }
  80 
  81     @Override
  82     protected NodeClass findClassForNode(Node obj) {
  83         NodeClass clazz = structure.classForNode(obj);
  84         if (clazz != null && (findNodeClass(clazz) == null || findNode(clazz) != null)) {
  85             throw new IllegalStateException("classForNode method shall return node class representation rather than node: " + clazz);
  86         }
  87         return clazz;
  88     }
  89 
  90     @Override
  91     protected String findNameTemplate(NodeClass clazz) {
  92         return structure.nameTemplate(clazz);
  93     }
  94 
  95     @Override
  96     protected int findNodeId(Node n) {
  97         return structure.nodeId(n);
  98     }
  99 
 100     @Override
 101     protected boolean hasPredecessor(Node node) {
 102         return structure.nodeHasPredecessor(node);
 103     }
 104 
 105     @Override
 106     protected int findNodesCount(Graph info) {
 107         return structure.nodesCount(info);
 108     }
 109 
 110     @Override
 111     protected Iterable<? extends Node> findNodes(Graph info) {
 112         return structure.nodes(info);
 113     }
 114 
 115     @Override
 116     protected void findNodeProperties(Node node, Map<String, Object> props, Graph info) {
 117         structure.nodeProperties(info, node, props);
 118     }
 119 
 120     @Override
 121     protected Port findClassEdges(NodeClass nodeClass, boolean dumpInputs) {
 122         if (dumpInputs) {
 123             return structure.portInputs(nodeClass);
 124         } else {
 125             return structure.portOutputs(nodeClass);
 126         }
 127     }
 128 
 129     @Override
 130     protected int findSize(Port edges) {
 131         return structure.portSize(edges);
 132     }
 133 
 134     @Override
 135     protected boolean isDirect(Port edges, int i) {
 136         return structure.edgeDirect(edges, i);
 137     }
 138 
 139     @Override
 140     protected String findName(Port edges, int i) {
 141         return structure.edgeName(edges, i);
 142     }
 143 
 144     @Override
 145     protected Object findType(Port edges, int i) {
 146         Object type = structure.edgeType(edges, i);
 147         if (findEnumOrdinal(type) < 0) {
 148             throw new IllegalStateException("edgeType method shall return an enum! Was: " + type);
 149         }
 150         return type;
 151     }
 152 
 153     @Override
 154     protected Collection<? extends Node> findNodes(Graph graph, Node node, Port port, int i) {
 155         return structure.edgeNodes(graph, node, port, i);
 156     }
 157 
 158     @Override
 159     protected Object findJavaClass(NodeClass clazz) {
 160         final Object type = structure.nodeClassType(clazz);
 161         if (!(type instanceof Class<?>) && findJavaTypeName(type) == null) {
 162             throw new IllegalStateException("nodeClassType method shall return a Java class (instance of Class)! Was: " + type);
 163         }
 164         return type;
 165     }
 166 
 167     @Override
 168     protected Object findEnumClass(Object enumValue) {
 169         return types.enumClass(enumValue);
 170     }
 171 
 172     @Override
 173     protected int findEnumOrdinal(Object obj) {
 174         return types.enumOrdinal(obj);
 175     }
 176 
 177     @Override
 178     protected String[] findEnumTypeValues(Object clazz) {
 179         return types.enumTypeValues(clazz);
 180     }
 181 
 182     @Override
 183     protected String findJavaTypeName(Object obj) {
 184         return types.typeName(obj);
 185     }
 186 
 187     @Override
 188     protected Collection<? extends Node> findBlockNodes(Graph info, Block block) {
 189         return blocks.blockNodes(info, block);
 190     }
 191 
 192     @Override
 193     protected int findBlockId(Block block) {
 194         return blocks.blockId(block);
 195     }
 196 
 197     @Override
 198     protected Collection<? extends Block> findBlocks(Graph graph) {
 199         return blocks.blocks(graph);
 200     }
 201 
 202     @Override
 203     protected Collection<? extends Block> findBlockSuccessors(Block block) {
 204         return blocks.blockSuccessors(block);
 205     }
 206 
 207     @Override
 208     protected ResolvedJavaMethod findMethod(Object obj) {
 209         return elements == null ? null : elements.method(obj);
 210     }
 211 
 212     @Override
 213     protected byte[] findMethodCode(ResolvedJavaMethod method) {
 214         return elements.methodCode(method);
 215     }
 216 
 217     @Override
 218     protected int findMethodModifiers(ResolvedJavaMethod method) {
 219         return elements.methodModifiers(method);
 220     }
 221 
 222     @Override
 223     protected Signature findMethodSignature(ResolvedJavaMethod method) {
 224         return elements.methodSignature(method);
 225     }
 226 
 227     @Override
 228     protected String findMethodName(ResolvedJavaMethod method) {
 229         return elements.methodName(method);
 230     }
 231 
 232     @Override
 233     protected Object findMethodDeclaringClass(ResolvedJavaMethod method) {
 234         return elements.methodDeclaringClass(method);
 235     }
 236 
 237     @Override
 238     protected int findFieldModifiers(ResolvedJavaField field) {
 239         return elements.fieldModifiers(field);
 240     }
 241 
 242     @Override
 243     protected String findFieldTypeName(ResolvedJavaField field) {
 244         return elements.fieldTypeName(field);
 245     }
 246 
 247     @Override
 248     protected String findFieldName(ResolvedJavaField field) {
 249         return elements.fieldName(field);
 250     }
 251 
 252     @Override
 253     protected Object findFieldDeclaringClass(ResolvedJavaField field) {
 254         return elements.fieldDeclaringClass(field);
 255     }
 256 
 257     @Override
 258     protected ResolvedJavaField findJavaField(Object object) {
 259         return elements == null ? null : elements.field(object);
 260     }
 261 
 262     @Override
 263     protected Signature findSignature(Object object) {
 264         return elements == null ? null : elements.signature(object);
 265     }
 266 
 267     @Override
 268     protected int findSignatureParameterCount(Signature signature) {
 269         return elements.signatureParameterCount(signature);
 270     }
 271 
 272     @Override
 273     protected String findSignatureParameterTypeName(Signature signature, int index) {
 274         return elements.signatureParameterTypeName(signature, index);
 275     }
 276 
 277     @Override
 278     protected String findSignatureReturnTypeName(Signature signature) {
 279         return elements.signatureReturnTypeName(signature);
 280     }
 281 
 282     @Override
 283     protected NodeSourcePosition findNodeSourcePosition(Object object) {
 284         return elements == null ? null : elements.nodeSourcePosition(object);
 285     }
 286 
 287     @Override
 288     protected ResolvedJavaMethod findNodeSourcePositionMethod(NodeSourcePosition pos) {
 289         return elements.nodeSourcePositionMethod(pos);
 290     }
 291 
 292     @Override
 293     protected NodeSourcePosition findNodeSourcePositionCaller(NodeSourcePosition pos) {
 294         return elements.nodeSourcePositionCaller(pos);
 295     }
 296 
 297     @Override
 298     protected int findNodeSourcePositionBCI(NodeSourcePosition pos) {
 299         return elements.nodeSourcePositionBCI(pos);
 300     }
 301 
 302     @Override
 303     protected Iterable<Location> findLocation(ResolvedJavaMethod method, int bci, NodeSourcePosition pos) {
 304         return locations.methodLocation(method, bci, pos);
 305     }
 306 
 307     @Override
 308     protected String findLocationFile(Location loc) throws IOException {
 309         if (loc == null) {
 310             return null;
 311         }
 312         URI u;
 313         try {
 314             u = locations.locationURI(loc);
 315         } catch (URISyntaxException ex) {
 316             throw new IOException(ex);
 317         }
 318         if (u == null) {
 319             return null;
 320         }
 321         if (u.getScheme() == null) {
 322             return u.getPath();
 323         }
 324         if ("file".equals(u.getScheme())) {
 325             return new File(u).getPath();
 326         }
 327         return null;
 328     }
 329 
 330     @Override
 331     protected int findLocationLine(Location loc) {
 332         return locations.locationLineNumber(loc);
 333     }
 334 
 335     @Override
 336     protected URI findLocationURI(Location loc) throws URISyntaxException {
 337         return locations.locationURI(loc);
 338     }
 339 
 340     @Override
 341     protected String findLocationLanguage(Location loc) {
 342         return locations.locationLanguage(loc);
 343     }
 344 
 345     @Override
 346     protected int findLocationStart(Location loc) {
 347         return locations.locationOffsetStart(loc);
 348     }
 349 
 350     @Override
 351     protected int findLocationEnd(Location loc) {
 352         return locations.locationOffsetEnd(loc);
 353     }
 354 
 355     @Override
 356     protected void findExtraNodes(Node node, Collection<? super Node> extraNodes) {
 357     }
 358 
 359     @Override
 360     protected String formatTitle(Graph graph, int id, String format, Object... args) {
 361         return String.format(format, args) + " [" + id + "]";
 362     }
 363 }