home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
PC World 1998 October
/
PCWorld_1998-10_cd.bin
/
software
/
prehled
/
komix
/
DATA.Z
/
cppgclasses.tcl
< prev
next >
Wrap
Text File
|
1997-12-01
|
104KB
|
3,987 lines
#---------------------------------------------------------------------------
#
# Copyright (c) 1997 by Cayenne Software, Inc.
#
# This software is furnished under a license and may be used only in
# accordance with the terms of such license and with the inclusion of
# the above copyright notice. This software or any other copies thereof
# may not be provided or otherwise made available to any other person.
# No title to and ownership of the software is hereby transferred.
#
# The information in this software is subject to change without notice
# and should not be construed as a commitment by Cayenne Software, Inc.
#
#---------------------------------------------------------------------------
#
# File : cppgclasses.tcl
# Author :
# Original date : November 1997
# Description : Classes for code generation
#
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
# File: @(#)cppgtype.tcl /main/titanic/8
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGType : {Object} {
constructor
method destructor
method check
method checkLocal
method generate
attribute loopCheck
}
constructor CppGType {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
$this loopCheck 0
# End constructor user section
return $this
}
method CppGType::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGType::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
return $errorCnt
}
method CppGType::checkLocal {this} {
return 0
}
method CppGType::generate {this tgt} {
m4_fatal $F_ABSTRACT "CppGType::generate"
}
# Do not delete this line -- regeneration end marker
if [isCommand CMType] {
Class CppGTypeD : {CppGType CMType} {
}
} else {
Class CppGTypeD : {CppGType OPType} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPType) CppGTypeD
selfPromoter OPType {this} {
CppGTypeD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgfeatur.tcl /main/titanic/7
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGFeature : {Object} {
constructor
method destructor
method check
method generate
}
constructor CppGFeature {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGFeature::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGFeature::check {this} {
return 0
}
method CppGFeature::generate {this class} {
m4_fatal $F_ABSTRACT "CppGFeature::generate"
}
# Do not delete this line -- regeneration end marker
if [isCommand CMFeature] {
Class CppGFeatureD : {CppGFeature CMFeature} {
}
} else {
Class CppGFeatureD : {CppGFeature OPFeature} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPFeature) CppGFeatureD
selfPromoter OPFeature {this} {
CppGFeatureD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgattrib.tcl /main/titanic/7
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGAttribute : {CppGFeature} {
constructor
method destructor
method check
method generate
}
constructor CppGAttribute {class this name} {
set this [CppGFeature::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGAttribute::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGAttribute::check {this} {
return 0
}
method CppGAttribute::generate {this class} {
m4_fatal $F_ABSTRACT "CppGAttribute::generate"
}
# Do not delete this line -- regeneration end marker
if [isCommand CMAttribute] {
Class CppGAttributeD : {CppGAttribute CMAttribute} {
}
} else {
Class CppGAttributeD : {CppGAttribute OPAttribute} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPAttribute) CppGAttributeD
selfPromoter OPAttribute {this} {
CppGAttributeD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppggenass.tcl /main/titanic/10
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGGenAssocAttr : {CppGAttribute} {
constructor
method destructor
method getClassLibDef
method check
method generate
method generator
attribute _generator
attribute cppAssocAttr
}
constructor CppGGenAssocAttr {class this name} {
set this [CppGAttribute::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGGenAssocAttr::destructor {this} {
set ref [$this _generator]
if {$ref != ""} {
$ref _assocAttr ""
}
# Start destructor user section
# End destructor user section
}
method CppGGenAssocAttr::getClassLibDef {this assocKind clss attr} {
global cplusplusClassLib
global cplusplusClassLibDefault
set classLibName [$this getPropertyValue "assoc_impl"]
if {($classLibName == "") || ($classLibName == "default")} {
set classLibName $cplusplusClassLibDefault
}
set implStrat [$this getPropertyValue "assoc_strategy"]
if {$implStrat == ""} {
set implStrat "default"
}
set aKind $assocKind
if [$this isOrdered] {
set aKind "O${assocKind}"
}
if {![info exists cplusplusClassLib($classLibName)]} {
m4_error $E_NOCLASSLIB $classLibName
set classLibName "default"
}
set bestCl ""
foreach {kind impl cl} $cplusplusClassLib($classLibName) {
if {($kind == $aKind) && ($impl == $implStrat)} {
return [$cl new $clss $attr]
}
if {$kind == $aKind} {
set bestCl $cl
}
}
if {$bestCl == ""} {
m4_fatal $E_NOCLASSLIB "$classLibName/$aKind/$implStrat"
exit
} else {
m4_error $E_NOCLASSLIB "$classLibName/$aKind/$implStrat"
return [$bestCl new $clss $attr]
}
}
method CppGGenAssocAttr::check {this} {
set errCnt 0
set opp ""
set oppA [$this opposite]
if {$oppA != ""} {
set opp [$oppA ooplClass]
if {$opp != ""} {
if {[$oppA isMandatory] && [$this isMandatory]} {
m4_error $E_MANDMAND \
[[$this ooplClass] getName] [$opp getName]
incr errCnt
}
}
}
set type [$this ooplType]
if {$type != ""} {
incr errCnt [$type check]
}
return $errCnt
}
method CppGGenAssocAttr::generate {this class} {
if [$this check] {
return
}
return [[$this generator] generate $class]
}
# Do not delete this line -- regeneration end marker
if [isCommand CMGenAssocAttr] {
Class CppGGenAssocAttrD : {CppGGenAssocAttr CMGenAssocAttr} {
}
} else {
Class CppGGenAssocAttrD : {CppGGenAssocAttr OPGenAssocAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPGenAssocAttr) CppGGenAssocAttrD
selfPromoter OPGenAssocAttr {this} {
CppGGenAssocAttrD promote $this
}
method CppGGenAssocAttr::generator {this args} {
if {$args == ""} {
return [$this _generator]
}
set ref [$this _generator]
if {$ref != ""} {
$ref _assocAttr ""
}
set obj [lindex $args 0]
if {$obj != ""} {
$obj _assocAttr $this
}
$this _generator $obj
}
#---------------------------------------------------------------------------
# File: @(#)cppglinkat.tcl /main/titanic/12
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGLinkAttr : {CppGGenAssocAttr} {
constructor
method destructor
method setGenerator
}
constructor CppGLinkAttr {class this name} {
set this [CppGGenAssocAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGLinkAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGLinkAttr::setGenerator {this clss} {
set ofPart ""
if {[$this opposite] != ""} {
set oClassName [[[$this opposite] ooplClass] getName]
set ofPart "Of${oClassName}"
}
if {[$this getMultiplicity]=="one"} {
set assImpl [CppGAssocOne new]
$assImpl attrName "[$this getName]${ofPart}Ptr"
$this generator $assImpl
set cldef [$this getClassLibDef "Ptr" $clss $assImpl]
} else {
set assImpl [CppGAssocMany new]
$assImpl attrName "[$this getName]${ofPart}Set"
$this generator $assImpl
set cldef [$this getClassLibDef "Set" $clss $assImpl]
}
$assImpl cldef $cldef
}
# Do not delete this line -- regeneration end marker
if [isCommand CMLinkAttr] {
Class CppGLinkAttrD : {CppGLinkAttr CMLinkAttr} {
}
} else {
Class CppGLinkAttrD : {CppGLinkAttr OPLinkAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPLinkAttr) CppGLinkAttrD
selfPromoter OPLinkAttr {this} {
CppGLinkAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgparame.tcl /main/titanic/7
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGParameter : {Object} {
constructor
method destructor
method check
method generate
}
constructor CppGParameter {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGParameter::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGParameter::check {this} {
return 0
}
method CppGParameter::generate {this method} {
m4_fatal $F_ABSTRACT "CppGParameter::generate"
}
# Do not delete this line -- regeneration end marker
if [isCommand CMParameter] {
Class CppGParameterD : {CppGParameter CMParameter} {
}
} else {
Class CppGParameterD : {CppGParameter OPParameter} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPParameter) CppGParameterD
selfPromoter OPParameter {this} {
CppGParameterD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgassoca.tcl /main/titanic/11
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGAssocAttr : {CppGGenAssocAttr} {
constructor
method destructor
method setGenerator
}
constructor CppGAssocAttr {class this name} {
set this [CppGGenAssocAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGAssocAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGAssocAttr::setGenerator {this clss} {
if {[$this getMultiplicity]=="one"} {
set assImpl [CppGAssocOne new]
$assImpl attrName "[$this getName]Ptr"
$this generator $assImpl
set cldef [$this getClassLibDef "Ptr" $clss $assImpl]
} else {
set assImpl [CppGAssocMany new]
$assImpl attrName "[$this getName]Set"
$this generator $assImpl
set cldef [$this getClassLibDef "Set" $clss $assImpl]
}
$assImpl cldef $cldef
}
# Do not delete this line -- regeneration end marker
if [isCommand CMAssocAttr] {
Class CppGAssocAttrD : {CppGAssocAttr CMAssocAttr} {
}
} else {
Class CppGAssocAttrD : {CppGAssocAttr OPAssocAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPAssocAttr) CppGAssocAttrD
selfPromoter OPAssocAttr {this} {
CppGAssocAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgassocg.tcl /main/titanic/15
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGAssocGen : {GCObject} {
constructor
method destructor
method check
method checkLocal
method getTypeDef
method generate
method generateInclude
method generateSet
method generateGet
method generateAdd
method generateRemove
method generateCtor
method generateDtor
method assocAttr
attribute attrName
attribute attrType
attribute cldef
attribute _assocAttr
}
constructor CppGAssocGen {class this} {
set this [GCObject::constructor $class $this]
# Start constructor user section
$this attrName ""
$this attrType ""
# End constructor user section
return $this
}
method CppGAssocGen::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGAssocGen::check {this} {
set errCnt 0
incr errCnt [$this checkLocal]
return $errCnt
}
method CppGAssocGen::checkLocal {this} {
return 0
}
method CppGAssocGen::getTypeDef {this} {
# Dummy function, should be overloaded in a sub class (when needed)
}
method CppGAssocGen::generate {this class} {
if [$this checkLocal] {
return
}
set opp ""
set oppA [[$this assocAttr] opposite]
if {$oppA != ""} {
set opp [$oppA ooplClass]
}
set type [$this getTypeDef]
set attr [CppAssocAttrib new $class Private $type]
$attr comment [[$this assocAttr] getPropertyValue "freeText"]
if {[$this attrName] == "" } {
$this attrName [[$this assocAttr] getName]
}
if {[$this attrType] == ""} {
set attrTypeObj [[[$this assocAttr] ooplType] generate [$class model]]
$attrTypeObj isReference 0
$attrTypeObj isPointer 0
$this attrType [$attrTypeObj getTypeName cpp $class]
}
$attr name [$this attrName]
[$this assocAttr] cppAssocAttr $attr
if {$opp != ""} {
set tgt [$class model]
set oppcl [ $tgt findDefinition [$opp getName] ]
if { $oppcl == "" } {
set oppcl [ $opp generate $tgt ]
$oppcl isSynthetic 1
}
$class addFriendClass $oppcl
}
$this generateInclude $class
$this generateSet $class
$this generateGet $class
$this generateAdd $class
$this generateRemove $class
$this generateCtor $class
$this generateDtor $class
return $attr
}
method CppGAssocGen::generateInclude {this class} {
# Dummy function, should be overloaded in a sub class (when needed)
}
method CppGAssocGen::generateSet {this class} {
# Dummy function, should be overloaded in a sub class (when needed)
}
method CppGAssocGen::generateGet {this class} {
# Dummy function, should be overloaded in a sub class (when needed)
}
method CppGAssocGen::generateAdd {this class} {
# Dummy function, should be overloaded in a sub class (when needed)
}
method CppGAssocGen::generateRemove {this class} {
# Dummy function, should be overloaded in a sub class (when needed)
}
method CppGAssocGen::generateCtor {this class} {
# Dummy function, should be overloaded in a sub class (when needed)
}
method CppGAssocGen::generateDtor {this class} {
# Dummy function, should be overloaded in a sub class (when needed)
}
# Do not delete this line -- regeneration end marker
method CppGAssocGen::assocAttr {this args} {
if {$args == ""} {
return [$this _assocAttr]
}
set ref [$this _assocAttr]
if {$ref != ""} {
$ref _generator ""
}
set obj [lindex $args 0]
if {$obj != ""} {
$obj _generator $this
}
$this _assocAttr $obj
}
#---------------------------------------------------------------------------
# File: @(#)cppgassoci.tcl /main/titanic/7
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGAssocInitializer : {Object} {
constructor
method destructor
method check
method generate
}
constructor CppGAssocInitializer {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGAssocInitializer::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGAssocInitializer::check {this} {
return 0
}
method CppGAssocInitializer::generate {this ctor} {
# No initializers are generated, all initializing is
# done in the constructor
# [[$this assoc] generator] generateInitializer $this $ctor
}
# Do not delete this line -- regeneration end marker
if [isCommand CMAssocInitializer] {
Class CppGAssocInitializerD : {CppGAssocInitializer CMAssocInitializer} {
}
} else {
Class CppGAssocInitializerD : {CppGAssocInitializer OPAssocInitializer} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPAssocInitializer) CppGAssocInitializerD
selfPromoter OPAssocInitializer {this} {
CppGAssocInitializerD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgattrin.tcl /main/titanic/7
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGAttrInitializer : {Object} {
constructor
method destructor
method check
method generate
}
constructor CppGAttrInitializer {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGAttrInitializer::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGAttrInitializer::check {this} {
return 0
}
method CppGAttrInitializer::generate {this ctor} {
set attr [$this attrib]
set class [$ctor cl]
set type [[$attr ooplType] generate [$class model]]
if { [$type name] == "char" && [$type isArray] } {
$class addExtIncl "string.h"
set ctorSect [CppGenCode new $ctor]
$ctorSect append "strcpy ([$attr getName], [$this getName]);\n"
} else {
set init [CppInitializer new $ctor]
$init name [$attr getName]
# Create value for this initializer
set initVal [CppInitValue new $init]
$initVal value [$this getName]
return $init
}
return ""
}
# Do not delete this line -- regeneration end marker
if [isCommand CMAttribInitializer] {
Class CppGAttrInitializerD : {CppGAttrInitializer CMAttribInitializer} {
}
} else {
Class CppGAttrInitializerD : {CppGAttrInitializer OPAttribInitializer} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPAttribInitializer) CppGAttrInitializerD
selfPromoter OPAttribInitializer {this} {
CppGAttrInitializerD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgbasety.tcl /main/titanic/6
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGBaseType : {CppGType} {
constructor
method destructor
method check
method generate
}
constructor CppGBaseType {class this name} {
set this [CppGType::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGBaseType::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGBaseType::check {this} {
return 0
}
method CppGBaseType::generate {this tgt} {
set type [CppType new]
set type3gl [$this getType3GL]
if [regexp {(var)?char\[[0-9][0-9]*]} $type3gl] {
regsub {(var)?([^\[]*)\[([0-9][0-9]*)]} $type3gl {\2} name
$type name $name
regsub {([^\[]*)\[([0-9][0-9]*)]} $type3gl {\2} size
if { $name == "char" } {
$type arraySize [expr $size + 1]
} else {
$type arraySize $size
}
} else {
$type name $type3gl
}
return $type
}
# Do not delete this line -- regeneration end marker
if [isCommand CMBaseType] {
Class CppGBaseTypeD : {CppGBaseType CMBaseType} {
}
} else {
Class CppGBaseTypeD : {CppGBaseType OPBaseType} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPBaseType) CppGBaseTypeD
selfPromoter OPBaseType {this} {
CppGBaseTypeD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgclass.tcl /main/titanic/17
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGClass : {Object} {
constructor
method destructor
method check
method checkLocal
method checkLoop
method generate
attribute loopTrace
attribute checkStatus
}
constructor CppGClass {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGClass::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGClass::check {this} {
if {[$this checkStatus] != ""} {
return [$this checkStatus]
}
set errorCnt 0
$this checkStatus 0
if {[$this checkLoop] == 1} {
incr errorCnt
} else {
foreach feature [$this featureSet] {
incr errorCnt [$feature check]
}
foreach genNode [$this genNodeSet] {
incr errorCnt [$genNode check]
}
}
$this checkStatus $errorCnt
return $errorCnt
}
method CppGClass::checkLocal {this} {
set errorCnt 0
incr errorCnt [$this checkLoop]
return $errorCnt
}
method CppGClass::checkLoop {this {recursiveCall 0}} {
if {[$this loopTrace] == 1} {
return 1
}
$this loopTrace 1
foreach genNode [$this genNodeSet] {
set super [$genNode superClass]
if {[$super checkLoop 1] == 1} {
$this loopTrace 0
return 1
}
}
foreach assocAttr [$this genAssocAttrSet] {
if [$assocAttr isMandatory] {
set type [$assocAttr ooplType]
if {$type != ""} {
if [$type isA OPClassType] {
set otherClass [$type ooplClass]
if {$otherClass != ""} {
if {[$otherClass checkLoop 1] == 1} {
if {$recursiveCall == 0} {
m4_error $E_ASSOCLOOP [$this getName]
}
$this loopTrace 0
return 1
}
}
}
}
}
}
$this loopTrace 0
return 0
}
method CppGClass::generate {this tgt} {
if {[$this checkLocal] > 0} {
set cl [ $tgt findDefinition [$this getName] ]
if {$cl == ""} {
set cl [CppClass new $this $tgt]
}
$cl isSynthetic 1
return $cl
}
set cl [ $tgt findDefinition [$this getName] ]
if { $cl == "" } {
set cl [CppClass new $this $tgt]
$cl isSynthetic 0
} else {
$cl isSynthetic 0
return $cl
}
$cl comment [$this getPropertyValue "freeText"]
# Generate destructor
set type [CppType new]
set dtor [CppDestructor new $cl "Public" $type]
set dynDtor 0
foreach genAssocAttr [$this genAssocAttrSet] {
$genAssocAttr setGenerator $cl
}
set ctor [$this constructor]
if {$ctor != ""} {
$ctor generate $cl
}
foreach dataAttr [$this dataAttrSet] {
$dataAttr generate $cl
}
foreach genAssocAttr [$this genAssocAttrSet] {
$genAssocAttr generate $cl
}
foreach operation [$this operationSet] {
$operation generate $cl
if [$operation isDynBound] {
set dynDtor 1
}
}
foreach genNode [$this genNodeSet] {
$genNode generate $cl
}
if {[llength [$this specNodeSet]] > 0} {
set dynDtor 1
}
switch [$this getPropertyValue "has_dyn_dtor"] {
yes { set dynDtor 1 }
no { set dynDtor 0 }
}
$dtor isDynamic $dynDtor
return $cl
}
# Do not delete this line -- regeneration end marker
if [isCommand CMClass] {
Class CppGClassD : {CppGClass CMClass} {
}
} else {
Class CppGClassD : {CppGClass OPClass} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPClass) CppGClassD
selfPromoter OPClass {this} {
CppGClassD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgclasst.tcl /main/titanic/11
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGClassType : {CppGType} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGClassType {class this name} {
set this [CppGType::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGClassType::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGClassType::check {this} {
set errorCnt 0
if {[$this ooplClass] != ""} {
incr errorCnt [[$this ooplClass] check]
}
return $errorCnt
}
method CppGClassType::checkLocal {this} {
set errorCnt 0
return $errorCnt
}
method CppGClassType::generate {this tgt} {
set type [CppType new]
if {[$this checkLocal] > 0} {
return $type
}
set oClass [$this ooplClass]
if { $oClass == "" } {
$type name [$this getType3GL]
} else {
set cl [$tgt findDefinition [$oClass getName]]
if { $cl == "" } {
set cl [$oClass generate $tgt]
$cl isSynthetic 1
}
$type localType $cl
}
return $type
}
# Do not delete this line -- regeneration end marker
if [isCommand CMClassType] {
Class CppGClassTypeD : {CppGClassType CMClassType} {
}
} else {
Class CppGClassTypeD : {CppGClassType OPClassType} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPClassType) CppGClassTypeD
selfPromoter OPClassType {this} {
CppGClassTypeD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgclenum.tcl /main/titanic/9
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGClEnum : {CppGClass} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGClEnum {class this name} {
set this [CppGClass::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGClEnum::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGClEnum::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
foreach feat [$this featureSet] {
incr errorCnt [$feat check]
}
return $errorCnt
}
method CppGClEnum::checkLocal {this} {
return 0
}
method CppGClEnum::generate {this tgt} {
set cl [ $tgt findDefinition [ $this getName ] ]
if {$cl != ""} {
$cl isSynthetic 0
} else {
set cl [CppEnum new $this $tgt]
$cl isSynthetic 0
$cl name [ $this getName ]
$cl comment [ $this getPropertyValue "freeText" ]
foreach feat [$this featureSet] {
set item [CppEnumItem new $cl]
$item item [$feat getName]
$item value [$feat getPropertyValue initial_value]
$item comment [$feat getPropertyValue "freeText"]
}
}
return $cl
}
# Do not delete this line -- regeneration end marker
if [isCommand CMClassEnum] {
Class CppGClEnumD : {CppGClEnum CMClassEnum} {
}
} else {
Class CppGClEnumD : {CppGClEnum OPClassEnum} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPClassEnum) CppGClEnumD
selfPromoter OPClassEnum {this} {
CppGClEnumD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgclgent.tcl /main/titanic/14
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGClGenTDef : {CppGClass} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGClGenTDef {class this name} {
set this [CppGClass::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGClGenTDef::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGClGenTDef::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
if {[$this loopTrace] == 1} {
m4_error $E_REFERTYPED [$this getName]
incr errorCnt
} else {
$this loopTrace 1
set assoc [lindex [$this genAssocAttrSet] 0]
if {$assoc != ""} {
incr errorCnt [$assoc check]
} else {
incr errorCnt
}
$this loopTrace 0
}
return $errorCnt
}
method CppGClGenTDef::checkLocal {this} {
return 0
}
method CppGClGenTDef::generate {this tgt} {
set typeDef [$tgt findDefinition [$this getName]]
if {$typeDef != ""} {
if [$typeDef isSynthetic] {
$typeDef isSynthetic 0
} else {
m4_error $E_EXISTS [$this getName]
}
} else {
if {[$this check] > 0} {
set typeDef [CppTypeDef new $this $tgt [CppType new]]
$typeDef isSynthetic 1
} else {
# faking type, will set it right after setGenerator
set typeDef [CppTypeDef new $this $tgt ""]
set assoc [lindex [$this genAssocAttrSet] 0]
$assoc setGenerator $typeDef
set type [[$assoc generator] getTypeDef]
$typeDef type $type
$typeDef isSynthetic 0
$typeDef comment [$this getPropertyValue "freeText"]
$typeDef name [$this getName]
[$assoc generator] generateInclude $typeDef
}
}
return $typeDef
}
# Do not delete this line -- regeneration end marker
if [isCommand CMClassGenericTypeDef] {
Class CppGClGenTDefD : {CppGClGenTDef CMClassGenericTypeDef} {
}
} else {
Class CppGClGenTDefD : {CppGClGenTDef OPClassGenericTypeDef} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPClassGenericTypeDef) CppGClGenTDefD
selfPromoter OPClassGenericTypeDef {this} {
CppGClGenTDefD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgcltdef.tcl /main/titanic/10
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGClTDef : {CppGClass} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGClTDef {class this name} {
set this [CppGClass::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGClTDef::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGClTDef::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
if {[$this loopTrace] == 1} {
m4_error $E_REFERTYPED [$this getName]
incr errorCnt
} else {
$this loopTrace 1
if {[$this dataAttrSet] != ""} {
set feat [lindex [$this dataAttrSet] 0]
incr errorCnt [[$feat ooplType] check]
}
$this loopTrace 0
}
return $errorCnt
}
method CppGClTDef::checkLocal {this} {
if {[$this dataAttrSet] == ""} {
return 1
}
return 0
}
method CppGClTDef::generate {this tgt} {
if {[$this checkLocal] > 0} {
set cl [CppTypeDef new $this $tgt [CppType new]]
$cl isSynthetic 1
return $cl
}
set cl [ $tgt findDefinition [ $this getName ] ]
if {$cl == ""} {
set feat [lindex [$this dataAttrSet] 0]
set type [[$feat ooplType] generate $tgt]
set cl [CppTypeDef new $this $tgt $type]
$cl name [ $this getName ]
$cl comment [ $this getPropertyValue "freeText" ]
}
$cl isSynthetic 0
return $cl
}
# Do not delete this line -- regeneration end marker
if [isCommand CMClassTDef] {
Class CppGClTDefD : {CppGClTDef CMClassTDef} {
}
} else {
Class CppGClTDefD : {CppGClTDef OPClassTDef} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPClassTDef) CppGClTDefD
selfPromoter OPClassTDef {this} {
CppGClTDefD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgconstr.tcl /main/titanic/8
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGConstructor : {CppGFeature} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGConstructor {class this name} {
set this [CppGFeature::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGConstructor::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGConstructor::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
foreach param [[$this ooplClass] fullCreationParamSet] {
incr errorCnt [$param check]
}
foreach initializer [$this fullInitializerSet] {
incr errorCnt [$initializer check]
}
return $errorCnt
}
method CppGConstructor::checkLocal {this} {
set errorCnt 0
return $errorCnt
}
method CppGConstructor::generate {this class} {
if {[$this checkLocal] > 0} {
return [CppConstructor new $class "Private" [CppType new]]
}
# class is the Cpp target class of this ctor
set access [$this getPropertyValue "method_access"]
set type [CppType new]
set ctor [CppConstructor new $class $access $type]
$ctor comment [$this getPropertyValue "freeText"]
foreach param [[$this ooplClass] fullCreationParamSet] {
$param generate $ctor
}
foreach initializer [$this fullInitializerSet] {
$initializer generate $ctor
}
return $ctor
}
# Do not delete this line -- regeneration end marker
if [isCommand CMConstructor] {
Class CppGConstructorD : {CppGConstructor CMConstructor} {
}
} else {
Class CppGConstructorD : {CppGConstructor OPConstructor} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPConstructor) CppGConstructorD
selfPromoter OPConstructor {this} {
CppGConstructorD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgctorpa.tcl /main/titanic/10
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGCtorParameter : {CppGParameter} {
constructor
method destructor
method check
method generate
}
constructor CppGCtorParameter {class this name} {
set this [CppGParameter::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGCtorParameter::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGCtorParameter::check {this} {
set errorCnt 0
incr errorCnt [[$this ooplType] check]
return $errorCnt
}
method CppGCtorParameter::generate {this method} {
set type [[$this ooplType] generate [[$method cl] model]]
switch [$this getPropertyValue "modifier"] {
"Value" {}
"Pointer" { $type isPointer 1 }
"Reference" { $type isReference 1 }
"Pointer to Const" { $type isPointer 1 ; $type isConst 1 }
"Reference to Const" { $type isReference 1 ; $type isConst 1 }
default { if {[$type localType]!=""} {$type isReference 1 ; $type isConst 1} }
}
set param [CppParam new $type $method]
$param name [$this getName]
set defaultValue [$this getPropertyValue "default_value"]
set attrib [$this attrib]
if {($defaultValue == "") && ($attrib != "")} {
set defaultValue [$attrib getInitialValue]
}
$param defaultValue $defaultValue
return $param
}
# Do not delete this line -- regeneration end marker
if [isCommand CMCtorParameter] {
Class CppGCtorParameterD : {CppGCtorParameter CMCtorParameter} {
}
} else {
Class CppGCtorParameterD : {CppGCtorParameter OPCtorParameter} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPCtorParameter) CppGCtorParameterD
selfPromoter OPCtorParameter {this} {
CppGCtorParameterD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdataat.tcl /main/titanic/16
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDataAttr : {CppGAttribute} {
constructor
method destructor
method check
method generate
}
constructor CppGDataAttr {class this name} {
set this [CppGAttribute::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDataAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGDataAttr::check {this} {
set errorCnt 0
if {(![$this isNullable]) && ([$this getInitialValue]!="")} {
set clName [[$this ooplClass] getName]
set attrName [$this getName]
m4_warning $W_NONULLDEFAULT $clName $attrName
}
incr errorCnt [[$this ooplType] check]
return $errorCnt
}
method CppGDataAttr::generate {this class} {
set type [[$this ooplType] generate [$class model]]
set accessTxt [$this getPropertyValue "attrib_access"]
set visibility [$this getPropertyValue "attrib_visibility"]
if {$visibility == ""} {
set visibility "Private"
}
set attr [CppUserAttrib new $class $visibility $type]
$attr name [$this getName]
$attr comment [$this getFreeText]
set defValue [$this getInitialValue]
if {![$this isNullable] && ($defValue!="")} {
set defValue ""
m4_warning $W_NONULLDEFAULT [$class name] [$attr name]
}
if {$defValue != ""} {
$attr defaultValue $defValue
if {! [$this isClassFeature]} {
set ctor ""
[$class featureSet] foreach feature {
if [$feature isA CppConstructor] {
set ctor $feature
break
}
}
if {$ctor != ""} {
if {[$type name] == "char" && [$type isArray] } {
$class addExtIncl "string.h"
set ctorSect [CppGenCode new $ctor]
$ctorSect append "strcpy ([$this getName], $defValue);\n"
} else {
set init [CppInitializer new $ctor]
$init name [$this getName]
set initVal [CppInitValue new $init]
if [regexp {\((.*)\)} $defValue mtv expression] {
$initVal value $expression
} else {
$initVal value $defValue
}
}
}
}
}
# generate get and set methods
set firstUp [string toupper [string range [$attr name] 0 0]]
set uName "${firstUp}[string range [$attr name] 1 end]"
set accessList [split $accessTxt -]
set readAccess [lindex $accessList 0]
if {$readAccess == ""} {
set readAccess "Public"
}
if {$readAccess != "None"} {
set getType [[$this ooplType] generate [$class model]]
set getMethd [CppAccMethod new $class $readAccess $getType $attr]
$getMethd name [$getMethd getMethodName "attrib-get" [$attr name]]
$getMethd isConst 1
$getMethd isInline 1
$getMethd kind "get"
set getGenCodeSect [CppGenCode new $getMethd]
$getGenCodeSect append "return [$attr name];\n"
if [$this isClassFeature] {
$getType isStatic 1
$getMethd isConst 0
}
}
set writeAccess [lindex $accessList 1]
if {$writeAccess == ""} {
set writeAccess "Public"
}
if {$writeAccess != "None"} {
set setType [CppType new]
set setMethd [CppAccMethod new $class $writeAccess $setType $attr]
$setMethd name [$setMethd getMethodName "attrib-set" [$attr name]]
$setMethd isInline 1
$setMethd kind "set"
set setPType [[$this ooplType] generate [$class model]]
set setParam [CppParam new $setPType $setMethd]
$setParam name "new${uName}"
set setGenCodeSect [CppGenCode new $setMethd]
if { [$type name] == "char" && [$type isArray] } {
$class addExtIncl "string.h"
$setGenCodeSect append "strcpy ([$attr name], new${uName});\n"
} else {
$setGenCodeSect append "[$attr name] = new${uName};\n"
}
if [$this isClassFeature] {
$setType isStatic 1
}
}
if [$this isClassFeature] {
$type isStatic 1
}
return $attr
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDataAttr] {
Class CppGDataAttrD : {CppGDataAttr CMDataAttr} {
}
} else {
Class CppGDataAttrD : {CppGDataAttr OPDataAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDataAttr) CppGDataAttrD
selfPromoter OPDataAttr {this} {
CppGDataAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgenumty.tcl /main/titanic/9
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGEnumType : {CppGType} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGEnumType {class this name} {
set this [CppGType::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGEnumType::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGEnumType::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
return $errorCnt
}
method CppGEnumType::checkLocal {this} {
if {[$this ooplClass] == ""} {
return 1
}
return 0
}
method CppGEnumType::generate {this tgt} {
if {[$this checkLocal] > 0} {
return ""
}
set cl [$tgt findDefinition [[$this ooplClass] getName]]
if {$cl == ""} {
set cl [[$this ooplClass] generate $tgt]
$cl isSynthetic 1
}
set type [CppType new]
$type localType $cl
return $type
}
# Do not delete this line -- regeneration end marker
if [isCommand CMEnumType] {
Class CppGEnumTypeD : {CppGEnumType CMEnumType} {
}
} else {
Class CppGEnumTypeD : {CppGEnumType OPEnumType} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPEnumType) CppGEnumTypeD
selfPromoter OPEnumType {this} {
CppGEnumTypeD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppginhgro.tcl /main/titanic/11
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGInhGroup : {Object} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGInhGroup {class this} {
# Start constructor user section
# End constructor user section
return $this
}
method CppGInhGroup::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGInhGroup::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
set super [$this superClass]
if {$super != ""} {
incr errorCnt [$super check]
}
return $errorCnt
}
method CppGInhGroup::checkLocal {this} {
return 0
}
method CppGInhGroup::generate {this cl} {
# Note that cl is our sub class
set accessTxt [$this getPropertyValue "inher_access"]
set access "public"
switch $accessTxt {
"Public" {set access "public"}
"Protected" {set access "protected"}
"Private" {set access "private"}
default {set access "public"}
}
set tgt [$cl model]
set super [$this superClass]
set supercl [$tgt findDefinition [$super getName]]
if {$supercl == ""} {
set supercl [$super generate $tgt]
$supercl isSynthetic 1
}
set gen [CppGen new $supercl $access]
if [$this isOverlapping] {
$gen isVirtual 1
}
$cl addGen $gen
return $gen
}
# Do not delete this line -- regeneration end marker
if [isCommand CMInhGroup] {
Class CppGInhGroupD : {CppGInhGroup CMInhGroup} {
}
} else {
Class CppGInhGroupD : {CppGInhGroup OPInhGroup} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPInhGroup) CppGInhGroupD
selfPromoter OPInhGroup {this} {
CppGInhGroupD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppginhkey.tcl /main/titanic/2
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGInhKeyInitializer : {Object} {
constructor
method destructor
method check
method generate
}
constructor CppGInhKeyInitializer {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGInhKeyInitializer::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGInhKeyInitializer::check {this} {
return 0
}
method CppGInhKeyInitializer::generate {this ctor} {
# empty
}
# Do not delete this line -- regeneration end marker
if [isCommand CMInhKeyInitializer] {
Class CppGInhKeyInitializerD : {CppGInhKeyInitializer CMInhKeyInitializer} {
}
} else {
Class CppGInhKeyInitializerD : {CppGInhKeyInitializer OPInhKeyInitializer} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPInhKeyInitializer) CppGInhKeyInitializerD
selfPromoter OPInhKeyInitializer {this} {
CppGInhKeyInitializerD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppglinkcl.tcl /main/titanic/8
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGLinkClass : {CppGClass} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGLinkClass {class this name} {
set this [CppGClass::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGLinkClass::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGLinkClass::check {this} {
return [$this CppGClass::check]
}
method CppGLinkClass::checkLocal {this} {
return 0
}
method CppGLinkClass::generate {this tgt} {
return [$this CppGClass::generate $tgt]
}
# Do not delete this line -- regeneration end marker
if [isCommand CMLinkClass] {
Class CppGLinkClassD : {CppGLinkClass CMLinkClass} {
}
} else {
Class CppGLinkClassD : {CppGLinkClass OPLinkClass} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPLinkClass) CppGLinkClassD
selfPromoter OPLinkClass {this} {
CppGLinkClassD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgoperat.tcl /main/titanic/15
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGOperation : {CppGFeature} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGOperation {class this name} {
set this [CppGFeature::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGOperation::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGOperation::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
foreach param [$this parameterSet] {
incr errorCnt [$param check]
}
return $errorCnt
}
method CppGOperation::checkLocal {this} {
set errorCnt 0
if {[$this getName] == [[$this ooplClass] getName]} {
m4_warning $W_USECTOR [[$this ooplClass] getName]
}
if {[$this isClassFeature] &&
([$this isAbstract] || [$this isDynBound])} {
set name [[$this ooplClass] getName]::[$this getName]
m4_error $E_STATICABSTRACT $name
incr errorCnt
}
return $errorCnt
}
method CppGOperation::generate {this class} {
set operationNameMap {
{"operatorDIV" "operator/"}
{"operatorPLUS" "operator+"}
{"operatorMIN" "operator-"}
{"operatorASSIGN" "operator="}
{"operatorASS_PLUS" "operator+="}
{"operatorASS_MIN" "operator-="}
{"operatorASS_STAR" "operator*="}
{"operatorASS_DIV" "operator/="}
{"operatorASS_MOD" "operator%="}
{"operatorASS_CIRCUM" "operator^="}
{"operatorASS_AMPER" "operator&="}
{"operatorASS_PIPE" "operator|="}
{"operatorASS_LSHIFT" "operator<<="}
{"operatorASS_RSHIFT" "operator>>="}
{"operatorEQ" "operator=="}
{"operatorNEQ" "operator!="}
{"operatorLE" "operator<="}
{"operatorGE" "operator>="}
{"operatorCOMMA" "operator,"}
{"operatorFUNC" "operator()"}
{"operatornew" "operator new"}
{"operatorNEW" "operator new"}
{"operatordelete" "operator delete"}
{"operatorDELETE" "operator delete"}
}
if {[$this checkLocal] > 0} {
set mthd [CppUserMethod new $class "Private" [CppType new]]
$mthd name [$this getName]
return $mthd
}
set access [$this getPropertyValue method_access]
if {$access == ""} {
set access "Public"
}
set oType [$this ooplType]
if {$oType != ""} {
set returnType [$oType generate [$class model]]
} else {
set returnType [CppType new]
$returnType name "void"
}
switch [$this getPropertyValue "modifier"] {
"Default" { if {[$returnType localType]!=""} {$type isReference 1} }
"Value" {}
"Pointer" { $returnType isPointer 1 }
"Reference" { $returnType isReference 1 }
"Pointer to Const" { $returnType isPointer 1 ; $returnType isConst 1 }
"Reference to Const" { $returnType isReference 1 ; $returnType isConst 1 }
"Other" { $returnType otherModifier [$this getPropertyValue "other_modifier"] }
}
if {[$this getName] == "type_conv"} {
set mthd [CppUserMethod new $class $access ""]
$mthd name [$this getName]
} else {
set mthd [CppUserMethod new $class $access $returnType]
$mthd name [$this getName]
}
foreach onmap $operationNameMap {
if {[lindex $onmap 0] == [$this getName]} {
$mthd name [lindex $onmap 1]
break
}
}
$returnType isStatic [$this isClassFeature]
if {[$this getName] == "type_conv"} {
$returnType isConst 0
$mthd name "operator [$returnType getTypeName {} {}]"
}
$mthd isConst [$this isConstFunc]
$mthd isDynamic [$this isDynBound]
$mthd isAbstract [$this isAbstract]
$mthd comment [$this getPropertyValue "freeText"]
if {[$this getPropertyValue "inline_method"] == "1"} {
$mthd isInline 1
}
foreach param [$this parameterSet] {
$param generate $mthd
}
return $mthd
}
# Do not delete this line -- regeneration end marker
if [isCommand CMOperation] {
Class CppGOperationD : {CppGOperation CMOperation} {
}
} else {
Class CppGOperationD : {CppGOperation OPOperation} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPOperation) CppGOperationD
selfPromoter OPOperation {this} {
CppGOperationD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgoperpa.tcl /main/titanic/11
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGOperParameter : {CppGParameter} {
constructor
method destructor
method check
method generate
}
constructor CppGOperParameter {class this name} {
set this [CppGParameter::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGOperParameter::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGOperParameter::check {this} {
set errorCnt 0
incr errorCnt [[$this ooplType] check]
return $errorCnt
}
method CppGOperParameter::generate {this method} {
set type [[$this ooplType] generate [[$method cl] model]]
set param [CppParam new $type $method]
switch [$this getPropertyValue "modifier"] {
"Default" { if {[$type localType]!=""} {$type isReference 1 ; $type isConst 1} }
"Value" {}
"Pointer" { $type isPointer 1 }
"Reference" { $type isReference 1 }
"Pointer to Const" { $type isPointer 1 ; $type isConst 1 }
"Reference to Const" { $type isReference 1 ; $type isConst 1 }
"Other" { $type otherModifier [$this getPropertyValue "other_modifier"] }
}
$param name [$this getName]
$param defaultValue [$this getPropertyValue "default_value"]
$param comment [$this getPropertyValue "freeText"]
return $param
}
# Do not delete this line -- regeneration end marker
if [isCommand CMOperParameter] {
Class CppGOperParameterD : {CppGOperParameter CMOperParameter} {
}
} else {
Class CppGOperParameterD : {CppGOperParameter OPOperParameter} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPOperParameter) CppGOperParameterD
selfPromoter OPOperParameter {this} {
CppGOperParameterD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgqualas.tcl /main/titanic/11
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGQualAssocAttr : {CppGGenAssocAttr} {
constructor
method destructor
method setGenerator
}
constructor CppGQualAssocAttr {class this name} {
set this [CppGGenAssocAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGQualAssocAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGQualAssocAttr::setGenerator {this clss} {
if {[$this getMultiplicity]=="one"} {
set assImpl [CppGOneQual new]
$assImpl attrName "[$this getName]Dict"
$this generator $assImpl
set cldef [$this getClassLibDef "Dict" $clss $assImpl]
} else {
set assImpl [CppGManyQual new]
$assImpl attrName "[$this getName]DictSet"
$this generator $assImpl
set cldef [$this getClassLibDef "SetDict" $clss $assImpl]
}
$assImpl cldef $cldef
}
# Do not delete this line -- regeneration end marker
if [isCommand CMQualAssocAttr] {
Class CppGQualAssocAttrD : {CppGQualAssocAttr CMQualAssocAttr} {
}
} else {
Class CppGQualAssocAttrD : {CppGQualAssocAttr OPQualAssocAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPQualAssocAttr) CppGQualAssocAttrD
selfPromoter OPQualAssocAttr {this} {
CppGQualAssocAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgqualin.tcl /main/titanic/7
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGQualInitializer : {Object} {
constructor
method destructor
method check
method generate
}
constructor CppGQualInitializer {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGQualInitializer::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGQualInitializer::check {this} {
return 0
}
method CppGQualInitializer::generate {this ctor} {
# No initializer is created for the keys of qual assocs
}
# Do not delete this line -- regeneration end marker
if [isCommand CMQualInitializer] {
Class CppGQualInitializerD : {CppGQualInitializer CMQualInitializer} {
}
} else {
Class CppGQualInitializerD : {CppGQualInitializer OPQualInitializer} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPQualInitializer) CppGQualInitializerD
selfPromoter OPQualInitializer {this} {
CppGQualInitializerD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgqualli.tcl /main/titanic/11
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGQualLinkAttr : {CppGGenAssocAttr} {
constructor
method destructor
method setGenerator
}
constructor CppGQualLinkAttr {class this name} {
set this [CppGGenAssocAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGQualLinkAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGQualLinkAttr::setGenerator {this clss} {
set ofPart ""
if {[$this opposite] != ""} {
set oClassName [[[$this opposite] ooplClass] getName]
set ofPart "Of${oClassName}"
}
if {[$this getMultiplicity]=="one"} {
set assImpl [CppGOneQual new]
$assImpl attrName "[$this getName]${ofPart}Dict"
$this generator $assImpl
set cldef [$this getClassLibDef "Dict" $clss $assImpl]
} else {
set assImpl [CppGManyQual new]
$assImpl attrName "[$this getName]${ofPart}DictSet"
$this generator $assImpl
set cldef [$this getClassLibDef "SetDict" $clss $assImpl]
}
$assImpl cldef $cldef
}
# Do not delete this line -- regeneration end marker
if [isCommand CMQualLinkAttr] {
Class CppGQualLinkAttrD : {CppGQualLinkAttr CMQualLinkAttr} {
}
} else {
Class CppGQualLinkAttrD : {CppGQualLinkAttr OPQualLinkAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPQualLinkAttr) CppGQualLinkAttrD
selfPromoter OPQualLinkAttr {this} {
CppGQualLinkAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgrevers.tcl /main/titanic/10
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGReverseLinkAttr : {CppGGenAssocAttr} {
constructor
method destructor
method setGenerator
}
constructor CppGReverseLinkAttr {class this name} {
set this [CppGGenAssocAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGReverseLinkAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGReverseLinkAttr::setGenerator {this clss} {
set assImpl [CppGAssocOne new]
$assImpl attrName "[$this getName]Ptr"
$this generator $assImpl
set opp [$this opposite]
if {$opp == ""} {
set opp $this
}
set cldef [$opp getClassLibDef "Ptr" $clss $assImpl]
$assImpl cldef $cldef
}
# Do not delete this line -- regeneration end marker
if [isCommand CMReverseLinkAttr] {
Class CppGReverseLinkAttrD : {CppGReverseLinkAttr CMReverseLinkAttr} {
}
} else {
Class CppGReverseLinkAttrD : {CppGReverseLinkAttr OPReverseLinkAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPReverseLinkAttr) CppGReverseLinkAttrD
selfPromoter OPReverseLinkAttr {this} {
CppGReverseLinkAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgsuperc.tcl /main/titanic/7
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGSuperClassInitializer : {Object} {
constructor
method destructor
method check
method generate
}
constructor CppGSuperClassInitializer {class this name} {
set this [Object::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGSuperClassInitializer::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGSuperClassInitializer::check {this} {
set errorCnt 0
foreach param [$this fullParameterSet] {
incr errorCnt [$param check]
}
return $errorCnt
}
method CppGSuperClassInitializer::generate {this ctor} {
# Create Initializer
set init [CppInitializer new $ctor]
$init name [[$this ooplClass] getName]
foreach param [$this fullParameterSet] {
# Create value for this initializer
set initVal [CppInitValue new $init]
$initVal value [$param getName]
}
return $init
}
# Do not delete this line -- regeneration end marker
if [isCommand CMSuperClassInitializer] {
Class CppGSuperClassInitializerD : {CppGSuperClassInitializer CMSuperClassInitializer} {
}
} else {
Class CppGSuperClassInitializerD : {CppGSuperClassInitializer OPSuperClassInitializer} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPSuperClassInitializer) CppGSuperClassInitializerD
selfPromoter OPSuperClassInitializer {this} {
CppGSuperClassInitializerD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdataba.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDatabaseClass : {CppGClass} {
constructor
method destructor
}
constructor CppGDatabaseClass {class this name} {
set this [CppGClass::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDatabaseClass::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDatabaseClass] {
Class CppGDatabaseClassD : {CppGDatabaseClass CMDatabaseClass} {
}
} else {
Class CppGDatabaseClassD : {CppGDatabaseClass OPDatabaseClass} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDatabaseClass) CppGDatabaseClassD
selfPromoter OPDatabaseClass {this} {
CppGDatabaseClassD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdbaatt.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDBAAttr : {CppGAssocAttr} {
constructor
method destructor
}
constructor CppGDBAAttr {class this name} {
set this [CppGAssocAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDBAAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDBAssocAttr] {
Class CppGDBAAttrD : {CppGDBAAttr CMDBAssocAttr} {
}
} else {
Class CppGDBAAttrD : {CppGDBAAttr OPDBAssocAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDBAssocAttr) CppGDBAAttrD
selfPromoter OPDBAssocAttr {this} {
CppGDBAAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdbdatt.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDBDAttr : {CppGDataAttr} {
constructor
method destructor
}
constructor CppGDBDAttr {class this name} {
set this [CppGDataAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDBDAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDBDataAttr] {
Class CppGDBDAttrD : {CppGDBDAttr CMDBDataAttr} {
}
} else {
Class CppGDBDAttrD : {CppGDBDAttr OPDBDataAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDBDataAttr) CppGDBDAttrD
selfPromoter OPDBDataAttr {this} {
CppGDBDAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdblatt.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDBLAttr : {CppGLinkAttr} {
constructor
method destructor
}
constructor CppGDBLAttr {class this name} {
set this [CppGLinkAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDBLAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDBLinkAttr] {
Class CppGDBLAttrD : {CppGDBLAttr CMDBLinkAttr} {
}
} else {
Class CppGDBLAttrD : {CppGDBLAttr OPDBLinkAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDBLinkAttr) CppGDBLAttrD
selfPromoter OPDBLinkAttr {this} {
CppGDBLAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdblcla.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDBLClass : {CppGLinkClass} {
constructor
method destructor
}
constructor CppGDBLClass {class this name} {
set this [CppGLinkClass::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDBLClass::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDBLinkClass] {
Class CppGDBLClassD : {CppGDBLClass CMDBLinkClass} {
}
} else {
Class CppGDBLClassD : {CppGDBLClass OPDBLinkClass} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDBLinkClass) CppGDBLClassD
selfPromoter OPDBLinkClass {this} {
CppGDBLClassD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdbqaat.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDBQAAttr : {CppGQualAssocAttr} {
constructor
method destructor
}
constructor CppGDBQAAttr {class this name} {
set this [CppGQualAssocAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDBQAAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDBQualAssocAttr] {
Class CppGDBQAAttrD : {CppGDBQAAttr CMDBQualAssocAttr} {
}
} else {
Class CppGDBQAAttrD : {CppGDBQAAttr OPDBQualAssocAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDBQualAssocAttr) CppGDBQAAttrD
selfPromoter OPDBQualAssocAttr {this} {
CppGDBQAAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdbqlat.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDBQLAttr : {CppGQualLinkAttr} {
constructor
method destructor
}
constructor CppGDBQLAttr {class this name} {
set this [CppGQualLinkAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDBQLAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDBQualLinkAttr] {
Class CppGDBQLAttrD : {CppGDBQLAttr CMDBQualLinkAttr} {
}
} else {
Class CppGDBQLAttrD : {CppGDBQLAttr OPDBQualLinkAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDBQualLinkAttr) CppGDBQLAttrD
selfPromoter OPDBQualLinkAttr {this} {
CppGDBQLAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgdbrlat.tcl /main/titanic/3
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGDBRLAttr : {CppGReverseLinkAttr} {
constructor
method destructor
}
constructor CppGDBRLAttr {class this name} {
set this [CppGReverseLinkAttr::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGDBRLAttr::destructor {this} {
# Start destructor user section
# End destructor user section
}
# Do not delete this line -- regeneration end marker
if [isCommand CMDBReverseLinkAttr] {
Class CppGDBRLAttrD : {CppGDBRLAttr CMDBReverseLinkAttr} {
}
} else {
Class CppGDBRLAttrD : {CppGDBRLAttr OPDBReverseLinkAttr} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPDBReverseLinkAttr) CppGDBRLAttrD
selfPromoter OPDBReverseLinkAttr {this} {
CppGDBRLAttrD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgtypede.tcl /main/titanic/10
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGTypeDefType : {CppGType} {
constructor
method destructor
method check
method checkLocal
method generate
}
constructor CppGTypeDefType {class this name} {
set this [CppGType::constructor $class $this $name]
# Start constructor user section
# End constructor user section
return $this
}
method CppGTypeDefType::destructor {this} {
# Start destructor user section
# End destructor user section
}
method CppGTypeDefType::check {this} {
set errorCnt 0
incr errorCnt [$this checkLocal]
if {[$this ooplClass] != ""} {
incr errorCnt [[$this ooplClass] check]
}
return $errorCnt
}
method CppGTypeDefType::checkLocal {this} {
if {[$this ooplClass] == ""} {
return 1
}
return 0
}
method CppGTypeDefType::generate {this tgt} {
set cl [$tgt findDefinition [[$this ooplClass] getName]]
if {$cl == ""} {
if [$this check] {
return [CppType new]
}
set cl [[$this ooplClass] generate $tgt]
$cl isSynthetic 1
}
set type [CppType new]
$type localType $cl
return $type
}
# Do not delete this line -- regeneration end marker
if [isCommand CMTypeDefType] {
Class CppGTypeDefTypeD : {CppGTypeDefType CMTypeDefType} {
}
} else {
Class CppGTypeDefTypeD : {CppGTypeDefType OPTypeDefType} {
}
}
global mostDerivedOOPL ; set mostDerivedOOPL(OPTypeDefType) CppGTypeDefTypeD
selfPromoter OPTypeDefType {this} {
CppGTypeDefTypeD promote $this
}
#---------------------------------------------------------------------------
# File: @(#)cppgmanyqu.tcl /main/titanic/18
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGManyQual : {CppGAssocGen} {
constructor
method destructor
method getTypeDef
method generateInclude
method generateAdd
method generateGet
method generateRemove
method generateCtor
method generateDtor
method generateOppSet
method generateOppAdd
method generateOppRemove
}
constructor CppGManyQual {class this} {
set this [CppGAssocGen::constructor $class $this]
# Start constructor user section
# End constructor user section
return $this
}
method CppGManyQual::destructor {this} {
# Start destructor user section
# End destructor user section
$this CppGAssocGen::destructor
}
method CppGManyQual::getTypeDef {this} {
if [$this checkLocal] {
return [CppType new]
}
set cldef [$this cldef]
return [$cldef getTypeAttr]
}
method CppGManyQual::generateInclude {this class} {
set cldef [$this cldef]
set includeList [$cldef getIncludeList]
lappend includeList [CppProtect::getInclude]
foreach file $includeList {
$class addExtIncl $file
}
}
method CppGManyQual::generateAdd {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 1]
if {$access == "None"} {
return
}
if {$access == ""} {
set access "Public"
}
set rtype [CppType new]
set assoc [$attr cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-add" [$attr getName]]
$methd kind "add"
set cldef [$this cldef]
set ktype [[[$attr qualifier] ooplType] generate [$class model]]
if {[$ktype localType] != ""} {
$ktype isConst 1
$ktype isReference 1
}
set keyParam [CppParam new $ktype $methd]
set keyName [[$attr qualifier] getName]
$keyParam name $keyName
set ptype [[$attr ooplType] generate [$class model]]
$ptype isPointer 1
set param [CppParam new $ptype $methd]
set pname "new${uName}"
$param name $pname
set genCode [CppGenCode new $methd]
if [$attr isMandatory] {
CppProtect::genCheck $genCode "$pname!=0"
}
set oAttr [$attr opposite]
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppSet $genCode $this \
[$oppGenerator attrName] $pname [$this attrName] \
[$oAttr isMandatory] [$attr isMandatory]
}
}
if {![$attr isMandatory]} {
$genCode append "if ($pname!=0) \{\n"
$genCode indent +
}
$genCode append [$cldef genAdd [$this attrName] $keyName $pname]
$genCode append ";\n"
if {![$attr isMandatory]} {
$genCode indent -
$genCode append "\}\n"
}
}
method CppGManyQual::generateGet {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 0]
if {$access == ""} {
set access "Public"
}
set cldef [$this cldef]
set rtype [$cldef getTypeGet]
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set assoc [[$this assocAttr] cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-get-set" [$attr getName]]
$methd kind "get"
$methd isConst 1
$methd isInline 1
set ktype [[[$attr qualifier] ooplType] generate [$class model]]
if {[$ktype localType] != ""} {
$ktype isConst 1
$ktype isReference 1
}
set keyParam [CppParam new $ktype $methd]
set keyName [[$attr qualifier] getName]
$keyParam name $keyName
set genCode [CppGenCode new $methd]
$genCode append "return "
$genCode append [$cldef genGet [$this attrName] $keyName]
$genCode append ";\n"
}
method CppGManyQual::generateRemove {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
if {$oAttr != ""} {
if {[$oAttr isMandatory] && [$oAttr getMultiplicity] != "many"} {
m4_warning $W_NOGENREMOVE [$class getName] [$this attrName]
return
}
}
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 1]
if {$access == "None"} {
return
}
if {$access == ""} {
set access "Public"
}
set rtype [CppType new]
set assoc [$attr cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-remove" [$attr getName]]
$methd kind "remove"
set cldef [$this cldef]
set ktype [[[$attr qualifier] ooplType] generate [$class model]]
if {[$ktype localType] != ""} {
$ktype isConst 1
$ktype isReference 1
}
set keyParam [CppParam new $ktype $methd]
set keyName [[$attr qualifier] getName]
$keyParam name $keyName
set ptype [[$attr ooplType] generate [$class model]]
$ptype isPointer 1
set param [CppParam new $ptype $methd]
set pname "old${uName}"
$param name $pname
set genCode [CppGenCode new $methd]
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $genCode $this \
[$oppGenerator attrName] "this" $pname \
[$oAttr isMandatory] [$attr isMandatory]
}
}
$genCode append [$cldef genRemove [$this attrName] $keyName $pname]
$genCode append ";\n"
if [$attr isMandatory] {
CppProtect::genCheck $genCode [$cldef genIsNotEmpty [$this attrName]]
}
}
method CppGManyQual::generateCtor {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set cldef [$this cldef]
[$class featureSet] foreach feature {
if [$feature isA CppConstructor] {
set genCode [CppGenCode new $feature]
$genCode append [$cldef genCtor]
}
}
}
method CppGManyQual::generateDtor {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set cldef [$this cldef]
[$class featureSet] foreach feature {
if [$feature isA CppDestructor] {
set genCode [CppGenCode new $feature]
set tmpSec [TextSection new]
set oAttr [$attr opposite]
if {$oAttr != ""} {
if [$oAttr isMandatory] {
CppProtect::genCheck $genCode [$cldef genIsEmpty [$this attrName]]
} else {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $tmpSec $this \
[$oppGenerator attrName] "this" {$loopVar} \
[$oAttr isMandatory] [$attr isMandatory]
}
$cldef genIterator $genCode [$tmpSec contents]
}
}
$genCode append [$cldef genDtor]
}
}
}
method CppGManyQual::generateOppSet {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
}
method CppGManyQual::generateOppAdd {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
}
method CppGManyQual::generateOppRemove {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
}
# Do not delete this line -- regeneration end marker
#---------------------------------------------------------------------------
# File: @(#)cppgassoco.tcl /main/titanic/15
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGAssocOne : {CppGAssocGen} {
constructor
method destructor
method getTypeDef
method generateInclude
method generateSet
method generateGet
method generateRemove
method generateCtor
method generateDtor
method generateOppSet
method generateOppAdd
method generateOppRemove
}
constructor CppGAssocOne {class this} {
set this [CppGAssocGen::constructor $class $this]
# Start constructor user section
# End constructor user section
return $this
}
method CppGAssocOne::destructor {this} {
# Start destructor user section
# End destructor user section
$this CppGAssocGen::destructor
}
method CppGAssocOne::getTypeDef {this} {
if [$this checkLocal] {
return [CppType new]
}
return [[$this cldef] getTypeAttr]
}
method CppGAssocOne::generateInclude {this class} {
set includeList [[$this cldef] getIncludeList]
lappend includeList [CppProtect::getInclude]
foreach file $includeList {
$class addExtIncl $file
}
}
method CppGAssocOne::generateSet {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
if {($oAttr != "") &&
([$oAttr isA OPQualAssocAttr] || [$oAttr isA OPQualLinkAttr])} {
m4_warning $W_NOGENUPDATE [$class getName] [$this attrName]
return
}
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 1]
if {$access == "None"} {
return
}
if {$access == ""} {
set access "Public"
}
set rtype [CppType new]
set assoc [$attr cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-set" [$attr getName]]
$methd kind "set"
set cldef [$this cldef]
set ptype [[$attr ooplType] generate [$class model]]
$ptype isPointer 1
set param [CppParam new $ptype $methd]
set pname "new${uName}"
$param name $pname
set genCode [CppGenCode new $methd]
if [$attr isMandatory] {
CppProtect::genCheck $genCode "$pname!=0"
}
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $genCode $this \
[$oppGenerator attrName] "this" [$this attrName] \
[$oAttr isMandatory] [$attr isMandatory]
$oppGenerator generateOppSet $genCode $this \
[$oppGenerator attrName] $pname [$this attrName] \
[$oAttr isMandatory] [$attr isMandatory]
}
}
$genCode append [$cldef genSet [$this attrName] $pname]
$genCode append ";\n"
}
method CppGAssocOne::generateGet {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 0]
if {$access == ""} {
set access "Public"
}
set cldef [$this cldef]
set rtype [$cldef getTypeAttr]
$rtype isConst 1
set assoc [[$this assocAttr] cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-get" [$attr getName]]
$methd kind "get"
$methd isConst 1
$methd isInline 1
set genCode [CppGenCode new $methd]
$genCode append "return "
$genCode append [$cldef genGet [$this attrName]]
$genCode append ";\n"
}
method CppGAssocOne::generateRemove {this class} {
# equal to set..(0)
}
method CppGAssocOne::generateCtor {this class} {
set cldef [$this cldef]
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
set pname "(&[$attr getName])"
set aname "[$this attrName]"
if {($oAttr != "") &&
([$oAttr isA OPQualAssocAttr] || [$oAttr isA OPQualLinkAttr])} {
m4_warning $W_NOGENCTOR [$class getName] [$this attrName]
return
}
[$class featureSet] foreach feature {
if [$feature isA CppConstructor] {
set genCode [CppGenCode new $feature]
$genCode append [$cldef genCtor]
if [$attr isMandatory] {
$genCode append "[$cldef genSet $aname $pname];\n"
set oAttr [$attr opposite]
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppSet $genCode $this \
[$oppGenerator attrName] $pname $aname \
[$oAttr isMandatory] [$attr isMandatory]
}
}
}
}
}
}
method CppGAssocOne::generateDtor {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
set cldef [$this cldef]
if {($oAttr != "") &&
([$oAttr isA OPQualAssocAttr] || [$oAttr isA OPQualLinkAttr])} {
m4_warning $W_NOGENDTOR [$class getName] [$this attrName]
return
}
[$class featureSet] foreach feature {
if [$feature isA CppDestructor] {
set genCode [CppGenCode new $feature]
set oAttr [$attr opposite]
set aname "[$this attrName]"
set pname "this"
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $genCode $this \
[$oppGenerator attrName] $pname $aname \
[$oAttr isMandatory] [$attr isMandatory]
}
}
$genCode append [$cldef genDtor]
}
}
}
method CppGAssocOne::generateOppSet {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
set cldef [$this cldef]
set newOAttr "${paramName}->${attrName}"
set oldOAttr "${oppAttrName}->${attrName}"
if { $oppAttrMand } {
CppProtect::genCheck $sec [$cldef genIsEmpty $newOAttr]
} else {
$sec append "if ([$cldef genIsNotEmpty $paramName]) \{\n"
$sec indent +
if { $other != "" } {
$other generateOppRemove $sec "" \
$oppAttrName $paramName $newOAttr \
$oppAttrMand $attrMand
}
}
$sec append [$cldef genSet $newOAttr "this"]
$sec append ";\n"
if { ! $oppAttrMand } {
$sec indent -
$sec append "\}\n"
}
}
method CppGAssocOne::generateOppAdd {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
$this generateOppSet $sec $attrName $paramName \
$oppAttrName $attrMand $oppAttrMand
}
method CppGAssocOne::generateOppRemove {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
set cldef [$this cldef]
set oAttr "${oppAttrName}->${attrName}"
if { $attrMand } {
CppProtect::genCheck $sec [$cldef genIsEmpty $oppAttrName]
} else {
if { ! $oppAttrMand } {
$sec append "if ([$cldef genIsNotEmpty ${oppAttrName}]) \{\n"
$sec indent +
}
$sec append [$cldef genSet $oAttr "0"]
$sec append ";\n"
if { ! $oppAttrMand } {
$sec indent -
$sec append "\}\n"
}
}
}
# Do not delete this line -- regeneration end marker
#---------------------------------------------------------------------------
# File: @(#)cppgoneopp.tcl /main/titanic/4
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGOneOppQual : {CppGAssocOne} {
constructor
method destructor
method getTypeDef
method generateSet
method generateGet
method generateRemove
method generateCtor
method generateDtor
method generateOppSet
method generateOppAdd
method generateOppRemove
}
constructor CppGOneOppQual {class this} {
set this [CppGAssocOne::constructor $class $this]
# Start constructor user section
# End constructor user section
return $this
}
method CppGOneOppQual::destructor {this} {
# Start destructor user section
# End destructor user section
$this CppGAssocOne::destructor
}
method CppGOneOppQual::getTypeDef {this} {
$this CppGAssocOne::getTypeDef
}
method CppGOneOppQual::generateSet {this class} {
# !! Implement this function !!
}
method CppGOneOppQual::generateGet {this class} {
# !! Implement this function !!
}
method CppGOneOppQual::generateRemove {this class} {
# !! Implement this function !!
}
method CppGOneOppQual::generateCtor {this class} {
# !! Implement this function !!
}
method CppGOneOppQual::generateDtor {this class} {
# !! Implement this function !!
}
method CppGOneOppQual::generateOppSet {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
# !! Implement this function !!
}
method CppGOneOppQual::generateOppAdd {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
# !! Implement this function !!
}
method CppGOneOppQual::generateOppRemove {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
# !! Implement this function !!
}
# Do not delete this line -- regeneration end marker
#---------------------------------------------------------------------------
# File: @(#)cppgonequa.tcl /main/titanic/17
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGOneQual : {CppGAssocGen} {
constructor
method destructor
method getTypeDef
method generateInclude
method generateSet
method generateGet
method generateRemove
method generateCtor
method generateDtor
method generateOppSet
method generateOppAdd
method generateOppRemove
}
constructor CppGOneQual {class this} {
set this [CppGAssocGen::constructor $class $this]
# Start constructor user section
# End constructor user section
return $this
}
method CppGOneQual::destructor {this} {
# Start destructor user section
# End destructor user section
$this CppGAssocGen::destructor
}
method CppGOneQual::getTypeDef {this} {
if [$this checkLocal] {
return [CppType new]
}
return [[$this cldef] getTypeAttr]
}
method CppGOneQual::generateInclude {this class} {
set includeList [[$this cldef] getIncludeList]
lappend includeList [CppProtect::getInclude]
foreach file $includeList {
$class addExtIncl $file
}
}
method CppGOneQual::generateSet {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 1]
if {$access == "None"} {
return
}
if {$access == ""} {
set access "Public"
}
set rtype [CppType new]
set assoc [$attr cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-set" [$attr getName]]
$methd kind "set"
set ktype [[[$attr qualifier] ooplType] generate [$class model]]
if {[$ktype localType] != "" } {
$ktype isConst 1
$ktype isReference 1
}
set keyParam [CppParam new $ktype $methd]
set keyName [[$attr qualifier] getName]
$keyParam name $keyName
set ptype [[$attr ooplType] generate [$class model]]
$ptype isPointer 1
set param [CppParam new $ptype $methd]
set pname "new${uName}"
$param name $pname
set genCode [CppGenCode new $methd]
if [$attr isMandatory] {
CppProtect::genCheck $genCode "$pname!=0"
}
set oAttr [$attr opposite]
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppSet $genCode $this \
[$oppGenerator attrName] $pname [$this attrName] \
[$oAttr isMandatory] [$attr isMandatory]
}
}
if {![$attr isMandatory]} {
$genCode append "if ($pname!=0) \{\n"
$genCode indent +
}
$genCode append [[$this cldef] genAdd [$this attrName] $keyName $pname]
$genCode append ";\n"
if {![$attr isMandatory]} {
$genCode indent -
$genCode append "\}\n"
}
}
method CppGOneQual::generateGet {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 0]
if {$access == ""} {
set access "Public"
}
set cldef [$this cldef]
set rtype [$cldef getTypeGet]
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set assoc [[$this assocAttr] cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-get" [$attr getName]]
$methd kind "get"
$methd isConst 1
$methd isInline 1
set ktype [[[$attr qualifier] ooplType] generate [$class model]]
if {[$ktype localType] != "" } {
$ktype isConst 1
$ktype isReference 1
}
set keyParam [CppParam new $ktype $methd]
set keyName [[$attr qualifier] getName]
$keyParam name $keyName
set genCode [CppGenCode new $methd]
$genCode append "return "
$genCode append [$cldef genGet [$this attrName] $keyName]
$genCode append ";\n"
}
method CppGOneQual::generateRemove {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
if {$oAttr != ""} {
if {[$oAttr isMandatory] && [$oAttr getMultiplicity] != "many"} {
m4_warning $W_NOGENREMOVE [$class getName] [$this attrName]
return
}
}
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 1]
if {$access == "None"} {
return
}
if {$access == ""} {
set access "Public"
}
set rtype [CppType new]
set assoc [$attr cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-remove" [$attr getName]]
$methd kind "remove"
set cldef [$this cldef]
set ktype [[[$attr qualifier] ooplType] generate [$class model]]
if {[$ktype localType] != "" } {
$ktype isConst 1
$ktype isReference 1
}
set keyParam [CppParam new $ktype $methd]
set keyName [[$attr qualifier] getName]
$keyParam name $keyName
set genCode [CppGenCode new $methd]
if {$oAttr != ""} {
set opptype [$cldef getTypeGet]
$opptype isConst 0
$opptype generate "opposite" $genCode "" ""
$genCode append "=[$cldef genGet [$this attrName] $keyName];\n"
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $genCode $this \
[$oppGenerator attrName] "this" "opposite" \
[$oAttr isMandatory] [$attr isMandatory]
}
}
$genCode append [$cldef genRemove [$this attrName] $keyName]
$genCode append ";\n"
if [$attr isMandatory] {
CppProtect::genCheck $genCode [$cldef genIsNotEmpty [$this attrName]]
}
}
method CppGOneQual::generateCtor {this class} {
set cldef [$this cldef]
[$class featureSet] foreach feature {
if [$feature isA CppConstructor] {
set genCode [CppGenCode new $feature]
$genCode append [$cldef genCtor]
}
}
}
method CppGOneQual::generateDtor {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set cldef [$this cldef]
[$class featureSet] foreach feature {
if [$feature isA CppDestructor] {
set genCode [CppGenCode new $feature]
set tmpSec [TextSection new]
set oAttr [$attr opposite]
if {$oAttr != ""} {
if [$oAttr isMandatory] {
CppProtect::genCheck $genCode [$cldef genIsEmpty [$this attrName]]
} else {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $tmpSec $this \
[$oppGenerator attrName] "this" {$loopVar} \
[$oAttr isMandatory] [$attr isMandatory]
}
$cldef genIterator $genCode [$tmpSec contents]
}
}
$genCode append [$cldef genDtor]
}
}
}
method CppGOneQual::generateOppSet {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
}
method CppGOneQual::generateOppAdd {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
$this generateOppSet $sec $other $attrName $paramName \
$oppAttrName $attrMand $oppAttrMand
}
method CppGOneQual::generateOppRemove {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
}
# Do not delete this line -- regeneration end marker
#---------------------------------------------------------------------------
# File: @(#)cppgassocm.tcl /main/titanic/17
#---------------------------------------------------------------------------
# Start user added include file section
# End user added include file section
Class CppGAssocMany : {CppGAssocGen} {
constructor
method destructor
method getTypeDef
method generateInclude
method generateAdd
method generateGet
method generateRemove
method generateCtor
method generateDtor
method generateOppSet
method generateOppAdd
method generateOppRemove
}
constructor CppGAssocMany {class this} {
set this [CppGAssocGen::constructor $class $this]
# Start constructor user section
# End constructor user section
return $this
}
method CppGAssocMany::destructor {this} {
# Start destructor user section
# End destructor user section
$this CppGAssocGen::destructor
}
method CppGAssocMany::getTypeDef {this} {
if [$this checkLocal] {
return [CppType new]
}
return [[$this cldef] getTypeAttr]
}
method CppGAssocMany::generateInclude {this class} {
set includeList [[$this cldef] getIncludeList]
lappend includeList [CppProtect::getInclude]
foreach file $includeList {
$class addExtIncl $file
}
}
method CppGAssocMany::generateAdd {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
if {($oAttr != "") &&
([$oAttr isA OPQualAssocAttr] || [$oAttr isA OPQualLinkAttr])} {
m4_warning $W_NOGENUPDATE [$class getName] [$this attrName]
return
}
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 1]
if {$access == "None"} {
return
}
if {$access == ""} {
set access "Public"
}
set rtype [CppType new]
set assoc [$attr cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-add" [$attr getName]]
$methd kind "add"
set cldef [$this cldef]
set ptype [[$attr ooplType] generate [$class model]]
$ptype isPointer 1
set param [CppParam new $ptype $methd]
set pname "new${uName}"
$param name $pname
set genCode [CppGenCode new $methd]
if [$attr isMandatory] {
CppProtect::genCheck $genCode "$pname!=0"
}
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppSet $genCode $this \
[$oppGenerator attrName] $pname [$this attrName] \
[$oAttr isMandatory] [$attr isMandatory]
}
}
if {![$attr isMandatory]} {
$genCode append "if ($pname!=0) \{\n"
$genCode indent +
}
$genCode append [$cldef genAdd [$this attrName] $pname]
$genCode append ";\n"
if {![$attr isMandatory]} {
$genCode indent -
$genCode append "\}\n"
}
}
method CppGAssocMany::generateGet {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 0]
if {$access == ""} {
set access "Public"
}
set cldef [$this cldef]
set rtype [$cldef getTypeGet]
set assoc [[$this assocAttr] cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-get-set" [$attr getName]]
$methd kind "get"
$methd isConst 1
$methd isInline 1
set genCode [CppGenCode new $methd]
$genCode append "return "
$genCode append [$cldef genGet [$this attrName]]
$genCode append ";\n"
}
method CppGAssocMany::generateRemove {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
if {$oAttr != ""} {
if {[$oAttr isMandatory] && [$oAttr getMultiplicity] != "many"} {
m4_warning $W_NOGENREMOVE [$class getName] [$this attrName]
return
}
}
if {($oAttr != "") &&
([$oAttr isA OPQualAssocAttr] || [$oAttr isA OPQualLinkAttr])} {
m4_warning $W_NOGENUPDATE [$class getName] [$this attrName]
return
}
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
set accessList [split [$attr getPropertyValue assoc_access] -]
set access [lindex $accessList 1]
if {$access == "None"} {
return
}
if {$access == ""} {
set access "Public"
}
set rtype [CppType new]
set assoc [$attr cppAssocAttr]
set methd [CppAccMethod new $class $access $rtype $assoc]
$methd name [$methd getMethodName "assoc-remove" [$attr getName]]
$methd kind "remove"
set cldef [$this cldef]
set ptype [[$attr ooplType] generate [$class model]]
$ptype isPointer 1
set param [CppParam new $ptype $methd]
set pname "old${uName}"
$param name $pname
set genCode [CppGenCode new $methd]
if {$oAttr != ""} {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $genCode $this \
[$oppGenerator attrName] "this" $pname \
[$oAttr isMandatory] [$attr isMandatory]
}
}
$genCode append [$cldef genRemove [$this attrName] $pname]
$genCode append ";\n"
if [$attr isMandatory] {
CppProtect::genCheck $genCode [$cldef genIsNotEmpty [$this attrName]]
}
}
method CppGAssocMany::generateCtor {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
set cldef [$this cldef]
if {($oAttr != "") &&
([$oAttr isA OPQualAssocAttr] || [$oAttr isA OPQualLinkAttr])} {
m4_warning $W_NOGENCTOR [$class getName] [$this attrName]
return
}
set firstUp [string toupper [string range [$attr getName] 0 0]]
set uName "${firstUp}[string range [$attr getName] 1 end]"
[$class featureSet] foreach feature {
if [$feature isA CppConstructor] {
set genCode [CppGenCode new $feature]
$genCode append [$cldef genCtor]
}
}
}
method CppGAssocMany::generateDtor {this class} {
set attr [$this assocAttr]
if {$attr == "" } { return }
set oAttr [$attr opposite]
set cldef [$this cldef]
if {($oAttr != "") &&
([$oAttr isA OPQualAssocAttr] || [$oAttr isA OPQualLinkAttr])} {
m4_warning $W_NOGENDTOR [$class getName] [$this attrName]
return
}
[$class featureSet] foreach feature {
if [$feature isA CppDestructor] {
set genCode [CppGenCode new $feature]
set tmpSec [TextSection new]
set oAttr [$attr opposite]
if {$oAttr != ""} {
if [$oAttr isMandatory] {
CppProtect::genCheck $genCode [$cldef genIsEmpty [$this attrName]]
} else {
set oppGenerator [$oAttr generator]
if {$oppGenerator != ""} {
$oppGenerator generateOppRemove $tmpSec $this \
[$oppGenerator attrName] "this" {$loopVar} \
[$oAttr isMandatory] [$attr isMandatory]
}
$cldef genIterator $genCode [$tmpSec contents]
}
}
$genCode append [$cldef genDtor]
}
}
}
method CppGAssocMany::generateOppSet {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
$this generateOppAdd $sec $other $attrName $paramName $oppAttrName $attrMand $oppAttrMand
}
method CppGAssocMany::generateOppAdd {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
set newOAttr "${paramName}->${attrName}"
set cldef [$this cldef]
if {!$oppAttrMand} {
$sec append "if (${paramName}!=0) \{\n"
$sec indent +
}
$sec append [$cldef genAdd $newOAttr "this"]
$sec append ";\n"
if {!$oppAttrMand} {
$sec indent -
$sec append "\}\n"
}
}
method CppGAssocMany::generateOppRemove {this sec other attrName paramName oppAttrName attrMand oppAttrMand} {
set oAttr "${oppAttrName}->${attrName}"
set cldef [$this cldef]
if { $attrMand } {
CppProtect::genCheck $sec [$cldef genIsEmpty $oAttr]
} else {
if {!$oppAttrMand} {
$sec append "if (${oppAttrName}!=0) \{\n"
$sec indent +
}
$sec append [$cldef genRemove $oAttr "$paramName"]
$sec append ";\n"
if {!$oppAttrMand} {
$sec indent -
$sec append "\}\n"
}
}
}
# Do not delete this line -- regeneration end marker
