Creating and Modifying Aspect Models

import static org.eclipse.esmf.metamodel.DataTypes.*;
import static org.eclipse.esmf.metamodel.Elements.*;
import static org.eclipse.esmf.metamodel.builder.SammBuilder.*;

import java.util.Locale;

import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
import org.eclipse.esmf.metamodel.Aspect;

final AspectModelUrn namespace = AspectModelUrn.fromUrn( "urn:samm:org.example:1.0.0" );
final Aspect aspect = aspect( namespace.withName( "Aspect" ) )
      .preferredName( "My Aspect" )
      .property( property( namespace.withName( "property" ) )
            .preferredName( "My Property" )
            .description( "This is a test property" )
            .characteristic( samm_c.Text )
            .build() )
      .property( property( namespace.withName( "mySecondProperty" ) )
            .preferredName( "My second Property", Locale.ENGLISH )
            .description( "This is my second test property", Locale.ENGLISH )
            .characteristic( trait( namespace.withName( "MyTrait" ) )
                  .preferredName( "My Trait" )
                  .baseCharacteristic( characteristic()
                        .preferredName( "Custom characteristic" )
                        .dataType( xsd.integer )
                        .build() )
                  .constraint( regularExpressionConstraint()
                        .value( "a.*b" )
                        .build() )
                  .build() )
            .build() )
      .build();

final AspectModel aspectModel = new AspectModelLoader().load(
      // a File, InputStream or AspectModelUrn
);

// All changes to an Aspect Model are done using an AspectChangeManager.
// Optionally, you can pass a config object as first constructor argument:
final AspectChangeManagerConfig config = AspectChangeManagerConfigBuilder.builder()
      .detailedChangeReport( true )
      .defaultFileHeader( List.of( "Generated on "
            + new SimpleDateFormat( "dd-MM-yyyy" ).format( new Date() ) ) )
      .build();
final AspectChangeManager changeManager = new AspectChangeManager( config, aspectModel );

// You can create a single change, or you can combine multiple changes into a group.
// For all possible refactoring operations, see classes implementing the Change interface.
final Change refactorModel = new ChangeGroup( List.of(
      // Rename an element. This works with with samm:Aspect and all other model elements.
      new RenameElement( aspectModel.aspect(), "MyAspect" ),
      // Move an element to a new Aspect Model file in the same namespace.
      new MoveElementToNewFile(
            // The element to move.
            aspectModel.aspect().getProperties().get( 0 ),
            // If you intend to write the model to the file system, set the location
            // for the newly created file to some sensible location  here.
            URI.create( "file:///temp/out.ttl" ) )
) );

// Apply the changes and get a report that summerizes the changes.
final ChangeReport changeReport = changeManager.applyChange( refactorModel );

// If you want to display the change report, you can serialize it to a string:
ChangeReportFormatter.INSTANCE.apply( changeReport, config );

// Alternatively, you can also get views on collections containing modified/
// added/removed files for the last applied change.
changeManager.createdFiles().forEach( file -> System.out.println( "Created: " + file ) );
changeManager.modifiedFiles().forEach( file -> System.out.println( "Modified: " + file ) );
changeManager.removedFiles().forEach( file -> System.out.println( "Removed: " + file ) );

// At this point, you could use the AspectChangeManager's undo() method to revert
// the last change (refactorModel in this case); afterwards you can also redo().
// This functionality is mainly interesting when refactoring the Aspect Model
// interactively.

// If you want to write the model changes to the file system, use the AspectSerializer.
// Each AspectModelFile will be written to its respective source location.
// Alternatively, the AspectSerializer also provides a method to write an AspectModelFile
// into a String.
AspectSerializer.INSTANCE.write( aspectModel );

// AspectModel as returned by the AspectModelLoader
final AspectModel aspectModel = // ...

// A String that contains the pretty printed Aspect Model
final String aspectString =
      AspectSerializer.INSTANCE.aspectToString( aspectModel.aspect() );

AspectModelFile aspectModelFile = // ...
final String fileString = aspectModelFile.sourceRepresentation();