_INSTANTIATING CODE PATTERNS_
by Fred Wild

Listing One

object PetOwner  
    Name            :       string ;
    Pet             :       ptr_to  Pet [is_owner] ;
    Vet             :       ptr_to  Veterinarian [is_shared] ;
end ;

object Veterinarian  
    Name            :       string ;
    StreetAddress   :       string ;
    Town            :       string ;
    Phone           :       string ;
end ;

object Pet 
    Name            :       string ;
    KindOfPet       :       string ;
end ;

foreign string [use_ref] ;


Listing Two

#   Create the header file ...
#
                :$$NEWFILE <dsm.name>.hxx
                :
                :#ifndef <dsm.name>_H
                :#define <dsm.name>_H
                :
                :// Forward references for each class
                :
.EAch_obj
                :class  <obj.name> ;
.ENd
                :
                :$$EXECMODULE emit_class_decls
                :
                :#endif
                :
#   Create the body file ...
#
                :$$NEWFILE <dsm.name>.cxx
                :
                :#include "<dsm.name>.hxx"
                :
                :$$EXECMODULE emit_class_bodies
                :
###################################################################
#   Module to emit class declarations
#
.MOdule emit_class_decls
.EAch_obj
                        :
                        ://
                        ://  Class <obj.name> --------------------------------
                        ://
                        :
                        :class <obj.name> \
<obj.has_parent>        :: \
.EAch_parent
                        :<parent.name>\
<!parent.is_nth>        :, 
<parent.is_nth>         : 
.ENd
                        :{
                        :$$EXECMODULE emit_member_variables
                        :
                        :   public:
                        :
                        :       <obj.name>();
                        :       <obj.name>(const <obj.name>& obj);
                        :       <obj.name> *makeCopy() const ;
                        :       virtual ~<obj.name>();
                        :
                        :       <obj.name> &operator=(const <obj.name> &rhs) ;
                        :
                        :$$EXECMODULE emit_attr_access_ftn_decls
                        :
                        :} ;
.ENd
.ENd

###################################################################
#   Modules to emit class member variable declarations
#
.MOdule emit_member_variables
.EAch_attr
<attr.simple>       :       <attr.kind>       <30>  m_<attr.name> ;
<attr.ptr_to>       :       <attr.kind>       <30> *m_<attr.name> ;
.ENd
.ENd

###################################################################
#   Module to emit attribute access function declarations
#
.MOdule emit_attr_access_ftn_decls
.EAch_attr
                    :$$EXECMODULE emit_get_decl
                    :$$EXECMODULE emit_set_decl
                    :
.ENd
.ENd

###################################################################
#   Module to emit get functions for an attribute
#
.MOdule emit_get_decl
<attr.simple><!attr.use_ref> : <attr.kind>   <35>Get<attr.name> () const ;
<attr.simple><attr.use_ref>  : const <attr.kind> & <35>Get<attr.name> () const;
<attr.ptr_to>                : const <attr.kind> * <35>Get<attr.name> () const;
.ENd

###################################################################
#   Module to emit set functions for an attribute
#
.MOdule emit_set_decl
<attr.simple><!attr.use_ref> : void <35>Set<attr.name>(const<attr.kind> val);
<attr.simple><attr.use_ref>  : void <35>Set<attr.name>(const<attr.kind> & val);
<attr.ptr_to>                : void <35>Set<attr.name>(<attr.kind> *val) ; 
<attr.ptr_to>                : void <35>Clear<attr.name> () ; 
.ENd

###################################################################
#   Module to emit the bodies of member functions for each class
#
.MOdule emit_class_bodies
.EAch_obj
            :
            ://////////////////////////////////////////////////////////
            ://     class <obj.name>

            :$$EXECMODULE emit_class_default_ctor
            :$$EXECMODULE emit_class_copy_ctor
            :$$EXECMODULE emit_class_destructor
            :$$EXECMODULE emit_assignment_op_body
            :$$EXECMODULE emit_get_and_set_ftn_bodies
.ENd
.ENd

###################################################################
#   Module to create a class' default constructor
#
.MOdule emit_class_default_ctor
                                 :
                                 :<obj.name>::<obj.name>()
                                 :{
.EAch_attr
<attr.ptr_to><!attr.has_init>    :   m_<attr.name> = NULL;
<attr.has_init>                  :   m_<attr.name> = <attr.init_val> ;
.ENd
                                 :}
.ENd

