Java Schematic.getUserDefinedType方法代码示例

import org.manifold.compiler.middle.Schematic; //导入方法依赖的package包/类
@Test
public void testDeserialize_UserDefinedArray()
    throws JsonSyntaxException, IOException, UndeclaredIdentifierException {
  URL url = Resources
      .getResource("org/manifold/compiler/serialization/data/"
          + "deserialization-udt-array.json");

  JsonObject json = new JsonParser().parse(
      Resources.toString(url, Charsets.UTF_8)).getAsJsonObject();
  Schematic sch = new SchematicDeserializer().deserialize(json);

  final String UDT_TYPENAME = "Bitvector";
  UserDefinedTypeValue udt = sch.getUserDefinedType(UDT_TYPENAME);
  assertTrue(udt.getTypeAlias() instanceof ArrayTypeValue);
  ArrayTypeValue arrayType = (ArrayTypeValue) udt.getTypeAlias();
  assertTrue(arrayType.getElementType()
      .isSubtypeOf(BooleanTypeValue.getInstance()));
}
 

import org.manifold.compiler.middle.Schematic; //导入方法依赖的package包/类
@Test
public void testSerialize_UserDefinedArray()
    throws SchematicException {
  // add an array UDT to the test schematic
  TypeValue bitvectorType = new ArrayTypeValue(
      testSchematic.getUserDefinedType("Bool"));
  String typename = "Bitvector";
  testSchematic.addUserDefinedType(
      new UserDefinedTypeValue(bitvectorType, typename));
  // serialize, deserialize, check that the type looks okay
  JsonObject result = SchematicSerializer.serialize(testSchematic);

  Gson gson = new GsonBuilder().setPrettyPrinting().create();
  JsonParser jp = new JsonParser();
  JsonElement je = jp.parse(result.toString());
  String prettyJsonString = gson.toJson(je);

  System.out.println(prettyJsonString);

  Schematic sch = new SchematicDeserializer().deserialize(result);
  try {
    UserDefinedTypeValue udt = sch.getUserDefinedType(typename);
    assertTrue(udt.getTypeAlias() instanceof ArrayTypeValue);
    ArrayTypeValue arrayType = (ArrayTypeValue) udt.getTypeAlias();
    assertTrue(arrayType.getElementType()
        .isSubtypeOf(BooleanTypeValue.getInstance()));
  } catch (UndeclaredIdentifierException e) {
    fail("undeclared identifier '" + e.getIdentifier() + "'; "
        + "the user-defined type may not have been serialized");
  }
}
 

import org.manifold.compiler.middle.Schematic; //导入方法依赖的package包/类
@Test
public void testGetUserDefinedType() throws SchematicException {
  Schematic sch = new Schematic("test");
  String udtName = "TestUDT";
  UserDefinedTypeValue tv = new UserDefinedTypeValue(
      BooleanTypeValue.getInstance(), udtName);
  sch.addUserDefinedType(tv);
  TypeValue actual = sch.getUserDefinedType(udtName);
  assertEquals(tv, actual);
}
 

import org.manifold.compiler.middle.Schematic; //导入方法依赖的package包/类
private void deserializePortTypes(Schematic sch, JsonObject in)
    throws JsonSyntaxException, MultipleDefinitionException,
    UndeclaredIdentifierException {

  if (in == null) {
    // TODO warning?
    return;
  }

  for (Entry<String, JsonElement> entry : in.entrySet()) {
    Map<String, TypeValue> attributeMap = getTypeDefAttributes(sch, entry
        .getValue().getAsJsonObject());

    // get signal type
    if (!(entry.getValue().getAsJsonObject().has(SIGNAL_TYPE))) {
      throw new JsonSyntaxException("port type '" + entry.getKey() + "'"
          + " does not define a signal type;"
          + " possible schematic version mismatch");
    }
    String signalTypeName = entry.getValue().getAsJsonObject()
        .get(SIGNAL_TYPE).getAsString();
    TypeValue signalType = sch.getUserDefinedType(signalTypeName);

    // get supertype if it exists
    PortTypeValue supertype = null;
    if (entry.getValue().getAsJsonObject().has(SUPERTYPE)) {
      String supertypeName = entry.getValue().getAsJsonObject()
          .get(SUPERTYPE).getAsString();
      supertype = sch.getPortType(supertypeName);
    }

    PortTypeValue portTypeValue = null;
    if (supertype == null) {
      portTypeValue = new PortTypeValue(signalType, attributeMap);
    } else {
      portTypeValue = new PortTypeValue(signalType, attributeMap, supertype);
    }

    compTable.put(entry.getKey(), portTypeValue);
    sch.addPortType(entry.getKey(), portTypeValue);
  }
}
 

