Problem

A Layout DXL Column script should show the differences to another baseline

Approach

• Right-click column header
• Select „New“
• Choose „Layout DXL“  radio button
• Click on the browser button
• Click on New
• Insert the script below
• Be aware to have all line breaks in the code like below

Replace {baselineToCompare} to the major version that you want to compare with the current version.

Solution

// This script shall be replace {baselineToCompare}
/**************************************************
 * Author: Björn Karpenstein
 * Date:   2014-10-09
 *
 * This is a layout DXL to show the differences from 
 * the current version to another baseline. 
 **************************************************/
Baseline oldBaseline = baseline({baselineToCompare}, 0,"");

Buffer bBefore = create;
Buffer bAfter = create;
Buffer result = create;
AttrDef ad;

Module oldModule = load(module(obj), oldBaseline, false)
Module currModule = current
showDeletedObjects(true)
int i = obj."Absolute Number"
Object oldObject = object(i, oldModule)

void compareColumn(string columnName)
{
  ad = find(oldModule, columnName);
		
  if(!null(ad) && !null(oldObject))
  {
    bBefore = oldObject.columnName;
  }
  else bBefore = "";
		
  ad = find(currModule, columnName)

  if(!null(ad))
  {
    bAfter = obj.columnName;
  }
  else bAfter = "";
		
  bAfter = obj.columnName;

  if( bBefore != bAfter )
  {
    diff(result, bBefore, bAfter);
    displayRichWithColor("{\\b " columnName " CHANGED}");
    displayRichWithColor(stringOf(result));
  }
}
				
if(null(oldObject))
{
  displayRichWithColor("{\\b NEW}");
  if(isDeleted(obj)) displayRichWithColor("{\\b DELETED}");
}
else
{			
  if(isDeleted(obj) && !isDeleted(oldObject))
  {
    displayRichWithColor("{\\b DELETED}");
  }
  else
  {
    if(!isDeleted(obj) && isDeleted(oldObject))
    {
      displayRichWithColor("{\\b UNDELETED}");
    }
  
    // Here you can add the 
    // module attributes to compare	
		
    /*** BB_ReqStatus ***/		
    compareColumn("BB_ReqStatus");
	
    /*** BB_Type ***/
    compareColumn("BB_Type");

    /*** Last Modified On ***/
    compareColumn("Last Modified On");
		
    /*** Object Heading ***/
    compareColumn("Object Heading");

    /*** Object Text ***/
    compareColumn("Object Text");
  }
}
		
delete bBefore;
delete bAfter;
delete result;

Problem

Ein Standard-Filter kann aus logischen Ausdrücke nach Spalten und Attributen bestehen. Möchte man einen Filter anhand komplexerer Strukturen aufbauen, stößt man bei den Möglichkeiten, die die Doors GUI bietet, an die Grenzen.

Approach

In solchen Fällen kann man die internen Funktionen benutzen, die bei einer Filterung verwendet werden.

• Filtern ausschalten
• Iteration über das Modul
• Abfrage der komplexeren Bedingungen, die das Filtern tun sollen (hier einfache IF() Struktur)
• accept(obj) <– diese Objekte kommen in den Filter
• reject(obj) <– diese Object werden aus dem Filter entfernt
• Filtern einschalten

Solution

Module m = current;
filtering off;	
Object anObject = null;
for anObject in m do
{
  if(anObject."BB_Type" "" != "Reviewer")
  {
    reject anObject;
  }
  else
  {
    accept anObject;
  }
}
filtering on;

Problem

A new view with the Main-Column (Object Heading and Object Text), a LayoutDXL Attribute and any other attribute shall be created.

Approach

• Create View from Default View (overwrite existing)
• Delete all columns in the Default View
• Insert Columns

Solution

With this script you can iterate over all Attributes you can select for the view:

Module m = current;
string attr;

for attr in m do
{
  print attr "\n";
}

The following script generates the view:

void createViewForModule(Module m, string viewName)
{	
  // construct view of attributes chosen
  Column c;
  int n = 0; // number of existing columns
  int i; // column index
	
  View v = view(viewName);
  bool isLoaded = load(m,v);

  if(!isLoaded)
  {
    // If the view is not existing
    // Save the view
    // Normally the default View 
    // is constructed 	
    // save(m,v) is not asking
    // if a view exists -> it 
    // overwrites any view with
    // the same name	
    save(m,v);
   }		
	
   // count the columns
   for c in m do
   {
      n++; 
   }
	
   // Delete all columns that were
   // contained in the default View
   // used as template
   for(i=1;i<=n;i++)
   {
     delete(column 0); 
   }
	
   // Add Object Identifier (i.e. CRS-CS-2)
   insert(column 0);
   attribute(column 0, "Object Identifier");
   width(column 0, 80);
   justify(column 0, left);
	
    // Add the main Column (Object Heading+
    // Object Text) to the View
    Column mainColumn = null;
    mainColumn = insert mainColumn;
    main mainColumn;
    width(mainColumn, 300);
	
    // Add Object Identifier (i.e. CRS-CS-2)
    insert(column 2);
    attribute(column 2, "BB_ReqStatus");
    width(column 2, 80);	
	
    // Create a LayoutDXL Column in a view
    insert(column 3);  
    // I would recommend to #include scripts
    dxl(column 3, "displayRich \"huhu\""); 
    width(column 3, 80);	

    // important! (last column does not appear
    // otherwise)
    refresh m; 
    save view viewName; 
}

