//==================================================================================================
// M e t a _ m o d e l                                                                    Interface
// S t r u c t u r e
//                                                                                By Bruno Bachelet
//==================================================================================================
// Copyright (c) 1999-2016
// Bruno Bachelet - bruno@nawouak.net - http://www.nawouak.net
//
// This file is part of the B++ Library. This library is free software; you can redistribute it
// and/or modify it under the terms of the GNU Library General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
// the GNU Library General Public License for more details (http://www.gnu.org).

/*DESCRIPTION*/
/* This module provides a simplified meta-model for C++/Java libraries like the B++ Library. */

// File Name //-------------------------------------------------------------------------------------
#line __LINE__ "meta_model/structure.hpp"

// Guardian //--------------------------------------------------------------------------------------
#ifndef guMetaModelStructure
#define guMetaModelStructure

// Headers //---------------------------------------------------------------------------------------
#include <set> /*INCLUDE*/
#include <bpp/standard.hpp> /*INCLUDE*/

namespace bpp {

// Importation/Exportation //-----------------------------------------------------------------------
#ifdef META_MODEL_DLL
 #define dll_export DLL_EXPORT
#else
 #define dll_export DLL_IMPORT
#endif

// Namespaces //------------------------------------------------------------------------------------
#define public_area  metaModelStructure
#define private_area metaModelStructure_private

namespace public_area  { /*NAMESPACE*/ using namespace standard; }
namespace private_area { using namespace public_area; }

extern_module_name;

// Initialization //--------------------------------------------------------------------------------
#define iniMetaModelStructure
has_initializer;

// Macrocommands //---------------------------------------------------------------------------------

// Types & Classes //-------------------------------------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Classes
 class clDependency;
 class clEntityInformation;
 class clFileDependency;
 class clLibraryDependency;
 class clModuleInformation;
 //-----------------------------------------------------------------------------------Variable Types
 /*TYPE*/ /* Association of module names with module information. */
 typedef std_map(clString,clModuleInformation *) clModuleInformationX;

 /*TYPE*/ /* List of entity information. */
 typedef std_vector(clEntityInformation) clEntityInformationS;

 /*TYPE*/ /* List of file names. */
 typedef std_set(clString) clFileS;

 /*TYPE*/ /* Association of aliases with the file name they represent. */
 typedef std_map(clString,clString) clAliasX;
 //-----------------------------------------------------------------------------------Constant Types
 typedef const clDependency        ctDependency;
 typedef const clEntityInformation ctEntityInformation;
 typedef const clFileDependency    ctFileDependency;
 typedef const clLibraryDependency ctLibraryDependency;
 typedef const clModuleInformation ctModuleInformation;

 typedef const clAliasX             ctAliasX;
 typedef const clEntityInformationS ctEntityInformationS;
 typedef const clFileS              ctFileS;
 typedef const clModuleInformationX ctModuleInformationX;
}

namespace private_area {}

// F i l e D e p e n d e n c y  Interface //--------------------------------------------------------
namespace public_area {
 /*CLASS clFileDependency */ /* Contains the dependency information of a source file. */
 class clFileDependency {
  //------------------------------------------------------------------------------------------Public
  /*ATTRIBUTE clFileDependency */
  /* Short name of the source file (used by <CODE>#include</CODE>). */
  read_write_attribute(clString,atAlias,alias);

  /*ATTRIBUTE clFileDependency */ /* Full name of the source file. */
  read_write_attribute(clString,atSourceName,sourceName);

  /*ATTRIBUTE clFileDependency */
  /* Full name of the object file associated with the source file. */
  read_write_attribute(clString,atObjectName,objectName);

  /*ATTRIBUTE clFileDependency */ /* List of the files the source file depends on. */
  read_write_attribute(clFileS,atFileS,files);

  /*ATTRIBUTE clFileDependency */ /* Indicates if the list above is complete. */
  read_write_attribute(tyBoolean,atComplete,complete);

  /*ATTRIBUTE clFileDependency */ /* Indicates if it's a Java file. */
  read_write_attribute(tyBoolean,atIsJava,isJava);

  public_property constructor clFileDependency(void);
  public_property constructor clFileDependency(ctFileDependency &);
  public_property destructor clFileDependency(void) {}

