using namespace MEDCoupling;
+
+std::string MEDFileSEHolder::getModelName() const
+{
+ return _father->getName();
+}
+
+void MEDFileSEHolder::setName(const std::string& name)
+{
+ _name=name;
+}
+
+std::size_t MEDFileSEHolder::getHeapMemorySizeLoc() const
+{
+ return _name.capacity();
+}
+
+////////////////////
+
+MEDFileSEConstAtt *MEDFileSEConstAtt::New(med_idt fid, MEDFileStructureElement *father, int idCstAtt)
+{
+ return new MEDFileSEConstAtt(fid,father,idCstAtt);
+}
+
+MEDFileSEConstAtt::MEDFileSEConstAtt(med_idt fid, MEDFileStructureElement *father, int idCstAtt):MEDFileSEHolder(father)
+{
+ std::string modelName(getModelName());
+ INTERP_KERNEL::AutoPtr<char> constattname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)),profilename(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
+ med_attribute_type constatttype;
+ int nbCompo;
+ med_entity_type met;
+ int pflSz;
+ MEDFILESAFECALLERRD0(MEDstructElementConstAttInfo,(fid,modelName.c_str(),idCstAtt+1,constattname,&constatttype,&nbCompo,&met,profilename,&pflSz));
+ std::string name(MEDLoaderBase::buildStringFromFortran(constattname,MED_NAME_SIZE));
+ setName(name);
+ setProfile(MEDLoaderBase::buildStringFromFortran(profilename,MED_NAME_SIZE));
+ _tof=MEDFileMesh::ConvertFromMEDFileEntity(met);
+ //
+ _val=MEDFileStructureElement::BuildFrom(constatttype);
+ nbCompo=MEDFileStructureElement::EffectiveNbCompo(constatttype,nbCompo);
+ if(pflSz==0 && getProfile().empty())
+ pflSz=1;
+ if(constatttype==MED_ATT_NAME)
+ pflSz++;
+ std::cerr << "******* " << pflSz << std::endl;
+ _val->alloc(pflSz,nbCompo);
+ MEDFILESAFECALLERRD0(MEDstructElementConstAttRd,(fid,modelName.c_str(),name.c_str(),_val->getVoidStarPointer()));
+ if(constatttype==MED_ATT_NAME)
+ { pflSz--; _val->reAlloc(pflSz); }
+}
+
+std::vector<const BigMemoryObject *> MEDFileSEConstAtt::getDirectChildrenWithNull() const
+{
+ std::vector<const BigMemoryObject *> ret;
+ ret.push_back(_val);
+ return ret;
+}
+
+std::size_t MEDFileSEConstAtt::getHeapMemorySizeWithoutChildren() const
+{
+ return getHeapMemorySizeLoc()+_pfl.capacity();
+}
+
+void MEDFileSEConstAtt::writeLL(med_idt fid) const
+{
+}
+
+void MEDFileSEConstAtt::setProfile(const std::string& name)
+{
+ _pfl=name;
+}
+
+std::string MEDFileSEConstAtt::getProfile() const
+{
+ return _pfl;
+}
+
+////////////////////
+
+MEDFileSEVarAtt *MEDFileSEVarAtt::New(med_idt fid, MEDFileStructureElement *father, int idVarAtt)
+{
+ return new MEDFileSEVarAtt(fid,father,idVarAtt);
+}
+
+MEDFileSEVarAtt::MEDFileSEVarAtt(med_idt fid, MEDFileStructureElement *father, int idVarAtt):MEDFileSEHolder(father)
+{
+ std::string modelName(getModelName());
+ INTERP_KERNEL::AutoPtr<char> varattname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)),profilename(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
+ med_attribute_type varatttype;
+ {
+ int pflSz;
+ MEDFILESAFECALLERRD0(MEDstructElementVarAttInfo,(fid,modelName.c_str(),idVarAtt+1,varattname,&varatttype,&_nb_compo));
+ }
+ setName(MEDLoaderBase::buildStringFromFortran(varattname,MED_NAME_SIZE));
+ _gen=MEDFileStructureElement::BuildFrom(varatttype);
+ _gen->alloc(0,1);
+}
+
+std::vector<const BigMemoryObject *> MEDFileSEVarAtt::getDirectChildrenWithNull() const
+{
+ return std::vector<const BigMemoryObject *>();
+}
+
+std::size_t MEDFileSEVarAtt::getHeapMemorySizeWithoutChildren() const
+{
+ return getHeapMemorySizeLoc();
+}
+
+void MEDFileSEVarAtt::writeLL(med_idt fid) const
+{
+}
+
+////////////////////
+
MEDFileStructureElement *MEDFileStructureElement::New(med_idt fid, int idSE)
{
return new MEDFileStructureElement(fid,idSE);
{
med_bool anyPfl;
int nnode(0),ncell(0);
- MEDstructElementInfo(fid,idSE+1,modelName,&_id_type,&_dim,supportMeshName,&entiyType,&nnode,&ncell,&sgeoType,&nConsAttr,&anyPfl,&nVarAttr);
+ MEDFILESAFECALLERRD0(MEDstructElementInfo,(fid,idSE+1,modelName,&_id_type,&_dim,supportMeshName,&entiyType,&nnode,&ncell,&sgeoType,&nConsAttr,&anyPfl,&nVarAttr));
}
- _model_name=MEDLoaderBase::buildStringFromFortran(modelName,MED_NAME_SIZE);
- _geo_type=MEDFileMesh::ConvertFromMEDFile(sgeoType);
+ _name=MEDLoaderBase::buildStringFromFortran(modelName,MED_NAME_SIZE);
+ _geo_type=MEDFileMesh::ConvertFromMEDFileGeoType(sgeoType);
+ _cst_att.resize(nConsAttr);
+ for(int i=0;i<nConsAttr;i++)
+ _cst_att[i]=MEDFileSEConstAtt::New(fid,this,i);
+ _var_att.resize(nVarAttr);
+ for(int i=0;i<nVarAttr;i++)
+ _var_att[i]=MEDFileSEVarAtt::New(fid,this,i);
+}
+
+std::vector<const BigMemoryObject *> MEDFileStructureElement::getDirectChildrenWithNull() const
+{
+ std::vector<const BigMemoryObject *> ret;
+ for(std::vector< MCAuto<MEDFileSEConstAtt> >::const_iterator it=_cst_att.begin();it!=_cst_att.end();it++)
+ ret.push_back(*it);
+ for(std::vector< MCAuto<MEDFileSEVarAtt> >::const_iterator it=_var_att.begin();it!=_var_att.end();it++)
+ ret.push_back(*it);
+ return ret;
+}
+
+std::size_t MEDFileStructureElement::getHeapMemorySizeWithoutChildren() const
+{
+ return _name.capacity()+_cst_att.capacity()*sizeof(MCAuto<MEDFileSEConstAtt>)+_var_att.capacity()*sizeof(MCAuto<MEDFileSEVarAtt>);
}
+void MEDFileStructureElement::writeLL(med_idt fid) const
+{
+}
+
+std::string MEDFileStructureElement::getName() const
+{
+ return _name;
+}
+
+MCAuto<DataArray> MEDFileStructureElement::BuildFrom(med_attribute_type mat)
+{
+ MCAuto<DataArray> ret;
+ switch(mat)
+ {
+ case MED_ATT_INT:
+ {
+ ret=DataArrayInt::New();
+ break;
+ }
+ case MED_ATT_FLOAT64:
+ {
+ ret=DataArrayDouble::New();
+ break;
+ }
+ case MED_ATT_NAME:
+ {
+ ret=DataArrayAsciiChar::New();
+ break;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructureElement::BuildFrom : not recognized type ! Only INT and FLOAT64 !");
+ }
+ return ret;
+}
+
+int MEDFileStructureElement::EffectiveNbCompo(med_attribute_type mat, int nbCompo)
+{
+ switch(mat)
+ {
+ case MED_ATT_INT:
+ case MED_ATT_FLOAT64:
+ return nbCompo;
+ case MED_ATT_NAME:
+ return nbCompo*MED_NAME_SIZE;
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructureElement::BuildFrom : not recognized type ! Only INT and FLOAT64 !");
+ }
+}
+
+////////////////////
+
MEDFileStructureElements *MEDFileStructureElements::New(med_idt fid)
{
return new MEDFileStructureElements(fid);
namespace MEDCoupling
{
+ class MEDFileStructureElement;
+
+ class MEDFileSEHolder
+ {
+ protected:
+ MEDFileSEHolder(MEDFileStructureElement *father):_father(father) { }
+ std::string getModelName() const;
+ void setName(const std::string& name);
+ std::size_t getHeapMemorySizeLoc() const;
+ private:
+ MEDFileStructureElement *_father;
+ std::string _name;
+ };
+
+class MEDFileSEConstAtt : public RefCountObject, public MEDFileWritableStandAlone, public MEDFileSEHolder
+ {
+ public:
+ static MEDFileSEConstAtt *New(med_idt fid, MEDFileStructureElement *father, int idCstAtt);
+ public:
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const;
+ void writeLL(med_idt fid) const;
+ void setProfile(const std::string& name);
+ std::string getProfile() const;
+ private:
+ MEDFileSEConstAtt(med_idt fid, MEDFileStructureElement *father, int idCstAtt);
+ private:
+ std::string _pfl;
+ TypeOfField _tof;
+ MCAuto<DataArray> _val;
+ };
+
+ class MEDFileSEVarAtt : public RefCountObject, public MEDFileWritableStandAlone, public MEDFileSEHolder
+ {
+ public:
+ static MEDFileSEVarAtt *New(med_idt fid, MEDFileStructureElement *father, int idVarAtt);
+ public:
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const;
+ void writeLL(med_idt fid) const;
+ private:
+ MEDFileSEVarAtt(med_idt fid, MEDFileStructureElement *father, int idVarAtt);
+ private:
+ int _nb_compo;
+ MCAuto<DataArray> _gen;
+ };
+
class MEDFileStructureElement : public RefCountObject, public MEDFileWritableStandAlone
{
public:
MEDLOADER_EXPORT static MEDFileStructureElement *New(med_idt fid, int idSE);
+ MEDLOADER_EXPORT std::string getName() const;
public:
std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
std::size_t getHeapMemorySizeWithoutChildren() const;
void writeLL(med_idt fid) const;
+ public:
+ static MCAuto<DataArray> BuildFrom(med_attribute_type mat);
+ static int EffectiveNbCompo(med_attribute_type mat, int nbCompo);
private:
MEDFileStructureElement(med_idt fid, int idSE);
private:
int _id_type;
- std::string _model_name;
+ std::string _name;
INTERP_KERNEL::NormalizedCellType _geo_type;
int _dim;
+ std::vector< MCAuto<MEDFileSEConstAtt> > _cst_att;
+ std::vector< MCAuto<MEDFileSEVarAtt> > _var_att;
};
class MEDFileStructureElements : public RefCountObject, public MEDFileWritableStandAlone
