mg_cg_operateur.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_operateur.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mg_cg_operateur.h"
#include "mg_cg_forme.h"
#include "mg_definition.h"
#include "mg_cg_modele.h"
 
MG_CG_OPERATEUR::MG_CG_OPERATEUR(MG_CG_MODELE* mgcg_modele,int semantique): MG_CONSTRUCTION_GEOMETRIQUE(),m_semantique(semantique)
{
  mgcg_modele->ajouter_mgcg_operateur(this);
  verifie_semantique();
  m_etat=MG_CG_OPERATEUR::ETAT_OPERATEUR::NON_CONSTRUIT;  
}
 
MG_CG_OPERATEUR::MG_CG_OPERATEUR(MG_CG_MODELE* mgcg_modele,int semantique, int etat, long unsigned int num): MG_CONSTRUCTION_GEOMETRIQUE(num),m_semantique(semantique),m_etat(etat)
{
  mgcg_modele->ajouter_mgcg_operateur(this);
  verifie_semantique();   
}
 
MG_CG_OPERATEUR::MG_CG_OPERATEUR(MG_CG_OPERATEUR& mdd)
{
  m_semantique=mdd.m_semantique;
  m_etat=MG_CG_OPERATEUR::ETAT_OPERATEUR::NON_CONSTRUIT;
  std::map<long,MG_CG_FORME*>::iterator it_forme;
  for(MG_CG_FORME* forme=mdd.get_premiere_mgcg_forme_entree(it_forme);forme!=NULL;forme=mdd.get_suivante_mgcg_forme_entree(it_forme))
  {
    ajouter_mgcg_forme_entree(forme);
  }
}
 
MG_CG_OPERATEUR::~MG_CG_OPERATEUR(void)
{
  std::map<long,MG_CG_FORME*>::iterator it_forme;
  for(MG_CG_FORME* forme=get_premiere_mgcg_forme_entree(it_forme);forme!=NULL;forme=get_suivante_mgcg_forme_entree(it_forme))
  {
    forme->retirer_mgcg_operateur_dependant(this);
  }
  for(MG_CG_FORME* forme=get_premiere_mgcg_forme_sortie(it_forme);forme!=NULL;forme=get_suivante_mgcg_forme_sortie(it_forme))
  {
    forme->change_mgcg_operateur_parent(NULL);
  }  
}
 
void MG_CG_OPERATEUR::change_mgcg_modele(MG_CG_MODELE* mgcg_modele)
{
  m_mgcg_modele=mgcg_modele;
}
 
MG_CG_MODELE* MG_CG_OPERATEUR::get_mgcg_modele(void)
{
  return m_mgcg_modele;
}
 
void MG_CG_OPERATEUR::change_etat(int etat_operateur)
{
  m_etat=etat_operateur;
}
 
int MG_CG_OPERATEUR::get_etat(void)
{
  return m_etat;
}
 
int MG_CG_OPERATEUR::get_semantique(void)
{
  return m_semantique;
}
 
void MG_CG_OPERATEUR::change_semantique(int semantique)
{
  m_semantique=semantique;
}
 
void MG_CG_OPERATEUR::verifie_semantique(void)
{
  if (m_semantique!=MAGIC::SEMANTIQUECSG::SANS)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::CHAMFREIN)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::CONGE)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::INTERSECTION)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::PERCAGE)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::SOUSTRACTION)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::UNION)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::FRAGMENT)
  if (m_semantique!=MAGIC::SEMANTIQUECSG::EXTRUSION)
      m_semantique=MAGIC::SEMANTIQUECSG::ERREUR;
}
 
long int MG_CG_OPERATEUR::get_nb_mgcg_forme_entree(void)
{
  return m_map_mgcg_forme_entree.size();
}
 
int MG_CG_OPERATEUR::ajouter_mgcg_forme_entree(MG_CG_FORME* mgcg_forme)
{
  std::pair<std::map<long,MG_CG_FORME*>::iterator,bool> p=m_map_mgcg_forme_entree.insert(std::pair<long,MG_CG_FORME*>(mgcg_forme->get_id(),mgcg_forme));
  if (!p.second)  
    return FAIL;
  mgcg_forme->ajouter_mgcg_operateur_dependant(this);
  return OK;
}
 
int MG_CG_OPERATEUR::retirer_mgcg_forme_entree(MG_CG_FORME* mgcg_forme)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  it=m_map_mgcg_forme_entree.find(mgcg_forme->get_id());
  if(it!=m_map_mgcg_forme_entree.end())
  {
    (it->second)->retirer_mgcg_operateur_dependant(this);
    m_map_mgcg_forme_entree.erase(it);
    
    return OK;
  }
  else return FAIL;
}
 
