home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / komix / DATA.Z / impfiles.tcl < prev    next >
Text File  |  1997-01-30  |  12KB  |  477 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. # Copyright (c) 1995 by Cadre Technologies Inc.
  4. #
  5. # This software is furnished under a license and may be used only in
  6. # accordance with the terms of such license and with the inclusion of
  7. # the above copyright notice. This software or any other copies thereof
  8. # may not be provided or otherwise made available to any other person.
  9. # No title to and ownership of the software is hereby transferred.
  10. #
  11. # The information in this software is subject to change without notice
  12. # and should not be construed as a commitment by Cadre Technologies Inc.
  13. #
  14. #---------------------------------------------------------------------------
  15. #
  16. #    File        : @(#)impfiles.tcl    /main/titanic/1
  17. #    Author        : Big Brother
  18. #    Original date    : September 1995
  19. #    Description    : Import files from same system in previous phase
  20. #              Import item properties for new items
  21. #              Overwrite descriptions is not supported, although
  22. #              it should not be a problem to implement it using
  23. #              the knownItems and knownQualItems lists.
  24. #
  25. #---------------------------------------------------------------------------
  26. #
  27.  
  28. source    [m4_path_name tcl cginit.tcl]
  29.  
  30. require    platform.tcl
  31.  
  32. Class FileImporter : GCObject {
  33.     #
  34.     # Context stuff
  35.     #
  36.     attribute cc
  37.     attribute currConfigV
  38.     attribute currPhaseV
  39.     attribute prevPhaseV
  40.     attribute currSysV
  41.     attribute prevSysV
  42.     #
  43.     # Overwrite properties ?
  44.     #
  45.     attribute overwriteProperties
  46.     #
  47.     # List of selected file id's in current system
  48.     #
  49.     attribute selectedFileList
  50.     #
  51.     # List of file versions to import
  52.     #
  53.     attribute importFileVList
  54.     #
  55.     # List of all items referred in files that we have to import and are
  56.     # defined in the system the file is in.
  57.     #
  58.     attribute itemList
  59.     #
  60.     # Lists of all normal and all qualified items from itemList that do not
  61.     # exist in the phase we are importing to
  62.     #
  63.     attribute newItems
  64.     attribute newQualItems
  65.     #
  66.     # List of all normal and all qualified items from itemList that exist in
  67.     # the phase we are importing to
  68.     #
  69.     attribute knownItems
  70.     attribute knownQualItems
  71.  
  72.     constructor
  73.  
  74.     method initialize
  75.     method listNewFiles
  76.     method listSelectedFiles
  77.     method buildItemList
  78.     method findItem
  79.     method findQualifiedItem
  80.     method import
  81.     method importFiles
  82.     method importItemProperties
  83.     method overwriteItemProperties
  84. }
  85.  
  86. constructor FileImporter {class object} {
  87.     set this [GCObject::constructor $class $object]
  88.  
  89.     $this overwriteProperties 0
  90.  
  91.     $this itemList [List new]
  92.     $this newItems [List new]
  93.     $this newQualItems [List new]
  94.     $this knownItems [List new]
  95.     $this knownQualItems [List new]
  96.  
  97.     return $this
  98. }
  99.  
  100. method FileImporter::initialize {this files} {
  101.     if {($files != "") && ([lindex $files 0] == "-overwrite")} {
  102.     lvarpop files
  103.     $this overwriteProperties 1
  104.     }
  105.  
  106.     $this selectedFileList $files
  107.  
  108.     $this cc [ClientContext::global]
  109.     $this currSysV [[$this cc] currentSystem]
  110.  
  111.     if {[[$this currSysV] isNil]} {
  112.     error "Not at system level"
  113.     }
  114.  
  115.     $this currConfigV [[$this cc] currentConfig]
  116.     $this currPhaseV [[$this cc] currentPhase]
  117.  
  118.     if {[[[$this currPhaseV] phase] type] == "Implementation"} {
  119.     error "Cannot copy files to implementation phase"
  120.     }
  121.  
  122.     $this prevPhaseV [[$this currPhaseV] previous [$this currConfigV]]
  123.  
  124.     if {[[$this prevPhaseV] isNil]} {
  125.     error "Previous phase version not found"
  126.     }
  127.  
  128.     set sysName [[[$this currSysV] system] name]
  129.     set sysType [[[$this currSysV] system] type]
  130.  
  131.     $this prevSysV [[$this prevPhaseV] findSystemVersion $sysName $sysType]
  132.  
  133.     if {[[$this prevSysV] isNil]} {
  134.     error "Unable to find system '$sysName.$sysType' in previous phase"
  135.     }
  136.  
  137.     if {[$this selectedFileList] == ""} {
  138.     #
  139.     # Import new: build a list of all new files
  140.     #
  141.  
  142.     $this listNewFiles
  143.     } else {
  144.     $this listSelectedFiles
  145.     }
  146.  
  147.     $this buildItemList
  148. }
  149.  
  150. #
  151. #    Build a list of all files that exist in previous system but not in
  152. #    current system
  153. #
  154.  
  155. method FileImporter::listNewFiles {this} {
  156.     foreach prevFileV [[$this prevSysV] allFileVersions] {
  157.     set fileName [[$prevFileV file] qualifiedName]
  158.     set fileType [[$prevFileV file] type]
  159.     if {[[[$this currSysV] findFileVersion $fileName $fileType] isNil]} {
  160.         if {[$prevFileV status] == "reused"} {
  161.         puts stdout "Skipping file $fileName.$fileType (reused)"
  162.         } else {
  163.         $this importFileVList [concat [$this importFileVList] $prevFileV]
  164.         }
  165.     }
  166.     }
  167. }
  168.  
  169. #
  170. #    Build a list of all files in the previous phase corresponding to the
  171. #    selected files in the current system
  172. #
  173.  
  174. method FileImporter::listSelectedFiles {this} {
  175.     foreach fileId [$this selectedFileList] {
  176.     set currFile [File new $fileId]
  177.  
  178.     if {[$currFile isNil]} {
  179.         puts stdout "File with id '$fileId' not found"
  180.         continue
  181.     }
  182.  
  183.     set fileName [$currFile qualifiedName]
  184.     set fileType [$currFile type]
  185.  
  186.     set prevFileV [[$this prevSysV] findFileVersion $fileName $fileType]
  187.  
  188.     if {[$prevFileV isNil]} {
  189.         puts stdout "File '$fileName.$fileType' not found in previous phase"
  190.         continue
  191.     }
  192.  
  193.     $this importFileVList [concat [$this importFileVList] $prevFileV]
  194.     }
  195. }
  196.  
  197. #
  198. #    Build lists of items that are defined in the system we are copying
  199. #    from and that are referred in the diagrams we are copying.
  200. #    Items with scope 'scopeFile' are not interesting because their
  201. #    properties are copied together with the file.
  202. #
  203.  
  204. method FileImporter::buildItemList {this} {
  205.     foreach fileV [$this importFileVList] {
  206.     foreach workItem [$fileV definedItemRefs [$this currConfigV]] {
  207.         if {[$workItem scope] != "scopeFile" &&
  208.         [lsearch [[$this itemList] contents] $workItem] == -1} {
  209.         [$this itemList] append $workItem
  210.         }
  211.     }
  212.     }
  213.  
  214.     #
  215.     # Check if item already exists in system we are importing to.
  216.     # If it already exists add it to one of the knownItems lists,
  217.     # otherwise to one of the newItems lists.
  218.     #
  219.  
  220.     [$this itemList] foreach workItem {
  221.     set name [$workItem name]
  222.     set type [$workItem type]
  223.     set qualifier [[$workItem item] qualifier]
  224.  
  225.     if [$qualifier isNil] {
  226.         set otherItem [$this findItem $name $type]
  227.  
  228.         if [$otherItem isNil] {
  229.         [$this newItems] append $workItem
  230.         } else {
  231.         [$this knownItems] append $workItem
  232.         }
  233.     } else {
  234.         set otherItem [$this findQualifiedItem $qualifier $name $type]
  235.  
  236.         if [$otherItem isNil] {
  237.         [$this newQualItems] append $workItem
  238.         } else {
  239.         [$this knownQualItems] append $workItem
  240.         }
  241.     }
  242.     }
  243. }
  244.  
  245. #
  246. #    Look for an item in the system we are importing to.
  247. #
  248.  
  249. method FileImporter::findItem {this name type} {
  250.     return [[$this currSysV] findDefinition $name $type [$this currConfigV]]
  251. }
  252.  
  253. #
  254. #    Look for a qualified item in the system we are importing to.
  255. #
  256.  
  257. method FileImporter::findQualifiedItem {this qualifier name type} {
  258.     #
  259.     # Find the qualifying item in current system
  260.     #
  261.  
  262.     set qualItem [$this findItem [$qualifier name] [$qualifier type]]
  263.  
  264.     if [$qualItem isNil] {
  265.     return $qualItem
  266.     }
  267.  
  268.     set sysV [$this currSysV]
  269.     set configV [$this currConfigV]
  270.  
  271.     return [$sysV findDefinition [$qualItem item] $name $type $configV]
  272. }
  273.  
  274. method FileImporter::import {this} {
  275.     $this importFiles
  276.  
  277.     if {([[$this newItems] contents] != "") ||
  278.     ([[$this newQualItems] contents] != "")} {
  279.     $this importItemProperties
  280.     }
  281.  
  282.     if [$this overwriteProperties] {
  283.     $this overwriteItemProperties
  284.     }
  285. }
  286.  
  287. #
  288. #    Copy file from previous system to current system
  289. #
  290.  
  291. method FileImporter::importFiles {this} {
  292.     foreach fileV [$this importFileVList] {
  293.     set fileName [[$fileV file] qualifiedName]
  294.     set fileType [[$fileV file] type]
  295.  
  296.     set confV [$this currConfigV]
  297.     set sysV [$this currSysV]
  298.  
  299.     puts stdout "Copying file '$fileName.$fileType'"
  300.  
  301.     if {[catch {$sysV copy -fileVersion $fileV $confV} reason]} {
  302.         puts stdout "Copy failed: $reason"
  303.     } else {
  304.         puts stdout "Copy succeeded"
  305.     }
  306.     }
  307. }
  308.  
  309. #
  310. # Import item properties for new items
  311. #
  312.  
  313. method FileImporter::importItemProperties {this} {
  314.  
  315.     puts stdout "Importing item properties for new items"
  316.  
  317.     set sysV [$this currSysV]
  318.  
  319.     #
  320.     # First copy properties for non qualified items
  321.     #
  322.  
  323.     [$this newItems] foreach workItem {
  324.     set name [$workItem name]
  325.     set type [$workItem type]
  326.  
  327.     set other [$this findItem $name $type]
  328.  
  329.     if [$other isNil] {
  330.         set scope [$workItem scope]
  331.  
  332.         set other [$sysV declareItem $name $type $scope]
  333.  
  334.         if [$other isNil] {
  335.         error "Unable to create item '$name.$type' with scope $scope"
  336.         }
  337.     }
  338.  
  339.     set oldProps [$workItem properties]
  340.     set newProps [$other properties]
  341.  
  342.     foreach prop [$oldProps properties] {
  343.         $newProps setProperty [$prop name] [$prop value]
  344.     }
  345.     }
  346.  
  347.     #
  348.     # Now copy properties for qualified items
  349.     #
  350.  
  351.     [$this newQualItems] foreach workItem {
  352.     set name [$workItem name]
  353.     set type [$workItem type]
  354.     set qualifier [[$workItem item] qualifier]
  355.  
  356.     set other [$this findQualifiedItem $qualifier $name $type]
  357.  
  358.     if [$other isNil] {
  359.         set qual [$this findItem [$qualifier name] [$qualifier type]]
  360.  
  361.         if [$qual isNil] {
  362.         continue
  363.         }
  364.  
  365.         set scope [$workItem scope]
  366.  
  367.         set other [$sysV declareItem [$qual item] $name $type $scope]
  368.  
  369.         if [$other isNil] {
  370.         error "Unable to create item '$name.$type' with scope $scope"
  371.         }
  372.     }
  373.  
  374.     set oldProps [$workItem properties]
  375.     set newProps [$other properties]
  376.  
  377.     foreach prop [$oldProps properties] {
  378.         $newProps setProperty [$prop name] [$prop value]
  379.     }
  380.     }
  381.  
  382.     puts stdout "Done"
  383. }
  384.  
  385. #
  386. # Overwrite item properties of existing items
  387. #
  388.  
  389. method FileImporter::overwriteItemProperties {this} {
  390.  
  391.     #
  392.     # Overwrite properties for existing non qualified items
  393.     #
  394.  
  395.     puts stdout "Overwriting item properties for existing items"
  396.  
  397.     [$this knownItems] foreach workItem {
  398.     set name [$workItem name]
  399.     set type [$workItem type]
  400.  
  401.     set other [$this findItem $name $type]
  402.  
  403.     if [$other isNil] {
  404.         error "Unable to find item '$name.$type' with scope $scope"
  405.     }
  406.  
  407.     set oldProps [$workItem properties]
  408.     set newProps [$other properties]
  409.  
  410.     #
  411.     # Remove existing properties
  412.     #
  413.  
  414.     foreach prop [$newProps properties] {
  415.         $newProps removeProperty [$prop name]
  416.     }
  417.  
  418.     #
  419.     # Copy new properties
  420.     #
  421.  
  422.     foreach prop [$oldProps properties] {
  423.         $newProps setProperty [$prop name] [$prop value]
  424.     }
  425.     }
  426.  
  427.     #
  428.     # Now copy properties for existing qualified items
  429.     #
  430.  
  431.     [$this knownQualItems] foreach workItem {
  432.     set name [$workItem name]
  433.     set type [$workItem type]
  434.     set qualifier [[$workItem item] qualifier]
  435.  
  436.     set other [$this findQualifiedItem $qualifier $name $type]
  437.  
  438.     if [$other isNil] {
  439.         error "Unable to qualified find item '$name.$type' with scope $scope"
  440.     }
  441.  
  442.     set oldProps [$workItem properties]
  443.     set newProps [$other properties]
  444.  
  445.     #
  446.     # Remove existing properties
  447.     #
  448.  
  449.     foreach prop [$newProps properties] {
  450.         $newProps removeProperty [$prop name]
  451.     }
  452.  
  453.     #
  454.     # Copy new properties
  455.     #
  456.  
  457.     foreach prop [$oldProps properties] {
  458.         $newProps setProperty [$prop name] [$prop value]
  459.     }
  460.     }
  461.  
  462.     puts stdout "Done"
  463. }
  464.  
  465. #
  466. # Create a FileImporter instance, initialize it and import ...
  467. #
  468.  
  469. global argv
  470.  
  471. set importer [FileImporter new]
  472.  
  473. if [catch {$importer initialize $argv; $importer import} myMessage] {
  474.     puts stderr $myMessage
  475. }
  476.  
  477.