
/*
 * This file was generated by the SOM Compiler.
 * FileName: somcm.h.
 * Generated using:
 *     SOM Precompiler somipc: 2.29.1.19
 *     SOM Emitter emith.dll: 2.31.1.64
 */

/*
 *  96F8647, 96F8648, 96F8850 (C) Copyright IBM Corp. 1992, 1994
 *  All Rights Reserved
 *  Licensed Materials - Property of IBM
 *   SOMClassMgr: System Object Model class manager
 */


#ifndef SOM_SOMClassMgr_h
#define SOM_SOMClassMgr_h


/*
 * The SOM_STRICT_IDL macro means that we can ignore stars
 * in our declarations of objects.
 */
#define SOM_STRICT_IDL 1


#include <som.h>
#ifndef SOM_IMPORTEXPORT_som_somcm
#ifdef SOM_DLL_som
	/* export semantics */
	#if defined(SOM_DEFFILE_som)\
	||(defined(SOM_DEFFILE_BY_DEFAULT)&&!defined(SOM_NODEFFILE_som))\
	|| !defined(SOM_Module_somcm_Source)
	#define SOM_IMPORTEXPORT_som_somcm
	#else
	#define SOM_IMPORTEXPORT_som_somcm SOMDLLEXPORT
	#endif
#else
	#define SOM_IMPORTEXPORT_som_somcm SOMDLLIMPORT
#endif
#endif

/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * Define the class name as an object type
 */
#ifndef SOMClassMgr
#define SOMClassMgr SOMObject
#endif
/*
 *  [Basic Functions Group]
 */

/*
 * Include Parent Bindings
 */
#ifndef SOM_SOMObject_h
#ifdef SOMLOCALINCLUDES
#include "somobj.h"
#else
#include <somobj.h>
#endif
#endif

/*
 * Start of bindings for IDL types
 */

#ifndef SOMClass
    #define SOMClass SOMObject
#endif /* SOMClass */
#ifndef Repository
    #define Repository SOMObject
#endif /* Repository */
typedef
SOMClass* SOMClassMgr_SOMClassArray;
/*
 *  Used for SOM 1.0 binary compatibility
 */

#ifndef _IDL_SEQUENCE_SOMClass_defined
#define _IDL_SEQUENCE_SOMClass_defined
typedef struct {
    unsigned long _maximum;
    unsigned long _length;
    SOMClass *_buffer;
} _IDL_SEQUENCE_SOMClass;
#endif /* _IDL_SEQUENCE_SOMClass_defined */ 

#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_SOMClassArray
    #ifdef SOMClassArray
        #undef SOMClassArray
        #define SOMTGD_SOMClassArray 1
    #else
        #define SOMClassArray SOMClassMgr_SOMClassArray
    #endif /* SOMClassArray */
#endif /* SOMTGD_SOMClassArray */
#endif /* SOM_DONT_USE_SHORT_NAMES */

#ifndef SOM_DONT_USE_SHORT_NAMES
#endif /* SOM_DONT_USE_SHORT_NAMES */

/*
 * End of bindings for IDL types.
 */

#define SOMClassMgr_MajorVersion 1
#define SOMClassMgr_MinorVersion 6

/*
 * Declare the class creation procedure
 */
SOMEXTERN SOM_IMPORTEXPORT_som_somcm SOMClass  SOMLINK SOMClassMgrNewClass(integer4 somtmajorVersion,
		integer4 somtminorVersion);

/*
 * Declare the ABI 2 ClassData structure
 */
SOMEXTERN struct SOMClassMgrClassDataStructure {
	SOMClass classObject;
	somMToken somFindClsInFile;
	somMToken somFindClass;
	somMToken somClassFromId;
	somMToken somRegisterClass;
	somMToken somUnregisterClass;
	somMToken somLocateClassFile;
	somMToken somLoadClassFile;
	somMToken somUnloadClassFile;
	somMToken somGetInitFunction;
	somMToken somMergeInto;
	somMToken somGetRelatedClasses;
	somMToken somSubstituteClass;
	somMToken _get_somInterfaceRepository;
	somMToken _set_somInterfaceRepository;
	somMToken _get_somRegisteredClasses;
	somMToken somBeginPersistentClasses;
	somMToken somEndPersistentClasses;
	somMToken somcmPrivate1;
	somMToken somcmPrivate2;
	somMToken somRegisterClassLibrary;
	somMToken somJoinAffinityGroup;
	somMToken somUnregisterClassLibrary;
	somMToken somImportObject;
	somMToken somcmPrivate3;
	somMToken somcmPrivate4;
} SOM_IMPORTEXPORT_som_somcm SOMDLINK SOMClassMgrClassData;

/*
 * Declare the ABI 2 CClassData structure
 */
SOMEXTERN struct SOMClassMgrCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken instanceDataToken;
} SOM_IMPORTEXPORT_som_somcm SOMDLINK SOMClassMgrCClassData;

