lgrUtilityFunctions.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/



#ifndef lgrUtilityFunctions_H_
#define lgrUtilityFunctions_H_

#include "lgrUtil.h"
#include <vlutil/vlNetTypes.h>
#include <vector>

namespace MAKLogger
{

   typedef std::vector<DtString> DtStringVector;
   const char theDefaultDeliminator = ';';

   inline size_t roundUpTo2( size_t sz )
   {
      return sz + (sz & (size_t)0x01);
   }

   inline int roundUpTo2( int sz )
   {
      return sz + (sz & (int)0x01);
   }

   inline size_t roundUpTo4( size_t sz )
   {
      size_t align = sz & (size_t)0x03;
      return align ? (sz + (size_t)4 - align) : sz;
   }
#ifdef _M_X64
   inline unsigned int roundUpTo4( unsigned int sz )
   {
      unsigned int align = sz & (unsigned int)0x03;
      return align ? (sz + (unsigned int)4 - align) : sz;
   }
#endif
   inline int roundUpTo4( int sz )
   {
      int align = sz & (int)0x03;
      return align ? (sz + (int)4 - align) : sz;
   }

   inline size_t roundUpTo8( size_t sz )
   {
      size_t align = sz & (size_t)0x07;
      return align ? (sz + (size_t)8 - align) : sz;
   }

#ifdef _M_X64
   inline unsigned int roundUpTo8( unsigned int sz )
   {
      unsigned int align = sz & (unsigned int)0x07;
      return align ? (sz + (unsigned int)8 - align) : sz;
   }
#endif


   inline int roundUpTo8( int sz )
   {
      int align = sz & (int)0x07;
      return align ? (sz + (int)8 - align) : sz;
   }

   inline void DtCreateDeliminatedString(const DtStringVector& stringList, DtString& deliminatedString, char deliminator=theDefaultDeliminator)
   {
      DtStringVector::const_iterator stringIter = stringList.begin();
      DtStringVector::const_iterator stringEnd = stringList.end();
      if (stringIter != stringEnd)
      {
         deliminatedString = *stringIter;
         for ( ++stringIter; stringIter != stringEnd; ++stringIter)
         {
            deliminatedString += deliminator;
            deliminatedString += *stringIter;
         }
      }
   }

   inline int DtSeparateDeliminatedString(const DtString& deliminatedString,
      DtStringVector& stringList, char deliminator=theDefaultDeliminator,
      bool allowEmptyTokens=false, bool appendToExistingList=false)
   {
      DtString buffer(deliminatedString);
      if (!appendToExistingList)
      {
         stringList.clear();
      }

      while (!buffer.isEmpty())
      {
         DtString token = buffer;
         if (!buffer.snipFront(deliminator))
         {
            buffer = DtString::nullString();
         }
         token.snipBack(deliminator, true);
         token.chompBack();
         token.chompFront();
         if (allowEmptyTokens || !token.isEmpty())
         {
            stringList.push_back(token);
         }
      }
      return stringList.size();
   }
}

#endif