int MG_CG_OPERATEUR::retirer_mgcg_forme_entreeid(long int id)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  it=m_map_mgcg_forme_entree.find(id);
  if(it!=m_map_mgcg_forme_entree.end())
  {
    (it->second)->retirer_mgcg_operateur_dependant(this);
    m_map_mgcg_forme_entree.erase(it);
    return OK;
  }
  else return FAIL;
}
 
void MG_CG_OPERATEUR::retirer_tout_mgcg_forme_entree(void)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  for(MG_CG_FORME* mgcg_forme=get_premiere_mgcg_forme_entree(it);mgcg_forme!=NULL;mgcg_forme=get_suivante_mgcg_forme_entree(it)) mgcg_forme->retirer_mgcg_operateur_dependant(this);
  m_map_mgcg_forme_entree.clear();
}
 
MG_CG_FORME* MG_CG_OPERATEUR::get_premiere_mgcg_forme_entree(std::map<long,MG_CG_FORME*>::iterator& it)
{
  it=m_map_mgcg_forme_entree.begin();
  if(it==m_map_mgcg_forme_entree.end())  
    return NULL;
  return it->second;
}
 
MG_CG_FORME* MG_CG_OPERATEUR::get_suivante_mgcg_forme_entree(std::map<long,MG_CG_FORME*>::iterator& it)
{
  it++;
  if(it==m_map_mgcg_forme_entree.end())  
    return NULL;
  return it->second;
}
 
MG_CG_FORME* MG_CG_OPERATEUR::get_mgcg_forme_entreeid(long int id)
{
  std::map<long,MG_CG_FORME*>::iterator it=m_map_mgcg_forme_entree.find(id);
  if (it==m_map_mgcg_forme_entree.end())
  {
      return NULL;
  }
  return ((*it).second);
}
 
long int MG_CG_OPERATEUR::get_nb_mgcg_forme_sortie(void)
{
  return m_map_mgcg_forme_sortie.size();
}
 
int MG_CG_OPERATEUR::ajouter_mgcg_forme_sortie(MG_CG_FORME* mgcg_forme)
{
  std::pair<std::map<long,MG_CG_FORME*>::iterator,bool> p=m_map_mgcg_forme_sortie.insert(std::pair<long,MG_CG_FORME*>(mgcg_forme->get_id(),mgcg_forme));
  if (!p.second)  
    return FAIL;
  return OK;
}
 
int MG_CG_OPERATEUR::retirer_mgcg_forme_sortie(MG_CG_FORME* mgcg_forme)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  it=m_map_mgcg_forme_sortie.find(mgcg_forme->get_id());
  if(it!=m_map_mgcg_forme_sortie.end())
  {
    m_map_mgcg_forme_sortie.erase(it);
    return OK;
  }
  else return FAIL;
}
 
int MG_CG_OPERATEUR::retirer_mgcg_forme_sortieid(long int id)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  it=m_map_mgcg_forme_sortie.find(id);
  if(it!=m_map_mgcg_forme_sortie.end())
  {
    m_map_mgcg_forme_sortie.erase(it);
    return OK;
  }
  else return FAIL;
}
 
void MG_CG_OPERATEUR::retirer_tout_mgcg_forme_sortie(void)
{
  m_map_mgcg_forme_sortie.clear();
}
 
MG_CG_FORME* MG_CG_OPERATEUR::get_premiere_mgcg_forme_sortie(std::map<long,MG_CG_FORME*>::iterator& it)
{
  it=m_map_mgcg_forme_sortie.begin();
  if(it==m_map_mgcg_forme_sortie.end())  
    return NULL;
  return it->second;
}
 
MG_CG_FORME* MG_CG_OPERATEUR::get_suivante_mgcg_forme_sortie(std::map<long,MG_CG_FORME*>::iterator& it)
{
  it++;
  if(it==m_map_mgcg_forme_sortie.end())  
    return NULL;
  return it->second;
}
 
MG_CG_FORME* MG_CG_OPERATEUR::get_mgcg_forme_sortieid(long int id)
{
  std::map<long,MG_CG_FORME*>::iterator it=m_map_mgcg_forme_sortie.find(id);
  if (it==m_map_mgcg_forme_sortie.end())
  {
      return NULL;
  }
  return ((*it).second);
}
 
int MG_CG_OPERATEUR::get_type_mg_construction_geometrique(void)
{
  return TYPE_MG_CONSTRUCTION_GEOMETRIQUE::MGCG_OPERATEUR;
}