util.h

/*
  Copyright (c) 2007-2008 by Jakob Schroeter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/

#ifndef UTIL_H__
#define UTIL_H__

#include "gloox.h"

#include <string>
#include <list>
#include <map>

namespace gloox
{

  namespace util
  {

    #define lookup( a, b ) _lookup( a, b, sizeof(b)/sizeof(char*) )
    #define lookup2( a, b ) _lookup2( a, b, sizeof(b)/sizeof(char*) )
    #define deflookup( a, b, c ) _lookup( a, b, sizeof(b)/sizeof(char*), c )
    #define deflookup2( a, b, c ) _lookup2( a, b, sizeof(b)/sizeof(char*), c )

    unsigned _lookup( const std::string& str, const char* values[],
                      unsigned size, int def = -1 );

    const std::string _lookup( unsigned code, const char* values[],
                               unsigned size, const std::string& def = EmptyString );

    unsigned _lookup2( const std::string& str, const char* values[],
                              unsigned size, int def = -1 );

    const std::string _lookup2( unsigned code, const char* values[],
                                unsigned size, const std::string& def = EmptyString );

    template< typename T, typename F >
    inline void ForEach( T& t, F f )
    {
      for( typename T::iterator it = t.begin(); it != t.end(); ++it )
        ( (*it)->*f )();
    }

    template< typename T, typename F, typename D >
    inline void ForEach( T& t, F f, D& d )
    {
      for( typename T::iterator it = t.begin(); it != t.end(); ++it )
        ( (*it)->*f )( d );
    }

    template< typename T, typename F, typename D1, typename D2 >
    inline void ForEach( T& t, F f, D1& d1, D2& d2 )
    {
      for( typename T::iterator it = t.begin(); it != t.end(); ++it )
        ( (*it)->*f )( d1, d2 );
    }

    template< typename T, typename F, typename D1, typename D2, typename D3 >
    inline void ForEach( T& t, F f, D1& d1, D2& d2, D3& d3 )
    {
      for( typename T::iterator it = t.begin(); it != t.end(); ++it )
        ( (*it)->*f )( d1, d2, d3 );
    }

//     template< typename T >
//     inline void clearList( std::list< T* >& L )
//     {
//       typename std::list< T* >::iterator it = L.begin();
//       typename std::list< T* >::iterator it2;
//       while( it != L.end() )
//       {
//         it2 = it++;
//         delete (*it2);
//         L.erase( it2 );
//       }
//     }

//     template< typename Key, typename T >
//     inline void clearMap( std::map< Key, T* >& M )
//     {
//       typename std::map< Key, T* >::iterator it = M.begin();
//       typename std::map< Key, T* >::iterator it2;
//       while( it != M.end() )
//       {
//         it2 = it++;
//         delete (*it2).second;
//         M.erase( it2 );
//       }
//     }

//     template< typename Key, typename T >
//     inline void clearMap( std::map< const Key, T* >& M )
//     {
//       typename std::map< const Key, T* >::iterator it = M.begin();
//       typename std::map< Key, T* >::iterator it2;
//       while( it != M.end() )
//       {
//         it2 = it++;
//         delete (*it2).second;
//         M.erase( it2 );
//       }
//     }

    const std::string escape( std::string what );

    bool checkValidXMLChars( const std::string& data );

    int log2( unsigned int n );
  }

}

#endif // UTIL_H__

---