Page principale | Liste des namespaces | Hiérarchie des classes | Liste par ordre alphabétique | Liste des composants | Liste des fichiers | Membres des namespaces | Composants | Déclarations

# Référence de la classe ExManagerId

`#include <ExManagerId.h>`

Graphe d'héritage de la classe ExManagerId

## Membres publics
void | Reset (void)
void | Init (void)
void | List (void)
ExNihilo::ExId | RecordObject (ExCObject &object)
ExNihilo::ExId | RecordObject (ExCObject *object)
ExNihilo::ExId | GetObjectId (std::string Name, std::string Type)
std::string | GetObjectName (ExNihilo::ExId id)
std::string | GetObjectType (ExNihilo::ExId id)
std::string | GetObjectManagerType (std::string ObjectType)
ExCAction | InputAction (ExCAction Action)
void | SetFlux (std::ostrstream *consol, ExCFluxAction *action)
bool | GetStatus (void)
void | SetStatus (bool status)
void | SetAskForCommand (bool status)
void | SetAskForExclusifCommand (bool status)
bool | AskForCommand (void)
bool | AskForExclusifCommand (void)
virtual void | Reload (void)
virtual ExCAction | InputCommand (ExCCommand Command)
## Membres publics statiques
ExManagerId * | CreateSingleton (void)
## Attributs Publics
std::ostrstream * | Consol
ExCFluxAction * | FluxAction
## Attributs Protégés
bool | m_Status
bool | m_AskForCommand
bool | m_Exclusif
## Membres privés
std::string | GetAviableName (std::string Name, std::string Type, int occu)
| ExManagerId (void)
| ~ExManagerId (void)
## Attributs Privés
int | m_ExIdCounter
std::map< ExNihilo::ExId, ExNihilo::ExObjectInfo, std::less< ExNihilo::ExId > > * | m_MapObjectInfo
std::map< ExNihilo::ExId, ExNihilo::ExObjectInfo, std::less< ExNihilo::ExId > >::iterator | m_ItMapObjectInfo
## Attributs Privés Statiques
bool | m_flag = false
ExManagerId * | m_instance = NULL

## Documentation des contructeurs et destructeurs

ExManagerId::ExManagerId | ( | void |  | ) | `[private]`

| Définition à la ligne 43 du fichier ExManagerId.cpp. Références ExManagerId(), Guard, m_ExIdCounter, et UnGuard. Référencé par ExManagerId(), et ~ExManagerId().
    00044 {
    00045 Guard(ExManagerId::ExManagerId())
    00046         m_ExIdCounter=0;
    00047 UnGuard
    00048 }

ExManagerId::~ExManagerId | ( | void |  | ) | `[private]`

| Définition à la ligne 50 du fichier ExManagerId.cpp. Références ExManagerId(), Guard, et UnGuard.
    00051 {
    00052 Guard(ExManagerId::~ExManagerId())
    00053 UnGuard
    00054 }

## Documentation des méthodes

bool ExManager::AskForCommand | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 89 du fichier ExManager.h. Références ExManager::m_AskForCommand. Référencé par ExManagerCommand::InputCommand().
    00089 {return m_AskForCommand;}

bool ExManager::AskForExclusifCommand | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 90 du fichier ExManager.h. Références ExManager::m_Exclusif. Référencé par ExManagerCommand::InputCommand().
    00090 {return m_Exclusif;}

ExManagerId * ExManagerId::CreateSingleton | ( | void |  | ) | `[static]`

| Définition à la ligne 29 du fichier ExManagerId.cpp. Références CreateSingleton(), Guard, m_flag, m_instance, et UnGuard. Référencé par CreateManager(), et CreateSingleton().
    00029                                              {
    00030 Guard(ExManagerId* ExManagerId::CreateSingleton(void))
    00031         if(!m_flag)
    00032         {
    00033                 m_flag = true; // We are creating the error log now, so set flag to true
    00034                 m_instance = new ExManagerId; // Create the error log
    00035         }else
    00036         {
    00037                 std::cout<<"Error singleton already created"<<std::endl;
    00038         }
    00039         return m_instance;
    00040 UnGuard
    00041 }

std::string ExManagerId::GetAviableName | ( | std::string | Name,
|  | std::string | Type,
|  | int | occu
| ) | `[private]`

