home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / komix / DATA.Z / classlib.tcl < prev    next >
Text File  |  1997-09-24  |  13KB  |  533 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. # Copyright (c) 1997 by Cayenne Software 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 Cayenne Software Inc.
  13. #
  14. #---------------------------------------------------------------------------
  15. #
  16. #       File            : @(#)classlib.tcl    /main/titanic/13 17 Jun 1997
  17. #       Description     : Classlib installation
  18. #
  19. #---------------------------------------------------------------------------
  20. #
  21.  
  22. require "cppclldef.tcl"
  23.  
  24. Class CaynPtrDef : {CppPtrDef} {
  25.     method getIncludeList
  26.     method getTypeAttr
  27.     method genIsEmpty
  28.     method genIsNotEmpty
  29.     method genGet
  30.     method genSet
  31.     method genDtor
  32.     method genCtor
  33. }
  34.  
  35. method CaynPtrDef::getIncludeList {this} {
  36.     return {}
  37. }
  38.  
  39. method CaynPtrDef::getTypeAttr {this} {
  40.     set attr [$this attr]
  41.     set tgt [[$this clss] model]
  42.     set type [[[$attr assocAttr] ooplType] generate $tgt]
  43.     $type isPointer 1
  44.     return $type
  45. }
  46.  
  47. method CaynPtrDef::genIsEmpty {this attrName} {
  48.     return "${attrName}==0"
  49. }
  50.  
  51. method CaynPtrDef::genIsNotEmpty {this attrName} {
  52.     return "${attrName}!=0"
  53. }
  54.  
  55. method CaynPtrDef::genGet {this attrName} {
  56.     return "$attrName"
  57. }
  58.  
  59. method CaynPtrDef::genSet {this attrName value} {
  60.     return "$attrName = $value"
  61. }
  62.  
  63. method CaynPtrDef::genDtor {this} {
  64.     return ""
  65. }
  66.  
  67. method CaynPtrDef::genCtor {this} {
  68.     return ""
  69. }
  70.  
  71. Class CaynSetDef : {CppSetDef} {
  72.     method getIncludeList
  73.     method getTypeAttr
  74.     method getTypeGet
  75.     method genIsEmpty
  76.     method genIsNotEmpty
  77.     method genGet
  78.     method genAdd
  79.     method genRemove
  80.     method genIterator
  81.     method genDtor
  82.     method genCtor
  83. }
  84.  
  85. method CaynSetDef::getIncludeList {this} {
  86.     return "PtrSet.hxx"
  87. }
  88.  
  89. method CaynSetDef::getTypeAttr {this} {
  90.     set attr [$this attr]
  91.     set tgt [[$this clss] model]
  92.     set contentsType [[[$attr assocAttr] ooplType] generate $tgt]
  93.     set type [CppType new]
  94.     $contentsType isPointer 0
  95.     $contentsType includeInFile "cpp"
  96.     $type name "PtrSet"
  97.     $type addTemplateParam $contentsType
  98.     return $type
  99. }
  100.  
  101. method CaynSetDef::getTypeGet {this} {
  102.     set type [$this getTypeAttr]
  103.     $type isConst 1
  104.     $type isReference 1
  105.     return $type
  106. }
  107.  
  108. method CaynSetDef::genIsEmpty {this attrName} {
  109.     return "${attrName}.size()==0"
  110. }
  111.  
  112. method CaynSetDef::genIsNotEmpty {this attrName} {
  113.     return "${attrName}.size()!=0"
  114. }
  115.  
  116. method CaynSetDef::genGet {this attrName} {
  117.     return "${attrName}"
  118. }
  119.  
  120. method CaynSetDef::genAdd {this attrName value} {
  121.     return "${attrName}.add(${value})"
  122. }
  123.  
  124. method CaynSetDef::genRemove {this attrName value} {
  125.     return "${attrName}.remove(${value})"
  126. }
  127.  
  128. method CaynSetDef::genIterator {this sect loopExpr} {
  129.     set attr [$this attr]
  130.     set attrName [$attr attrName]
  131.     set attrType [$attr attrType]
  132.     $sect append "$attrType *${attrName}Iter;\n"
  133.     $sect append "for (${attrName}Iter=${attrName}.first(); "
  134.     $sect append "${attrName}Iter!=0; "
  135.     $sect append "${attrName}Iter=${attrName}.next()) \{\n"
  136.     $sect indent +
  137.     set loopVar "${attrName}Iter"
  138.     if [regsub -all {\$loopVar} $loopExpr $loopVar expr] {
  139.         $sect append $expr
  140.     } else {
  141.         $sect append $loopExpr
  142.     }
  143.     $sect indent -
  144.     $sect append "\}\n"
  145. }
  146.  
  147. method CaynSetDef::genDtor {this} {
  148.     return ""
  149. }
  150.  
  151. method CaynSetDef::genCtor {this} {
  152.     return ""
  153. }
  154.  
  155. Class CaynDictDef : {CppDictDef} {
  156.     method getIncludeList
  157.     method getTypeAttr
  158.     method getTypeGet
  159.     method genIsEmpty
  160.     method genIsNotEmpty
  161.     method genGet
  162.     method genAdd
  163.     method genRemove
  164.     method genIterator
  165.     method genDtor
  166.     method genCtor
  167. }
  168.  
  169. method CaynDictDef::getIncludeList {this} {
  170.     return "PtrDict.hxx"
  171. }
  172.  
  173. method CaynDictDef::getTypeAttr {this} {
  174.     set attr [$this attr]
  175.     set tgt [[$this clss] model]
  176.     set contentsType [[[$attr assocAttr] ooplType] generate $tgt]
  177.     $contentsType isPointer 0
  178.     $contentsType includeInFile "cpp"
  179.     set ktype [[[[$attr assocAttr] qualifier] ooplType] generate $tgt]
  180.     $ktype isPointer 0
  181.     set type [CppType new]
  182.     $type name "PtrDict"
  183.     $type addTemplateParam $ktype
  184.     $type addTemplateParam $contentsType
  185.     return $type
  186. }
  187.  
  188. method CaynDictDef::getTypeGet {this} {
  189.     set attr [$this attr]
  190.     set tgt [[$this clss] model]
  191.     set type [[[$attr assocAttr] ooplType] generate $tgt]
  192.     $type isPointer 1
  193.     return $type
  194. }
  195.  
  196. method CaynDictDef::genIsEmpty {this attrName} {
  197.     return "${attrName}.firstValue()==0"
  198. }
  199.  
  200. method CaynDictDef::genIsNotEmpty {this attrName} {
  201.     return "${attrName}.firstValue()!=0"
  202. }
  203.  
  204. method CaynDictDef::genGet {this attrName keyName} {
  205.     return "${attrName}.get(${keyName})"
  206. }
  207.  
  208. method CaynDictDef::genAdd {this attrName keyName value} {
  209.     return "${attrName}.set(${keyName},${value})"
  210. }
  211.  
  212. method CaynDictDef::genRemove {this attrName keyName} {
  213.     return "${attrName}.remove(${keyName})"
  214. }
  215.  
  216. method CaynDictDef::genIterator {this sect loopExpr} {
  217.     set attr [$this attr]
  218.     set attrName [$attr attrName]
  219.     set attrType [$attr attrType]
  220.     $sect append "${attrType}* ${attrName}Iter;\n"
  221.     $sect append "for (${attrName}Iter=${attrName}.firstValue(); "
  222.     $sect append "${attrName}Iter!=0; "
  223.     $sect append "${attrName}Iter=${attrName}.nextValue()) \{\n"
  224.     $sect indent +
  225.     set loopVar "${attrName}Iter"
  226.     if [regsub -all {\$loopVar} $loopExpr $loopVar expr] {
  227.         $sect append $expr
  228.     } else {
  229.         $sect append $loopExpr
  230.     }
  231.     $sect indent -
  232.     $sect append "\}\n"
  233. }
  234.  
  235. method CaynDictDef::genDtor {this} {
  236.     return ""
  237. }
  238.  
  239. method CaynDictDef::genCtor {this} {
  240.     return ""
  241. }
  242.  
  243. Class CaynSetDictDef : {CppSetDictDef} {
  244.     method getIncludeList
  245.     method getTypeAttr
  246.     method getTypeGet
  247.     method genIsEmpty
  248.     method genIsNotEmpty
  249.     method genGet
  250.     method genAdd
  251.     method genRemove
  252.     method genIterator
  253.     method genDtor
  254.     method genCtor
  255. }
  256.  
  257. method CaynSetDictDef::getIncludeList {this} {
  258.     return "PSetDict.hxx"
  259. }
  260.  
  261. method CaynSetDictDef::getTypeAttr {this} {
  262.     set attr [$this attr]
  263.     set tgt [[$this clss] model]
  264.     set contentsType [[[$attr assocAttr] ooplType] generate $tgt]
  265.     $contentsType isPointer 0
  266.     $contentsType includeInFile "cpp"
  267.     set ktype [[[[$attr assocAttr] qualifier] ooplType] generate $tgt]
  268.     $ktype isPointer 0
  269.     set type [CppType new]
  270.     $type name "PSetDict"
  271.     $type addTemplateParam $ktype
  272.     $type addTemplateParam $contentsType
  273.     return $type
  274. }
  275.  
  276. method CaynSetDictDef::getTypeGet {this} {
  277.     set attr [$this attr]
  278.     set tgt [[$this clss] model]
  279.     set contentsType [[[$attr assocAttr] ooplType] generate $tgt]
  280.     $contentsType isPointer 0
  281.     $contentsType includeInFile "cpp"
  282.     set type [CppType new]
  283.     $type name "PtrSet"
  284.     $type addTemplateParam $contentsType
  285.     $type isReference 1
  286.     $type isConst 1
  287.     return $type
  288. }
  289.  
  290. method CaynSetDictDef::genIsEmpty {this attrName} {
  291.     return "${attrName}.firstValue()==0"
  292. }
  293.  
  294. method CaynSetDictDef::genIsNotEmpty {this attrName} {
  295.     return "${attrName}.firstValue()!=0"
  296. }
  297.  
  298. method CaynSetDictDef::genGet {this attrName keyName} {
  299.     return "*${attrName}.get(${keyName})"
  300. }
  301.  
  302. method CaynSetDictDef::genAdd {this attrName keyName value} {
  303.     return "${attrName}.add(${keyName},${value})"
  304. }
  305.  
  306. method CaynSetDictDef::genRemove {this attrName keyName value} {
  307.     return "${attrName}.remove(${keyName},${value})"
  308. }
  309.  
  310. method CaynSetDictDef::genIterator {this sect loopExpr} {
  311.     set attr [$this attr]
  312.     set attrName [$attr attrName]
  313.     set attrType [$attr attrType]
  314.     $sect append "PtrSet<${attrType}>* ${attrName}Iter;\n"
  315.     $sect append "for (${attrName}Iter=${attrName}.firstValue(); "
  316.     $sect append "${attrName}Iter!=0; "
  317.     $sect append "${attrName}Iter=${attrName}.nextValue()) \{\n"
  318.     $sect indent +
  319.     $sect append "${attrType}* ${attrName}SubIter;\n"
  320.     $sect append "for (${attrName}SubIter=${attrName}Iter->first(); "
  321.     $sect append "${attrName}SubIter!=0; "
  322.     $sect append "${attrName}SubIter=${attrName}Iter->next()) \{\n"
  323.     $sect indent +
  324.  
  325.     set loopVar "${attrName}SubIter"
  326.     if [regsub -all {\$loopVar} $loopExpr $loopVar expr] {
  327.         $sect append $expr
  328.     } else {
  329.         $sect append $loopExpr
  330.     }
  331.  
  332.     $sect indent -
  333.     $sect append "\}\n"
  334.     $sect indent -
  335.     $sect append "\}\n"
  336. }
  337.  
  338. method CaynSetDictDef::genDtor {this} {
  339.     return ""
  340. }
  341.  
  342. method CaynSetDictDef::genCtor {this} {
  343.     return ""
  344. }
  345.  
  346. Class CaynOSetDef : {CaynSetDef} {
  347.     method getIncludeList
  348.     method getTypeAttr
  349.     method getTypeGet
  350.     method genIsEmpty
  351.     method genIsNotEmpty
  352.     method genGet
  353.     method genAdd
  354.     method genRemove
  355.     method genIterator
  356.     method genDtor
  357.     method genCtor
  358. }
  359.  
  360. method CaynOSetDef::getIncludeList {this} {
  361.     return "OPtrSet.hxx"
  362. }
  363.  
  364. method CaynOSetDef::getTypeAttr {this} {
  365.     set attr [$this attr]
  366.     set tgt [[$this clss] model]
  367.     set contentsType [[[$attr assocAttr] ooplType] generate $tgt]
  368.     set type [CppType new]
  369.     $contentsType isPointer 0
  370.     $contentsType includeInFile "cpp"
  371.     $type name "OPtrSet"
  372.     $type addTemplateParam $contentsType
  373.     return $type
  374. }
  375.  
  376. method CaynOSetDef::getTypeGet {this} {
  377.     set attr [$this attr]
  378.     set tgt [[$this clss] model]
  379.     set type [$this getTypeAttr]
  380.     $type isConst 1
  381.     $type isReference 1
  382.     return $type
  383. }
  384.  
  385. method CaynOSetDef::genIsEmpty {this attrName} {
  386.     return "${attrName}.size()==0"
  387. }
  388.  
  389. method CaynOSetDef::genIsNotEmpty {this attrName} {
  390.     return "${attrName}.size()!=0"
  391. }
  392.  
  393. method CaynOSetDef::genGet {this attrName} {
  394.     return "${attrName}"
  395. }
  396.  
  397. method CaynOSetDef::genAdd {this attrName value} {
  398.     return "${attrName}.append(${value})"
  399. }
  400.  
  401. method CaynOSetDef::genRemove {this attrName value} {
  402.     return "${attrName}.remove(${value})"
  403. }
  404.  
  405. method CaynOSetDef::genIterator {this sect loopExpr} {
  406.     set attr [$this attr]
  407.     set attrName [$attr attrName]
  408.     set attrType [$attr attrType]
  409.     $sect append "int ${attrName}Cnt;\n"
  410.     $sect append "for (${attrName}Cnt=0; "
  411.     $sect append "${attrName}Cnt<${attrName}.size(); "
  412.     $sect append "${attrName}Cnt++) \{\n"
  413.  
  414.     $sect indent +
  415.     set loopVar "${attrName}.at(${attrName}Cnt)"
  416.     if [regsub -all {\$loopVar} $loopExpr $loopVar expr] {
  417.         $sect append $expr
  418.     } else {
  419.         $sect append $loopExpr
  420.     }
  421.  
  422.     $sect indent -
  423.     $sect append "\}\n"
  424. }
  425.  
  426. method CaynOSetDef::genDtor {this} {
  427.     return ""
  428. }
  429.  
  430. method CaynOSetDef::genCtor {this} {
  431.     return ""
  432. }
  433.  
  434. Class CaynOSetDictDef : {CaynSetDictDef} {
  435.     method getIncludeList
  436.     method getTypeAttr
  437.     method getTypeGet
  438.     method genIsEmpty
  439.     method genIsNotEmpty
  440.     method genGet
  441.     method genAdd
  442.     method genRemove
  443.     method genIterator
  444.     method genDtor
  445.     method genCtor
  446. }
  447.  
  448. method CaynOSetDictDef::getIncludeList {this} {
  449.     return "OPSetDict.hxx"
  450. }
  451.  
  452. method CaynOSetDictDef::getTypeAttr {this} {
  453.     set attr [$this attr]
  454.     set tgt [[$this clss] model]
  455.     set contentsType [[[$attr assocAttr] ooplType] generate $tgt]
  456.     $contentsType isPointer 0
  457.     $contentsType includeInFile "cpp"
  458.     set ktype [[[[$attr assocAttr] qualifier] ooplType] generate $tgt]
  459.     $ktype isPointer 0
  460.     set type [CppType new]
  461.     $type name "OPSetDict"
  462.     $type addTemplateParam $ktype
  463.     $type addTemplateParam $contentsType
  464.     return $type
  465. }
  466.  
  467. method CaynOSetDictDef::getTypeGet {this} {
  468.     set attr [$this attr]
  469.     set tgt [[$this clss] model]
  470.     set contentsType [[[$attr assocAttr] ooplType] generate $tgt]
  471.     set type [CppType new]
  472.     $type name "OPtrSet"
  473.     $type addTemplateParam $contentsType
  474.     $type isReference 1
  475.     $type isConst 1
  476.     return $type
  477. }
  478.  
  479. method CaynOSetDictDef::genIsEmpty {this attrName} {
  480.     return "${attrName}.firstValue()==0"
  481. }
  482.  
  483. method CaynOSetDictDef::genIsNotEmpty {this attrName} {
  484.     return "${attrName}.firstValue()!=0"
  485. }
  486.  
  487. method CaynOSetDictDef::genGet {this attrName keyName} {
  488.     return "*${attrName}.get(${keyName})"
  489. }
  490.  
  491. method CaynOSetDictDef::genAdd {this attrName keyName value} {
  492.     return "${attrName}.add(${keyName},${value})"
  493. }
  494.  
  495. method CaynOSetDictDef::genRemove {this attrName keyName value} {
  496.     return "${attrName}.remove(${keyName},${value})"
  497. }
  498.  
  499. method CaynOSetDictDef::genIterator {this sect loopExpr} {
  500.     set attr [$this attr]
  501.     set attrName [$attr attrName]
  502.     set attrType [$attr attrType]
  503.     $sect append "OPtrSet<${attrType}>* ${attrName}Iter;\n"
  504.     $sect append "for (${attrName}Iter=${attrName}.firstValue(); "
  505.     $sect append "${attrName}Iter!=0; "
  506.     $sect append "${attrName}Iter=${attrName}.nextValue()) \{\n"
  507.     $sect indent +
  508.     $sect append "int ${attrName}Cnt;\n"
  509.     $sect append "for (${attrName}Cnt=0; "
  510.     $sect append "${attrName}Cnt<${attrName}Iter->size(); "
  511.     $sect append "${attrName}Cnt++) \{\n"
  512.     $sect indent +
  513.     set loopVar "${attrName}Iter->at(${attrName}Cnt)"
  514.     
  515.     if [regsub -all {\$loopVar} $loopExpr $loopVar expr] {
  516.         $sect append $expr
  517.     } else {
  518.         $sect append $loopExpr
  519.     }
  520.     $sect indent -
  521.     $sect append "\}\n"
  522.     $sect indent -
  523.     $sect append "\}\n"
  524. }
  525.  
  526. method CaynOSetDictDef::genDtor {this} {
  527.     return ""
  528. }
  529.  
  530. method CaynOSetDictDef::genCtor {this} {
  531.     return ""
  532. }
  533.