mg_cg_forme.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_cg_forme.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mg_cg_forme.h"
#include "mg_cg_modele.h"
#include "mg_cg_operateur.h"
#include "mg_geometrie.h"
#include "mg_cg_info.h"
MG_CG_FORME::MG_CG_FORME(MG_CG_MODELE* mgcg_modele,int provenance): MG_CONSTRUCTION_GEOMETRIQUE(),m_provenance(provenance),m_mgcg_modele(mgcg_modele),m_mgcg_operateur_parent(NULL)
{
  m_mgcg_modele->ajouter_mgcg_forme(this);
}
 
MG_CG_FORME::MG_CG_FORME(MG_CG_MODELE* mgcg_modele,int provenance, int etat, long unsigned int num): MG_CONSTRUCTION_GEOMETRIQUE(num),m_provenance(provenance),m_etat(etat),m_mgcg_modele(mgcg_modele),m_mgcg_operateur_parent(NULL)
{
  m_mgcg_modele->ajouter_mgcg_forme(this);
}
 
 
MG_CG_FORME::MG_CG_FORME(MG_CG_FORME& mdd): MG_CONSTRUCTION_GEOMETRIQUE(mdd)
{
  m_mgcg_modele=mdd.get_mgcg_modele();
  m_provenance=mdd.m_provenance;
  m_etat=mdd.m_etat;
  m_mgcg_operateur_parent=mdd.m_mgcg_operateur_parent;
}
 
MG_CG_FORME::~MG_CG_FORME()
{
  if(m_provenance==GENEREE && m_mgcg_operateur_parent!=NULL) m_mgcg_operateur_parent->retirer_mgcg_forme_sortie(this);
  std::map<long,MG_CG_OPERATEUR*>::iterator it_operateur_dependant;
  for(MG_CG_OPERATEUR* operateur=get_premier_mgcg_operateur_dependant(it_operateur_dependant);operateur!=NULL;operateur=get_suivant_mgcg_operateur_dependant(it_operateur_dependant))
  {
    operateur->retirer_mgcg_forme_entree(this);
  }
}
 
void MG_CG_FORME::change_mgcg_modele(MG_CG_MODELE* mgcg_modele)
{
  m_mgcg_modele=mgcg_modele;
}
 
MG_CG_MODELE* MG_CG_FORME::get_mgcg_modele(void)
{
  return m_mgcg_modele;
}
 
int MG_CG_FORME::get_provenance(void)
{
  return m_provenance;
}
 
void MG_CG_FORME::change_provenance(int provenance_forme)
{
  m_provenance=provenance_forme;
}
 
int MG_CG_FORME::get_etat(void)
{
  return m_etat;
}
 
void MG_CG_FORME::change_etat(int etat_forme)
{
  m_etat=etat_forme;
}
 
MG_CG_OPERATEUR* MG_CG_FORME::get_mgcg_operateur_parent(void)
{
  return m_mgcg_operateur_parent;
}
 
void MG_CG_FORME::change_mgcg_operateur_parent(MG_CG_OPERATEUR* mgcg_operateur)
{
  m_mgcg_operateur_parent=mgcg_operateur;
}
 
long int MG_CG_FORME::get_nb_mgcg_operateur_dependant(void)
{
  return m_map_mgcg_operateur_dependant.size();
}
 
int MG_CG_FORME::ajouter_mgcg_operateur_dependant(MG_CG_OPERATEUR* mgcg_operateur)
{
  std::pair<std::map<long,MG_CG_OPERATEUR*>::iterator,bool> p = m_map_mgcg_operateur_dependant.insert(std::pair<long,MG_CG_OPERATEUR*>(mgcg_operateur->get_id(),mgcg_operateur));
  if(p.second==false) return FAIL;
  return OK;
}
 
int MG_CG_FORME::retirer_mgcg_operateur_dependant(MG_CG_OPERATEUR* mgcg_operateur)
{
  std::map<long,MG_CG_OPERATEUR*>::iterator it;
  it=m_map_mgcg_operateur_dependant.find(mgcg_operateur->get_id());
  if(it!=m_map_mgcg_operateur_dependant.end())
  {
    m_map_mgcg_operateur_dependant.erase(it);
    return OK;
  }
  else return FAIL;
}
 
void MG_CG_FORME::retirer_tout_mgcg_operateur_dependant(void)
{
  m_map_mgcg_operateur_dependant.clear();
}
 
MG_CG_OPERATEUR* MG_CG_FORME::get_premier_mgcg_operateur_dependant(std::map<long,MG_CG_OPERATEUR*>::iterator& it)
{
  it=m_map_mgcg_operateur_dependant.begin();
  if(it==m_map_mgcg_operateur_dependant.end())  
    return NULL;
  return it->second; 
}
 
MG_CG_OPERATEUR* MG_CG_FORME::get_suivant_mgcg_operateur_dependant(std::map<long,MG_CG_OPERATEUR*>::iterator& it)
{
  it++;
  if(it==m_map_mgcg_operateur_dependant.end())  
    return NULL;
  return it->second; 
}
 
int MG_CG_FORME::get_type_mg_construction_geometrique(void)
{
  return TYPE_MG_CONSTRUCTION_GEOMETRIQUE::MGCG_FORME;
}