/*
 * Class Object and Method Token Macros
 */
#define _SOMCLASS_SOMClassMgr (SOMClassMgrClassData.classObject)
#ifndef SOMGD_SOMClassMgr
    #if (defined(_SOMClassMgr) || defined(__SOMClassMgr))
        #undef _SOMClassMgr
        #undef __SOMClassMgr
        #define SOMGD_SOMClassMgr 1
    #else
        #define _SOMClassMgr _SOMCLASS_SOMClassMgr
    #endif /* _SOMClassMgr */
#endif /* SOMGD_SOMClassMgr */
#define SOMClassMgr_classObj _SOMCLASS_SOMClassMgr
#define _SOMMTOKEN_SOMClassMgr(method) ((somMToken)SOMClassMgrClassData.method)

/*
 * New and Renew macros for SOMClassMgr
 */
#define SOMClassMgrNew() \
   ( _SOMClassMgr ? \
	_somNew(_SOMClassMgr) \
	: ( SOMClassMgrNewClass(\
		SOMClassMgr_MajorVersion, \
		SOMClassMgr_MinorVersion),\
	   _somNew(_SOMClassMgr)))
#define SOMClassMgrRenew(buf) \
   ( _SOMClassMgr ? \
	_somRenew(_SOMClassMgr, buf) \
	: ( SOMClassMgrNewClass(\
		SOMClassMgr_MajorVersion, \
		SOMClassMgr_MinorVersion),\
	   _somRenew(_SOMClassMgr, buf)))

/*
 * New Method: somLoadClassFile
 */
typedef SOMClass   SOMLINK somTP_SOMClassMgr_somLoadClassFile(SOMClassMgr somSelf, 
		somId classId, 
		long majorVersion, 
		long minorVersion, 
		string file);
typedef somTP_SOMClassMgr_somLoadClassFile *somTD_SOMClassMgr_somLoadClassFile;
/*
 *  Loads the class' code and initializes the class object.
 */
#define somMD_SOMClassMgr_somLoadClassFile "::SOMClassMgr::somLoadClassFile"
#define SOMClassMgr_somLoadClassFile(somSelf,classId,majorVersion,minorVersion,file) \
    (SOM_Resolve(somSelf, SOMClassMgr, somLoadClassFile) \
	(somSelf,classId,majorVersion,minorVersion,file))
#ifndef SOMGD_somLoadClassFile
    #if (defined(_somLoadClassFile) || defined(__somLoadClassFile))
        #undef _somLoadClassFile
        #undef __somLoadClassFile
        #define SOMGD_somLoadClassFile 1
    #else
        #define _somLoadClassFile SOMClassMgr_somLoadClassFile
    #endif /* _somLoadClassFile */
#endif /* SOMGD_somLoadClassFile */

/*
 * New Method: somLocateClassFile
 */
typedef string   SOMLINK somTP_SOMClassMgr_somLocateClassFile(SOMClassMgr somSelf, 
		somId classId, 
		long majorVersion, 
		long minorVersion);
typedef somTP_SOMClassMgr_somLocateClassFile *somTD_SOMClassMgr_somLocateClassFile;
/*
 *  Real implementation supplied by subclasses.  Default implementation
 *  will lookup the class name in the Interface Repository (if one is
 *  available) to determine the implementation file name (ie, DLL name).
 *  If this information is not available, the class name itself is
 *  returned as the file name.   Subclasses may use version number
 *  info to assist in deriving the file name.
 */
#define somMD_SOMClassMgr_somLocateClassFile "::SOMClassMgr::somLocateClassFile"
#define SOMClassMgr_somLocateClassFile(somSelf,classId,majorVersion,minorVersion) \
    (SOM_Resolve(somSelf, SOMClassMgr, somLocateClassFile) \
	(somSelf,classId,majorVersion,minorVersion))
#ifndef SOMGD_somLocateClassFile
    #if (defined(_somLocateClassFile) || defined(__somLocateClassFile))
        #undef _somLocateClassFile
        #undef __somLocateClassFile
        #define SOMGD_somLocateClassFile 1
    #else
        #define _somLocateClassFile SOMClassMgr_somLocateClassFile
    #endif /* _somLocateClassFile */
#endif /* SOMGD_somLocateClassFile */

/*
 * New Method: somRegisterClass
 */
typedef void   SOMLINK somTP_SOMClassMgr_somRegisterClass(SOMClassMgr somSelf, 
		SOMClass classObj);
typedef somTP_SOMClassMgr_somRegisterClass *somTD_SOMClassMgr_somRegisterClass;
/*
 *  Lets the class manager know that the specified class is installed
 *  and tells it where the class object is.
 */
#define somMD_SOMClassMgr_somRegisterClass "::SOMClassMgr::somRegisterClass"
#define SOMClassMgr_somRegisterClass(somSelf,classObj) \
    (SOM_Resolve(somSelf, SOMClassMgr, somRegisterClass) \
	(somSelf,classObj))