| Définition à la ligne 75 du fichier ExManagerId.cpp. Références GetAviableName(), GetObjectId(), Guard, et UnGuard. Référencé par GetAviableName(), et RecordObject().
    00076 {
    00077 Guard(std::string ExManagerId::GetAviableName(std::string Name,std::string Type,int occu))
    00078         if(GetObjectId(Name,Type)==-1)//new name
    00079         {
    00080                 return Name;
    00081         }
    00082
    00083         //here code to change name
    00084         if(occu>0)
    00085         {
    00086                 Name.erase(Name.end()-1,Name.end());
    00087         }
    00088         if(occu>10)
    00089         {
    00090                 Name.erase(Name.end()-1,Name.end());
    00091         }
    00092         if(occu>100)
    00093         {
    00094                 Name.erase(Name.end()-1,Name.end());
    00095         }
    00096         if(occu>1000)
    00097         {
    00098                 Name.erase(Name.end()-1,Name.end());
    00099         }
    00100         if(occu>10000)
    00101         {
    00102                 Name.erase(Name.end()-1,Name.end());
    00103         }
    00104         char buffer[255];
    00105         memset(buffer,0,255);
    00106         sprintf(buffer,"%s%d",Name.data(),occu);
    00107
    00108         return GetAviableName(buffer,Type,occu+1);
    00109
    00110 UnGuard
    00111 }

ExNihilo::ExId ExManagerId::GetObjectId | ( | std::string | Name,
|  | std::string | Type
| ) |

| Définition à la ligne 177 du fichier ExManagerId.cpp. Références ExNihilo::ExId, GetObjectId(), Guard, m_ItMapObjectInfo, m_MapObjectInfo, et UnGuard. Référencé par ExManagerTexture::CheckExist(), GetAviableName(), ExManagerObject< TypeA >::GetObject(), GetObjectId(), ExManagerTexture::GetTextureId(), ExCAnimation::LoadFile(), ExManagerObject< TypeA >::Remove(), ExManagerTexture::SetCurrentObject(), et ExManagerObject< TypeA >::SetCurrentObject().
    00178 {
    00179 Guard(ExNihilo::ExId    ExManagerId::GetObjectId(std::string Name,std::string Type))
    00180         for(m_ItMapObjectInfo=m_MapObjectInfo->begin();m_ItMapObjectInfo!=m_MapObjectInfo->end();m_ItMapObjectInfo++)
    00181         {
    00182                 if(Name==m_ItMapObjectInfo->second.m_Name)//||Type==m_ItMapObjectInfo->second.m_Type)
    00183                         return  m_ItMapObjectInfo->second.m_Id;
    00184         }
    00185         return -1;
    00186 UnGuard
    00187 }

std::string ExManagerId::GetObjectManagerType | ( | std::string | ObjectType | ) |

| Définition à la ligne 241 du fichier ExManagerId.cpp. Références GetObjectManagerType(), Guard, et UnGuard. Référencé par GetObjectManagerType(), et ExCAnimation::LoadFile().
    00242 {
    00243 Guard(std::string               ExManagerId::GetObjectManagerType(std::string ObjectType))
    00244         //std::cout<<"Type:"<<ObjectType<<std::endl;
    00245         try
    00246         {
    00247                 //Entity manager
    00248                 if(strcmpi(ObjectType.data(),"ExCEntity")==0)return "ExManagerEntity";
    00249                 //Camera manager
    00250                 if(strcmpi(ObjectType.data(),"ExCCamera")==0)return "ExManagerCamera";
    00251                 if(strcmpi(ObjectType.data(),"ExCCameraFree")==0)return "ExManagerCamera";
    00252                 if(strcmpi(ObjectType.data(),"ExCCameraChase")==0)return "ExManagerCamera";
    00253                 if(strcmpi(ObjectType.data(),"ExCCameraFirst")==0)return "ExManagerCamera";
    00254                 if(strcmpi(ObjectType.data(),"ExCCameraFlight")==0)return "ExManagerCamera";
    00255                 //Model Manager
    00256                 if(strcmpi(ObjectType.data(),"ExCModel")==0)return "ExManagerModel";
    00257                 if(strcmpi(ObjectType.data(),"ExCModelASC")==0)return "ExManagerModel";
    00258                 if(strcmpi(ObjectType.data(),"ExCModelASE")==0)return "ExManagerModel";
    00259                 if(strcmpi(ObjectType.data(),"ExCModelEXM")==0)return "ExManagerModel";
    00260                 if(strcmpi(ObjectType.data(),"ExCModelMD")==0)return "ExManagerModel";
    00261                 if(strcmpi(ObjectType.data(),"ExCModelMD2")==0)return "ExManagerModel";
    00262                 if(strcmpi(ObjectType.data(),"ExCModelMD3")==0)return "ExManagerModel";
    00263                 if(strcmpi(ObjectType.data(),"ExCModel3DS")==0)return "ExManagerModel";
    00264                 if(strcmpi(ObjectType.data(),"ExCModelOBJ")==0)return "ExManagerModel";
    00265                 //MEsh Manager
    00266                 if(strcmpi(ObjectType.data(),"ExCMesh")==0)return "ExManagerMesh";
    00267                 if(strcmpi(ObjectType.data(),"ExCMeshFireEffect")==0)return "ExManagerMesh";
    00268                 if(strcmpi(ObjectType.data(),"ExCMeshWaterEffect")==0)return "ExManagerMesh";
    00269                 if(strcmpi(ObjectType.data(),"ExCMeshSummonCylenderEffect")==0)return "ExManagerMesh";
    00270                 if(strcmpi(ObjectType.data(),"ExCMeshSmogEffect")==0)return "ExManagerMesh";
    00271                 if(strcmpi(ObjectType.data(),"ExCMeshWaterDisqueEffect")==0)return "ExManagerMesh";
    00272                 if(strcmpi(ObjectType.data(),"ExCMeshLOD3ds")==0)return "ExManagerMesh";
    00273                 if(strcmpi(ObjectType.data(),"ExCMeshSauronEffect")==0)return "ExManagerMesh";
    00274                 if(strcmpi(ObjectType.data(),"ExCMesh3ds")==0)return "ExManagerMesh";
    00275         }
    00276         catch(...)
    00277         {
    00278                 return "Unknow manager";
    00279         }
    00280 UnGuard
    00281 }