###################################################################
#   Module to create a class' copy ctor and 'makeCopy' function
#
.MOdule emit_class_copy_ctor
                                 :
                                 :<obj.name>::<obj.name>(const <obj.name>& obj)
<obj.has_parent>                 :   : \

.EAch_parent
                                 :<parent.name>(obj)\
<!parent.is_nth>                 :,
<!parent.is_nth>                 :     \
<parent.is_nth>                  :
.ENd
                                 :{
.EAch_attr
<attr.simple>                  : m_<attr.name> = obj.m_<attr.name>;
<attr.ptr_to><attr.is_shared>  : m_<attr.name> = obj.m_<attr.name>;
<attr.ptr_to><attr.is_owner>   : m_<attr.name> = obj.m_<attr.name>->makeCopy();
.ENd
                                 :}
                                 :
                                 :<obj.name> *<obj.name>::makeCopy() const 
                                 :{
                                 :    return new <obj.name>(*this);
                                 :}
.ENd

###################################################################
#   Module to create a class' destructor
#
.MOdule emit_class_destructor
                                 :
                                 :<obj.name>::~<obj.name>()
                                 :{
.EAch_attr
<attr.ptr_to><attr.is_owner>     :   delete m_<attr.name> ;
.ENd
                                 :}
.ENd

###################################################################
#   Module to create a class' assignment operator
#
.MOdule emit_assignment_op_body
                                :
                                :<obj.name> &
                                :<obj.name>::operator=(const <obj.name> &rhs)
                                :{
                                :   if (this == &rhs) return *this ;
                                :       // No changes if assignment to self 
                                :
.EAch_parent
                                :   ((<parent.name> &) (*this)) = rhs ;  
                                :       // Assign base class members of <parent.name>
.ENd
.EAch_attr
<attr.simple>                  : m_<attr.name> = rhs.m_<attr.name>;
<attr.ptr_to><attr.is_shared>  : m_<attr.name> = rhs.m_<attr.name>;
<attr.ptr_to><attr.is_owner>   : m_<attr.name> = rhs.m_<attr.name>->makeCopy();
.ENd
                                :
                                :   return *this ;
                                :}
.ENd

###################################################################
# Module to create class member functions that access single valued member vars
#
.MOdule emit_get_and_set_ftn_bodies
.EAch_attr
<attr.getset>   :$$EXECMODULE emit_get_ftn_body
<attr.getset>   :$$EXECMODULE emit_set_and_clear_ftn_bodies
.ENd
.ENd

###################################################################
#   Module to create a 'Get' function body for accessing an attribute
#
.MOdule emit_get_ftn_body
<attr.simple><!attr.use_ref>    :<attr.kind> Get<attr.name> () const
<attr.simple><attr.use_ref>     :const <attr.kind> & Get<attr.name> () const 
<attr.ptr_to>                   :const <attr.kind> * Get<attr.name> () const 
                                :{
                                :    return m_<attr.name> ;
                                :}
.ENd

###################################################################
#   Module to create a 'Set' and 'Clear' function bodies
#
.MOdule emit_set_and_clear_ftn_bodies
<attr.simple><!attr.use_ref>    :void Set<attr.name> (const <attr.kind> val)
<attr.simple><attr.use_ref>     :void Set<attr.name> (const <attr.kind> & val)
<attr.ptr_to>                   :void Set<attr.name> (<attr.kind> *val)
                                :{
<attr.simple>                   :  <attr.name> = val ;
<attr.ptr_to><attr.is_owner>    :  if (<attr.name> != NULL) delete <attr.name>;
<attr.ptr_to>                   :  <attr.name> = val ;
                                :}
<attr.ptr_to>                   :
<attr.ptr_to>                   :
<attr.ptr_to>                   :void Clear<attr.name> ()
<attr.ptr_to>                   :{
<attr.ptr_to><attr.is_owner>    : if (<attr.name> != NULL) delete <attr.name> ;
<attr.ptr_to>                   : <attr.name> = NULL ;
<attr.ptr_to>                   :}
.ENd
.ENd


Listing Three

#ifndef pets_H
#define pets_H

// Forward references for each class

class  PetOwner ;
class  Veterinarian ;
class  Pet ;

//  Class PetOwner --------------------------------
class PetOwner {
       string                  m_Name ;
       Pet                    *m_Pet ;
       Veterinarian           *m_Vet ;
   public:
       PetOwner();
       PetOwner(const PetOwner& obj);
       PetOwner *makeCopy() const ;
       virtual ~PetOwner();

