vtypes.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vtypes_h
#define vtypes_h

// This block comment is read by Doxygen to generate the index page:
/*
Next we include the few platform-specific definitions we've defined.
Which actual file this refers to will depend on the include path
set up for this platform build.
*/
#include "vtypes_platform.h"

#include <memory> // C++11 shared_ptr
#include <vector>
#include <stdarg.h>
#include <vector>
#include <iostream>
#include <deque>
#include <map>
#include <limits>

/*
We choose to define just the basic specific-sized data types. Most
code should just use 'int' wherever a 32-bit signed value is sufficient.
But if you need a specific size (such as when doing stream i/o or
talking to an external API that uses a specific sized type, these
are our official definitions.
*/
typedef int8_t              Vs8;    
typedef uint8_t             Vu8;    

typedef int16_t             Vs16;   
typedef uint16_t            Vu16;   

typedef int32_t             Vs32;   
typedef uint32_t            Vu32;   

#ifndef VCOMPILER_MSVC_6_CRIPPLED /* MSVC++ 6 hacks for this are defined in the _win platform header */
typedef int64_t             Vs64;   
typedef uint64_t            Vu64;   
#endif

typedef float               VFloat;     
typedef double              VDouble;    
typedef Vs64                VFSize;     
typedef size_t              VSizeType;  

/*
These three defines are to future-proof against compile errors when overloading functions
that take various integer types. Which overloads are actually identical (and thus duplicates)
depends on the compile flags. Specifically, and in most 32- and 64-bit environments,
Vs32 = int32_t = int, so you can't have an overloaded function with both int and Vs32 versions.
But if you use an ILP64 model, then Vs64 = int64_t = int, in which case the error would be if
you overload a function with both int and Vs64 versions. I don't yet have an example to know
how to detect ILP64, and all others (e.g., 32-bit and LP64) have int32_t = int, so for now we
just define the first one all the time (Vs32 / Vu32 are int / unsigned int), and therefore
where we have int overloads (VString assignment and increment, VAssert variants) we don't define
the 32-bit overloads. If you use ILP64, make this define conditional on something appropriate,
and we'll avoid defining the 64-bit overloads. The definition of size_t can also conflict with
unsigned int if, as Microsoft does, the headers declare it as such a typedef.
An enhancement would be to auto-detect or more conditionally define these; for now all supported
environments use the Vx32_IS_xINT model, and V_SIZE_T_IS_UNSIGNED_INT is handled in the platform
header for Windows, so that's not necessary.
@see http://en.wikipedia.org/wiki/LP64#64-bit_data_models
*/
#define Vx32_IS_xINT /* Vs32 is int32_t is typedef of int. Correct for 32-bit, as well as 64-bit when using LLP64/IL32P64 (e.g. Microsoft X64/IA-64) or LP64/I32LP64 (e.g. Unix; everyone but Microsoft). The norm. */
//#define Vx64_IS_xINT /* Vs64 is int64_t is typedef of int. Correct for 64-bit when using ILP64 or SILP64. The oddball case. */
//#define V_SIZE_T_IS_UNSIGNED_INT /* size_t is typedef of unsigned int. This is defined in _win/vtypes_platform.h because in MS defines size_t this way, so overloading a function signature both ways won't work. */

#ifndef NULL
    #define NULL 0  ///< Definition of NULL in compiler environments that don't already define it.
#endif

/*
Because MSVC++ 6 uses nonstandard notation, we use a macro whenever we need
to define a 64-bit constant value.

For signed, instead of:
12345678901234567890LL or 0x0123456789ABCDEFLL
we must use:
CONST_S64(12345678901234567890) or CONST_S64(0x0123456789ABCDEF)

For unsigned, instead of:
12345678901234567890ULL or 0x0123456789ABCDEFULL
we must use:
CONST_U64(12345678901234567890) or CONST_U64(0x0123456789ABCDEF)
*/
#ifndef VCOMPILER_MSVC_6_CRIPPLED /* MSVC++ 6 hacks for this are defined in Win32 platform header */
    #define CONST_S64(s) /*lint -save -e961*/ s##LL    /*lint -restore*/ ///< Macro to declare a Vs64 constant in a way that works even in VC++ 6.
    #define CONST_U64(s) s##ULL    ///< Macro to declare a Vu64 constant in a way that works even in VC++ 6.
#endif

