How to use kieker.analysisteetime.model.analysismodel.type

/**
 * @since 1.14
 */
public default String build(final OperationType operationType) {
  return this.build(operationType.getModifiers(), operationType.getReturnType(), operationType.getName(), operationType.getParameterTypes());
}

private OperationType addOperationType(final ComponentType componentType, final String operationSignature) {
  final String operationTypeKey = operationSignature;
  OperationType operationType = componentType.getProvidedOperations().get(operationSignature);
  if (operationType == null) {
    operationType = this.factory.createOperationType();
    operationType.setSignature(operationSignature);
    this.operationSignatureExtractor.extract(operationType);
    componentType.getProvidedOperations().put(operationTypeKey, operationType);
  }
  return operationType;
}

private OperationType buildOperationTypeBySiganture(final String signature) {
  final OperationType operationType = TypeFactory.eINSTANCE.createOperationType();
  operationType.setSignature(signature);
  return operationType;
}

/**
 * Test method for {@link kieker.analysisteetime.model.TypeModelAssembler#addRecord(java.lang.String, java.lang.String)}.
 */
@Test
public void testOperationExistsAfterAddRecordFromString() {
  final TypeModel typeModel = this.factory.createTypeModel();
  final TypeModelAssembler typeModelAssembler = new TypeModelAssembler(typeModel, new JavaComponentSignatureExtractor(),
      new JavaOperationSignatureExtractor());
  typeModelAssembler.addRecord(EXAMPLE_CLASS_SIGNATURE_1, EXAMPLE_OPERATION_SIGNATURE_1);
  typeModelAssembler.addRecord(EXAMPLE_CLASS_SIGNATURE_1, EXAMPLE_OPERATION_SIGNATURE_2);
  typeModelAssembler.addRecord(EXAMPLE_CLASS_SIGNATURE_2, EXAMPLE_OPERATION_SIGNATURE_3);
  final List<String> actualList = typeModel.getComponentTypes().get(EXAMPLE_CLASS_SIGNATURE_1).getProvidedOperations().values().stream()
      .map(c -> c.getSignature()).collect(Collectors.toList());
  final List<String> expectedList = Arrays.asList(EXAMPLE_OPERATION_SIGNATURE_1, EXAMPLE_OPERATION_SIGNATURE_2);
  Collections.sort(actualList);
  Collections.sort(expectedList);
  Assert.assertTrue(actualList.equals(expectedList));
}

private ComponentType addComponentType(final String componentSignature) {
  final String componentTypeKey = componentSignature;
  ComponentType componentType = this.typeModel.getComponentTypes().get(componentTypeKey);
  if (componentType == null) {
    componentType = this.factory.createComponentType();
    componentType.setSignature(componentSignature);
    this.componentSignatureExtractor.extract(componentType);
    this.typeModel.getComponentTypes().put(componentTypeKey, componentType);
  }
  return componentType;
}

/**
 * Test method for {@link kieker.analysisteetime.model.TypeModelAssembler#addRecord(kieker.common.record.flow.IOperationRecord)}.
 */
@Test
public void testOperationKeysExistsAfterAddRecordFromRecord() {
  final TypeModel typeModel = this.factory.createTypeModel();
  final TypeModelAssembler typeModelAssembler = new TypeModelAssembler(typeModel, new JavaComponentSignatureExtractor(),
      new JavaOperationSignatureExtractor());
  typeModelAssembler.addRecord(this.beforeOperationEvent1);
  typeModelAssembler.addRecord(this.beforeOperationEvent2);
  typeModelAssembler.addRecord(this.beforeOperationEvent3);
  final List<String> actualList = new ArrayList<>(typeModel.getComponentTypes().get(EXAMPLE_CLASS_SIGNATURE_1).getProvidedOperations().keySet());
  final List<String> expectedList = Arrays.asList(EXAMPLE_OPERATION_SIGNATURE_1, EXAMPLE_OPERATION_SIGNATURE_2);
  Collections.sort(actualList);
  Collections.sort(expectedList);
  Assert.assertTrue(actualList.equals(expectedList));
}

@Override
protected IVertex addVertex(final DeployedOperation deployedOperation) {
  final OperationType operation = deployedOperation.getAssemblyOperation().getOperationType();
  final ComponentType component = operation.getComponentType();
  final int componentId = this.identifierRegistry.getIdentifier(component);
  final IVertex componentVertex = this.graph.addVertexIfAbsent(componentId);
  componentVertex.setPropertyIfAbsent(PropertyKeys.TYPE, VertexType.COMPONENT_TYPE);
  componentVertex.setPropertyIfAbsent(PropertyKeys.NAME, component.getName());
  componentVertex.setPropertyIfAbsent(PropertyKeys.PACKAGE_NAME, component.getPackage());
  this.responseTimeDecorator.decorate(componentVertex, component);
  return componentVertex;
}

/**
 * @since 1.14
 */
public default String build(final ComponentType componentType) {
  return this.build(componentType.getPackage(), componentType.getName());
}

private ComponentType buildComponentTypeBySiganture(final String signature) {
  final ComponentType componentType = TypeFactory.eINSTANCE.createComponentType();
  componentType.setSignature(signature);
  return componentType;
}

