datatypes.java

好东西啊！你看看就知道了

package edu.stanford.db.rdf.uml.vocabulary.uml_datatypes_20000507;

import org.w3c.rdf.model.*;

/**
 * This class provides convenient access to schema information.
 * DO NOT MODIFY THIS FILE.
 * It was generated automatically by edu.stanford.db.rdf.vocabulary.Generator
 */

public class DataTypes {

  /** Namespace URI of this schema */
  public static final String _Namespace = "http://www.omg.org/uml/1.3/Foundation.Data_Types.";

  public static Resource MultiplicityRange_lower;

  public static Resource BooleanExpression;

  public static Resource CallConcurrencyKind;

  public static Resource UnlimitedInteger_c42;

  public static Resource AggregationKind;

  public static Resource ProcedureExpression;

  public static Resource Multiplicity_range;

  public static Resource MultiplicityRange;

  public static Resource Boolean;

  public static Resource MappingExpression;

  public static Resource ScopeKind_instance;

  public static Resource PseudostateKind_initial;

  public static Resource ParameterDirectionKind_in;

  public static Resource String;

  public static Resource ChangeableKind_addOnly;

  public static Resource Name;

  public static Resource PseudostateKind;

  public static Resource AggregationKind_aggregate;

  public static Resource MultiplicityRange_upper;

  public static Resource TimeExpression;

  public static Resource OrderingKind_ordered;

  public static Resource CallConcurrencyKind_guarded;

  public static Resource ParameterDirectionKind_return;

  public static Resource PseudostateKind_choice;

  public static Resource Expression;

  public static Resource ParameterDirectionKind_inout;

  public static Resource OrderingKind_unordered;

  public static Resource Name_body;

  public static Resource Expression_language;

  public static Resource UnlimitedInteger;

  public static Resource Time;

  public static Resource PseudostateKind_deepHistory;

  public static Resource CallConcurrencyKind_concurrent;

  public static Resource VisibilityKind_private;

  public static Resource VisibilityKind_protected;

  public static Resource Expression_body;

  public static Resource ScopeKind_classifier;

  public static Resource Multiplicity;

  public static Resource PseudostateKind_shallowHistory;

  public static Resource ParameterDirectionKind;

  public static Resource CallConcurrencyKind_sequential;

  public static Resource VisibilityKind_public;

  public static Resource Boolean_false;

  public static Resource ParameterDirectionKind_out;

  public static Resource AggregationKind_none;

  public static Resource ChangeableKind;

  public static Resource AggregationKind_composite;

  public static Resource Integer;

  public static Resource ChangeableKind_frozen;

  public static Resource ScopeKind;

  public static Resource Boolean_true;

  public static Resource PseudostateKind_join;

  public static Resource ChangeableKind_changeable;

  public static Resource PseudostateKind_junction;

  public static Resource OrderingKind;

  public static Resource VisibilityKind;

  public static Resource PseudostateKind_fork;

  static {
    try {
      setNodeFactory(new org.w3c.rdf.implementation.model.NodeFactoryImpl());
    } catch (ModelException ex) { ex.printStackTrace(System.err); }
  }

  private static Resource createResource(NodeFactory f, String suffix) throws ModelException {
    return f.createResource(_Namespace + suffix);
  }

  public static void setNodeFactory(NodeFactory f) throws ModelException {

    MultiplicityRange_lower = createResource(f, "MultiplicityRange.lower");
    BooleanExpression = createResource(f, "BooleanExpression");
    CallConcurrencyKind = createResource(f, "CallConcurrencyKind");
    UnlimitedInteger_c42 = createResource(f, "UnlimitedInteger.*");
    AggregationKind = createResource(f, "AggregationKind");
    ProcedureExpression = createResource(f, "ProcedureExpression");
    Multiplicity_range = createResource(f, "Multiplicity.range");
    MultiplicityRange = createResource(f, "MultiplicityRange");
    Boolean = createResource(f, "Boolean");
    MappingExpression = createResource(f, "MappingExpression");
    ScopeKind_instance = createResource(f, "ScopeKind.instance");
    PseudostateKind_initial = createResource(f, "PseudostateKind.initial");
    ParameterDirectionKind_in = createResource(f, "ParameterDirectionKind.in");
    String = createResource(f, "String");
    ChangeableKind_addOnly = createResource(f, "ChangeableKind.addOnly");
    Name = createResource(f, "Name");
    PseudostateKind = createResource(f, "PseudostateKind");
    AggregationKind_aggregate = createResource(f, "AggregationKind.aggregate");
    MultiplicityRange_upper = createResource(f, "MultiplicityRange.upper");
    TimeExpression = createResource(f, "TimeExpression");
    OrderingKind_ordered = createResource(f, "OrderingKind.ordered");
    CallConcurrencyKind_guarded = createResource(f, "CallConcurrencyKind.guarded");
    ParameterDirectionKind_return = createResource(f, "ParameterDirectionKind.return");
    PseudostateKind_choice = createResource(f, "PseudostateKind.choice");
    Expression = createResource(f, "Expression");
    ParameterDirectionKind_inout = createResource(f, "ParameterDirectionKind.inout");
    OrderingKind_unordered = createResource(f, "OrderingKind.unordered");
    Name_body = createResource(f, "Name.body");
    Expression_language = createResource(f, "Expression.language");
    UnlimitedInteger = createResource(f, "UnlimitedInteger");
    Time = createResource(f, "Time");
    PseudostateKind_deepHistory = createResource(f, "PseudostateKind.deepHistory");
    CallConcurrencyKind_concurrent = createResource(f, "CallConcurrencyKind.concurrent");
    VisibilityKind_private = createResource(f, "VisibilityKind.private");
    VisibilityKind_protected = createResource(f, "VisibilityKind.protected");
    Expression_body = createResource(f, "Expression.body");
    ScopeKind_classifier = createResource(f, "ScopeKind.classifier");
    Multiplicity = createResource(f, "Multiplicity");
    PseudostateKind_shallowHistory = createResource(f, "PseudostateKind.shallowHistory");
    ParameterDirectionKind = createResource(f, "ParameterDirectionKind");
    CallConcurrencyKind_sequential = createResource(f, "CallConcurrencyKind.sequential");
    VisibilityKind_public = createResource(f, "VisibilityKind.public");
    Boolean_false = createResource(f, "Boolean.false");
    ParameterDirectionKind_out = createResource(f, "ParameterDirectionKind.out");
    AggregationKind_none = createResource(f, "AggregationKind.none");
    ChangeableKind = createResource(f, "ChangeableKind");
    AggregationKind_composite = createResource(f, "AggregationKind.composite");
    Integer = createResource(f, "Integer");
    ChangeableKind_frozen = createResource(f, "ChangeableKind.frozen");
    ScopeKind = createResource(f, "ScopeKind");
    Boolean_true = createResource(f, "Boolean.true");
    PseudostateKind_join = createResource(f, "PseudostateKind.join");
    ChangeableKind_changeable = createResource(f, "ChangeableKind.changeable");
    PseudostateKind_junction = createResource(f, "PseudostateKind.junction");
    OrderingKind = createResource(f, "OrderingKind");
    VisibilityKind = createResource(f, "VisibilityKind");
    PseudostateKind_fork = createResource(f, "PseudostateKind.fork");
  }
}