src/MEDCoupling/MEDCouplingRefCountObject.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDCouplingRefCountObject.hxx"
  22 #include "MEDCoupling_version.h"
  23 #include "MCType.hxx"
  24
  25 #include "InterpKernelException.hxx"
  26
  27 #include <sstream>
  28 #include <algorithm>
  29
  30 using namespace MEDCoupling;
  31
  32 GlobalDict *GlobalDict::UNIQUE_INSTANCE=0;
  33
  34 const char *MEDCoupling::MEDCouplingVersionStr()
  35 {
  36   return MEDCOUPLING_VERSION_STR;
  37 }
  38
  39 int MEDCoupling::MEDCouplingVersion()
  40 {
  41   return MEDCOUPLING_VERSION;
  42 }
  43
  44 void MEDCoupling::MEDCouplingVersionMajMinRel(int& maj, int& minor, int& releas)
  45 {
  46   int ver=MEDCOUPLING_VERSION;
  47   maj=(ver & 0xFF0000) >> 16;
  48   minor=(ver & 0xFF00) >> 8;
  49   releas=(ver & 0xFF);
  50 }
  51
  52 int MEDCoupling::MEDCouplingSizeOfVoidStar()
  53 {
  54   return 8*sizeof(std::size_t);
  55 }
  56
  57 std::size_t MEDCoupling::MEDCouplingSizeOfIDs()
  58 {
  59   return 8*sizeof(mcIdType);
  60 }
  61
  62 /*!
  63  * If true is returned it is a LittleEndian machine.
  64  * If false it is a BigEndian machine.
  65  * \return the coding mode of integers of the machine.
  66  */
  67 bool MEDCoupling::MEDCouplingByteOrder()
  68 {
  69   unsigned int x(1);
  70   unsigned char *xc(reinterpret_cast<unsigned char *>(&x));
  71   return xc[0]==1;
  72 }
  73
  74 const char *MEDCoupling::MEDCouplingByteOrderStr()
  75 {
  76   static const char LITTLEENDIAN_STR[]="LittleEndian";
  77   static const char BIGENDIAN_STR[]="BigEndian";
  78   if(MEDCouplingByteOrder())
  79     return LITTLEENDIAN_STR;
  80   else
  81     return BIGENDIAN_STR;
  82 }
  83
  84 bool MEDCoupling::IsCXX11Compiled()
  85 {
  86   return true;
  87 }
  88
  89 //=
  90
  91 std::size_t BigMemoryObject::getHeapMemorySize() const
  92 {
  93   std::size_t ret(getHeapMemorySizeWithoutChildren());
  94   std::vector<const BigMemoryObject *> v(getDirectChildren());
  95   std::set<const BigMemoryObject *> s1,s2(v.begin(),v.end());
  96   return ret+GetHeapMemoryOfSet(s1,s2);
  97 }
  98
  99 /*!
 100  * This method returns all the progeny of \a this (this is \b not included in returned vector).
 101  * All the progeny means all the subobjects (children), subsubobjects (little children), ... of \a this.
 102  * The elements in returned array are reported only once even if they appear several times in the progeny of \a this.
 103  */
 104 std::vector<const BigMemoryObject *> BigMemoryObject::getAllTheProgeny() const
 105 {
 106   std::vector<const BigMemoryObject *> s1(getDirectChildren());
 107   std::vector<const BigMemoryObject *> ret;
 108   while(!s1.empty())
 109     {
 110       ret.insert(ret.end(),s1.begin(),s1.end());
 111       std::vector<const BigMemoryObject *> s3;
 112       for(std::vector<const BigMemoryObject *>::const_iterator it0=s1.begin();it0!=s1.end();it0++)
 113         {
 114           std::vector<const BigMemoryObject *> s2;
 115           if(*it0)
 116             s2=(*it0)->getDirectChildren();
 117           for(std::vector<const BigMemoryObject *>::const_iterator it1=s2.begin();it1!=s2.end();it1++)
 118             {
 119               if(*it1)
 120                 if(std::find(ret.begin(),ret.end(),*it1)==ret.end())
 121                   s3.push_back(*it1);
 122             }
 123         }
 124       s1=s3;
 125     }
 126   return ret;
 127 }
 128
 129 /*!
 130  * This method scan all the progeny of \a this (\a this excluded) to see if \a obj is part of it.
 131  * If obj is NULL false is returned.
 132  * \sa BigMemoryObject::getAllTheProgeny
 133  */
 134 bool BigMemoryObject::isObjectInTheProgeny(const BigMemoryObject *obj) const
 135 {
 136   if(!obj)
 137     return false;
 138   std::vector<const BigMemoryObject *> objs(getAllTheProgeny());
 139   return std::find(objs.begin(),objs.end(),obj)!=objs.end();
 140 }
 141
 142 std::size_t BigMemoryObject::GetHeapMemorySizeOfObjs(const std::vector<const BigMemoryObject *>& objs)
 143 {
 144   std::size_t ret(0);
 145   std::set<const BigMemoryObject *> s1,s2;
 146   for(std::vector<const BigMemoryObject *>::const_iterator it0=objs.begin();it0!=objs.end();it0++)
 147     {
 148       if(*it0)
 149         if(s1.find(*it0)==s1.end())
 150           {
 151             std::vector<const BigMemoryObject *> vTmp((*it0)->getDirectChildren());
 152             s2.insert(vTmp.begin(),vTmp.end());
 153             ret+=(*it0)->getHeapMemorySizeWithoutChildren();
 154             s1.insert(*it0);
 155           }
 156     }
 157   return ret+GetHeapMemoryOfSet(s1,s2);
 158 }
 159
 160 std::size_t BigMemoryObject::GetHeapMemoryOfSet(std::set<const BigMemoryObject *>& s1, std::set<const BigMemoryObject *>& s2)
 161 {
 162   std::size_t ret(0);
 163   while(!s2.empty())
 164     {
 165       std::set<const BigMemoryObject *> s3;
 166       for(std::set<const BigMemoryObject *>::const_iterator it=s2.begin();it!=s2.end();it++)
 167         {
 168           if(s1.find(*it)==s1.end())
 169             {
 170               ret+=(*it)->getHeapMemorySizeWithoutChildren();
 171               s1.insert(*it);
 172               std::vector<const BigMemoryObject *> v2((*it)->getDirectChildren());
 173               for(std::vector<const BigMemoryObject *>::const_iterator it2=v2.begin();it2!=v2.end();it2++)
 174                 if(s1.find(*it2)==s1.end())
 175                   s3.insert(*it2);
 176             }
 177         }
 178       s2=s3;
 179     }
 180   return ret;
 181 }
 182
 183 std::string BigMemoryObject::getHeapMemorySizeStr() const
 184 {
 185   static const char *UNITS[4]={"B","kB","MB","GB"};
 186   std::size_t m(getHeapMemorySize());
 187   std::ostringstream oss; oss.precision(3);
 188   std::size_t remain(0);
 189   int i(0);
 190   for(;i<4;i++)
 191     {
 192       if(m<1024)
 193         {
 194           oss << m;
 195           if(remain!=0)
 196             {
 197               std::ostringstream oss2; oss2 << std::fixed << ((double)remain)/1024.;
 198               std::string s(oss2.str());
 199               s=s.substr(1,4);
 200               std::size_t pos(s.find_last_not_of('0'));
 201               if(pos==4)
 202                 oss << s;
 203               else
 204                 oss << s.substr(0,pos+1);
 205             }
 206           oss << " " << UNITS[i];
 207           break;
 208         }
 209       else
 210         {
 211           if(i!=3)
 212             {
 213               remain=(m%1024);
 214               m/=1024;
 215             }
 216         }
 217     }
 218   if(i==4)
 219     oss << m << " " << UNITS[3];
 220   return oss.str();
 221 }
 222
 223 std::vector<const BigMemoryObject *> BigMemoryObject::getDirectChildren() const
 224 {
 225   std::vector<const BigMemoryObject *> ret;
 226   std::vector<const BigMemoryObject *> retWithNull(getDirectChildrenWithNull());
 227   for(std::vector<const BigMemoryObject *>::const_iterator it=retWithNull.begin();it!=retWithNull.end();it++)
 228     if(*it)
 229       ret.push_back(*it);
 230   return ret;
 231 }
 232
 233 BigMemoryObject::~BigMemoryObject()
 234 {
 235 }
 236
 237 //=
 238
 239 RefCountObjectOnly::RefCountObjectOnly():_cnt(1)
 240 {
 241 }
 242
 243 RefCountObjectOnly::RefCountObjectOnly(const RefCountObjectOnly& other):_cnt(1)
 244 {
 245 }
 246
 247 bool RefCountObjectOnly::decrRef() const
 248 {
 249   bool ret=((--_cnt)==0);
 250   if(ret)
 251     delete this;
 252   return ret;
 253 }
 254
 255 void RefCountObjectOnly::incrRef() const
 256 {
 257   _cnt++;
 258 }
 259
 260 int RefCountObjectOnly::getRCValue() const
 261 {
 262   return _cnt;
 263 }
 264
 265 RefCountObjectOnly::~RefCountObjectOnly()
 266 {
 267 }
 268
 269 /*!
 270  * Do nothing here ! It is not a bug ( I hope :) ) because all subclasses that
 271  * copies using operator= should not copy the ref counter of \a other !
 272  */
 273 RefCountObjectOnly& RefCountObjectOnly::operator=(const RefCountObjectOnly& other)
 274 {
 275   return *this;
 276 }
 277
 278 //=
 279
 280 RefCountObject::RefCountObject()
 281 {
 282 }
 283
 284 RefCountObject::RefCountObject(const RefCountObject& other):RefCountObjectOnly(other)
 285 {
 286 }
 287
 288 RefCountObject::~RefCountObject()
 289 {
 290 }
 291
 292 //=
 293
 294 GlobalDict *GlobalDict::GetInstance()
 295 {
 296   if(!UNIQUE_INSTANCE)
 297     UNIQUE_INSTANCE=new GlobalDict;
 298   return UNIQUE_INSTANCE;
 299 }
 300
 301 bool GlobalDict::hasKey(const std::string& key) const
 302 {
 303   std::map<std::string, std::string>::const_iterator it(_my_map.find(key));
 304   return it!=_my_map.end();
 305 }
 306
 307 std::string GlobalDict::value(const std::string& key) const
 308 {
 309   std::map<std::string, std::string>::const_iterator it(_my_map.find(key));
 310   if(it==_my_map.end())
 311     {
 312       std::ostringstream oss;
 313       oss << "GlobalDict::value : key \"" << key << "\" is not in map !";
 314       throw INTERP_KERNEL::Exception(oss.str().c_str());
 315     }
 316   return (*it).second;
 317 }
 318
 319 std::vector<std::string> GlobalDict::keys() const
 320 {
 321   std::vector<std::string> ret;
 322   for(std::map<std::string, std::string>::const_iterator it=_my_map.begin();it!=_my_map.end();it++)
 323     ret.push_back((*it).first);
 324   return ret;
 325 }
 326
 327 void GlobalDict::erase(const std::string& key)
 328 {
 329   std::map<std::string, std::string>::iterator it(_my_map.find(key));
 330   if(it==_my_map.end())
 331     {
 332       std::ostringstream oss;
 333       oss << "GlobalDict::erase : key \"" << key << "\" is not in map !";
 334       throw INTERP_KERNEL::Exception(oss.str().c_str());
 335     }
 336   _my_map.erase(it);
 337 }
 338
 339 void GlobalDict::clear()
 340 {
 341   _my_map.clear();
 342 }
 343
 344 void GlobalDict::setKeyValue(const std::string& key, const std::string& val)
 345 {
 346   std::map<std::string, std::string>::const_iterator it(_my_map.find(key));
 347   if(it!=_my_map.end())
 348     {
 349       std::ostringstream oss;
 350       oss << "GlobalDict::setKeyValue : key \"" << key << "\" already exists !";
 351       throw INTERP_KERNEL::Exception(oss.str().c_str());
 352     }
 353   _my_map[key]=val;
 354 }
 355
 356 void GlobalDict::setKeyValueForce(const std::string& key, const std::string& val)
 357 {
 358   _my_map[key]=val;
 359 }
 360
 361 std::string GlobalDict::printSelf() const
 362 {
 363   std::ostringstream oss;
 364   for(std::map<std::string, std::string>::const_iterator it=_my_map.begin();it!=_my_map.end();it++)
 365     {
 366       oss << "(" << (*it).first << "," << (*it).second << ")" << std::endl;
 367     }
 368   return oss.str();
 369 }