#ifndef SOMGD_somRegisterClass
    #if (defined(_somRegisterClass) || defined(__somRegisterClass))
        #undef _somRegisterClass
        #undef __somRegisterClass
        #define SOMGD_somRegisterClass 1
    #else
        #define _somRegisterClass SOMClassMgr_somRegisterClass
    #endif /* _somRegisterClass */
#endif /* SOMGD_somRegisterClass */

/*
 * New Method: somRegisterClassLibrary
 */
typedef void   SOMLINK somTP_SOMClassMgr_somRegisterClassLibrary(SOMClassMgr somSelf, 
		string libraryName, 
		somMethodPtr libraryInitRtn);
typedef somTP_SOMClassMgr_somRegisterClassLibrary *somTD_SOMClassMgr_somRegisterClassLibrary;
/*
 *  Informs the class manager that a class library has been loaded.
 *  "libraryName" is the name associated with the file containing the
 *  implementation(s) of the class(es) in the class library.
 *  "libraryInitRtn" is the entry point of a SOMInitModule function
 *  that can be used to initialize the class library.  For platforms
 *  that have the capability to automatically invoke a library
 *  initialization function whenever a library is loaded, a call
 *  to this method should occur within the library's automatic init
 *  function.
 */
#define somMD_SOMClassMgr_somRegisterClassLibrary "::SOMClassMgr::somRegisterClassLibrary"
#define SOMClassMgr_somRegisterClassLibrary(somSelf,libraryName,libraryInitRtn) \
    (SOM_Resolve(somSelf, SOMClassMgr, somRegisterClassLibrary) \
	(somSelf,libraryName,libraryInitRtn))
#ifndef SOMGD_somRegisterClassLibrary
    #if (defined(_somRegisterClassLibrary) || defined(__somRegisterClassLibrary))
        #undef _somRegisterClassLibrary
        #undef __somRegisterClassLibrary
        #define SOMGD_somRegisterClassLibrary 1
    #else
        #define _somRegisterClassLibrary SOMClassMgr_somRegisterClassLibrary
    #endif /* _somRegisterClassLibrary */
#endif /* SOMGD_somRegisterClassLibrary */

/*
 * New Method: somUnregisterClassLibrary
 */
typedef void   SOMLINK somTP_SOMClassMgr_somUnregisterClassLibrary(SOMClassMgr somSelf, 
		string libraryName);
typedef somTP_SOMClassMgr_somUnregisterClassLibrary *somTD_SOMClassMgr_somUnregisterClassLibrary;
/*
 *  Informs the class manager that a class library has been unloaded.
 *  "libraryName" is the name associated with the file containing the
 *  implementation(s) of the class(es) in the class library.
 *  For platforms that have the capability to automatically invoke a
 *  library termination function whenever a library is unloaded, a call
 *  to this method should occur within the library's automatic
 *  termination function.
 */
#define somMD_SOMClassMgr_somUnregisterClassLibrary "::SOMClassMgr::somUnregisterClassLibrary"
#define SOMClassMgr_somUnregisterClassLibrary(somSelf,libraryName) \
    (SOM_Resolve(somSelf, SOMClassMgr, somUnregisterClassLibrary) \
	(somSelf,libraryName))
#ifndef SOMGD_somUnregisterClassLibrary
    #if (defined(_somUnregisterClassLibrary) || defined(__somUnregisterClassLibrary))
        #undef _somUnregisterClassLibrary
        #undef __somUnregisterClassLibrary
        #define SOMGD_somUnregisterClassLibrary 1
    #else
        #define _somUnregisterClassLibrary SOMClassMgr_somUnregisterClassLibrary
    #endif /* _somUnregisterClassLibrary */
#endif /* SOMGD_somUnregisterClassLibrary */

/*
 * New Method: somUnloadClassFile
 */
typedef long   SOMLINK somTP_SOMClassMgr_somUnloadClassFile(SOMClassMgr somSelf, 
		SOMClass classObj);
typedef somTP_SOMClassMgr_somUnloadClassFile *somTD_SOMClassMgr_somUnloadClassFile;
/*
 *  Releases the class' code and unregisters all classes in the
 *  same affinity group (see somGetRelatedClasses below).
 */
#define somMD_SOMClassMgr_somUnloadClassFile "::SOMClassMgr::somUnloadClassFile"
#define SOMClassMgr_somUnloadClassFile(somSelf,classObj) \
    (SOM_Resolve(somSelf, SOMClassMgr, somUnloadClassFile) \
	(somSelf,classObj))
#ifndef SOMGD_somUnloadClassFile
    #if (defined(_somUnloadClassFile) || defined(__somUnloadClassFile))
        #undef _somUnloadClassFile
        #undef __somUnloadClassFile
        #define SOMGD_somUnloadClassFile 1
    #else
        #define _somUnloadClassFile SOMClassMgr_somUnloadClassFile
    #endif /* _somUnloadClassFile */