@Override
public void extract(final ComponentType componentType) {
  // BETTER code clean up, copied from old kieker analysis
  final String signature = componentType.getSignature();
  final String packageName;
  final String name;
  if (signature.indexOf('.') != -1) {
    final String tmpComponentName = signature;
    int index = 0;
    for (index = tmpComponentName.length() - 1; index > 0; index--) {
      if (tmpComponentName.charAt(index) == '.') {
        break;
      }
    }
    packageName = tmpComponentName.substring(0, index);
    name = tmpComponentName.substring(index + 1);
  } else {
    packageName = "";
    name = signature;
  }
  componentType.setName(name);
  componentType.setPackage(packageName);
}

@Override
public String toString() {
  return String.format("%s: %s", this.getClass().getName(), assemblyOperation.getOperationType().getSignature());
}

public StaticModelsAssemblerStage(final SignatureExtractor signatureExtractor) {
  this(TypeFactory.eINSTANCE.createTypeModel(), AssemblyFactory.eINSTANCE.createAssemblyModel(), DeploymentFactory.eINSTANCE.createDeploymentModel(),
      signatureExtractor);
}

private void printComponent(final DeployedComponent component) {
  final String name = component.getAssemblyComponent().getComponentType().getSignature();
  this.printStream.println(INSERTION + name);
}

private AssemblyOperation addAssemblyOperation(final AssemblyComponent component, final String operationSignature) {
  final String operationKey = operationSignature;
  AssemblyOperation operation = component.getAssemblyOperations().get(operationKey);
  if (operation == null) {
    operation = this.factory.createAssemblyOperation();
    component.getAssemblyOperations().put(operationKey, operation);
    final ComponentType componentType = component.getComponentType();
    final String operationTypeKey = operationSignature;
    final OperationType operationType = componentType.getProvidedOperations().get(operationTypeKey);
    operation.setOperationType(operationType);
  }
  return operation;
}

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
public ComponentType getComponentType() {
  if (componentType != null && componentType.eIsProxy()) {
    InternalEObject oldComponentType = (InternalEObject)componentType;
    componentType = (ComponentType)eResolveProxy(oldComponentType);
    if (componentType != oldComponentType) {
      if (eNotificationRequired())
        eNotify(new ENotificationImpl(this, Notification.RESOLVE, AssemblyPackage.ASSEMBLY_COMPONENT__COMPONENT_TYPE, oldComponentType, componentType));
    }
  }
  return componentType;
}

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
public OperationType getOperationType() {
  if (operationType != null && operationType.eIsProxy()) {
    InternalEObject oldOperationType = (InternalEObject)operationType;
    operationType = (OperationType)eResolveProxy(oldOperationType);
    if (operationType != oldOperationType) {
      if (eNotificationRequired())
        eNotify(new ENotificationImpl(this, Notification.RESOLVE, AssemblyPackage.ASSEMBLY_OPERATION__OPERATION_TYPE, oldOperationType, operationType));
    }
  }
  return operationType;
}

private void testExtraction(final List<String> modifiers, final String returnType, final String name, final List<String> parameters) { // NOPMD (assert for other
                                                                    // tests)
  final OperationType operationType = this.buildComponentTypeByNames(modifiers, returnType, name, parameters);
  this.signatureExtractor.extract(operationType);
  final List<String> extractedModifiers = operationType.getModifiers();
  final String extractedReturnType = operationType.getReturnType();
  final String extractedName = operationType.getName();
  final List<String> extractedParameters = operationType.getParameterTypes();
  Assert.assertEquals(modifiers, extractedModifiers);
  Assert.assertEquals(returnType, extractedReturnType);
  Assert.assertEquals(name, extractedName);
  Assert.assertEquals(parameters, extractedParameters);
}

/**
 * Test method for {@link kieker.analysisteetime.model.TypeModelAssembler#addRecord(kieker.common.record.flow.IOperationRecord)}.
 */
@Test
public void testOperationExistsAfterAddRecordFromRecord() {
  final TypeModel typeModel = this.factory.createTypeModel();
  final TypeModelAssembler typeModelAssembler = new TypeModelAssembler(typeModel, new JavaComponentSignatureExtractor(),
      new JavaOperationSignatureExtractor());
  typeModelAssembler.addRecord(this.beforeOperationEvent1);
  typeModelAssembler.addRecord(this.beforeOperationEvent2);
  typeModelAssembler.addRecord(this.beforeOperationEvent3);
  final List<String> actualList = typeModel.getComponentTypes().get(EXAMPLE_CLASS_SIGNATURE_1).getProvidedOperations().values().stream()
      .map(c -> c.getSignature()).collect(Collectors.toList());
  final List<String> expectedList = Arrays.asList(EXAMPLE_OPERATION_SIGNATURE_1, EXAMPLE_OPERATION_SIGNATURE_2);
  Collections.sort(actualList);
  Collections.sort(expectedList);
  Assert.assertTrue(actualList.equals(expectedList));
}

private void testExtraction(final String packageName, final String name) { // NOPMD (assert for other tests)
  final ComponentType componentType = this.buildComponentTypeByNames(packageName, name);
  this.signatureExtractor.extract(componentType);
  final String extractedPackage = componentType.getPackage();
  final String extractedName = componentType.getName();
  Assert.assertEquals(packageName, extractedPackage);
  Assert.assertEquals(name, extractedName);
}

private void printOperation(final DeployedOperation operation) {
  final String name = operation.getAssemblyOperation().getOperationType().getSignature();
  this.printStream.println(INSERTION + INSERTION + name);
}