Problem

It shall be checked, if a view in an Formal module exists.

Approach

The load method returns false if a View cannot be loaded.

Solution

bool checkIfViewExists(Module m)
{
   View v = view("12 REVIEW L/C Status");
   bool isLoaded = load(m,v);

   if(isLoaded)
   {
     return true;		
   }
   else
   {
     return false;
   }	
   return false;
}

Problem

In Doors DXL all modules of a project should be read.

Approach

It is possible to filter for the ItemRef-Type „Formal“ when iterating a project without using recursion.

Solution

// This is necessary that it works
/*******************************************************
 * Author: Björn Karpenstein
 * Date:   2014-10-08
 * 
 * This DXL script iterates through all formal modules
 ******************************************************/

void forAllModules(void)
{
  Item itemRef;
  string shType;
  string sItemNameFull;
  string sItemName;
  Module moduleReference;
	
  string projectName = "/" name(current Project);
  print projectName "\n";
	
  for itemRef in project projectName do 
  {
    shType = type(itemRef);
    print shType "\t";

    sItemNameFull = fullName(itemRef);
    print sItemNameFull "\t";
		
    sItemName = name(itemRef);
    print sItemName "\n";	
	
    if(shType=="Formal")
    {
      moduleReference = read(sItemNameFull,false);
    }
  }
}

// Main-Method
void main(void)
{
  forAllModules();
}

main();

Für alle Module eine Folders (rekursiv) siehe …
To get all modules from a folder also see …

IBM Doors DXL: Rekursiv durch alle Module eines Folders / Iterate recursive all formal modules of a folder

Problem

A String should be analyzed for it’s ASCII codes. Sometimes this is helpful when you get import files from a foreign system.
Sometimes there are invisible signs that can only be shown in the ASCII Code.

Approach

A string will be generated that shows the sign (c) and the real ASCII Code in brackets c[ASCII]

Solution

// Zum analysieren eines Strings auf seine Ascii Zeichen
string giveMeAscii(string withoutAscii)
{
string myAsciiString = „“;

for (i=0; i

Problem

A module or a string should be analyzed for HTML or XML Tags.

Approach

The tags withing a module attribute shall be counted and the output should be send to the DXL Interaction window.

By running through the whole string, opening and closing tags can be found.
Here the steps are the following:
1.) Create a Skip-List that counts all tags
2.) Create a loop over the current module
3.) Within the loop call the Method checkForTags and

Solution

pragma runLim, 0;

/********************************************************************
 * Author: 	Bjoern Karpenstein
 * Date: 	2014-09-16
 * Parameter: 
 * Skipliste tagCount (vorher mit Skip tagCount=create; erzeugen)
 * string textToCheck (der auf XML Tags zu prüfende Text)
 * string tag (nach welchen Tag sehen? Falls leer alle Tags sammeln
 ********************************************************************/
void checkForTags(Skip tagCount, string textToCheck, string tag)
{
   // init loop variables
 bool currentIsInTag = false;
 bool tagEnded = false;
 string tagBetweenBrackets = "";
 int x;
   	
 for (x=0; x<length(textToCheck)-1;x++)
 {
  if(textToCheck&#91;x:x&#93; "" == "<" "")
  {
    currentIsInTag = true;
    tagBetweenBrackets = "";
   }
           
   if(textToCheck&#91;x:x&#93; "" == ">" "" && currentIsInTag)
   {
     currentIsInTag = false;

     // Wenn der Tag schon vorhanden ... eins hochzählen
     int vorhanden = 0;

     if(find(tagCount, tagBetweenBrackets ">", vorhanden))
     {
       // nehmen und eins hochzählen
       if(matches(lower(tag), lower(tagBetweenBrackets)))
       {
	// Lösche den aktuellen Wert in Skip-Liste		   		   
	delete (tagCount, tagBetweenBrackets ">");
		   		   
	// Füge den aktuellen Wert inkrementiert in Stückliste ein
	put(tagCount, tagBetweenBrackets ">", vorhanden+1);
       }
    }
    else
    {
      // Wenn nicht vorhanden initial mit 1 einfügen
      if(matches(lower(tag), lower(tagBetweenBrackets)))
      {
         put(tagCount, tagBetweenBrackets ">", 1);
      }
     }  
    }
      
    if(currentIsInTag)
    {
       tagBetweenBrackets = tagBetweenBrackets textToCheck[x:x] "";
    }
  }   
}

void main()
{
  Object o;
  Module m = current;
  Filter off;
  Skip tagCount = create;
	
  for o in m do
  {		
    string engText = o."Text_english" "";
    string gerText = o."Text_german" "";
		
    checkForTags(tagCount, engText, "");
    checkForTags(tagCount, gerText, "");
  }
	
  for myIterator in tagCount do 
  {
    string keyValue = (string key(tagCount));
   
    int dasVorhandene=0;
	   
    if(find(tagCount, keyValue, dasVorhandene))
    {
      print keyValue " \t" dasVorhandene "\n";
    }
  }
	
  delete(tagCount);
}

main();