import org.manifold.compiler.middle.Schematic; //导入方法依赖的package包/类
@Before
public void setup() throws SchematicException {

  testSchematic = new Schematic(TEST_SCHEMATIC_NAME);

  // port type
  PortTypeValue din = new PortTypeValue(
      testSchematic.getUserDefinedType("Bool"), new HashMap<>());
  PortTypeValue dout = new PortTypeValue(
      testSchematic.getUserDefinedType("Bool"), new HashMap<>());
  testSchematic.addPortType(DIGITAL_IN, din);
  testSchematic.addPortType(DIGITAL_OUT, dout);

  // node type
  HashMap<String, PortTypeValue> dinPortMap = new HashMap<>();
  dinPortMap.put(IN_PORT_NAME, din);

  HashMap<String, PortTypeValue> doutPortMap = new HashMap<>();
  doutPortMap.put(OUT_PORT_NAME, dout);

  NodeTypeValue dinNodeType = new NodeTypeValue(new HashMap<>(), dinPortMap);
  NodeTypeValue doutNodeType = new NodeTypeValue(new HashMap<>(),
      doutPortMap);

  testSchematic.addNodeType(IN_NODE_NAME, dinNodeType);
  testSchematic.addNodeType(OUT_NODE_NAME, doutNodeType);

  // node
  Map<String, Map<String, Value>> inNodeAttr = new HashMap<>();
  inNodeAttr.put(IN_PORT_NAME, new HashMap<>());

  Map<String, Map<String, Value>> outNodeAttr = new HashMap<>();
  outNodeAttr.put(OUT_PORT_NAME, new HashMap<>());

  NodeValue inNode = new NodeValue(dinNodeType, new HashMap<>(), inNodeAttr);
  testSchematic.addNode("nIN", inNode);

  NodeValue outNode = new NodeValue(doutNodeType, new HashMap<>(),
      outNodeAttr);
  testSchematic.addNode("nOUT", outNode);

  ConnectionValue con = new ConnectionValue(inNode
      .getPort(IN_PORT_NAME), outNode.getPort(OUT_PORT_NAME),
      new HashMap<>());

  testSchematic.addConnection(CONNECTION_NAME, con);

  // constraint
  TypeValue stringType = testSchematic.getUserDefinedType("String");
  ConstraintType constraintType = new ConstraintType(ImmutableMap.of(
      "foo", stringType,
      "din_reference", dinNodeType,
      "port_reference", din));
  testSchematic.addConstraintType(TEST_CONSTRAINT_TYPE_NAME, constraintType);

  ConstraintValue constraintValue = new ConstraintValue(constraintType,
      ImmutableMap.of(
          "foo", new StringValue(stringType, "bar"),
          "din_reference", inNode,
          "port_reference", inNode.getPort(IN_PORT_NAME)));

  testSchematic.addConstraint("c1", constraintValue);
}
 

import org.manifold.compiler.middle.Schematic; //导入方法依赖的package包/类
@Test
public void testSerializeInferredAttributes() throws
    SchematicException {

  final String NODE_TYPE_NAME = "NodeInferred";
  final String INFERRED_TYPE_NAME = "InferredBool";
  InferredTypeValue maybe = new InferredTypeValue(
      testSchematic.getUserDefinedType("Bool"));
  // add an inferred UDT to the test schematic
  UserDefinedTypeValue udtMaybe =
      new UserDefinedTypeValue(maybe, INFERRED_TYPE_NAME);
  testSchematic.addUserDefinedType(udtMaybe);
  BooleanValue trueValue = BooleanValue.getInstance(true);

  NodeTypeValue testNodeType = new NodeTypeValue(
      ImmutableMap.of("foom", udtMaybe), new HashMap<>());
  testSchematic.addNodeType(NODE_TYPE_NAME, testNodeType);

  Map<String, Value> withInferred =
      ImmutableMap.of("foom", new InferredValue(maybe, trueValue));
  Map<String, Value> withoutInferred =
      ImmutableMap.of("foom", new InferredValue(maybe));

  NodeValue nodeWithoutInferred =
      new NodeValue(testNodeType, withoutInferred, new HashMap<>());
  NodeValue nodeWithInferred =
      new NodeValue(testNodeType, withInferred, new HashMap<>());
  testSchematic.addNode("n1", nodeWithoutInferred);
  testSchematic.addNode("n2", nodeWithInferred);

  // serialize, deserialize, check that the type looks okay
  JsonObject result = SchematicSerializer.serialize(testSchematic);

  Gson gson = new GsonBuilder().setPrettyPrinting().create();
  JsonParser jp = new JsonParser();
  JsonElement je = jp.parse(result.toString());
  String prettyJsonString = gson.toJson(je);

  System.out.println(prettyJsonString);

  Schematic sch = new SchematicDeserializer().deserialize(result);
  try {
    UserDefinedTypeValue udt = sch.getUserDefinedType(INFERRED_TYPE_NAME);
    assertTrue(udt.getTypeAlias() instanceof InferredTypeValue);
    InferredTypeValue inferredType = (InferredTypeValue) udt.getTypeAlias();
    assertTrue(inferredType.getInferredType()
        .isSubtypeOf(BooleanTypeValue.getInstance()));
  } catch (UndeclaredIdentifierException e) {
    fail("undeclared identifier '" + e.getIdentifier() + "'; "
        + "the user-defined type may not have been serialized");
  }

  NodeValue n2 = sch.getNode("n2");
  InferredValue v2 = (InferredValue) n2.getAttribute("foom");
  assertEquals(trueValue, v2.get());
  NodeValue n1 = sch.getNode("n1");
  InferredValue v1 = (InferredValue) n1.getAttribute("foom");
  assertEquals(null, v1.get());
}
 

import org.manifold.compiler.middle.Schematic; //导入方法依赖的package包/类
@Test(expected = UndeclaredIdentifierException.class)
public void testGetUserDefinedType_Undeclared_ThrowsException()
    throws SchematicException {
  Schematic sch = new Schematic("test");
  TypeValue tv = sch.getUserDefinedType("bogus");
}