misc.h

#ifndef GM_MISC_H
#define GM_MISC_H

#include <sstream>
#include <string>

#include "gm/debug.h"

typedef unsigned char byte;

namespace GNUMessenger
{
    using namespace std;



    static string iToA(long int candidate)
    {
        stringstream tmp;
        tmp << candidate;
        return tmp.str();
    }

    template< typename T > inline void checked_array_delete(T * x)
    {
        typedef char type_must_be_complete[sizeof(T)];
        delete [] x;
    }

    template<typename T> 
    class scoped_array // noncopyable
    {
    private:

        T * ptr;

        scoped_array(scoped_array const &);
        scoped_array & operator=(scoped_array const &);

    public:

        typedef T element_type;

        explicit scoped_array(T * p = 0) : ptr(p) // never throws
        {
        }

        ~scoped_array() // never throws
        {
            checked_array_delete(ptr);
        }

        void reset(T * p = 0) // never throws
        {
            if (ptr != p)
            {
                checked_array_delete(ptr);
                ptr = p;
            }
        }

        T & operator[](std::ptrdiff_t i) const // never throws
        {
            GM_ASSERT(ptr != 0);
            GM_ASSERT(i >= 0);
            return ptr[i];
        }

        T * get() const // never throws
        {
            return ptr;
        }

        void swap(scoped_array & b) // never throws
        {
            T * tmp = b.ptr;
            b.ptr = ptr;
            ptr = tmp;
        }

    };

    template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
    {
        a.swap(b);
    }
    
    template <class T>
    class ReferenceCounted
    {
    public:     
        ReferenceCounted(const ReferenceCounted<T>& other)
        {
            m_refCount = other.m_refCount;
            m_data = other.m_data;
            
            ref();  
        }
        
        T& operator =(const ReferenceCounted<T>& other)
        {
            m_refCount = other.m_refCount;
            m_data = other.m_data;
            
            ref();
            
            return *m_data;
        }
        
        ~ReferenceCounted()
        {
            if (deref() == 0)
            {
                delete m_data;
            } 
        }   
        
        int deref()
        {
            return --*m_refCount;
        }   
        int ref()
        {
            return ++*m_refCount;
        }
        
    private:
        T * m_data; 
        int* m_refCount;    
    };




} 

#endif

---