#endif /* SOMGD_somUnloadClassFile */

/*
 * New Method: somUnregisterClass
 */
typedef long   SOMLINK somTP_SOMClassMgr_somUnregisterClass(SOMClassMgr somSelf, 
		SOMClass classObj);
typedef somTP_SOMClassMgr_somUnregisterClass *somTD_SOMClassMgr_somUnregisterClass;
/*
 *  Free the class object and removes the class from the SOM registry.
 *  If the class caused dynamic loading to occur, it is also unloaded
 *  (causing its entire affinity group to be unregistered as well).
 */
#define somMD_SOMClassMgr_somUnregisterClass "::SOMClassMgr::somUnregisterClass"
#define SOMClassMgr_somUnregisterClass(somSelf,classObj) \
    (SOM_Resolve(somSelf, SOMClassMgr, somUnregisterClass) \
	(somSelf,classObj))
#ifndef SOMGD_somUnregisterClass
    #if (defined(_somUnregisterClass) || defined(__somUnregisterClass))
        #undef _somUnregisterClass
        #undef __somUnregisterClass
        #define SOMGD_somUnregisterClass 1
    #else
        #define _somUnregisterClass SOMClassMgr_somUnregisterClass
    #endif /* _somUnregisterClass */
#endif /* SOMGD_somUnregisterClass */

/*
 * New Method: somBeginPersistentClasses
 */
typedef void   SOMLINK somTP_SOMClassMgr_somBeginPersistentClasses(SOMClassMgr somSelf);
typedef somTP_SOMClassMgr_somBeginPersistentClasses *somTD_SOMClassMgr_somBeginPersistentClasses;
/*
 *  Starts a bracket for the current thread wherein all classes
 *  that are registered are marked as permanant and cannot be
 *  unregistered or unloaded.  Persistent classes brackets may be
 *  nested.
 */
#define somMD_SOMClassMgr_somBeginPersistentClasses "::SOMClassMgr::somBeginPersistentClasses"
#define SOMClassMgr_somBeginPersistentClasses(somSelf) \
    (SOM_Resolve(somSelf, SOMClassMgr, somBeginPersistentClasses) \
	(somSelf))
#ifndef SOMGD_somBeginPersistentClasses
    #if (defined(_somBeginPersistentClasses) || defined(__somBeginPersistentClasses))
        #undef _somBeginPersistentClasses
        #undef __somBeginPersistentClasses
        #define SOMGD_somBeginPersistentClasses 1
    #else
        #define _somBeginPersistentClasses SOMClassMgr_somBeginPersistentClasses
    #endif /* _somBeginPersistentClasses */
#endif /* SOMGD_somBeginPersistentClasses */

/*
 * New Method: somEndPersistentClasses
 */
typedef void   SOMLINK somTP_SOMClassMgr_somEndPersistentClasses(SOMClassMgr somSelf);
typedef somTP_SOMClassMgr_somEndPersistentClasses *somTD_SOMClassMgr_somEndPersistentClasses;
/*
 *  Ends a persistent classes bracket for the current thread.
 */
#define somMD_SOMClassMgr_somEndPersistentClasses "::SOMClassMgr::somEndPersistentClasses"
#define SOMClassMgr_somEndPersistentClasses(somSelf) \
    (SOM_Resolve(somSelf, SOMClassMgr, somEndPersistentClasses) \
	(somSelf))
#ifndef SOMGD_somEndPersistentClasses
    #if (defined(_somEndPersistentClasses) || defined(__somEndPersistentClasses))
        #undef _somEndPersistentClasses
        #undef __somEndPersistentClasses
        #define SOMGD_somEndPersistentClasses 1
    #else
        #define _somEndPersistentClasses SOMClassMgr_somEndPersistentClasses
    #endif /* _somEndPersistentClasses */
#endif /* SOMGD_somEndPersistentClasses */

/*
 * New Method: somJoinAffinityGroup
 */
typedef boolean   SOMLINK somTP_SOMClassMgr_somJoinAffinityGroup(SOMClassMgr somSelf, 
		SOMClass newClass, 
		SOMClass affClass);
typedef somTP_SOMClassMgr_somJoinAffinityGroup *somTD_SOMClassMgr_somJoinAffinityGroup;
/*
 *  If <affClass> is a member of an affinity group, and <newClass> is not a
 *  member of any affinity group, this method adds <newClass> to the
 *  same affinity group as <affClass>.  If the method succeeds it returns
 *  TRUE, otherwise it returns FALSE.  Adding a class to an affinity group
 *  effectively equates its lifetime with that of the other members of
 *  the affinity group.
 *  [Access Group]
 */
