MercuryUtil.h

Go to the documentation of this file.

#ifndef _MERCURY_UTIL_H
#define _MERCURY_UTIL_H

#include "global.h"

MString ConvertToCFormat( const MString & ncf );

MString ConvertToUnformatted( const MString & cf );

#if defined(WIN32)
#define PROPERRETURN "\r\n"
#else
#define PROPERRETURN "\n"
#endif

void Sleep(float msec);

#define CLASS_RTTI( CLASSNAME, PARENTCLASS )  \
    virtual MString GetType() { return #CLASSNAME; } \
    virtual void GetAllTypes( MVector<MString> & vOut ) { vOut.push_back( #CLASSNAME ); PARENTCLASS::GetAllTypes( vOut ); } \
    virtual bool IsTypeOf( const MString & sType ) { if( sType == #CLASSNAME ) return true; return PARENTCLASS::IsTypeOf( sType ); } 

/*  These two functions are very different. nextPow2 will go to the NEXT power of 2
    even if x is already a power of 2. makePow2 will make sure the number is a power
    of 2 at least equak to x. */
inline int nextPow2(int x) { int num = 1; while(num <= x) num <<= 1; return num; }
inline int makePow2(int x) { int num = 1; while(num < x) num <<= 1; return num; }

//Returns -1 if failure, otherwise # of bytes read.
//Will initialize and malloc data.  Will ignore whatever was in it before.

long    DumpFromFile( const MString & filename, char * & data );

bool    DumpToFile( const MString & filename, const char * data, long bytes );

void    FileToMString( const MString & filename, MString & data );

void    MStringToFile( const MString & filename, const MString & data );

//Return if file exists
bool    FileExists( const MString & filename );

//plain text processing,
//strin = string to process, slen = length
//termin = tokens to check, termlen = length

long    BytesUntil( const char* strin, const char * termin, long start, long slen, long termlen );

long    BytesNUntil( const char* strin, const char * termin, long start, long slen, long termlen );

template<typename T>
inline T Clamp(const T& in, const T& min, const T& max) { if (in<min) return min; if ( in > max ) return max; return in; }

//Special crashing code

void mercury_crash( const char *reason = "Internal error" );  
#define ASSERT_M(COND, MESSAGE) { if(!(COND)) { mercury_crash(MESSAGE); } }
#define ASSERT(COND) ASSERT_M((COND), "Assertion \"" + MString( #COND ) + "\" failed in: " + ssprintf( "%s:%d", __FILE__, __LINE__  ) )
#define FAIL(MESSAGE) mercury_crash( MESSAGE )

//I know this looks a little cookey but it's gotta get included here, otherwise it won't have access to what it needs.
#include "MercuryVector.h"

void    SplitStrings( const MString & in, MVector < MString > & out, const char * termin, const char * whitespace, long termlen, long wslen );

inline unsigned int Swap32( unsigned int n )
{
    return (n >> 24) |
            ((n >>  8) & 0x0000FF00) |
            ((n <<  8) & 0x00FF0000) |
            (n << 24);
}

inline unsigned short Swap16( unsigned short n )
{
    return (n >>  8) | (n <<  8);
}

template<typename T>
void Destructor(T* t) { t->~T(); }

//This counter is used with singletons to
//ensure proper destruction order of the
//singleton
template<typename T>
class InstanceCounter
{
public:
    InstanceCounter()
    {
        if (m_count == 0)
            T::GetInstance();
        ++m_count;
    }
    ~InstanceCounter()
    {
        --m_count;
        if (m_count == 0)
        {
            T* i = &T::GetInstance();
            SAFE_DELETE(i);
        }
    }
private:
    static unsigned int m_count;
};

template<typename T>
unsigned int InstanceCounter<T>::m_count = 0;

template<typename T>
class MAutoPtr
{
    public:
        MAutoPtr(T* ptr)
        {
            m_ptr = ptr;
            m_count = new unsigned int;
            *m_count = 1;
        }

        MAutoPtr() : m_ptr(NULL), m_count(new unsigned int)
        {
            *m_count = 0;
        }
        
        MAutoPtr(const MAutoPtr<T>& autoPtr)
        {
            m_ptr = autoPtr.m_ptr;
            m_count = autoPtr.m_count;
            ++(*m_count);
        }
        
        inline ~MAutoPtr() { TryDelete(); }

        //Comparative
        inline bool operator<(const MAutoPtr& rhs) const { return m_ptr < rhs.m_ptr; }
        inline bool operator>(const MAutoPtr& rhs) const { return m_ptr > rhs.m_ptr; }
        inline bool operator<=(const MAutoPtr& rhs) const { return m_ptr <= rhs.m_ptr; }
        inline bool operator>=(const MAutoPtr& rhs) const { return m_ptr >= rhs.m_ptr; }
        inline bool operator==(const MAutoPtr& rhs) const { return m_ptr == rhs.m_ptr; }
        inline bool operator!=(const MAutoPtr& rhs) const { return m_ptr != rhs.m_ptr; }

        //Assignment
        MAutoPtr& operator=(const MAutoPtr& rhs)
        {
            TryDelete();
            
            m_ptr = rhs.m_ptr;
            m_count = rhs.m_count;
            ++(*m_count);
    
            return *this;
        }

        inline const T& operator->*(MAutoPtr<T>& autoPtr) const { return *m_ptr; }
        inline T& operator->*(MAutoPtr<T>& autoPtr) { return *m_ptr; }
        
        inline operator T*() { return m_ptr; }
        inline operator const T*() const { return m_ptr; }

    private:
        void TryDelete()
        {
            if (*m_count > 0)
                --(*m_count);
            if (*m_count == 0)
            {
                SAFE_DELETE(m_ptr);
                SAFE_DELETE(m_count);
            }
        }
        
        T* m_ptr;
        unsigned int* m_count;
};

int GetAPrime( int ith );

#endif 

/* 
 * Copyright (c) 2005-2006, Charles Lohr, Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by