@Override
 public int hashCode() {
   if (classifier == null) {
     return nextClassifier.hashCode();
   } else {
     return classifier.hashCode();
   }
 }
 protected ProxyClassInstance(UmlClass classifier, ProxyModelContext context) {
   super(classifier, context.getModel());
   this.classifier = classifier;
   for (Tag aTag : classifier.getTag()) {
     if (aTag.getName().equals(JavaModelGenerationDoclet.CLASS_PROXY_TAG)) {
       try {
         theClass = PlugInActivator.getClassLoader().loadClass(aTag.getValue());
       } catch (ClassNotFoundException e) {
         throw new ProxyModelException("Class not found", e);
       }
     }
   }
   if (theClass == null) {
     throw new ProxyModelException("assert");
   }
 }
  @Override
  public void fire(ActivityInstance context) {
    // perform all as semantics actions
    Object contextValue = null;
    MofClassSemantics semantics = null;
    switch (self.getActionKind()) {
      case EXPRESSION:
        DebugInfo.printInfo("eval " + self.getActionBody());
        propagateOutput(
            evaluateExpression(self, self.getActionBody(), self.getInput(), context),
            true,
            context);
        break;
      case CALL:
        DebugInfo.printInfo("call " + self.getActionBody());
        String operationName = getActionBody();
        ;
        contextValue = context.getOclContext();
        ReflectiveSequence<Argument> arguments = new ListImpl<Argument>();
        for (InputPin pin : self.getInput()) {
          if (pin instanceof ContextPin) {
            contextValue = ((PinInstance) context.getPlaces(pin)).getValue();
          } else {
            arguments.add(
                new ArgumentImpl(null, ((PinInstance) context.getPlaces(pin)).getValue()));
          }
        }
        if (contextValue == null) {
          throw new SemanticException("Context must not be null for call " + self.getActionBody());
        }
        semantics =
            MofClassSemantics.createClassClassifierForUmlClass(
                (UmlClass) getTypeForObject(contextValue));

        for (InputPin inputPin : self.getInput()) {
          if (!(inputPin instanceof ContextPin)) {
            operationName +=
                "_" + getTypeOfValue(((PinInstance) context.getPlaces(inputPin)).getValue());
          }
        }
        Operation operation = semantics.getFinalOperation(operationName);
        if (operation == null) {
          throw new SemanticException(
              "The arguments of action "
                  + toString()
                  + "(call "
                  + operationName
                  + ") does not match to an operation in the given context.");
        }
        Object result =
            ((cmof.reflection.Object) contextValue).invokeOperation(operation, arguments);
        propagateOutput(result, false, context);
        DebugInfo.printInfo("end call " + self.getActionBody());
        break;
      case PRINT:
        System.out.println(self.getActionBody());
        break;
      case WRITE_STRUCTURAL_FEATURE:
        DebugInfo.printInfo("set " + self.getActionBody());
        contextValue = context.getOclContext();
        Object featureValue = null;
        Object qualifierValue = null;
        for (InputPin pin : self.getInput()) {
          if (pin instanceof ContextPin) {
            contextValue = ((PinInstance) context.getPlaces(pin)).getValue();
          } else {
            if (featureValue != null) {
              if (qualifierValue != null) {
                throw new SemanticException(
                    "To much input pins for a write structural feature action.");
              }
              qualifierValue = featureValue;
            }
            featureValue = ((PinInstance) context.getPlaces(pin)).getValue();
            if (featureValue instanceof MofClassSemantics) {
              System.out.println("Fehler!!!");
            }
          }
        }
        Property feature = resolveFeature(contextValue);
        if (qualifierValue != null) {
          if (feature.getQualifier() == null) {
            throw new SemanticException(
                "To much input pins for a write structural feature action without qualifier.");
          }
          ((cmof.reflection.Object) contextValue).set(feature, qualifierValue, featureValue);
        } else {
          if (feature.getQualifier() != null) {
            throw new SemanticException(
                "Not enough input pins for a write structural feature action with qualifier.");
          }
          ((cmof.reflection.Object) contextValue).set(feature, featureValue);
        }
        break;
      case WRITE_STRUCTURAL_FEATURE_VALUE:
        DebugInfo.printInfo("add " + self.getActionBody());
        contextValue = context.getOclContext();
        featureValue = null;
        for (InputPin pin : self.getInput()) {
          if (pin instanceof ContextPin) {
            contextValue = ((PinInstance) context.getPlaces(pin)).getValue();
          } else {
            if (featureValue != null) {
              throw new SemanticException(
                  "To much input pins for a write structural feature action.");
            }
            featureValue = ((PinInstance) context.getPlaces(pin)).getValue();
          }
        }
        feature = resolveFeature(contextValue);
        ((ReflectiveSequence) ((cmof.reflection.Object) contextValue).get(feature))
            .add(featureValue);
        break;
      case REMOVE_STRUCTURAL_FEATURE_VALUE:
        DebugInfo.printInfo("remove " + self.getActionBody());
        contextValue = context.getOclContext();
        featureValue = null;
        for (InputPin pin : self.getInput()) {
          if (pin instanceof ContextPin) {
            contextValue = ((PinInstance) context.getPlaces(pin)).getValue();
          } else {
            if (featureValue != null) {
              throw new SemanticException(
                  "To much input pins for a write structural feature action.");
            }
            featureValue = ((PinInstance) context.getPlaces(pin)).getValue();
          }
        }
        feature = resolveFeature(contextValue);
        ((ReflectiveSequence) ((cmof.reflection.Object) contextValue).get(feature))
            .remove(featureValue);
        break;
      case CREATE_OBJECT:
        DebugInfo.printInfo("create " + self.getActionBody());
        boolean hasContextClass = false;
        contextValue = context.getOclContext();
        for (InputPin pin : self.getInput()) {
          if (pin instanceof ContextPin) {
            contextValue = ((PinInstance) context.getPlaces(pin)).getValue();
            hasContextClass = true;
          } else {
            throw new SemanticException(
                "Only a single context pin is allowed for a create action.");
          }
        }
        if (hasContextClass) {
          UmlClass syntaxClass = (UmlClass) getTypeForObject(contextValue);
          String className = self.getActionBody();
          UmlClass runtimeClass = null;
          for (Type classAsType : syntaxClass.getPackage().getOwnedType()) {
            if (classAsType instanceof UmlClass && className.equals(classAsType.getName())) {
              runtimeClass = (UmlClass) classAsType;
            }
          }
          if (runtimeClass == null) {
            throw new SemanticException(
                "Class with name "
                    + className
                    + " does not exist in package "
                    + syntaxClass.getPackage().getQualifiedName()
                    + ".");
          }
          semantics = MofClassSemantics.createClassClassifierForUmlClass(syntaxClass);
          Operation op =
              semantics.getFinalOperation(M1SemanticModel.getCreateOperationName(runtimeClass));
          result =
              ((cmof.reflection.Object) contextValue).invokeOperation(op, new ListImpl<Argument>());
          propagateOutput(result, false, context);
        } else {
          throw new SemanticException("not implemented yet.");
        }
        break;
      case PRINT_EXPRESSION:
        System.out.println(
            evaluateExpression(self, self.getActionBody(), self.getInput(), context));
        break;
      default:
        System.out.println("WARNING: unknown action kind");
    }

    // call the actual petri net semantics perfom method
    ((Transition) getSuper(Transition.class)).fire(context);
  }
 @Override
 public String toString() {
   return "ClassClass of " + classifier.toString();
 }