std::string ExManagerId::GetObjectName | ( | ExNihilo::ExId | id | ) |

| Définition à la ligne 189 du fichier ExManagerId.cpp. Références ExNihilo::ExId, GetObjectName(), Guard, m_MapObjectInfo, et UnGuard. Référencé par GetObjectName().
    00190 {
    00191 Guard(std::string               ExManagerId::GetObjectName(ExNihilo::ExId id))
    00192         try
    00193         {
    00194                 return m_MapObjectInfo->find(id)->second.m_Name;
    00195         }
    00196         catch(...)
    00197         {
    00198                 return "NoName";
    00199         }
    00200 UnGuard
    00201 }

std::string ExManagerId::GetObjectType | ( | ExNihilo::ExId | id | ) |

| Définition à la ligne 203 du fichier ExManagerId.cpp. Références ExNihilo::ExId, GetObjectType(), Guard, m_MapObjectInfo, et UnGuard. Référencé par GetObjectType().
    00204 {
    00205 Guard(std::string               ExManagerId::GetObjectType(ExNihilo::ExId id))
    00206         try
    00207         {
    00208                 return m_MapObjectInfo->find(id)->second.m_Type;
    00209         }
    00210         catch(...)
    00211         {
    00212                 return "NoName";
    00213         }
    00214 UnGuard
    00215 }

bool ExManager::GetStatus | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 85 du fichier ExManager.h. Références ExManager::m_Status. Référencé par ExManagerInterface::Draw(), ExManagerConsole::Draw(), et ExManagerOutput::DrawScene().
    00085 {return m_Status;}

void ExManagerId::Init | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 68 du fichier ExManagerId.cpp. Références Guard, Init(), m_MapObjectInfo, et UnGuard. Référencé par Init(), PreInitManager(), et Reset().
    00069 {
    00070 Guard(ExManagerId::Init(void))
    00071         m_MapObjectInfo=new std::map<  ExNihilo::ExId   , ExNihilo::ExObjectInfo , std::less <ExNihilo::ExId  >  >;
    00072 UnGuard
    00073 }