// Limit constants.
static const Vs64 V_MIN_S8  = CONST_S64(0xFFFFFFFFFFFFFF80); 
static const Vs64 V_MAX_S8  = CONST_S64(0x000000000000007F); 
static const Vs64 V_MAX_U8  = CONST_S64(0x00000000000000FF); 
static const Vs64 V_MIN_S16 = CONST_S64(0xFFFFFFFFFFFF8000); 
static const Vs64 V_MAX_S16 = CONST_S64(0x0000000000007FFF); 
static const Vs64 V_MAX_U16 = CONST_S64(0x000000000000FFFF); 
static const Vs64 V_MIN_S32 = CONST_S64(0xFFFFFFFF80000000); 
static const Vs64 V_MAX_S32 = CONST_S64(0x000000007FFFFFFF); 
static const Vs64 V_MAX_U32 = CONST_S64(0x00000000FFFFFFFF); 
static const Vs64 V_MIN_S64 = CONST_S64(0x8000000000000000); 
static const Vs64 V_MAX_S64 = CONST_S64(0x7FFFFFFFFFFFFFFF); 
static const Vs64 V_MAX_U64 = CONST_S64(0xFFFFFFFFFFFFFFFF); 
static const size_t V_MAX_SIZE = std::numeric_limits<size_t>::max(); 

namespace vault {

extern Vu16 VbyteSwap16(Vu16 a16BitValue);

extern Vu32 VbyteSwap32(Vu32 a32BitValue);

extern Vu64 VbyteSwap64(Vu64 a64BitValue);

extern VFloat VbyteSwapFloat(VFloat a32BitValue);

extern VDouble VbyteSwapDouble(VDouble a64BitValue);

extern Vs64 VgetMemoryUsage();

inline void Vmemcpy(Vu8* to, Vu8* from, int length) {
    ::memcpy(to, (char*) from, (VSizeType) length);
}

extern const Vu8* VgetNativeLineEnding(int& numBytes);

template <class T>
void vectorDeleteAll(std::vector<T*>& v) {
    for (typename std::vector<T*>::iterator i = v.begin(); i != v.end(); ++i) {
        delete(*i);
    }

    v.clear();
}

template <class KEY_TYPE, class VALUE_TYPE>
void mapDeleteAllValues(std::map<KEY_TYPE, VALUE_TYPE*>& m) {
    for (typename std::map<KEY_TYPE, VALUE_TYPE*>::const_iterator i = m.begin(); i != m.end(); ++i) {
        delete(*i).second;
    }

    m.clear();
}

template <class KEY_TYPE, class VALUE_TYPE>
void mapDeleteOneValue(std::map<KEY_TYPE, VALUE_TYPE*>& m, KEY_TYPE key) {
    typename std::map<KEY_TYPE, VALUE_TYPE*>::iterator position = m.find(key);
    if (position != m.end()) {
        delete position->second; // Delete heap object pointed to by the value.
        (void) m.erase(position); // Remove the dead entry from the map.
    }
}

} // namespace vault