#define somMD_SOMClassMgr_somJoinAffinityGroup "::SOMClassMgr::somJoinAffinityGroup"
#define SOMClassMgr_somJoinAffinityGroup(somSelf,newClass,affClass) \
    (SOM_Resolve(somSelf, SOMClassMgr, somJoinAffinityGroup) \
	(somSelf,newClass,affClass))
#ifndef SOMGD_somJoinAffinityGroup
    #if (defined(_somJoinAffinityGroup) || defined(__somJoinAffinityGroup))
        #undef _somJoinAffinityGroup
        #undef __somJoinAffinityGroup
        #define SOMGD_somJoinAffinityGroup 1
    #else
        #define _somJoinAffinityGroup SOMClassMgr_somJoinAffinityGroup
    #endif /* _somJoinAffinityGroup */
#endif /* SOMGD_somJoinAffinityGroup */

/*
 * New Method: somGetInitFunction
 */
typedef string   SOMLINK somTP_SOMClassMgr_somGetInitFunction(SOMClassMgr somSelf);
typedef somTP_SOMClassMgr_somGetInitFunction *somTD_SOMClassMgr_somGetInitFunction;
/*
 *  The name of the initialization function in the class' code file.
 *  Default implementation returns (*SOMClassInitFuncName)().
 */
#define somMD_SOMClassMgr_somGetInitFunction "::SOMClassMgr::somGetInitFunction"
#define SOMClassMgr_somGetInitFunction(somSelf) \
    (SOM_Resolve(somSelf, SOMClassMgr, somGetInitFunction) \
	(somSelf))
#ifndef SOMGD_somGetInitFunction
    #if (defined(_somGetInitFunction) || defined(__somGetInitFunction))
        #undef _somGetInitFunction
        #undef __somGetInitFunction
        #define SOMGD_somGetInitFunction 1
    #else
        #define _somGetInitFunction SOMClassMgr_somGetInitFunction
    #endif /* _somGetInitFunction */
#endif /* SOMGD_somGetInitFunction */

/*
 * New Method: _get_somInterfaceRepository
 */
typedef Repository   SOMLINK somTP_SOMClassMgr__get_somInterfaceRepository(SOMClassMgr somSelf);
typedef somTP_SOMClassMgr__get_somInterfaceRepository *somTD_SOMClassMgr__get_somInterfaceRepository;
/*
 *  The Repository object that provides access to the Interface Repository,
 *  If no Interface Repository has yet been assigned to this attribute,
 *  and the SOMClassMgr is unable to load and instantiate it, the attribute
 *  will have the value NULL.  When finished using the Repository object
 *  you should release your reference using the somDestruct method with
 *  a non-zero <doFree> parameter.
 */
#define somMD_SOMClassMgr__get_somInterfaceRepository "::SOMClassMgr::_get_somInterfaceRepository"
#define SOMClassMgr__get_somInterfaceRepository(somSelf) \
    (SOM_Resolve(somSelf, SOMClassMgr, _get_somInterfaceRepository) \
	(somSelf))
#ifndef SOMGD_get_somInterfaceRepository
    #if (defined(_get_somInterfaceRepository) || defined(__get_somInterfaceRepository))
        #undef _get_somInterfaceRepository
        #undef __get_somInterfaceRepository
        #define SOMGD_get_somInterfaceRepository 1
    #else
        #define __get_somInterfaceRepository SOMClassMgr__get_somInterfaceRepository
    #endif /* __get_somInterfaceRepository */
#endif /* SOMGD_get_somInterfaceRepository */

/*
 * New Method: _set_somInterfaceRepository
 */
typedef void   SOMLINK somTP_SOMClassMgr__set_somInterfaceRepository(SOMClassMgr somSelf, 
		Repository somInterfaceRepository);
typedef somTP_SOMClassMgr__set_somInterfaceRepository *somTD_SOMClassMgr__set_somInterfaceRepository;
/*
 *  The Repository object that provides access to the Interface Repository,
 *  If no Interface Repository has yet been assigned to this attribute,
 *  and the SOMClassMgr is unable to load and instantiate it, the attribute
 *  will have the value NULL.  When finished using the Repository object
 *  you should release your reference using the somDestruct method with
 *  a non-zero <doFree> parameter.
 */
#define somMD_SOMClassMgr__set_somInterfaceRepository "::SOMClassMgr::_set_somInterfaceRepository"
#define SOMClassMgr__set_somInterfaceRepository(somSelf,somInterfaceRepository) \
    (SOM_Resolve(somSelf, SOMClassMgr, _set_somInterfaceRepository) \
	(somSelf,somInterfaceRepository))
#ifndef SOMGD_set_somInterfaceRepository
    #if (defined(_set_somInterfaceRepository) || defined(__set_somInterfaceRepository))
        #undef _set_somInterfaceRepository
        #undef __set_somInterfaceRepository
        #define SOMGD_set_somInterfaceRepository 1
    #else
        #define __set_somInterfaceRepository SOMClassMgr__set_somInterfaceRepository
    #endif /* __set_somInterfaceRepository */