  public_property clFileDependency & operator = (ctFileDependency &);
 };
}

// L i b r a r y D e p e n d e n c y  Interface //--------------------------------------------------
namespace public_area {
 /*CLASS clLibraryDependency */ /* Contains the dependency information of a library. */
 class clLibraryDependency {
  //------------------------------------------------------------------------------------------Public
  /*ATTRIBUTE clLibraryDependency */ /* Full name of the static version of the library. */
  read_write_attribute(clString,atName,name);

  /*ATTRIBUTE clLibraryDependency */ /* Full name of the dynamic version of the library. */
  read_write_attribute(clString,atDllName,dllName);

  /*ATTRIBUTE clLibraryDependency */ /* Short name of the static version of the library. */
  read_write_attribute(clString,atAlias,alias);

  /*ATTRIBUTE clLibraryDependency */ /* Short name of the dynamic version of the library. */
  read_write_attribute(clString,atDllAlias,dllAlias);

  /*ATTRIBUTE clLibraryDependency */ /* List of the files the library depends on. */
  read_write_attribute(clFileS,atFileS,files);

  public_property constructor clLibraryDependency(void);
  public_property constructor clLibraryDependency(ctLibraryDependency &);
  public_property destructor clLibraryDependency(void) {}

  public_property clLibraryDependency & operator = (ctLibraryDependency &);
 };
}

namespace public_area {
 //-----------------------------------------------------------------------------------Variable Types
 /*TYPE*/ /* Association of file names with their dependency information. */
 typedef std_map(clString,clFileDependency) clFileDependencyX;

 /*TYPE*/ /* Association of library names with their dependency information. */
 typedef std_map(clString,clLibraryDependency) clLibraryDependencyX;
 //-----------------------------------------------------------------------------------Constant Types
 typedef const clFileDependencyX    ctFileDependencyX;
 typedef const clLibraryDependencyX ctLibraryDependencyX;
}

// Functions Interface //---------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// Errors //----------------------------------------------------------------------------------------
namespace public_area {}

// Constants & Variables //-------------------------------------------------------------------------
/*CONSTANT*/ /* Extension of the C++ implementation source file names. */
extern_static_constant(public,tcString,goCppExtension,cppExtension);

/*CONSTANT*/ /* Extension of the dynamic-link library file names. */
extern_static_constant(public,tcString,goDllExtension,dllExtension);

/*CONSTANT*/ /* Prefix of the dynamic-link library file names. */
extern_static_constant(public,tcString,goDllPrefix,dllPrefix);

/*CONSTANT*/ /* Extension of the C++ interface source file names. */
extern_static_constant(public,tcString,goHppExtension,hppExtension);

/*CONSTANT*/ /* Extension of the static library file names. */
extern_static_constant(public,tcString,goLibraryExtension,libraryExtension);

/*CONSTANT*/ /* Extension of the object file names. */
extern_static_constant(public,tcString,goObjectExtension,objectExtension);

// D e p e n d e n c y  Interface //----------------------------------------------------------------
namespace public_area {
 /*CLASS clDependency */
 /* Represents the dependencies of files and libraries in a list of folders. */
 class clDependency {
  //------------------------------------------------------------------------------------------Public
  /*ATTRIBUTE clDependency */ /* List of files and their dependency. */
  read_write_attribute(clFileDependencyX,atFileX,files);

  /*ATTRIBUTE clDependency */ /* List of libraries and their dependency. */
  read_write_attribute(clLibraryDependencyX,atLibraryX,libraries);

  /*ATTRIBUTE clDependency */
  /* List of the folders (containing the source files) and their alias (for the makefile). */
  read_write_attribute(clAliasX,atPathX,paths);

  public_property constructor clDependency(void);
  public_property constructor clDependency(ctDependency &);
  public_property destructor clDependency(void) {}

  public_property clDependency & operator = (ctDependency &);
 };
}

// E n t i t y I n f o r m a t i o n  Interface //--------------------------------------------------
namespace public_area {
 /*CLASS clEntityInformation */ /* Represents the information of an entity of the meta-model. */
 class clEntityInformation {
  //------------------------------------------------------------------------------------------Public
  /*ATTRIBUTE clEntityInformation */ /* Name of the entity. */
  read_write_attribute(clString,atName,name);