// The vtypes_platform.h header decided whether VBYTESWAP_NEEDED is defined.
#ifdef VBYTESWAP_NEEDED

    // Signed 16-bit actual swapping:
    #define V_BYTESWAP_HTON_S16_GET(x)      vault::VbyteSwap16((Vu16) x)
    #define V_BYTESWAP_NTOH_S16_GET(x)      vault::VbyteSwap16((Vu16) x)
    #define V_BYTESWAP_HTON_S16_IN_PLACE(x) ((x) = (vault::VbyteSwap16((Vu16) x)))
    #define V_BYTESWAP_NTOH_S16_IN_PLACE(x) ((x) = (vault::VbyteSwap16((Vu16) x)))
    // Unsigned 16-bit actual swapping:
    #define V_BYTESWAP_HTON_U16_GET(x)      vault::VbyteSwap16(x)
    #define V_BYTESWAP_NTOH_U16_GET(x)      vault::VbyteSwap16(x)
    #define V_BYTESWAP_HTON_U16_IN_PLACE(x) ((x) = (vault::VbyteSwap16(x)))
    #define V_BYTESWAP_NTOH_U16_IN_PLACE(x) ((x) = (vault::VbyteSwap16(x)))

    // Signed 32-bit actual swapping:
    #define V_BYTESWAP_HTON_S32_GET(x)      vault::VbyteSwap32((Vu32) x)
    #define V_BYTESWAP_NTOH_S32_GET(x)      vault::VbyteSwap32((Vu32) x)
    #define V_BYTESWAP_HTON_S32_IN_PLACE(x) ((x) = (Vs32)(vault::VbyteSwap32((Vu32) x)))
    #define V_BYTESWAP_NTOH_S32_IN_PLACE(x) ((x) = (Vs32)(vault::VbyteSwap32((Vu32) x)))
    // Unsigned 32-bit actual swapping:
    #define V_BYTESWAP_HTON_U32_GET(x)      vault::VbyteSwap32(x)
    #define V_BYTESWAP_NTOH_U32_GET(x)      vault::VbyteSwap32(x)
    #define V_BYTESWAP_HTON_U32_IN_PLACE(x) ((x) = (vault::VbyteSwap32(x)))
    #define V_BYTESWAP_NTOH_U32_IN_PLACE(x) ((x) = (vault::VbyteSwap32(x)))

    // Signed 64-bit actual swapping:
    #define V_BYTESWAP_HTON_S64_GET(x)      vault::VbyteSwap64((Vu64) x)
    #define V_BYTESWAP_NTOH_S64_GET(x)      vault::VbyteSwap64((Vu64) x)
    #define V_BYTESWAP_HTON_S64_IN_PLACE(x) ((x) = (vault::VbyteSwap64((Vu64) x)))
    #define V_BYTESWAP_NTOH_S64_IN_PLACE(x) ((x) = (vault::VbyteSwap64((Vu64) x)))
    // Unsigned 64-bit actual swapping:
    #define V_BYTESWAP_HTON_U64_GET(x)      vault::VbyteSwap64(x)
    #define V_BYTESWAP_NTOH_U64_GET(x)      vault::VbyteSwap64(x)
    #define V_BYTESWAP_HTON_U64_IN_PLACE(x) ((x) = (vault::VbyteSwap64(x)))
    #define V_BYTESWAP_NTOH_U64_IN_PLACE(x) ((x) = (vault::VbyteSwap64(x)))

    // VFloat (float) actual swapping:
    #define V_BYTESWAP_HTON_F_GET(x)        vault::VbyteSwapFloat(x)
    #define V_BYTESWAP_NTOH_F_GET(x)        vault::VbyteSwapFloat(x)
    #define V_BYTESWAP_HTON_F_IN_PLACE(x)   ((x) = (vault::VbyteSwapFloat(x)))
    #define V_BYTESWAP_NTOH_F_IN_PLACE(x)   ((x) = (vault::VbyteSwapFloat(x)))

    // VDouble (double) actual swapping:
    #define V_BYTESWAP_HTON_D_GET(x)        vault::VbyteSwapDouble(x)
    #define V_BYTESWAP_NTOH_D_GET(x)        vault::VbyteSwapDouble(x)
    #define V_BYTESWAP_HTON_D_IN_PLACE(x)   ((x) = (vault::VbyteSwapDouble(x)))
    #define V_BYTESWAP_NTOH_D_IN_PLACE(x)   ((x) = (vault::VbyteSwapDouble(x)))

#else

    // Signed 16-bit no-op non-swapping:
    #define V_BYTESWAP_HTON_S16_GET(x)      (x)
    #define V_BYTESWAP_NTOH_S16_GET(x)      (x)
    #define V_BYTESWAP_HTON_S16_IN_PLACE(x) ((void)0)
    #define V_BYTESWAP_NTOH_S16_IN_PLACE(x) ((void)0)
    // Unsigned 16-bit no-op non-swapping:
    #define V_BYTESWAP_HTON_U16_GET(x)      (x)
    #define V_BYTESWAP_NTOH_U16_GET(x)      (x)
    #define V_BYTESWAP_HTON_U16_IN_PLACE(x) ((void)0)
    #define V_BYTESWAP_NTOH_U16_IN_PLACE(x) ((void)0)

    // Signed 32-bit no-op non-swapping:
    #define V_BYTESWAP_HTON_S32_GET(x)      (x)
    #define V_BYTESWAP_NTOH_S32_GET(x)      (x)
    #define V_BYTESWAP_HTON_S32_IN_PLACE(x) ((void)0)
    #define V_BYTESWAP_NTOH_S32_IN_PLACE(x) ((void)0)
    // Unsigned 32-bit no-op non-swapping:
    #define V_BYTESWAP_HTON_U32_GET(x)      (x)
    #define V_BYTESWAP_NTOH_U32_GET(x)      (x)
    #define V_BYTESWAP_HTON_U32_IN_PLACE(x) ((void)0)
    #define V_BYTESWAP_NTOH_U32_IN_PLACE(x) ((void)0)

    // Signed 64-bit no-op non-swapping:
    #define V_BYTESWAP_HTON_S64_GET(x)      (x)
    #define V_BYTESWAP_NTOH_S64_GET(x)      (x)
    #define V_BYTESWAP_HTON_S64_IN_PLACE(x) ((void)0)
    #define V_BYTESWAP_NTOH_S64_IN_PLACE(x) ((void)0)
    // Unsigned 64-bit no-op non-swapping:
    #define V_BYTESWAP_HTON_U64_GET(x)      (x)
    #define V_BYTESWAP_NTOH_U64_GET(x)      (x)
    #define V_BYTESWAP_HTON_U64_IN_PLACE(x) ((void)0)
    #define V_BYTESWAP_NTOH_U64_IN_PLACE(x) ((void)0)

    // VFloat (float) no-op non-swapping:
    #define V_BYTESWAP_HTON_F_GET(x)        (x)
    #define V_BYTESWAP_NTOH_F_GET(x)        (x)
    #define V_BYTESWAP_HTON_F_IN_PLACE(x)   ((void)0)
    #define V_BYTESWAP_NTOH_F_IN_PLACE(x)   ((void)0)

    // VDouble (double) no-op non-swapping:
    #define V_BYTESWAP_HTON_D_GET(x)        (x)
    #define V_BYTESWAP_NTOH_D_GET(x)        (x)
    #define V_BYTESWAP_HTON_D_IN_PLACE(x)   ((void)0)
    #define V_BYTESWAP_NTOH_D_IN_PLACE(x)   ((void)0)

