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 {
  76     refitElemNum();
  77 }
  78
  79 /*! copy constructor
  80  */
  81
  82 StatCollector::StatCollector(const StatCollector &source) :
  83      Inherited(source),
  84     _elemVec  (      )
  85 {
  86     _elemVec.resize(source._elemVec.size());
  87
  88     for(UInt32 i = 0; i < source._elemVec.size(); ++i)
  89     {
  90         if(source._elemVec[i])
  91         {
  92             _elemVec[i] = source._elemVec[i]->clone();
  93         }
  94         else
  95         {
  96             _elemVec[i] = NULL;
  97         }
  98     }
  99 }
 100
 101 StatCollector *StatCollector::create(void)
 102 {
 103     return new StatCollector();
 104 }
 105
 106 StatCollector::~StatCollector(void)
 107 {
 108     for(UInt32 i = 0; i < _elemVec.size(); ++i)
 109         delete _elemVec[i];
 110 }
 111
 112 /*-------------------------- your_category---------------------------------*/
 113
 114 /*! Increase the size of the StatCollector's data array. This is called during
 115     construction and will only be needed later, when a new StatElem has been
 116     added after the StatCollector was instanced. This will very rarely be the
 117     case.
 118  */
 119 void StatCollector::refitElemNum(void)
 120 {
 121     SizeT eN = _elemVec.size();
 122     SizeT dN = StatElemDescBase::getNumOfDescs();
 123
 124     if(eN != dN)
 125     {
 126         _elemVec.resize(dN, 0);
 127     }
 128 }
 129
 130 /*! Convert the current contents into a string. This
 131     string can be used as a compact representation of the data, and as input
 132     for StatCollector::getFromString.
 133  */
 134 void StatCollector::putToString(std::string &str) const
 135 {
 136     bool first = true;
 137
 138     str = "{";
 139
 140     StatElemStoreConstIt it    = _elemVec.begin();
 141     StatElemStoreConstIt endIt = _elemVec.end();
 142
 143     for(; it != endIt; ++it)
 144     {
 145         if(*it != NULL)
 146         {
 147             std::string elem;
 148
 149             if(!first)
 150                 str.append("|");
 151
 152             str.append((*it)->getDesc()->getName().c_str());
 153             str.append("=");
 154             (*it)->putToString(elem);
 155             str.append(elem);
 156             first = false;
 157         }
 158     }
 159     str.append("}");
 160 }
 161
 162
 163 /*! Set the contents from a string. The string has to have the format that is
 164     used by StatCollector::putToString.
 165  */
 166 bool StatCollector::getFromCString(const Char8 *&inVal)
 167 {
 168     const Char8 *c = inVal;
 169
 170     if(*c++ != '{')
 171         return false;
 172
 173     StatElemDescBase *desc;
 174     StatElem *elem;
 175
 176     clearElems();
 177
 178     while(*c && *c != '}')
 179     {
 180         const Char8 *end = c;
 181
 182         while(*end != 0 && *end != '=' && *end != '}' && *end != '|')
 183             end++;
 184
 185         if(*end == 0 || *end == '}' || *end == '|')
 186             return false;
 187
 188         std::string name(c, end - c);
 189         desc = StatElemDescBase::findDescByName(name.c_str());
 190
 191         if(!desc)
 192             return false;
 193
 194         elem = getElem(*desc);
 195
 196         c = end = end + 1;
 197         while(*end != 0 && *end != '}' && *end != '|')
 198             end++;
 199
 200         if(*end == 0)
 201             return false;
 202
 203         std::string val(c, end - c);
 204         const Char8 *valp = val.c_str();
 205         if(!elem->getFromCString(valp))
 206             return false;
 207
 208         c = end + 1;
 209     }
 210     return true;
 211 }
 212
 213 /*! Get the value of the named element, if it exists, return false if not.
 214  */
 215
 216 bool StatCollector::getValue(std::string &name, Real64 &val)
 217 {
 218     StatElemDescBase *desc = StatElemDescBase::findDescByName(name.c_str());
 219
 220     if(!desc)
 221         return false;
 222
 223     StatElem *el = getElem(*desc, false);
 224
 225     if(!el)
 226         return false;
 227
 228     val = el->getValue();
 229
 230     return true;
 231 }
 232
 233 /*! Remove all elements from the collector.
 234  */
 235 void StatCollector::clearElems(void)
 236 {
 237     StatElemStoreIt      it    = _elemVec.begin();
 238     StatElemStoreConstIt endIt = _elemVec.end();
 239
 240     for(; it != endIt; ++it)
 241     {
 242         if(*it != NULL)
 243         {
 244             delete *it;
 245
 246             *it = NULL;
 247         }
 248     }
 249     _elemVec.clear();
 250 }
 251
 252 /*! Reset all elements to the start value.
 253  */
 254 void StatCollector::reset(StatElemDescBase::ResetMode mode)
 255 {
 256     StatElemStoreIt      it    = _elemVec.begin();
 257     StatElemStoreConstIt endIt = _elemVec.end();
 258
 259     for(; it != endIt; ++it)
 260     {
 261         if(*it != NULL && (*it)->getDesc()->getResetMode() >= mode)
 262         {
 263             (*it)->reset();
 264         }
 265     }
 266 }
 267
 268 /*-------------------------- assignment -----------------------------------*/
 269
 270 const StatCollector &StatCollector::operator = (const StatCollector &source)
 271 {
 272     if(this == &source)
 273         return *this;
 274
 275     _elemVec = source._elemVec;
 276
 277     return *this;
 278 }
 279
 280 /*-------------------------- comparison -----------------------------------*/
 281
 282 /*! The comparison is only done on the addresses, as a real comparison is not
 283     well defined on a StatCollector.
 284  */
 285 bool StatCollector::operator < (const StatCollector &other) const
 286 {
 287     return this < &other;
 288 }
 289
 290 bool StatCollector::operator == (const StatCollector &rhs  ) const
 291 {
 292     return false;
 293 }
 294
 295 StatCollector StatCollector::operator + (const StatCollector &other)
 296 {
 297     StatCollector res(*this);
 298
 299     res += other;
 300
 301     return res;
 302 }
 303
 304 StatCollector &StatCollector::operator += (const StatCollector &other)
 305 {
 306     if(other._elemVec.size() > _elemVec.size())
 307     {
 308         _elemVec.resize(other._elemVec.size());
 309     }
 310
 311     for(UInt32 i = 0; i < _elemVec.size(); ++i)
 312     {
 313         if(_elemVec[i])
 314         {
 315             *_elemVec[i] += *other._elemVec[i];
 316         }
 317     }
 318
 319     return *this;
 320 }
 321
 322 OSG_END_NAMESPACE
 323
 324 #include "OSGSField.h"
 325 #include "OSGSField.ins"
 326
 327 #include "OSGMField.h"
 328 #include "OSGMField.ins"
 329
 330 #include "OSGFieldContainer.h"
 331
 332 OSG_BEGIN_NAMESPACE
 333
 334 #ifndef OSG_DO_DOC
 335
 336 /*-------------------------- field instantiations -------------------------*/
 337
 338 DataType FieldTraits<StatCollectorP>::_type("StatCollectorP",
 339                                             "TypeRoot");
 340
 341
 342 DataType &FieldTraits<StatCollectorP>::getType(void)
 343 {
 344     return _type;
 345 }
 346 #endif
 347
 348 OSG_FIELD_DLLEXPORT_DEF1(SField, StatCollectorP);
 349
 350 OSG_END_NAMESPACE
 351