src/MEDCoupling/MEDCouplingRefCountObject.cxx

   1 // Copyright (C) 2007-2013  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.
   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 "MED_version.h"
  23
  24 #include <sstream>
  25 #include <set>
  26
  27 using namespace ParaMEDMEM;
  28
  29 const char *ParaMEDMEM::MEDCouplingVersionStr()
  30 {
  31   return SALOMEMED_VERSION_STR;
  32 }
  33
  34 int ParaMEDMEM::MEDCouplingVersion()
  35 {
  36   return SALOMEMED_VERSION;
  37 }
  38
  39 void ParaMEDMEM::MEDCouplingVersionMajMinRel(int& maj, int& minor, int& releas)
  40 {
  41   int ver=SALOMEMED_VERSION;
  42   maj=(ver & 0xFF0000) >> 16;
  43   minor=(ver & 0xFF00) >> 8;
  44   releas=(ver & 0xFF);
  45 }
  46
  47 int ParaMEDMEM::MEDCouplingSizeOfVoidStar()
  48 {
  49   return 8*sizeof(std::size_t);
  50 }
  51
  52 /*!
  53  * If true is returned it is a LittleEndian machine.
  54  * If false it is a BigEndian machine.
  55  * \return the coding mode of integers of the machine.
  56  */
  57 bool ParaMEDMEM::MEDCouplingByteOrder()
  58 {
  59   unsigned int x(1);
  60   unsigned char *xc(reinterpret_cast<unsigned char *>(&x));
  61   return xc[0]==1;
  62 }
  63
  64 const char *ParaMEDMEM::MEDCouplingByteOrderStr()
  65 {
  66   static const char LITTLEENDIAN_STR[]="LittleEndian";
  67   static const char BIGENDIAN_STR[]="BigEndian";
  68   if(MEDCouplingByteOrder())
  69     return LITTLEENDIAN_STR;
  70   else
  71     return BIGENDIAN_STR;
  72 }
  73
  74 RefCountObject::RefCountObject():_cnt(1)
  75 {
  76 }
  77
  78 RefCountObject::RefCountObject(const RefCountObject& other):_cnt(1)
  79 {
  80 }
  81
  82 /*!
  83  * Do nothing here ! It is not a bug ( I hope :) ) because all subclasses that
  84  * copies using operator= should not copy the ref counter of \a other !
  85  */
  86 RefCountObject& RefCountObject::operator=(const RefCountObject& other)
  87 {
  88   return *this;
  89 }
  90
  91 std::size_t RefCountObject::getHeapMemorySize() const
  92 {
  93   std::size_t ret(getHeapMemorySizeWithoutChildren());
  94   std::vector<RefCountObject *> v(getDirectChildren());
  95   std::set<RefCountObject *> s1,s2(v.begin(),v.end());
  96   while(!s2.empty())
  97     {
  98       std::set<RefCountObject *> s3;
  99       for(std::set<RefCountObject *>::const_iterator it=s2.begin();it!=s2.end();it++)
 100         {
 101           if(s1.find(*it)==s1.end())
 102             {
 103               ret+=(*it)->getHeapMemorySizeWithoutChildren();
 104               s1.insert(*it);
 105               std::vector<RefCountObject *> v2((*it)->getDirectChildren());
 106               for(std::vector<RefCountObject *>::const_iterator it2=v2.begin();it2!=v2.end();it2++)
 107                 if(s1.find(*it2)==s1.end())
 108                   s3.insert(*it2);
 109             }
 110         }
 111       s2=s3;
 112     }
 113   return ret;
 114 }
 115
 116 std::string RefCountObject::getHeapMemorySizeStr() const
 117 {
 118   static const char *UNITS[4]={"B","kB","MB","GB"};
 119   std::size_t m(getHeapMemorySize());
 120   std::ostringstream oss; oss.precision(3);
 121   std::size_t remain(0);
 122   int i(0);
 123   for(;i<4;i++)
 124     {
 125       if(m<1024)
 126         {
 127           oss << m;
 128           if(remain!=0)
 129             {
 130               std::ostringstream oss2; oss2 << std::fixed << ((double)remain)/1024.;
 131               std::string s(oss2.str());
 132               s=s.substr(1,4);
 133               std::size_t pos(s.find_last_not_of('0'));
 134               if(pos==4)
 135                 oss << s;
 136               else
 137                 oss << s.substr(0,pos+1);
 138             }
 139           oss << " " << UNITS[i];
 140           break;
 141         }
 142       else
 143         {
 144           if(i!=3)
 145             {
 146               remain=(m%1024);
 147               m/=1024;
 148             }
 149         }
 150     }
 151   if(i==4)
 152     oss << m << " " << UNITS[3];
 153   return oss.str();
 154 }
 155
 156 bool RefCountObject::decrRef() const
 157 {
 158   bool ret=((--_cnt)==0);
 159   if(ret)
 160     delete this;
 161   return ret;
 162 }
 163
 164 void RefCountObject::incrRef() const
 165 {
 166   _cnt++;
 167 }
 168
 169 int RefCountObject::getRCValue() const
 170 {
 171   return _cnt;
 172 }
 173
 174 RefCountObject::~RefCountObject()
 175 {
 176 }