#endif

/*
Because MSVC++ 6 does not support the C++ standard we must define a macro
for defining static class constants such as "const static int kFoo = 1;"
and doing something different in that compiler.
*/
#ifndef VCOMPILER_MSVC_6_CRIPPLED /* MSVC++ 6 hacks for this are defined in Win32 platform header */
    #define CLASS_CONST(type, name, init) static const type name = (init)    ///< Macro to declare a class static constant in a way that works even in VC++ 6.
#endif

/*
Here is where we use a hierarchy of preprocessor symbols to control assertion behavior.
The hierarchy of user-definable symbols is:
  VAULT_ASSERTIONS_ENABLED
    V_ASSERT_INVARIANT_ENABLED
      V_ASSERT_INVARIANT_classname_ENABLED (for a given classname)

In vconfigure.h, you may define any or all of these symbols to 0 or 1 to force them off or on;
by default, V_ASSERT_ENABLED is on unless VAULT_ASSERTIONS_NOOP is defined; and the others inherit their state from
the level above.

Internally, we use the above symbols to define or leave undefined the following symbols:
  V_ASSERT_ACTIVE
    V_ASSERT_INVARIANT_ACTIVE
      V_ASSERT_INVARIANT_classname_ACTIVE (for a given classname)

This allows to the Vault code to simply #ifdef the existence of those symbols.

The following values for classname are implemented:
    VEXCEPTION
    VSTRING
    VDATE_AND_TIME
    VMESSAGE
    VMEMORYSTREAM
    VTEXTIOSTREAM
*/

// Do the VASSERT macros do anything if called?
#ifndef VAULT_ASSERTIONS_ENABLED
    #define V_ASSERT_ACTIVE
#else
    #if VAULT_ASSERTIONS_ENABLED == 0
        // don't define V_ASSERT_ACTIVE, thereby disabling the VASSERT macros
    #else
        #define V_ASSERT_ACTIVE
    #endif
#endif

// Does a "failed assertion" (e.g., VASSERT(false)) throws a VStackTraceException in addition to logging an error?
// Turned on by default here; define to 0 in vconfigure.h to turn it off.
#ifndef VAULT_ASSERTIONS_THROW
    #define V_ASSERT_THROWS_EXCEPTION
#else
    #if VAULT_ASSERTIONS_THROW == 0
        // don't define V_ASSERT_THROWS_EXCEPTION, thereby disabling throwing upon assertion failure
    #else
        #define V_ASSERT_THROWS_EXCEPTION
    #endif
#endif

// Does ASSERT_INVARIANT actually call this->_assertInvariant?
#ifdef V_ASSERT_INVARIANT_ENABLED
    #if V_ASSERT_INVARIANT_ENABLED == 1
        #define V_ASSERT_INVARIANT_ACTIVE
    #endif
#else
    #ifdef V_ASSERT_ACTIVE
        #define V_ASSERT_INVARIANT_ACTIVE
    #endif
#endif

/*
Now we can actually decide on the definition of ASSERT_INVARIANT().
It either calls this->_assertInvariant() or does nothing.
*/
#ifdef V_ASSERT_INVARIANT_ACTIVE
    #define ASSERT_INVARIANT() this->_assertInvariant() ///< Macro to call this->_assertInvariant().