       PetOwner &operator=(const PetOwner &rhs) ;

       const string &             GetName () const ;
       void                       SetName (const string & val) ;

       const Pet *                GetPet () const ;
       void                       SetPet (Pet *val) ; 
       void                       ClearPet () ; 

       const Veterinarian *       GetVet () const ;
       void                       SetVet (Veterinarian *val) ; 
       void                       ClearVet () ; 
} ;

//  Class Veterinarian --------------------------------
class Veterinarian {
       string                  m_Name ;
       string                  m_StreetAddress ;
       string                  m_Town ;
       string                  m_Phone ;
   public:
       Veterinarian();
       Veterinarian(const Veterinarian& obj);
       Veterinarian *makeCopy() const ;
       virtual ~Veterinarian();

       Veterinarian &operator=(const Veterinarian &rhs) ;

       const string &             GetName () const ;
       void                       SetName (const string & val) ;

       const string &             GetStreetAddress () const ;
       void                       SetStreetAddress (const string & val) ;

       const string &             GetTown () const ;
       void                       SetTown (const string & val) ;

       const string &             GetPhone () const ;
       void                       SetPhone (const string & val) ;
} ;

//  Class Pet --------------------------------
class Pet {
       string                  m_Name ;
       string                  m_KindOfPet ;
   public:
       Pet();
       Pet(const Pet& obj);
       Pet *makeCopy() const ;
       virtual ~Pet();

       Pet &operator=(const Pet &rhs) ;

       const string &             GetName () const ;
       void                       SetName (const string & val) ;

       const string &             GetKindOfPet () const ;
       void                       SetKindOfPet (const string & val) ;
} ;
#endif


Listing Four

#include "pets.hxx"

//////////////////////////////////////////////////////////
//     class PetOwner
PetOwner::PetOwner()
{
   m_Pet = NULL;
   m_Vet = NULL;
}
PetOwner::PetOwner(const PetOwner& obj)
{
   m_Name = obj.m_Name;
   m_Pet = obj.m_Pet->makeCopy();
   m_Vet = obj.m_Vet;
}
PetOwner *PetOwner::makeCopy() const 
{
    return new PetOwner(*this);
}
PetOwner::~PetOwner()
{
   delete m_Pet ;
}
PetOwner &
PetOwner::operator=(const PetOwner &rhs)
{
   if (this == &rhs) return *this ;
       // No changes if assignment to self 
   m_Name = rhs.m_Name;
   m_Pet = rhs.m_Pet->makeCopy();
   m_Vet = rhs.m_Vet;

   return *this ;
}
//////////////////////////////////////////////////////////
//     class Veterinarian

Veterinarian::Veterinarian()
{
}
Veterinarian::Veterinarian(const Veterinarian& obj)
{
   m_Name = obj.m_Name;
   m_StreetAddress = obj.m_StreetAddress;
   m_Town = obj.m_Town;
   m_Phone = obj.m_Phone;
}
Veterinarian *Veterinarian::makeCopy() const 
{
    return new Veterinarian(*this);
}
Veterinarian::~Veterinarian()
{
}
Veterinarian &
Veterinarian::operator=(const Veterinarian &rhs)
{
   if (this == &rhs) return *this ;
       // No changes if assignment to self 
   m_Name = rhs.m_Name;
   m_StreetAddress = rhs.m_StreetAddress;
   m_Town = rhs.m_Town;
   m_Phone = rhs.m_Phone;

   return *this ;
}
//////////////////////////////////////////////////////////
//     class Pet
Pet::Pet()
{
}
Pet::Pet(const Pet& obj)
{
   m_Name = obj.m_Name;
   m_KindOfPet = obj.m_KindOfPet;
}
Pet *Pet::makeCopy() const 
{
    return new Pet(*this);
}
Pet::~Pet()
{
}
Pet &
Pet::operator=(const Pet &rhs)
{
   if (this == &rhs) return *this ;
       // No changes if assignment to self 
   m_Name = rhs.m_Name;
   m_KindOfPet = rhs.m_KindOfPet;

   return *this ;
}


Example 1:

				://
				://  Class <obj.name> -------------
				://
				:
				:class <obj.name> \
	<obj.has_parent>	:: \
	.each_parent
				:<parent.name>\
	<!parent.is_nth>	:, 
	<parent.is_nth>	: 
	.end
				:{



Example 2:

PetOwner::~PetOwner()
{
   delete m_Pet ;
}