#endif /* SOMGD_set_somInterfaceRepository */

/*
 * New Method: _get_somRegisteredClasses
 */
typedef _IDL_SEQUENCE_SOMClass   SOMLINK somTP_SOMClassMgr__get_somRegisteredClasses(SOMClassMgr somSelf);
typedef somTP_SOMClassMgr__get_somRegisteredClasses *somTD_SOMClassMgr__get_somRegisteredClasses;
/*
 *  A list of all classes currently registered in this process.
 */
#define somMD_SOMClassMgr__get_somRegisteredClasses "::SOMClassMgr::_get_somRegisteredClasses"
#define SOMClassMgr__get_somRegisteredClasses(somSelf) \
    (SOM_Resolve(somSelf, SOMClassMgr, _get_somRegisteredClasses) \
	(somSelf))
#ifndef SOMGD_get_somRegisteredClasses
    #if (defined(_get_somRegisteredClasses) || defined(__get_somRegisteredClasses))
        #undef _get_somRegisteredClasses
        #undef __get_somRegisteredClasses
        #define SOMGD_get_somRegisteredClasses 1
    #else
        #define __get_somRegisteredClasses SOMClassMgr__get_somRegisteredClasses
    #endif /* __get_somRegisteredClasses */
#endif /* SOMGD_get_somRegisteredClasses */

/*
 * New Method: somGetRelatedClasses
 */
typedef SOMClassMgr_SOMClassArray   SOMLINK somTP_SOMClassMgr_somGetRelatedClasses(SOMClassMgr somSelf, 
		SOMClass classObj);
typedef somTP_SOMClassMgr_somGetRelatedClasses *somTD_SOMClassMgr_somGetRelatedClasses;
/*
 *  Returns an array of class objects that were all registered during
 *  the dynamic loading of a class.    These classes are considered to
 *  define an affinity group.  Any class is a member of at most one
 *  affinity group.    The affinity group returned by this call is the
 *  one containing the class identified by classObj.  The first element
 *  in the array is the class that caused the group to be loaded, or the
 *  special value -1 which means that the SOMClassMgr is currently in the
 *  process of unregistering and deleting the affinity group (only
 *  SOMClassMgr subclasses would ever see this value).
 *  The remainder of the array (elements one thru n) consists of
 *  pointers to class objects ordered in reverse chronological sequence
 *  to that in which they were originally registered.  This list includes
 *  the given argument, classObj, as one of its elements, as well as the
 *  class, if any, returned as element[0] above.  The array is terminated
 *  by a NULL pointer as the last element.  Use SOMFree to release the
 *  array when it is no longer needed.  If the supplied class was not
 *  dynamically loaded, it is not a member of any affinity
 *  group and NULL is returned.
 *  [Dynamic Group]
 */
#define somMD_SOMClassMgr_somGetRelatedClasses "::SOMClassMgr::somGetRelatedClasses"
#define SOMClassMgr_somGetRelatedClasses(somSelf,classObj) \
    (SOM_Resolve(somSelf, SOMClassMgr, somGetRelatedClasses) \
	(somSelf,classObj))
#ifndef SOMGD_somGetRelatedClasses
    #if (defined(_somGetRelatedClasses) || defined(__somGetRelatedClasses))
        #undef _somGetRelatedClasses
        #undef __somGetRelatedClasses
        #define SOMGD_somGetRelatedClasses 1
    #else
        #define _somGetRelatedClasses SOMClassMgr_somGetRelatedClasses
    #endif /* _somGetRelatedClasses */
#endif /* SOMGD_somGetRelatedClasses */

/*
 * New Method: somClassFromId
 */
typedef SOMClass   SOMLINK somTP_SOMClassMgr_somClassFromId(SOMClassMgr somSelf, 
		somId classId);
typedef somTP_SOMClassMgr_somClassFromId *somTD_SOMClassMgr_somClassFromId;
/*
 *  Finds the class object, given its Id, if it already exists.
 *  Does not load the class.  Returns NULL if the class object does
 *  not yet exist.
 */
#define somMD_SOMClassMgr_somClassFromId "::SOMClassMgr::somClassFromId"
#define SOMClassMgr_somClassFromId(somSelf,classId) \
    (SOM_Resolve(somSelf, SOMClassMgr, somClassFromId) \
	(somSelf,classId))
#ifndef SOMGD_somClassFromId
    #if (defined(_somClassFromId) || defined(__somClassFromId))
        #undef _somClassFromId
        #undef __somClassFromId
        #define SOMGD_somClassFromId 1
    #else
        #define _somClassFromId SOMClassMgr_somClassFromId
    #endif /* _somClassFromId */
#endif /* SOMGD_somClassFromId */

/*
 * New Method: somFindClass
 */
