X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling%2FMEDCouplingRefCountObject.cxx;h=b7e08b45aa54556587edca3bd70a1e51899e9c7e;hb=e7835cba1eb17f50ef4e130c2cb8d0f54bc25083;hp=49d954f8e217cd25a4692976e8409cdd75b27bd0;hpb=2bfeb4634e57f1036cb10eedd35ac75b3a2249fa;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling/MEDCouplingRefCountObject.cxx b/src/MEDCoupling/MEDCouplingRefCountObject.cxx index 49d954f8e..b7e08b45a 100644 --- a/src/MEDCoupling/MEDCouplingRefCountObject.cxx +++ b/src/MEDCoupling/MEDCouplingRefCountObject.cxx @@ -1,9 +1,9 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D +// Copyright (C) 2007-2016 CEA/DEN, EDF R&D // // 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. +// version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,32 +19,36 @@ // Author : Anthony Geay (CEA/DEN) #include "MEDCouplingRefCountObject.hxx" -#include "MED_version.h" +#include "MEDCoupling_version.h" + +#include "InterpKernelException.hxx" #include -#include +#include + +using namespace MEDCoupling; -using namespace ParaMEDMEM; +GlobalDict *GlobalDict::UNIQUE_INSTANCE=0; -const char *ParaMEDMEM::MEDCouplingVersionStr() +const char *MEDCoupling::MEDCouplingVersionStr() { - return SALOMEMED_VERSION_STR; + return MEDCOUPLING_VERSION_STR; } -int ParaMEDMEM::MEDCouplingVersion() +int MEDCoupling::MEDCouplingVersion() { - return SALOMEMED_VERSION; + return MEDCOUPLING_VERSION; } -void ParaMEDMEM::MEDCouplingVersionMajMinRel(int& maj, int& minor, int& releas) +void MEDCoupling::MEDCouplingVersionMajMinRel(int& maj, int& minor, int& releas) { - int ver=SALOMEMED_VERSION; + int ver=MEDCOUPLING_VERSION; maj=(ver & 0xFF0000) >> 16; minor=(ver & 0xFF00) >> 8; releas=(ver & 0xFF); } -int ParaMEDMEM::MEDCouplingSizeOfVoidStar() +int MEDCoupling::MEDCouplingSizeOfVoidStar() { return 8*sizeof(std::size_t); } @@ -54,14 +58,14 @@ int ParaMEDMEM::MEDCouplingSizeOfVoidStar() * If false it is a BigEndian machine. * \return the coding mode of integers of the machine. */ -bool ParaMEDMEM::MEDCouplingByteOrder() +bool MEDCoupling::MEDCouplingByteOrder() { unsigned int x(1); unsigned char *xc(reinterpret_cast(&x)); return xc[0]==1; } -const char *ParaMEDMEM::MEDCouplingByteOrderStr() +const char *MEDCoupling::MEDCouplingByteOrderStr() { static const char LITTLEENDIAN_STR[]="LittleEndian"; static const char BIGENDIAN_STR[]="BigEndian"; @@ -71,39 +75,100 @@ const char *ParaMEDMEM::MEDCouplingByteOrderStr() return BIGENDIAN_STR; } -RefCountObject::RefCountObject():_cnt(1) +bool MEDCoupling::IsCXX11Compiled() { +#if __cplusplus >= 201103L + return true; +#else + return false; +#endif } -RefCountObject::RefCountObject(const RefCountObject& other):_cnt(1) +//= + +std::size_t BigMemoryObject::getHeapMemorySize() const { + std::size_t ret(getHeapMemorySizeWithoutChildren()); + std::vector v(getDirectChildren()); + std::set s1,s2(v.begin(),v.end()); + return ret+GetHeapMemoryOfSet(s1,s2); } /*! - * Do nothing here ! It is not a bug ( I hope :) ) because all subclasses that - * copies using operator= should not copy the ref counter of \a other ! + * This method returns all the progeny of \a this (this is \b not included in returned vector). + * All the progeny means all the subobjects (children), subsubobjects (little children), ... of \a this. + * The elements in returned array are reported only once even if they appear several times in the progeny of \a this. */ -RefCountObject& RefCountObject::operator=(const RefCountObject& other) +std::vector BigMemoryObject::getAllTheProgeny() const { - return *this; + std::vector s1(getDirectChildren()); + std::vector ret; + while(!s1.empty()) + { + ret.insert(ret.end(),s1.begin(),s1.end()); + std::vector s3; + for(std::vector::const_iterator it0=s1.begin();it0!=s1.end();it0++) + { + std::vector s2; + if(*it0) + s2=(*it0)->getDirectChildren(); + for(std::vector::const_iterator it1=s2.begin();it1!=s2.end();it1++) + { + if(*it1) + if(std::find(ret.begin(),ret.end(),*it1)==ret.end()) + s3.push_back(*it1); + } + } + s1=s3; + } + return ret; } -std::size_t RefCountObject::getHeapMemorySize() const +/*! + * This method scan all the progeny of \a this (\a this excluded) to see if \a obj is part of it. + * If obj is NULL false is returned. + * \sa BigMemoryObject::getAllTheProgeny + */ +bool BigMemoryObject::isObjectInTheProgeny(const BigMemoryObject *obj) const { - std::size_t ret(getHeapMemorySizeWithoutChildren()); - std::vector v(getDirectChildren()); - std::set s1,s2(v.begin(),v.end()); + if(!obj) + return false; + std::vector objs(getAllTheProgeny()); + return std::find(objs.begin(),objs.end(),obj)!=objs.end(); +} + +std::size_t BigMemoryObject::GetHeapMemorySizeOfObjs(const std::vector& objs) +{ + std::size_t ret(0); + std::set s1,s2; + for(std::vector::const_iterator it0=objs.begin();it0!=objs.end();it0++) + { + if(*it0) + if(s1.find(*it0)==s1.end()) + { + std::vector vTmp((*it0)->getDirectChildren()); + s2.insert(vTmp.begin(),vTmp.end()); + ret+=(*it0)->getHeapMemorySizeWithoutChildren(); + s1.insert(*it0); + } + } + return ret+GetHeapMemoryOfSet(s1,s2); +} + +std::size_t BigMemoryObject::GetHeapMemoryOfSet(std::set& s1, std::set& s2) +{ + std::size_t ret(0); while(!s2.empty()) { - std::set s3; - for(std::set::const_iterator it=s2.begin();it!=s2.end();it++) + std::set s3; + for(std::set::const_iterator it=s2.begin();it!=s2.end();it++) { if(s1.find(*it)==s1.end()) { ret+=(*it)->getHeapMemorySizeWithoutChildren(); s1.insert(*it); - std::vector v2((*it)->getDirectChildren()); - for(std::vector::const_iterator it2=v2.begin();it2!=v2.end();it2++) + std::vector v2((*it)->getDirectChildren()); + for(std::vector::const_iterator it2=v2.begin();it2!=v2.end();it2++) if(s1.find(*it2)==s1.end()) s3.insert(*it2); } @@ -113,7 +178,7 @@ std::size_t RefCountObject::getHeapMemorySize() const return ret; } -std::string RefCountObject::getHeapMemorySizeStr() const +std::string BigMemoryObject::getHeapMemorySizeStr() const { static const char *UNITS[4]={"B","kB","MB","GB"}; std::size_t m(getHeapMemorySize()); @@ -153,7 +218,31 @@ std::string RefCountObject::getHeapMemorySizeStr() const return oss.str(); } -bool RefCountObject::decrRef() const +std::vector BigMemoryObject::getDirectChildren() const +{ + std::vector ret; + std::vector retWithNull(getDirectChildrenWithNull()); + for(std::vector::const_iterator it=retWithNull.begin();it!=retWithNull.end();it++) + if(*it) + ret.push_back(*it); + return ret; +} + +BigMemoryObject::~BigMemoryObject() +{ +} + +//= + +RefCountObjectOnly::RefCountObjectOnly():_cnt(1) +{ +} + +RefCountObjectOnly::RefCountObjectOnly(const RefCountObjectOnly& other):_cnt(1) +{ +} + +bool RefCountObjectOnly::decrRef() const { bool ret=((--_cnt)==0); if(ret) @@ -161,16 +250,118 @@ bool RefCountObject::decrRef() const return ret; } -void RefCountObject::incrRef() const +void RefCountObjectOnly::incrRef() const { _cnt++; } -int RefCountObject::getRCValue() const +int RefCountObjectOnly::getRCValue() const { return _cnt; } +RefCountObjectOnly::~RefCountObjectOnly() +{ +} + +/*! + * Do nothing here ! It is not a bug ( I hope :) ) because all subclasses that + * copies using operator= should not copy the ref counter of \a other ! + */ +RefCountObjectOnly& RefCountObjectOnly::operator=(const RefCountObjectOnly& other) +{ + return *this; +} + +//= + +RefCountObject::RefCountObject() +{ +} + +RefCountObject::RefCountObject(const RefCountObject& other):RefCountObjectOnly(other) +{ +} + RefCountObject::~RefCountObject() { } + +//= + +GlobalDict *GlobalDict::GetInstance() +{ + if(!UNIQUE_INSTANCE) + UNIQUE_INSTANCE=new GlobalDict; + return UNIQUE_INSTANCE; +} + +bool GlobalDict::hasKey(const std::string& key) const +{ + std::map::const_iterator it(_my_map.find(key)); + return it!=_my_map.end(); +} + +std::string GlobalDict::value(const std::string& key) const +{ + std::map::const_iterator it(_my_map.find(key)); + if(it==_my_map.end()) + { + std::ostringstream oss; + oss << "GlobalDict::value : key \"" << key << "\" is not in map !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + return (*it).second; +} + +std::vector GlobalDict::keys() const +{ + std::vector ret; + for(std::map::const_iterator it=_my_map.begin();it!=_my_map.end();it++) + ret.push_back((*it).first); + return ret; +} + +void GlobalDict::erase(const std::string& key) +{ + std::map::iterator it(_my_map.find(key)); + if(it==_my_map.end()) + { + std::ostringstream oss; + oss << "GlobalDict::erase : key \"" << key << "\" is not in map !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + _my_map.erase(it); +} + +void GlobalDict::clear() +{ + _my_map.clear(); +} + +void GlobalDict::setKeyValue(const std::string& key, const std::string& val) +{ + std::map::const_iterator it(_my_map.find(key)); + if(it!=_my_map.end()) + { + std::ostringstream oss; + oss << "GlobalDict::setKeyValue : key \"" << key << "\" already exists !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + _my_map[key]=val; +} + +void GlobalDict::setKeyValueForce(const std::string& key, const std::string& val) +{ + _my_map[key]=val; +} + +std::string GlobalDict::printSelf() const +{ + std::ostringstream oss; + for(std::map::const_iterator it=_my_map.begin();it!=_my_map.end();it++) + { + oss << "(" << (*it).first << "," << (*it).second << ")" << std::endl; + } + return oss.str(); +}