src/MEDMEM/MEDMEM_CellModel.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser 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
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

/*
 File MEDMEM_CellModel.hxx
*/

#ifndef CELLMODEL_HXX
#define CELLMODEL_HXX

#include <MEDMEM.hxx>

#include <set>
#include <map>
#include <string>

#include "MEDMEM_Utilities.hxx"
#include "MEDMEM_define.hxx"

using namespace std ;

namespace MEDMEM {
  class CELLMODEL;
  MEDMEM_EXPORT ostream & operator<<(ostream &os,const CELLMODEL &my);

class MEDMEM_EXPORT CELLMODEL 
{

private:
  void init(const CELLMODEL &m);

  void clean();


  //protected:
  string             _name;
  MED_EN::medGeometryElement _type;
  int                _dimension;
  int                _numberOfNodes;
  int                _numberOfVertexes;
  int                _numberOfConstituentsDimension;
  int*               _numberOfConstituents ;
  int**              _numberOfNodeOfEachConstituent ;
  int***                _constituents ;
  MED_EN::medGeometryElement**  _constituentsType ;

public :

  inline CELLMODEL();
  CELLMODEL(MED_EN::medGeometryElement t);
  inline CELLMODEL(const CELLMODEL &m);
  inline ~CELLMODEL();

  inline CELLMODEL & operator=(const CELLMODEL &m);

  friend MEDMEM_EXPORT ostream & operator<<(ostream &os,const CELLMODEL &my);

  inline string                 getName()             const;

  inline int                    getNumberOfVertexes() const;

  inline int                    getNumberOfNodes()    const;

  inline int                    getDimension()        const;

  inline MED_EN::medGeometryElement     getType()             const;

  int** getConstituents(int dim) const;

  int   getNumberOfConstituents(int dim) const;

  int* getNodesConstituent(int dim,int num) const;

  int getNodeConstituent(int dim,int num,int nodes_index) const;

  MED_EN::medGeometryElement*  getConstituentsType(int dim) const;

  MED_EN::medGeometryElement getConstituentType(int dim,int num) const;

  int getNumberOfConstituentsType() const;

  set<MED_EN::medGeometryElement>  getAllConstituentsType() const;

  map<MED_EN::medGeometryElement,int>  getNumberOfConstituentsForeachType() const;


};

// ------------------------------------------
//      Methodes Inline
// ------------------------------------------

inline CELLMODEL::CELLMODEL():
    _type(MED_EN::MED_NONE),
    _dimension(0),
    _numberOfNodes(0),
    _numberOfVertexes(0),
    _numberOfConstituentsDimension(0),
    _numberOfConstituents((int*)NULL),
    _numberOfNodeOfEachConstituent((int**)NULL),
    _constituents((int***)NULL),
    _constituentsType((MED_EN::medGeometryElement**)NULL)
{
}
inline CELLMODEL::CELLMODEL(const CELLMODEL &m):
    _type(MED_EN::MED_NONE),
    _dimension(0),
    _numberOfNodes(0),
    _numberOfVertexes(0),
    _numberOfConstituentsDimension(0),
    _numberOfConstituents((int*)NULL),
    _numberOfNodeOfEachConstituent((int**)NULL),
    _constituents((int***)NULL),
    _constituentsType((MED_EN::medGeometryElement**)NULL)
{
    init(m) ;
}
inline CELLMODEL::~CELLMODEL() 
{
  //  MESSAGE_MED("CELLMODEL::~CELLMODEL() destroying the cell");
  clean() ;
}
inline CELLMODEL & CELLMODEL::operator=(const CELLMODEL &m) 
{
    clean() ;
    init(m) ;
    return *this ;
}
inline string CELLMODEL::getName() const
{
  return _name ;
}
inline int CELLMODEL::getNumberOfVertexes() const
{
  return _numberOfVertexes;
}
inline int CELLMODEL::getNumberOfNodes() const
{
  return _numberOfNodes;
}
inline int CELLMODEL::getDimension() const
{
  return _dimension;
}
inline MED_EN::medGeometryElement CELLMODEL::getType() const
{
  return _type;
}
inline int** CELLMODEL::getConstituents(int dim) const
{
  return _constituents[dim-1] ;
}
inline int CELLMODEL::getNumberOfConstituents(int dim) const
{
  return _numberOfConstituents[dim-1] ;
}
inline int* CELLMODEL::getNodesConstituent(int dim,int num) const
{
  return _constituents[dim-1][num-1];
}
inline int CELLMODEL::getNodeConstituent(int dim,int num,int nodesNumber) const
{
  return _constituents[dim-1][num-1][nodesNumber-1] ;
}
inline MED_EN::medGeometryElement* CELLMODEL::getConstituentsType(int dim) const
{
  return _constituentsType[dim-1];
}
inline MED_EN::medGeometryElement CELLMODEL::getConstituentType(int dim,int num) const
{
  return _constituentsType[dim-1][num-1];
}

class MEDMEM_EXPORT CELLMODEL_Map
{
public:
  static const MEDMEM::CELLMODEL& retrieveCellModel(MED_EN::medGeometryElement type);
private:
  static CELLMODEL_Map *getInstance();
  static CELLMODEL_Map *_singleton;
  std::map<MED_EN::medGeometryElement,MEDMEM::CELLMODEL> _cell_models;

  CELLMODEL_Map() {}
  ~CELLMODEL_Map(){ if(_singleton) delete _singleton;}

  const MEDMEM::CELLMODEL& getCellModel(MED_EN::medGeometryElement type);

};

}//End of namespace MEDMEM

#endif /* CELLMODEL_HXX */