#else
    #define ASSERT_INVARIANT() ((void) 0) ///< No-op.
#endif

// This is useful in some _assertInvariant() methods, to detect when there is a
// pointer that was already deallocated. In debug mode, VC++ generally sets pointers to
// this value upon deleting the pointer.
extern const void* const VCPP_DEBUG_BAD_POINTER_VALUE;

// Uncomment this define, or define it in your vconfigure.h to get a trace of static
// initialization through the macro below:
//#define V_DEBUG_STATIC_INITIALIZATION_TRACE 1

extern int Vtrace(const char* fileName, int lineNumber);
#ifdef V_DEBUG_STATIC_INITIALIZATION_TRACE
    #define V_STATIC_INIT_TRACE static int staticVtrace = Vtrace(__FILE__, __LINE__);
#else
    #define V_STATIC_INIT_TRACE
#endif

#define V_CONSTRAIN_MINMAX(n, minValue, maxValue) V_MAX(minValue, V_MIN(maxValue, n))

class VAutoreleasePool {
    public:
        VAutoreleasePool();
        ~VAutoreleasePool();
        void drain();
    private:
        void* mPool; // "void*" so as not to add a type dependency on includers.
};

// In vconfigure.h this symbol's presence or lack thereof tells us whether we are
// using the C++11 or Boost implementations of various smart pointer templates.
// Any necessary boost includes and related compatibility stuff was done above in
// vtypes_platform.h, so here we finally define the library-neutral names for
// these things. The C++11 types are already made available by including <memory>.
#ifdef VAULT_BOOST_SHARED_PTR_INCLUDE
    #define VUniquePtr              boost::scoped_ptr
    #define VSharedPtr              boost::shared_ptr
    #define VWeakPtr                boost::weak_ptr
    #define VEnableSharedFromThis   boost::enable_shared_from_this
    #define VStaticPtrCast          boost::static_pointer_cast
    #define VDynamicPtrCast         boost::dynamic_pointer_cast
    #define VConstPtrCast           boost::const_pointer_cast
#else
    #define VUniquePtr              std::unique_ptr
    #define VSharedPtr              std::shared_ptr
    #define VWeakPtr                std::weak_ptr
    #define VEnableSharedFromThis   std::enable_shared_from_this
    #define VStaticPtrCast          std::static_pointer_cast
    #define VDynamicPtrCast         std::dynamic_pointer_cast
    #define VConstPtrCast           std::const_pointer_cast
#endif

/*
Memory leak tracking facility. See implementation in vmemorytracker.cpp.
The feature is compiled in, or not, based on this defined preprocessor symbol.
*/
#ifndef __OBJC__ /* Redefining new is not compatible with NSObject use of new keyword. So OC code will not see this feature. */
#ifdef VAULT_MEMORY_ALLOCATION_TRACKING_SUPPORT

void* operator new(size_t size, const char* file, int line);
void operator delete(void* p, const char* file, int line);
void operator delete(void* p) throw();
void* operator new[](size_t size, const char* file, int line);
void operator delete[](void* p, const char* file, int line);
void operator delete[](void* p) throw();
#define V_NEW new(__FILE__, __LINE__)
#define new V_NEW

class VTextIOStream;
class VString;
class VDuration;

class VMemoryTracker {
    public:

        VMemoryTracker(bool enableAtStart = false);
        ~VMemoryTracker();

        static void enable();                           
        static void disable();                          
        static void reset();                            
        static bool isEnabled();                        
        static void setOver(size_t newOver);            
        static size_t getOver();                        
        static void setUnder(size_t newOver);           
        static size_t getUnder();                       
        static void setLimit(int maxNumAllocations);    
        static int  getLimit();                         
        static void setExpiration(const VDuration& d);  
        static Vs64 getExpirationTime();                
        static Vs64 getExpirationMilliseconds();        
        static void omitPointer(const void* p);         
        static void enableCodeLocationCrawl(const VString& file, int line);
        static void disableCodeLocationCrawl(const VString& file, int line);
        static Vs64 getAllocationNumber();
        static void reportMemoryTracking(const VString& label, bool toLogger, bool toConsole, VTextIOStream* toStream, Vs64 bufferLengthLimit, bool showDetails, bool performAnalysis);
};

#endif /* VAULT_MEMORY_ALLOCATION_TRACKING_SUPPORT */
#endif /* __OBJC__ */

// Give app a chance to configure after us as well as before.
#define VCONFIGURE_AFTER_VTYPES
#include "vconfigure.h"
#undef VCONFIGURE_AFTER_VTYPES

#endif /* vtypes_h */