typedef SOMClass   SOMLINK somTP_SOMClassMgr_somFindClass(SOMClassMgr somSelf, 
		somId classId, 
		long majorVersion, 
		long minorVersion);
typedef somTP_SOMClassMgr_somFindClass *somTD_SOMClassMgr_somFindClass;
/*
 *  Returns the class object for the specified class.  This may result
 *  in dynamic loading.  Uses somLocateClassFile to obtain the name of
 *  the file where the class' code resides, then uses somFindClsInFile.
 */
#define somMD_SOMClassMgr_somFindClass "::SOMClassMgr::somFindClass"
#define SOMClassMgr_somFindClass(somSelf,classId,majorVersion,minorVersion) \
    (SOM_Resolve(somSelf, SOMClassMgr, somFindClass) \
	(somSelf,classId,majorVersion,minorVersion))
#ifndef SOMGD_somFindClass
    #if (defined(_somFindClass) || defined(__somFindClass))
        #undef _somFindClass
        #undef __somFindClass
        #define SOMGD_somFindClass 1
    #else
        #define _somFindClass SOMClassMgr_somFindClass
    #endif /* _somFindClass */
#endif /* SOMGD_somFindClass */

/*
 * New Method: somFindClsInFile
 */
typedef SOMClass   SOMLINK somTP_SOMClassMgr_somFindClsInFile(SOMClassMgr somSelf, 
		somId classId, 
		long majorVersion, 
		long minorVersion, 
		string file);
typedef somTP_SOMClassMgr_somFindClsInFile *somTD_SOMClassMgr_somFindClsInFile;
/*
 *  Returns the class object for the specified class.  This may result
 *  in dynamic loading.  If the class already exists <file> is ignored,
 *  otherwise it is used to locate and dynamically load the class.
 *  Values of 0 for major and minor version numbers bypass version checking.
 */
#define somMD_SOMClassMgr_somFindClsInFile "::SOMClassMgr::somFindClsInFile"
#define SOMClassMgr_somFindClsInFile(somSelf,classId,majorVersion,minorVersion,file) \
    (SOM_Resolve(somSelf, SOMClassMgr, somFindClsInFile) \
	(somSelf,classId,majorVersion,minorVersion,file))
#ifndef SOMGD_somFindClsInFile
    #if (defined(_somFindClsInFile) || defined(__somFindClsInFile))
        #undef _somFindClsInFile
        #undef __somFindClsInFile
        #define SOMGD_somFindClsInFile 1
    #else
        #define _somFindClsInFile SOMClassMgr_somFindClsInFile
    #endif /* _somFindClsInFile */
#endif /* SOMGD_somFindClsInFile */

/*
 * New Method: somMergeInto
 */
typedef void   SOMLINK somTP_SOMClassMgr_somMergeInto(SOMClassMgr somSelf, 
		SOMObject targetObj);
typedef somTP_SOMClassMgr_somMergeInto *somTD_SOMClassMgr_somMergeInto;
/*
 *  Merges the SOMClassMgr registry information from the receiver to
 *  <targetObj>.  <targetObj> is required to be an instance of SOMClassMgr
 *  or one of its subclasses.  At the completion of this operation,
 *  the <targetObj> should be able to function as a replacement for the
 *  receiver.  At the end of the operation the receiver object (which is
 *  then in a newly uninitialized state) is freed.  Subclasses that
 *  override this method should similarly transfer their sections of
 *  the object and pass this method to their parent as the final step.
 *  If the receiving object is the distinguished instance pointed to
 *  from the global variable SOMClassMgrObject, SOMCLassMgrObject is
 *  then reassigned to point to <targetObj>.
 */
#define somMD_SOMClassMgr_somMergeInto "::SOMClassMgr::somMergeInto"
#define SOMClassMgr_somMergeInto(somSelf,targetObj) \
    (SOM_Resolve(somSelf, SOMClassMgr, somMergeInto) \
	(somSelf,targetObj))
#ifndef SOMGD_somMergeInto
    #if (defined(_somMergeInto) || defined(__somMergeInto))
        #undef _somMergeInto
        #undef __somMergeInto
        #define SOMGD_somMergeInto 1
    #else
        #define _somMergeInto SOMClassMgr_somMergeInto
    #endif /* _somMergeInto */
#endif /* SOMGD_somMergeInto */

/*
 * New Method: somSubstituteClass
 */
typedef long   SOMLINK somTP_SOMClassMgr_somSubstituteClass(SOMClassMgr somSelf, 
		string origClassName, 
		string newClassName);
