Source/Base/Statistics/OSGStatCollector.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGStatElemDesc.h"
  49 #include "OSGStatElem.h"
  50
  51 #include "OSGStatCollector.h"
  52
  53 OSG_BEGIN_NAMESPACE
  54
  55 /***************************************************************************\
  56  *                            Description                                  *
  57 \***************************************************************************/
  58
  59 /*! \class OSG::StatCollector
  60
  61     The StatCollector is responsible for managing a set of OSG::StatElem
  62     elements, see \ref PageSystemStatistics for details.
  63 */
  64
  65 /***************************************************************************\
  66  *                         Instance methods                                *
  67 \***************************************************************************/
  68
  69 /*-------------------------------------------------------------------------*\
  70  -  public                                                                -
  71 \*-------------------------------------------------------------------------*/
  72
  73 StatCollector::StatCollector(void) :
  74      Inherited(),
  75     _elemVec  ()
  76 {
  77     refitElemNum();
  78 }
  79
  80 /*! copy constructor
  81  */
  82
  83 StatCollector::StatCollector(const StatCollector &source) :
  84      Inherited(source),
  85     _elemVec  (      )
  86 {
  87     _elemVec.resize(source._elemVec.size());
  88
  89     for(UInt32 i = 0; i < source._elemVec.size(); ++i)
  90     {
  91         if(source._elemVec[i])
  92         {
  93             _elemVec[i] = source._elemVec[i]->clone();
  94         }
  95         else
  96         {
  97             _elemVec[i] = NULL;
  98         }
  99     }
 100 }
 101
 102 StatCollector *StatCollector::create(void)
 103 {
 104     return new StatCollector();
 105 }
 106
 107 StatCollector::~StatCollector(void)
 108 {
 109     for(UInt32 i = 0; i < _elemVec.size(); ++i)
 110         delete _elemVec[i];
 111 }
 112
 113 /*-------------------------- your_category---------------------------------*/
 114
 115 /*! Increase the size of the StatCollector's data array. This is called during
 116     construction and will only be needed later, when a new StatElem has been
 117     added after the StatCollector was instanced. This will very rarely be the
 118     case.
 119  */
 120 void StatCollector::refitElemNum(void)
 121 {
 122     SizeT eN = _elemVec.size();
 123     SizeT dN = StatElemDescBase::getNumOfDescs();
 124
 125     if(eN != dN)
 126     {
 127         _elemVec.resize(dN, 0);
 128     }
 129 }
 130
 131 /*! Convert the current contents into a string. This
 132     string can be used as a compact representation of the data, and as input
 133     for StatCollector::getFromString.
 134  */
 135 void StatCollector::putToString(std::string &str) const
 136 {
 137     bool first = true;
 138
 139     str = "{";
 140
 141     StatElemStoreConstIt it    = _elemVec.begin();
 142     StatElemStoreConstIt endIt = _elemVec.end();
 143
 144     for(; it != endIt; ++it)
 145     {
 146         if(*it != NULL)
 147         {
 148             std::string elem;
 149
 150             if(!first)
 151                 str.append("|");
 152
 153             str.append((*it)->getDesc()->getName().c_str());
 154             str.append("=");
 155             (*it)->putToString(elem);
 156             str.append(elem);
 157             first = false;
 158         }
 159     }
 160     str.append("}");
 161 }
 162
 163
 164 /*! Set the contents from a string. The string has to have the format that is
 165     used by StatCollector::putToString.
 166  */
 167 bool StatCollector::getFromCString(const Char8 *&inVal)
 168 {
 169     const Char8 *c = inVal;
 170
 171     if(*c++ != '{')
 172         return false;
 173
 174     StatElemDescBase *desc;
 175     StatElem *elem;
 176
 177     clearElems();
 178
 179     while(*c && *c != '}')
 180     {
 181         const Char8 *end = c;
 182
 183         while(*end != 0 && *end != '=' && *end != '}' && *end != '|')
 184             end++;
 185
 186         if(*end == 0 || *end == '}' || *end == '|')
 187             return false;
 188
 189         std::string name(c, end - c);
 190         desc = StatElemDescBase::findDescByName(name.c_str());
 191
 192         if(!desc)
 193             return false;
 194
 195         elem = getElem(*desc);
 196
 197         c = end = end + 1;
 198         while(*end != 0 && *end != '}' && *end != '|')
 199             end++;
 200
 201         if(*end == 0)
 202             return false;
 203
 204         std::string val(c, end - c);
 205         const Char8 *valp = val.c_str();
 206         if(!elem->getFromCString(valp))
 207             return false;
 208
 209         c = end + 1;
 210     }
 211     return true;
 212 }
 213
 214 /*! Get the value of the named element, if it exists, return false if not.
 215  */
 216
 217 bool StatCollector::getValue(std::string &name, Real64 &val)
 218 {
 219     StatElemDescBase *desc = StatElemDescBase::findDescByName(name.c_str());
 220
 221     if(!desc)
 222         return false;
 223
 224     StatElem *el = getElem(*desc, false);
 225
 226     if(!el)
 227         return false;
 228
 229     val = el->getValue();
 230
 231     return true;
 232 }
 233
 234 /*! Remove all elements from the collector.
 235  */
 236 void StatCollector::clearElems(void)
 237 {
 238     StatElemStoreIt      it    = _elemVec.begin();
 239     StatElemStoreConstIt endIt = _elemVec.end();
 240
 241     for(; it != endIt; ++it)
 242     {
 243         if(*it != NULL)
 244         {
 245             delete *it;
 246
 247             *it = NULL;
 248         }
 249     }
 250     _elemVec.clear();
 251 }
 252
 253 /*! Reset all elements to the start value.
 254  */
 255 void StatCollector::reset(StatElemDescBase::ResetMode mode)
 256 {
 257     StatElemStoreIt      it    = _elemVec.begin();
 258     StatElemStoreConstIt endIt = _elemVec.end();
 259
 260     for(; it != endIt; ++it)
 261     {
 262         if(*it != NULL && (*it)->getDesc()->getResetMode() >= mode)
 263         {
 264             (*it)->reset();
 265         }
 266     }
 267 }
 268
 269 /*-------------------------- assignment -----------------------------------*/
 270
 271 const StatCollector &StatCollector::operator = (const StatCollector &source)
 272 {
 273     if(this == &source)
 274         return *this;
 275
 276     _elemVec = source._elemVec;
 277
 278     return *this;
 279 }
 280
 281 /*-------------------------- comparison -----------------------------------*/
 282
 283 /*! The comparison is only done on the addresses, as a real comparison is not
 284     well defined on a StatCollector.
 285  */
 286 bool StatCollector::operator < (const StatCollector &other) const
 287 {
 288     return this < &other;
 289 }
 290
 291 bool StatCollector::operator == (const StatCollector &rhs  ) const
 292 {
 293     return false;
 294 }
 295
 296 StatCollector StatCollector::operator + (const StatCollector &other)
 297 {
 298     StatCollector res(*this);
 299
 300     res += other;
 301
 302     return res;
 303 }
 304
 305 StatCollector &StatCollector::operator += (const StatCollector &other)
 306 {
 307     if(other._elemVec.size() > _elemVec.size())
 308     {
 309         _elemVec.resize(other._elemVec.size());
 310     }
 311
 312     for(UInt32 i = 0; i < _elemVec.size(); ++i)
 313     {
 314         if(_elemVec[i])
 315         {
 316             *_elemVec[i] += *other._elemVec[i];
 317         }
 318     }
 319
 320     return *this;
 321 }
 322
 323 OSG_END_NAMESPACE
 324
 325 #include "OSGSField.h"
 326 #include "OSGSField.ins"
 327
 328 #include "OSGMField.h"
 329 #include "OSGMField.ins"
 330
 331 #include "OSGFieldContainer.h"
 332
 333 OSG_BEGIN_NAMESPACE
 334
 335 #ifndef OSG_DO_DOC
 336
 337 /*-------------------------- field instantiations -------------------------*/
 338
 339 DataType FieldTraits<StatCollectorP>::_type("StatCollectorP",
 340                                             "TypeRoot");
 341
 342
 343 DataType &FieldTraits<StatCollectorP>::getType(void)
 344 {
 345     return _type;
 346 }
 347 #endif
 348
 349 OSG_FIELD_DLLEXPORT_DEF1(SField, StatCollectorP)
 350
 351 OSG_END_NAMESPACE
 352