ExCAction ExManagerId::InputAction | ( | ExCAction | Action | ) | `[virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 227 du fichier ExManagerId.cpp. Références Guard, ID_LIST, InputAction(), List(), ExCAction::m_Action, ExCAction::m_NextAction, NOTHING, et UnGuard. Référencé par InputAction(), et ExManagerCommand::ProcesExCAction().
    00228 {
    00229 Guard(ExCAction ExManagerId::InputAction(ExCAction Action))
    00230         switch(Action.m_Action)
    00231         {
    00232         case ID_LIST:
    00233                 List();
    00234                 break;
    00235         }
    00236         if(Action.m_NextAction){return *Action.m_NextAction;}
    00237         else{return NOTHING;}
    00238 UnGuard
    00239 }

ExCAction ExManager::InputCommand | ( | ExCCommand | Command | ) | `[virtual, inherited]`

| Redéfinie dans ExManagerCommand, ExManagerConsole, ExManagerFog, ExManagerMap, ExManagerNetwork, ExManagerPVS, ExManagerSpecialEffect, ExManagerWindow, ExManagerLoad, ExManagerAnimation, ExManagerCamera, ExManagerEntity, ExManagerInterface, ExManagerLoad, ExManagerMesh, ExManagerModel, ExManagerObjectWindow, ExManagerParticuleSystem, et ExManagerSound. Définition à la ligne 40 du fichier ExManager.cpp. Références NOTHING.
    00041 {return NOTHING;}

void ExManagerId::List | ( | void |  | ) |

| Définition à la ligne 217 du fichier ExManagerId.cpp. Références ExManager::Consol, Guard, List(), m_ItMapObjectInfo, m_MapObjectInfo, et UnGuard. Référencé par InputAction(), et List().
    00218 {
    00219 Guard(void ExManagerId::List(void))
    00220         for(m_ItMapObjectInfo=m_MapObjectInfo->begin();m_ItMapObjectInfo!=m_MapObjectInfo->end();m_ItMapObjectInfo++)
    00221         {
    00222                 *Consol<<"Id :"<<m_ItMapObjectInfo->second.m_Id<<"  For name:"<<m_ItMapObjectInfo->second.m_Name<<" Type:"<<m_ItMapObjectInfo->second.m_Type<<std::endl;
    00223         }
    00224 UnGuard
    00225 }

ExNihilo::ExId ExManagerId::RecordObject | ( | ExCObject * | object | ) |

| Définition à la ligne 150 du fichier ExManagerId.cpp. Références ExManager::Consol, ExNihilo::ExId, GetAviableName(), ExCObject::GetId(), ExCObject::GetName(), ExCObject::GetType(), Guard, m_ExIdCounter, ExNihilo::ExObjectInfo::m_Id, m_MapObjectInfo, ExNihilo::ExObjectInfo::m_Name, ExNihilo::ExObjectInfo::m_Type, RecordObject(), ExCObject::SetId(), ExCObject::SetName(), ExCObject::SetType(), et UnGuard.
    00151 {
    00152 Guard(ExNihilo::ExId ExManagerId::RecordObject(ExCObject *object))
    00153         object->SetId(m_ExIdCounter);m_ExIdCounter++;
    00154         std::string name(object->GetType());
    00155         if(name.find(" *")<name.length())
    00156         {
    00157                 name.erase(name.find(" *"),name.length()-name.find(" *"));
    00158         }
    00159         object->SetName(GetAviableName(object->GetName(),object->GetType(),0));
    00160         object->SetType(name);
    00161
    00162         ExNihilo::ExObjectInfo Info;
    00163         Info.m_Id       = object->GetId();
    00164         Info.m_Name     = object->GetName();
    00165         Info.m_Type = object->GetType();
    00166
    00167         std::pair<ExNihilo::ExId,ExNihilo::ExObjectInfo>  obj;
    00168         obj.first=object->GetId();
    00169         obj.second=Info;
    00170         m_MapObjectInfo->insert(obj);
    00171
    00172         *Consol<<"ExManagerId:: New Id :"<<Info.m_Id<<"  For name:"<<Info.m_Name<<" Type:"<<Info.m_Type<<std::endl;
    00173         return Info.m_Id;
    00174 UnGuard
    00175 }

ExNihilo::ExId ExManagerId::RecordObject | ( | ExCObject & | object | ) |

| Définition à la ligne 113 du fichier ExManagerId.cpp. Références ExManager::Consol, ExNihilo::ExId, ExManager::FluxAction, GetAviableName(), ExCObject::GetId(), ExCObject::GetName(), ExCObject::GetType(), Guard, m_ExIdCounter, ExNihilo::ExObjectInfo::m_Id, m_MapObjectInfo, ExNihilo::ExObjectInfo::m_Name, ExNihilo::ExObjectInfo::m_Type, RecordObject(), ExCObject::SetFlux(), ExCObject::SetId(), ExCObject::SetName(), ExCObject::SetType(), et UnGuard. Référencé par ExManagerObject< TypeA >::Add(), et RecordObject().
    00114 {
    00115 Guard(ExNihilo::ExId ExManagerId::RecordObject(ExCObject &object))
    00116         try
    00117         {
    00118                 object.SetId(m_ExIdCounter);m_ExIdCounter++;
    00119                 std::string name(object.GetType());
    00120                 if(name.find(" *")<name.length())
    00121                 {
    00122                         name.erase(name.find(" *"),name.length()-name.find(" *"));
    00123                 }
    00124                 object.SetName(GetAviableName(object.GetName(),object.GetType(),0));
    00125                 object.SetType(name);
    00126                 object.SetFlux(Consol,FluxAction);
    00127
    00128
    00129                 ExNihilo::ExObjectInfo Info;
    00130                 Info.m_Id       = object.GetId();
    00131                 Info.m_Name     = object.GetName();
    00132                 Info.m_Type = object.GetType();
    00133
    00134                 std::pair<ExNihilo::ExId,ExNihilo::ExObjectInfo>  obj;
    00135                 obj.first=object.GetId();
    00136                 obj.second=Info;
    00137                 m_MapObjectInfo->insert(obj);
    00138
    00139
    00140
    00141                 *Consol<<"ExManagerId:: New Id :"<<Info.m_Id<<"  For name:"<<Info.m_Name<<" Type:"<<Info.m_Type<<std::endl;
    00142                 return Info.m_Id;
    00143         }catch(...)
    00144         {
    00145                 throw ExCExpRecordObject();
    00146         }
    00147 UnGuard
    00148 }

void ExManager::Reload | ( | void |  | ) | `[virtual, inherited]`

| Redéfinie dans ExManagerCollision, ExManagerAnimation, ExManagerEntity, ExManagerModel, ExManagerObject< TypeA >, ExManagerTexture, ExManagerObject< ExCAnimation >, ExManagerObject< ExCModel * >, ExManagerObject< ExCWindow >, ExManagerObject< ExCVertexProgram >, ExManagerObject< ExCLight >, ExManagerObject< ExCLoadingAnimation >, ExManagerObject< ExCInterface >, ExManagerObject< ExCSound >, ExManagerObject< ExCCamera * >, ExManagerObject< ExCFont >, ExManagerObject< ExCGizmo >, ExManagerObject< ExCMesh * >, ExManagerObject< ExCTexture >, ExManagerObject< ExCEntity * >, ExManagerObject< ExCSystemeParticule >, et ExManagerObject< ExCSpirit >. Définition à la ligne 33 du fichier ExManager.cpp. Référencé par ExManagerCommand::ProcesExCAction().
    00034 {}

void ExManagerId::Reset | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 58 du fichier ExManagerId.cpp. Références Guard, Init(), m_ExIdCounter, m_MapObjectInfo, Reset(), et UnGuard. Référencé par ExManagerCommand::ProcesExCAction(), et Reset().
    00059 {
    00060 Guard(ExManagerId::Reset(void))
    00061         m_MapObjectInfo->clear();
    00062         delete m_MapObjectInfo;
    00063         m_ExIdCounter=0;
    00064         Init();
    00065 UnGuard
    00066 }

void ExManager::SetAskForCommand | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 87 du fichier ExManager.h. Références ExManager::m_AskForCommand. Référencé par ExManagerConsole::ExManagerConsole(), ExManagerModel::ExManagerModel(), ExManagerObjectWindow::Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), ExManagerLoad::LoadSetOfFile(), et ExManagerNetwork::Say().
    00087 {m_AskForCommand=status;}

void ExManager::SetAskForExclusifCommand | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 88 du fichier ExManager.h. Références ExManager::m_Exclusif. Référencé par ExManagerConsole::ExManagerConsole(), ExManagerModel::ExManagerModel(), ExManagerObjectWindow::Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), et ExManagerNetwork::Say().
    00088 {m_Exclusif=status;}

void ExManager::SetFlux | ( | std::ostrstream * | consol,
|  | ExCFluxAction * | action
| ) | `[inherited]`

| Définition à la ligne 35 du fichier ExManager.cpp. Références ExManager::Consol, et ExManager::FluxAction. Référencé par SetManagerLink().
    00036 {
    00037         Consol=consol;
    00038         FluxAction=action;
    00039 }

void ExManager::SetStatus | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 86 du fichier ExManager.h. Références ExManager::m_Status. Référencé par ExManagerConsole::Draw(), ExManagerConsole::ExManagerConsole(), ExManagerObjectWindow::Init(), ExManagerInterface::Init(), ExManagerConsole::InputAction(), ExManagerLoad::LoadSetOfFile(), et ExManagerConsole::SetConsoleState().
    00086 {m_Status=status;}

## Documentation des données imbriquées

std::ostrstream* ExManager::Consol`[inherited]`

| Définition à la ligne 73 du fichier ExManager.h. Référencé par ExManagerObject< TypeA >::Add(), ExManagerConsole::AddStringAction(), ExManagerConsole::ApplyBuffCommand(), ExManagerInputGLUT::CheckInput(), ExManagerSound::DisplayAviableInput(), ExManagerInputGLUT::DisplayAviableInput(), ExManagerLoad::DisplayFileType(), ExManagerLoad::GetFileType(), ExManagerVertexArrays::Init(), ExManagerTexture::Init(), ExManagerSound::Init(), ExManagerFog::Init(), ExManagerSound::InputAction(), ExManagerPVS::InputAction(), ExManagerParticuleSystem::InputAction(), ExManagerModel::InputAction(), ExManagerMesh::InputAction(), ExManagerMap::InputAction(), ExManagerLoad::InputAction(), ExManagerInterface::InputAction(), ExManagerFog::InputAction(), ExManagerEntity::InputAction(), ExManagerConsole::InputAction(), ExManagerCommand::InputAction(), ExManagerCamera::InputAction(), ExManagerAnimation::InputAction(), ExManagerObject< TypeA >::List(), ExManagerModel::List(), List(), ExManagerConsole::ListConsoleCommand(), ExManagerTexture::Load(), ExManagerParticuleSystem::Load(), ExManagerModel::Load(), ExManagerInterface::Load(), ExManagerTexture::LoadCubeMap(), ExManagerLoad::LoadSetOfFile(), ExManagerSound::LoadSound(), ExManagerSound::PauseSound(), ExManagerSound::PlaySound(), ExManagerCommand::ProcesExCAction(), RecordObject(), ExManager::SetFlux(), ExManagerSound::SetRepeatSound(), ExManagerSound::StopSound(), ExManagerConsole::UpdateConsolBuffer(), et ExManagerConsole::Write().

ExCFluxAction* ExManager::FluxAction`[inherited]`

| Définition à la ligne 74 du fichier ExManager.h. Référencé par ExManagerWindow::Apply(), ExManagerCommand::ApplyAction(), ExManagerCommand::LoadExecFile(), RecordObject(), ExManager::SetFlux(), et ExManagerSpecialEffect::Specialeffect().

bool ExManager::m_AskForCommand`[protected, inherited]`

| Définition à la ligne 70 du fichier ExManager.h. Référencé par ExManager::AskForCommand(), ExManagerConsole::ExManagerConsole(), et ExManager::SetAskForCommand().

bool ExManager::m_Exclusif`[protected, inherited]`

| Définition à la ligne 71 du fichier ExManager.h. Référencé par ExManager::AskForExclusifCommand(), et ExManager::SetAskForExclusifCommand().

int ExManagerId::m_ExIdCounter`[private]`

| Définition à la ligne 70 du fichier ExManagerId.h. Référencé par ExManagerId(), RecordObject(), et Reset().

bool ExManagerId::m_flag = false`[static, private]`

| Définition à la ligne 26 du fichier ExManagerId.cpp. Référencé par CreateSingleton().

ExManagerId * ExManagerId::m_instance = NULL`[static, private]`

| Définition à la ligne 27 du fichier ExManagerId.cpp. Référencé par CreateSingleton().

std::map< ExNihilo::ExId , ExNihilo::ExObjectInfo , std::less <ExNihilo::ExId > >::iterator ExManagerId::m_ItMapObjectInfo`[private]`

| Définition à la ligne 73 du fichier ExManagerId.h. Référencé par GetObjectId(), et List().

std::map< ExNihilo::ExId , ExNihilo::ExObjectInfo , std::less <ExNihilo::ExId > >* ExManagerId::m_MapObjectInfo`[private]`

| Définition à la ligne 72 du fichier ExManagerId.h. Référencé par GetObjectId(), GetObjectName(), GetObjectType(), Init(), List(), RecordObject(), et Reset().

bool ExManager::m_Status`[protected, inherited]`

| Définition à la ligne 69 du fichier ExManager.h. Référencé par ExManager::GetStatus(), et ExManager::SetStatus().

La documentation associée à cette classe a été générée à partir des fichiers suivants :

- ExManagerId.h
- ExManagerId.cpp