  /*ATTRIBUTE clEntityInformation */ /* C++ declaration of the entity. */
  read_write_attribute(clString,atDeclaration,declaration);

  /*ATTRIBUTE clEntityInformation */ /* Description of the entity. */
  read_write_attribute(clString,atDescription,description);

  /*ATTRIBUTE clEntityInformation */ /* HTML reference of the entity. */
  read_write_attribute(tyCardinal,atReference,reference);

  public_property constructor clEntityInformation(void);
  public_property constructor clEntityInformation(ctEntityInformation &);
  public_property destructor clEntityInformation(void) {}

  public_property clEntityInformation & operator = (ctEntityInformation &);
 };
}

// M o d u l e I n f o r m a t i o n  Interface //--------------------------------------------------
namespace public_area {
 /*CLASS clModuleInformation */ /* Represents the information of a module in the meta-model. */
 class clModuleInformation {
  //-----------------------------------------------------------------------------------------Private
  private_property typedef std_set(clString)    clChildS;
  private_property typedef clEntityInformationS clEntityS;
  private_property typedef std_vector(clString) clNameS;
  //------------------------------------------------------------------------------------------Public
  /*ATTRIBUTE clModuleInformation */ /* Name of the module. */
  read_write_attribute(clString,atName,name);

  /*ATTRIBUTE clModuleInformation */ /* Path of the module. */
  read_write_attribute(clString,atPath,path);

  /*ATTRIBUTE clModuleInformation */ /* Short name of the module. */
  read_write_attribute(clString,atShortName,shortName);

  /*ATTRIBUTE clModuleInformation */ /* Indicates if the module is written in Java. */
  read_write_attribute(tyBoolean,atIsJava,isJava);

  /*ATTRIBUTE clModuleInformation */ /* Namespace associated with the module. */
  read_write_attribute(clString,atNameSpace,nameSpace);

  /*ATTRIBUTE clModuleInformation */ /* Parent module of the module. */
  read_write_attribute(clString,atParent,parent);

  /*ATTRIBUTE clModuleInformation */ /* Description of the module. */
  read_write_attribute(clString,atDescription,description);

  /*ATTRIBUTE clModuleInformation */ /* Level of the module in the modules hierarchy. */
  read_write_attribute(tyCardinal,atLevel,level);

  /*ATTRIBUTE clModuleInformation */
  /* Name of the HTML file containing the source code of the module. */
  read_write_attribute(clString,atCodeTargetFile,codeTargetFile);

  /*ATTRIBUTE clModuleInformation */ /* Name of the implementation source file of the module. */
  read_write_attribute(clString,atCppSourceFile,cppSourceFile);

  /*ATTRIBUTE clModuleInformation */
  /* Name of the HTML file containing the documentation of the module. */
  read_write_attribute(clString,atHomeTargetFile,homeTargetFile);

  /*ATTRIBUTE clModuleInformation */ /* Name of the interface source file of the module. */
  read_write_attribute(clString,atHppSourceFile,hppSourceFile);

  /*ATTRIBUTE clModuleInformation */
  /* Name of the framed HTML file containing the documentation of the module. */
  read_write_attribute(clString,atIndexTargetFile,indexTargetFile);

  /*ATTRIBUTE clModuleInformation */
  /* Name of the HTML file containing the menu of the documentation of the module. */
  read_write_attribute(clString,atMenuTargetFile,menuTargetFile);

  /*ATTRIBUTE clModuleInformation */ /* List of the child modules of the module. */
  read_write_attribute(clChildS,atChildS,children);

  /*ATTRIBUTE clModuleInformation */
  /* List of the files included into the interface of the module. */
  read_write_attribute(clNameS,atIncludeS,includes);

  /*ATTRIBUTE clModuleInformation */
  /* List of the files used by the implementation of the module. */
  read_write_attribute(clNameS,atNeeds,needs);

  /*ATTRIBUTE clModuleInformation */ /* List of the namespaces integrated into the module. */
  read_write_attribute(clNameS,atNamespaceS,namespaces);

  /*ATTRIBUTE clModuleInformation */ /* List of the aliases used by the module. */
  read_write_attribute(clEntityS,atAliaseS,aliases);

