cppheadb.sct

c#设计模式WithCla

// Class: CLASS_NAME            //ANSI C++

#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H  //Required for CLASS_NAME class
  #define __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H

#ifndef __IOSTREAM_H            //Required for cin and cout
  #include <iostream.h>                 
#endif

#ifndef __CSTRING_H            //Required for CString class
  #include <CString.h>                 
#endif

[                               
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$BASE_CLASS$_H     //Required for BASE_CLASS class
  #include "TRUNCATE_EIGHT$BASE_CLASS$.h"
#endif
] 
[#include <INCLUDE_FILE>        //Required for include files ] 
[                               //Required for 1:1 association classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$ASSOCIATION_ONE_CLASS$_H    //ASSOCIATION_ONE_CLASS
  #include "TRUNCATE_EIGHT$ASSOCIATION_ONE_CLASS.h"
#endif ]
[                               //Required for 1:1 aggregation (part) classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$AGGREGATION_ONE_CLASS$_H    //AGGREGATION_ONE_CLASS
  #include "TRUNCATE_EIGHT$AGGREGATION_ONE_CLASS$.h"
#endif ] 
[                               //Required for 1:M association classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$ASSOCIATION_MANY_CLASS$_H   //ASSOCIATION_MANY_CLASS
  #include "TRUNCATE_EIGHT$ASSOCIATION_MANY_CLASS$.h"
#endif ] 
[                               //Required for 1:M aggregation (part) classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$AGGREGATION_MANY_CLASS$_H   //AGGREGATION_MANY_CLASS
  #include "TRUNCATE_EIGHT$AGGREGATION_MANY_CLASS$.h"
#endif ] 
          NO_OUTPUT_BEGIN Use the the CLASS_USER fields for typedef, enum, const declarations, e.g.
          const int maxNumberOfTires = 4; NO_OUTPUT_END
CLASS_USER1
CLASS_USER2

class CLASS_NAME[NO_RETURN NO_REPEAT: NO_REPEAT public BASE_CLASS ,DELETE_LAST_SYMBOL] CLASS_LIBRARY_BASE_CLASS     
{ SELECT_WHEN ATTRIBUTE_ACCESS == private
  [CPP_ATTRIBUTE_STATIC CPP_ATTRIBUTE_CONSTANT ATTRIBUTE_TYPE ATTRIBUTE_NAME$; //Attribute data member] 

  [AGGREGATION_ONE_CLASS AGGREGATION_ONE_NAME$; //1:1 aggregation part data member] 

  [ASSOCIATION_ONE_CLASS$* ASSOCIATION_ONE_NAME$; //1:1 association object data member] 

  [ASSOCIATION_ONE_CLASS null$ASSOCIATION_ONE_CLASS;// Null association object for association object]

  [int AGGREGATION_MANY_NAME$Index; //Index for array of 1:M aggregation part objects]

  [          //1:M aggregation part data member
            //Change C array to C++ collection class with iterator
   AGGREGATION_MANY_CLASS AGGREGATION_MANY_NAME LITERAL_SYMBOL[maxNumberOf$AGGREGATION_MANY_CLASS$s LITERAL_SYMBOL];]   

  [int ASSOCIATION_MANY_NAME$Index; //Index for array of 1:M association objects] 

  [          //1:M association object data member
            //Change C array to C++ collection class with iterator
   ASSOCIATION_MANY_CLASS$* ASSOCIATION_MANY_NAME LITERAL_SYMBOL[maxNumberOf$ASSOCIATION_MANY_CLASS$s LITERAL_SYMBOL];] 

  [          // Null association object for initialization of association object data member
  ASSOCIATION_MANY_CLASS$ null$ASSOCIATION_MANY_CLASS;]

SELECT_WHEN OPERATION_ACCESS == private
[  CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL  ; ]

protected:
SELECT_WHEN OPERATION_ACCESS == protected
[  CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL ; ]

SELECT_WHEN ATTRIBUTE_ACCESS == protected 
[CPP_ATTRIBUTE_STATIC CPP_ATTRIBUTE_CONSTANT ATTRIBUTE_TYPE ATTRIBUTE_NAME$;]  

public:

  SELECT_WHEN ATTRIBUTE_ACCESS == public
  [CPP_ATTRIBUTE_STATIC CPP_ATTRIBUTE_CONSTANT ATTRIBUTE_TYPE ATTRIBUTE_NAME$;]

             //Default constructor alternative to compiler provided default constructor
             //Ensure correct initial values
             //Initialization list has members in the order declared
             //Association object data member pointers initialized to null association object
  CLASS_NAME ();

             //Constructor with arguments
             //Update to argument list to initialize base class data members, 
             //e.g. (int aNumber) : BaseClass (aNumber)
  CLASS_NAME ( SELECT_WHEN LOGICAL_NOT ATTRIBUTE_IS_STATIC [NO_RETURN ATTRIBUTE_TYPE a$ATTRIBUTE_NAME,DELETE_LAST_SYMBOL] ) ;
  
             //Copy Constructor NO_OUTPUT_BEGIN
             //Copy constructor alternative to compiler provided default copy constructor
             //Copy alternatives for association objects: (1) initialize association object to nullAssociation Object
             //(2) Shallow copy to copy pointers of association objects (3) Deep copy to create new association objects
             //and copy values of association objects
             //Commented out code assigns 1:1 and 1:M association object data member pointers for shallow copy
             //Remove // if you desire to assign pointers NO_OUTPUT_END
  CLASS_NAME (const CLASS_NAME$& a$CLASS_NAME );

             //Operator= Assignment Operator NO_OUTPUT_BEGIN
             // Alternatives to compiler provided default operator=
             //Assignment alternatives for association objects: (1) initialize association object to nullAssociation Object
             //(2) Shallow copy to copy pointers to association objects (3) Deep copy to create new association objects
             //and copy values of association objects
             //Commented out code assigns 1:1 association object data member pointers for shallow copy 
             //Remove // if you desire to assign association object pointers for shallow copy    NO_OUTPUT_END
  CLASS_NAME& operator= (const CLASS_NAME$& a$CLASS_NAME);
 
            //Operator== Equality Operator NO_OUTPUT_BEGIN
            //No compiler default operator== generated 
            //Update to access 1:1 association object data members
            //Function does not compare 1:1 and 1:M association object data member pointers     NO_OUTPUT_END
  int operator== (const CLASS_NAME$& a$CLASS_NAME) const;

            //Operator<< for cout
  friend ostream& operator<< (ostream& os, const CLASS_NAME$& a$CLASS_NAME);

            //Operator>> for cin
  friend istream& operator>> (istream& is, CLASS_NAME$& a$CLASS_NAME);

SELECT_WHEN ATTRIBUTE_IS_NORMAL 
[          //Get accessor function for non-static attribute data member
  ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$() const
  { return ATTRIBUTE_NAME$;
  }  ] 
SELECT_WHEN ATTRIBUTE_IS_NORMAL 
[          //Set accessor function for non-static attribute data member
  void set$ATTRIBUTE_NAME (const ATTRIBUTE_TYPE a$ATTRIBUTE_NAME$)
  { ATTRIBUTE_NAME = a$ATTRIBUTE_NAME$;
  }  ] 
SELECT_WHEN ATTRIBUTE_IS_STATIC 
[          //Get accessor function for static attribute data member
  static ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$()
  { return ATTRIBUTE_NAME$;
  }  ]  
SELECT_WHEN ATTRIBUTE_IS_STATIC 
[          //Set accessor function for static attribute data member
  static void set$ATTRIBUTE_NAME ( const ATTRIBUTE_TYPE a$ATTRIBUTE_NAME$)
  { ATTRIBUTE_NAME = a$ATTRIBUTE_NAME$;
  }  ] 
SELECT_WHEN ATTRIBUTE_IS_CONSTANT 
[          //Get accessor function for constant attribute data member
  ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$()
  { return ATTRIBUTE_NAME$;
  }  ]  
[          //Get accessor function for 1:1 aggregation part data member
  const AGGREGATION_ONE_CLASS$& get$AGGREGATION_ONE_CLASS$() const
  { return AGGREGATION_ONE_NAME$;
  }  ] 
[          //Set accessor function for 1:1 aggregation part data member
  void set$AGGREGATION_ONE_CLASS (const AGGREGATION_ONE_CLASS$& a$AGGREGATION_ONE_NAME$)
  { AGGREGATION_ONE_NAME = a$AGGREGATION_ONE_NAME$;
  }  ]
[          //Get accessor function for 1:1 association object data member
  const ASSOCIATION_ONE_CLASS$* get$ASSOCIATION_ONE_CLASS$() const
  { return ASSOCIATION_ONE_NAME$;
  }  ]  
[          //Set accessor function for 1:1 association object data member
  void set$ASSOCIATION_ONE_CLASS ($ASSOCIATION_ONE_CLASS$* const a$ASSOCIATION_ONE_NAME$)
  { ASSOCIATION_ONE_NAME = a$ASSOCIATION_ONE_NAME$;
  }  ]
[          //Remove function for 1:1 association object data member
          //Warning delete ASSOCIATION_ONE_NAME object if dynamic object
  void remove$ASSOCIATION_ONE_CLASS$(); //throw (string)  ] 

[          //Exists function for 1:1 association object data member
  int exists$ASSOCIATION_ONE_CLASS$() const;  ] 

[          //Exists function with argument for 1:1 association object data member
  int exists$ASSOCIATION_ONE_CLASS ($ASSOCIATION_ONE_CLASS$* const a$ASSOCIATION_ONE_NAME$) const;  ] 

[           //Get accessor function for 1:M aggregation collection NO_OUTPUT_BEGIN
           //Change C array to C++ collection class with iterator
           //Returns pointer to the 1st element of the C array NO_OUTPUT_END
  const AGGREGATION_MANY_CLASS$* get$AGGREGATION_MANY_CLASS$Collection () const ;  ] 

[            //Set accessor function for 1:M aggregation collection  NO_OUTPUT_BEGIN
            //Change C array to C++ collection class with iterator
            //Parameter is pointer to the first element of the C array  NO_OUTPUT_END
  void set$AGGREGATION_MANY_CLASS$Collection ($AGGREGATION_MANY_CLASS$* const a$AGGREGATION_MANY_NAME$Collection); ]

[            //Get accessor function for 1:M aggregation part data member  NO_OUTPUT_BEGIN
            //Returns the first 1:M aggregation part in the array
            //Change C array to C++ collection class with iterator  NO_OUTPUT_END
  const AGGREGATION_MANY_CLASS$& getFirst$AGGREGATION_MANY_CLASS$() const ;  ]

[            //Exists function for 1:M aggregation part data member  NO_OUTPUT_BEGIN
            //Change C array to C++ collection class with iterator  NO_OUTPUT_END
  int exists$AGGREGATION_MANY_CLASS (const AGGREGATION_MANY_CLASS$& a$AGGREGATION_MANY_CLASS$) const ;   ] 

[             //Get accessor function for 1:M association collection  NO_OUTPUT_BEGIN
             //Change C array to C++ collection class with iterator
             //Returns pointer to 1st element of the C array  NO_OUTPUT_END
  const ASSOCIATION_MANY_CLASS$* get$ASSOCIATION_MANY_CLASS$Collection() const ;  ] 

[             //Set accessor function for 1:M association collection  NO_OUTPUT_BEGIN
             //Change C array to C++ collection class with iterator
             //Parameter is pointer to 1st element of the C array  NO_OUTPUT_END
  void set$ASSOCIATION_MANY_CLASS$Collection ($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$Collection); ]

[             //Add function for 1:M association object data member  NO_OUTPUT_BEGIN
             //Change C array to C++ collection class with iterator  NO_OUTPUT_END
  void add$ASSOCIATION_MANY_CLASS ($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$); //throw (string) ]

[            //Remove function for 1:M association object data member
            //Warning delete ASSOCIATION_MANY_NAME object if dynamic object  NO_OUTPUT_BEGIN
            //Change C array to C++ collection class with iterator  NO_OUTPUT_END
  void removeLast$ASSOCIATION_MANY_CLASS ( ) ;//throw (string)  ] 

[            //Remove all function for 1:M association object data member
            //Warning delete ASSOCIATION_MANY_NAME object if dynamic object  NO_OUTPUT_BEGIN
            //Change C array to C++ collection class with iterator  NO_OUTPUT_END
  void removeAll$ASSOCIATION_MANY_CLASS$s ( ) ;//throw (string)  ]

[            //Get accessor function for 1:M association object data member  NO_OUTPUT_BEGIN
            //Change C array to C++ collection class with iterator
            //Returns the first 1:M association object pointer in the array  NO_OUTPUT_END
  const ASSOCIATION_MANY_CLASS$* getFirst$ASSOCIATION_MANY_CLASS$() const ;//throw (string)  ] 

[            //Exists function for 1:M association object data member  NO_OUTPUT_BEGIN
            //Change C array to C++ collection class with iterator  NO_OUTPUT_END
  int exists$ASSOCIATION_MANY_CLASS$() const ;  ] 

[            //Exists function for 1:M association object data member  NO_OUTPUT_BEGIN
            //Change C array to C++ collection class with iterator  NO_OUTPUT_END
  int exists$ASSOCIATION_MANY_CLASS ($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$) const ;  ] 
SELECT_WHEN OPERATION_ACCESS == public
[CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL  ;  ] 

 OPERATION_CPP_VIRTUAL_BASE_CLASS ~ CLASS_NAME ( ) { }  //Destructor - Delete any pointer data members that used new in constructors 
               //Destructor should be virtual if and only if class contains at least one virtual function
              //Objects destroyed in the reverse order of the construction order
};

#endif