typedef somTP_SOMClassMgr_somSubstituteClass *somTD_SOMClassMgr_somSubstituteClass;
/*
 *  This method causes the somFindClass, somFindClsInFile, and
 *  somClassFromId methods to return the class named newClassName
 *  whenever they would have normally returned the class named
 *  origClassName.  This effectively results in class <newClassName>
 *  replacing or substituting itself for class <origClassName>.
 *  Some restrictions are enforced to insure that this works well.
 *  Both class <origClassName> and class <newClassName> must
 *  have been already registered before issuing this method, and newClass
 *  must be an immediate child of origClass.  In addition (although not
 *  enforceable), no instances should exist of either class at the time
 *  this method is invoked.    A return value of zero indicates success;
 *  a non-zero value indicates an error was detected.
 */
#define somMD_SOMClassMgr_somSubstituteClass "::SOMClassMgr::somSubstituteClass"
#define SOMClassMgr_somSubstituteClass(somSelf,origClassName,newClassName) \
    (SOM_Resolve(somSelf, SOMClassMgr, somSubstituteClass) \
	(somSelf,origClassName,newClassName))
#ifndef SOMGD_somSubstituteClass
    #if (defined(_somSubstituteClass) || defined(__somSubstituteClass))
        #undef _somSubstituteClass
        #undef __somSubstituteClass
        #define SOMGD_somSubstituteClass 1
    #else
        #define _somSubstituteClass SOMClassMgr_somSubstituteClass
    #endif /* _somSubstituteClass */
#endif /* SOMGD_somSubstituteClass */

/*
 * New Method: somImportObject
 */
typedef boolean   SOMLINK somTP_SOMClassMgr_somImportObject(SOMClassMgr somSelf, 
		SOMObject objToBeShared);
typedef somTP_SOMClassMgr_somImportObject *somTD_SOMClassMgr_somImportObject;
/*
 *  This method causes the local class manager to load the
 *  dlls that are required for sharing the object <objToBeShared>.
 *  The returned boolean indicates whether or not the operation succeeded.
 *  A return of FALSE (the operation failed) means that it is not safe
 *  to use the object, i.e., invoking a method on the object may lead to
 *  an exception.
 */
#define somMD_SOMClassMgr_somImportObject "::SOMClassMgr::somImportObject"
#define SOMClassMgr_somImportObject(somSelf,objToBeShared) \
    (SOM_Resolve(somSelf, SOMClassMgr, somImportObject) \
	(somSelf,objToBeShared))
#ifndef SOMGD_somImportObject
    #if (defined(_somImportObject) || defined(__somImportObject))
        #undef _somImportObject
        #undef __somImportObject
        #define SOMGD_somImportObject 1
    #else
        #define _somImportObject SOMClassMgr_somImportObject
    #endif /* _somImportObject */
#endif /* SOMGD_somImportObject */

/*
 * Full Names for Inherited Methods
 */
/* overridden methods */
#define SOMClassMgr_somDefaultInit SOMObject_somDefaultInit
#define SOMClassMgr_somDestruct SOMObject_somDestruct
#define SOMClassMgr_somDumpSelfInt SOMObject_somDumpSelfInt

#ifndef SOM_DONT_USE_INHERITED_MACROS
#define SOMClassMgr_somDefaultCopyInit SOMObject_somDefaultCopyInit
#define SOMClassMgr_somDefaultAssign SOMObject_somDefaultAssign
#define SOMClassMgr_somDefaultConstCopyInit SOMObject_somDefaultConstCopyInit
#define SOMClassMgr_somDefaultVCopyInit SOMObject_somDefaultVCopyInit
#define SOMClassMgr_somDefaultConstVCopyInit SOMObject_somDefaultConstVCopyInit
#define SOMClassMgr_somDefaultConstAssign SOMObject_somDefaultConstAssign
#define SOMClassMgr_somDefaultVAssign SOMObject_somDefaultVAssign
#define SOMClassMgr_somDefaultConstVAssign SOMObject_somDefaultConstVAssign
#define SOMClassMgr_somInit SOMObject_somInit
#define SOMClassMgr_somUninit SOMObject_somUninit
#define SOMClassMgr_somFree SOMObject_somFree
#define SOMClassMgr_somGetClass SOMObject_somGetClass
#define SOMClassMgr_somGetClassName SOMObject_somGetClassName
#define SOMClassMgr_somGetSize SOMObject_somGetSize
#define SOMClassMgr_somIsA SOMObject_somIsA
#define SOMClassMgr_somIsInstanceOf SOMObject_somIsInstanceOf
#define SOMClassMgr_somRespondsTo SOMObject_somRespondsTo
#define SOMClassMgr_somDispatch SOMObject_somDispatch
#define SOMClassMgr_somClassDispatch SOMObject_somClassDispatch
#define SOMClassMgr_somCastObj SOMObject_somCastObj
#define SOMClassMgr_somResetObj SOMObject_somResetObj
#define SOMClassMgr_somPrintSelf SOMObject_somPrintSelf
#define SOMClassMgr_somDumpSelf SOMObject_somDumpSelf
#endif /* SOM_DONT_USE_INHERITED_MACROS */

#endif       /* SOM_SOMClassMgr_h */