  /*ATTRIBUTE clModuleInformation */ /* List of the macrocommands defined by the module. */
  read_write_attribute(clEntityS,atMacrocommandS,macrocommands);

  /*ATTRIBUTE clModuleInformation */ /* List of the types defined in the module. */
  read_write_attribute(clEntityS,atTypeS,types);

  /*ATTRIBUTE clModuleInformation */ /* List of the errors defined in the module. */
  read_write_attribute(clEntityS,atErrorS,errors);

  /*ATTRIBUTE clModuleInformation */ /* List of the constants defined in the module. */
  read_write_attribute(clEntityS,atConstantS,constants);

  /*ATTRIBUTE clModuleInformation */ /* List of the variables defined in the module. */
  read_write_attribute(clEntityS,atVariableS,variables);

  /*ATTRIBUTE clModuleInformation */ /* List of the functions defined in the module. */
  read_write_attribute(clEntityS,atFunctionS,functions);

  /*ATTRIBUTE clModuleInformation */ /* List of the classes defined in the module. */
  read_write_attribute(clEntityS,atClasseS,classes);

  /*ATTRIBUTE clModuleInformation */
  /* List of the attributes of the classes defined in the module. */
  read_write_attribute(clEntityS,atAttributeS,attributes);

  /*ATTRIBUTE clModuleInformation */
  /* List of the methods of the classes defined in the module. */
  read_write_attribute(clEntityS,atMethodS,methods);

  /*ATTRIBUTE clModuleInformation */
  /* List of the types in the classes defined in the module. */
  read_write_attribute(clEntityS,atClassTypeS,classTypes);

  public_property constructor clModuleInformation(void);
  public_property constructor clModuleInformation(ctModuleInformation &);
  public_property destructor clModuleInformation(void) {}

  public_property clModuleInformation & operator = (ctModuleInformation &);
 };
}

// Functions Inline //------------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// X X X  Inline //---------------------------------------------------------------------------------
namespace {}

// End //-------------------------------------------------------------------------------------------
}
#undef dll_export
#undef public_area
#undef private_area
#endif
 
//==================================================================================================
// M e t a _ m o d e l                                                               Implementation
// S t r u c t u r e
//                                                                                By Bruno Bachelet
//==================================================================================================
// Copyright (c) 1999-2016
// Bruno Bachelet - bruno@nawouak.net
//
// This file is part of the B++ Library. This library is free software you can redistribute it
// and/or modify it under the terms of the GNU Library General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
// the GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License along with this
// library; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.

// File Name //-------------------------------------------------------------------------------------
#line __LINE__ "meta_model/structure.cpp"

// DLL Belonging //---------------------------------------------------------------------------------
#define META_MODEL_DLL

// Headers //---------------------------------------------------------------------------------------
#include <bpp/meta_model/structure.hpp> /*INTERFACE*/

namespace bpp {

// Namespaces //------------------------------------------------------------------------------------
#define public_area  metaModelStructure
#define private_area metaModelStructure_private
#define dll_export   DLL_EXPORT

namespace public_area  {}
namespace private_area {}

static_module_name("Meta_model/Structure");

// Initialization //--------------------------------------------------------------------------------
#undef iniMetaModelStructure
static_constant(private_area::clInitializer,goInitializer);

// Errors //----------------------------------------------------------------------------------------
namespace public_area {}

// Constants & Variables //-------------------------------------------------------------------------
static_constant(tcString,goCppExtension);
static_constant(tcString,goDllExtension);
static_constant(tcString,goDllPrefix);
static_constant(tcString,goHppExtension);
static_constant(tcString,goLibraryExtension);
static_constant(tcString,goObjectExtension);

// Static Members //--------------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// Functions Implementation //----------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// D e p e n d e n c y  Implementation //-----------------------------------------------------------
namespace public_area {
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clDependency */ /* Builds a default object. */
 property clDependency::clDependency(void)
 : atFileX(),atLibraryX(),atPathX() {}
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clDependency */ /* Builds an object from another one. */
 property clDependency::clDependency(ctDependency & agDependency)
 : atFileX(agDependency.atFileX),atLibraryX(agDependency.atLibraryX),
   atPathX(agDependency.atPathX) {}
 //---------------------------------------------------------------------------------------Operator =
 /*METHOD clDependency */ /* Copies an object. */
 property clDependency & clDependency::operator = (ctDependency & agDependency) {
  atFileX=agDependency.atFileX;
  atLibraryX=agDependency.atLibraryX;
  atPathX=agDependency.atPathX;
  return (*this);
 }
}

// E n t i t y I n f o r m a t i o n  Implementation //---------------------------------------------
namespace public_area {
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clEntityInformation */ /* Builds a default object. */
 property clEntityInformation::clEntityInformation(void)
 : atName(),atDeclaration(),atDescription(),atReference(0) {}
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clEntityInformation */ /* Builds an object from another one. */
 property clEntityInformation::clEntityInformation(ctEntityInformation & agInfo)
 : atName(agInfo.atName),atDeclaration(agInfo.atDeclaration),atDescription(agInfo.atDescription),
   atReference(agInfo.atReference) {}
 //---------------------------------------------------------------------------------------Operator =
 /*METHOD clEntityInformation */ /* Copies an object. */
 property clEntityInformation & clEntityInformation::operator = (ctEntityInformation & agInfo) {
  atName=agInfo.name();
  atDeclaration=agInfo.declaration();
  atDescription=agInfo.description();
  atReference=agInfo.reference();

  return (*this);
 }
}

// F i l e D e p e n d e n c y  Implementation //---------------------------------------------------
namespace public_area {
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clFileDependency */ /* Builds a default object. */
 property clFileDependency::clFileDependency(void)
 : atAlias(),atSourceName(),atObjectName(),atFileS(),atComplete(false),atIsJava(false) {}
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clFileDependency */ /* Builds an object from another one. */
 property clFileDependency::clFileDependency(ctFileDependency & agDependency)
 : atAlias(agDependency.atAlias),atSourceName(agDependency.atSourceName),
   atObjectName(agDependency.atObjectName),atFileS(agDependency.atFileS),atComplete(false),
   atIsJava(agDependency.atIsJava) {}
 //---------------------------------------------------------------------------------------Operator =
 /*METHOD clFileDependency */ /* Copies an object. */
 property clFileDependency & clFileDependency::operator = (ctFileDependency & agDependency) {
  atAlias=agDependency.atAlias;
  atSourceName=agDependency.atSourceName;
  atObjectName=agDependency.atObjectName;
  atFileS=agDependency.atFileS;
  atComplete=agDependency.atComplete;
  atIsJava=agDependency.atIsJava;
  return (*this);
 }
}

// L i b r a r y D e p e n d e n c y  Implementation //---------------------------------------------
namespace public_area {
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clLibraryDependency */ /* Builds a default object. */
 property clLibraryDependency::clLibraryDependency(void)
 : atName(),atDllName(),atAlias(),atDllAlias(),atFileS() {}
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clLibraryDependency */ /* Builds an objet from another one. */
 property clLibraryDependency::clLibraryDependency(ctLibraryDependency & agDependency)
 : atName(agDependency.atName),atDllName(agDependency.atDllName),atAlias(agDependency.atAlias),
   atDllAlias(agDependency.atDllAlias),atFileS(agDependency.atFileS) {}
 //---------------------------------------------------------------------------------------Operator =
 /*METHOD clLibraryDependency */ /* Copies an object. */
 property clLibraryDependency &
 clLibraryDependency::operator = (ctLibraryDependency & agDependency) {
  atName=agDependency.atName;
  atDllName=agDependency.atDllName;
  atAlias=agDependency.atAlias;
  atDllAlias=agDependency.atDllAlias;
  atFileS=agDependency.atFileS;
  return (*this);
 }
}

// M o d u l e I n f o r m a t i o n  Implementation //---------------------------------------------
namespace public_area {
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clModuleInformation */ /* Builds a default object. */
 property clModuleInformation::clModuleInformation(void)
 : atName(),atPath(),atShortName(),atIsJava(false),atNameSpace(),atParent(),atDescription(),
   atLevel(0),atCodeTargetFile(),atCppSourceFile(),atHomeTargetFile(),atHppSourceFile(),
   atIndexTargetFile(),atMenuTargetFile(),atChildS(),atIncludeS(),atNeeds(),atNamespaceS(),
   atAliaseS(),atMacrocommandS(),atTypeS(),atErrorS(),atConstantS(),atVariableS(),atFunctionS(),
   atClasseS(),atAttributeS(),atMethodS(),atClassTypeS() {}
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clModuleInformation */ /* Builds an object from another one. */
 property clModuleInformation::clModuleInformation(ctModuleInformation & agInfo)
 : atName(agInfo.atName),atPath(agInfo.atPath),atShortName(agInfo.atShortName),
   atIsJava(agInfo.atIsJava),atNameSpace(agInfo.atNameSpace),atParent(agInfo.atParent),
   atDescription(agInfo.atDescription),atLevel(agInfo.atLevel),
   atCodeTargetFile(agInfo.atCodeTargetFile),atCppSourceFile(agInfo.atCppSourceFile),
   atHomeTargetFile(agInfo.atHomeTargetFile),atHppSourceFile(agInfo.atHppSourceFile),
   atIndexTargetFile(agInfo.atIndexTargetFile),atMenuTargetFile(agInfo.atMenuTargetFile),
   atChildS(agInfo.atChildS),atIncludeS(agInfo.atIncludeS),atNeeds(agInfo.atNeeds),
   atNamespaceS(agInfo.atNamespaceS),atAliaseS(agInfo.atAliaseS),
   atMacrocommandS(agInfo.atMacrocommandS),atTypeS(agInfo.atTypeS),
   atErrorS(agInfo.atErrorS),atConstantS(agInfo.atConstantS),atVariableS(agInfo.atVariableS),
   atFunctionS(agInfo.atFunctionS),atClasseS(agInfo.atClasseS),
   atAttributeS(agInfo.atAttributeS),atMethodS(agInfo.atMethodS),atClassTypeS(agInfo.atClassTypeS)
 {}
 //---------------------------------------------------------------------------------------Operator =
 /*METHOD clModuleInformation */ /* Copies an object. */
 property clModuleInformation & clModuleInformation::operator = (ctModuleInformation & agInfo) {
  atName=agInfo.atName;
  atPath=agInfo.atPath;
  atShortName=agInfo.atShortName;
  atIsJava=agInfo.atIsJava;
  atNameSpace=agInfo.atNameSpace;
  atParent=agInfo.atParent;
  atDescription=agInfo.atDescription;
  atLevel=agInfo.atLevel;

  atCodeTargetFile=agInfo.atCodeTargetFile;
  atCppSourceFile=agInfo.atCppSourceFile;
  atHomeTargetFile=agInfo.atHomeTargetFile;
  atHppSourceFile=agInfo.atHppSourceFile;
  atIndexTargetFile=agInfo.atIndexTargetFile;
  atMenuTargetFile=agInfo.atMenuTargetFile;

  atChildS=agInfo.atChildS;
  atIncludeS=agInfo.atIncludeS;
  atNeeds=agInfo.atNeeds;
  atNamespaceS=agInfo.atNamespaceS;
  atAliaseS=agInfo.atAliaseS;
  atMacrocommandS=agInfo.atMacrocommandS;
  atTypeS=agInfo.atTypeS;
  atErrorS=agInfo.atErrorS;
  atConstantS=agInfo.atConstantS;
  atVariableS=agInfo.atVariableS;
  atFunctionS=agInfo.atFunctionS;
  atClasseS=agInfo.atClasseS;
  atAttributeS=agInfo.atAttributeS;
  atMethodS=agInfo.atMethodS;
  atClassTypeS=agInfo.atClassTypeS;

  return (*this);
 }
}

// I n i t i a l i z e r  Implementation //---------------------------------------------------------
namespace private_area {
 //--------------------------------------------------------------------------------------------Start
 property void clInitializer::start(void) {
  if (atCounter++ == 0) {
   try {
    #include <bpp/modules.hpp> /*NEED*/
    registerStop(this);
    environment::informInitialization(goModuleName);

    goCppExtension     = "cpp";
    goDllExtension     = "$(DLL)";
    goDllPrefix        = "$(PRE)";
    goHppExtension     = "hpp";
    goLibraryExtension = "$(LIB)";
    goObjectExtension  = "$(OBJ)";
   }

   initializer_catch;
  }
 }
 //---------------------------------------------------------------------------------------------Stop
 property void clInitializer::stop(void) { environment::informTermination(goModuleName); }
}

// End //-------------------------------------------------------------------------------------------
}