types.h

Go to the documentation of this file.

/**************************************************************
 **
 ** @file base/types.h
 **
 ** Copyright (C) 2012  Xpace, LLC.  All rights reserved
 **
 ** www.xpace.net
 **
 **************************************************************/


#ifndef XPACE_TYPES_H
#define XPACE_TYPES_H

#include <cstdlib>  // for size_t
#include <memory>   // for unique_ptr
#include <functional>
#include <cassert>
#include <cerrno>
#include <limits>

#include <vector>

#define XPACE_RELEASE 1.1.5

#if defined _WIN32 && defined _DEBUG
  #define _CRTDBG_MAP_ALLOC
  #include <stdlib.h>
  #include <crtdbg.h>
//!!! have to do this bcs Qt uses free & realloc as function names
  #undef free
  #undef realloc 
#endif

/// import/export attribute, used only for Windows DLLs
#if !defined XPACE_EXPORT
# if !defined _WIN32 || defined XPACE_STATICLIB
#   define XPACE_EXPORT
# else
#   define XPACE_EXPORT __declspec(dllimport)
# endif
#endif

/// this definition requests an 'inline' that the compiler should honor
#if !defined FORCEINLINE
# if defined NDEBUG
#  if defined _WIN32
#    define FORCEINLINE __forceinline
#  elif defined __GNUC__
#    define FORCEINLINE inline __attribute__((always_inline))
#  else
#    error need to define FORCEINLINE for this compiler
#  endif
# else
#  define FORCEINLINE inline
# endif
#endif

#if defined __GNUC__
#define override  // until GCC 4.7
#endif

// on Windows, these may be defined
#undef max
#undef min

/// %Xpace project main namespace
namespace Xpace 
{
  /// @name unsigned types
  //@{
  typedef unsigned char uchar;
  typedef uchar byte;
  typedef unsigned int uint;
  //@}

  /// @name explicity-sized types
  //@{
  typedef char int8;
  typedef unsigned char uint8;
  typedef short int16;
  typedef unsigned short uint16;
  typedef int int32;
  typedef unsigned int uint32;
  typedef long long int64;
  typedef unsigned long long uint64;
  //@}

  /// @name check an unsigned number against an error value
  /// @param the (unsigned) number to test
  /// @return bool if it's invalid
  template <typename N> 
  inline
  bool INVALID
    (N n) 
  {
    return n == N(~0);
  }

  /// @name convert signed type to unsigned type
  //@{
  template<typename intType> struct Unsigned { typedef intType Type; };

  template<> struct Unsigned<int8>   { typedef uint8 Type; };
  template<> struct Unsigned<int16>  { typedef uint16 Type; };
  template<> struct Unsigned<int32>  { typedef uint32 Type; };
  template<> struct Unsigned<int64>  { typedef uint64 Type; };

  #define UNSIGN(T) typename Unsigned<T>::Type
  //@}

  /// @name convert unsigned type to signed type
  //@{
  template<typename intType> struct Signed { typedef intType Type; };

  template<> struct Signed<uint8>  { typedef int8 Type; };
  template<> struct Signed<uint16> { typedef int16 Type; };
  template<> struct Signed<uint32> { typedef int32 Type; };
  template<> struct Signed<uint64> { typedef int64 Type; };

  #define SIGN(T) typename Signed<T>::Type
  #define DIFF(T) typename Signed<T>::Type

  //@}

  /// @name convert unsigned type to signed type, unsigned to signed
  //@{
  template<typename intType> struct ChangeSign {};

  template<> struct ChangeSign<int8>   { typedef uint8 Type; };
  template<> struct ChangeSign<uint8>  { typedef int8 Type; };
  template<> struct ChangeSign<int16>  { typedef uint16 Type; };
  template<> struct ChangeSign<uint16> { typedef int16 Type; };
  template<> struct ChangeSign<int32>  { typedef uint32 Type; };
  template<> struct ChangeSign<uint32> { typedef int32 Type; };
  template<> struct ChangeSign<int64>  { typedef uint64 Type; };
  template<> struct ChangeSign<uint64> { typedef int64 Type; };

  #define CHANGE_SIGN(T) typename ChangeSign<T>::Type
  //@}

  /// @name UTF char types
  //@{
  typedef unsigned char utf8_t;
  typedef unsigned short utf16_t;

  //@}

  /// @name fastest native types of at least 32 bits
  //@{
  #if defined _WIN64 || defined __LP64__
   // native 64-bit
   typedef int64 int_fast32;
   typedef uint64 uint_fast32;
  #else
   // native 32-bit
   typedef int32 int_fast32;
   typedef uint32 uint_fast32;
  #endif
  //@}

  /// A low-level const data holder 
  template <typename T>
  struct Ref
  {
    typedef T baseType;

    const T* data;          ///< first T
    size_t length;          ///< number of Ts

    /// constructor
    /// @param d first T
    /// @param len number of Ts
    Ref
      (const T* d = 0,
       size_t len = 0); 
  }; 

  typedef Ref<byte> BytesRef;

  /// A low-level data holder 
  template <typename T>
  struct Buf
  {
    T *const data;          ///< first T
    size_t length;          ///< number of Ts

    /// constructor
    /// @param d first T
    /// @param len number of Ts
    Buf
      (T* d,
       size_t len = 0); 
  }; 


  // ================================ STRINGS =================

  /// Raw Strings - just a pointer and length
  template <typename CH>
  struct RawString
  {
    typedef CH charType;

    CH* data;
    size_t length;    

    RawString
      (CH* d = 0,
       size_t len = 0) :
        data(d),
        length(len)
    {
    }

    const RawString& operator=
      (const RawString<CH>& rhs)
    {
      length = rhs.length;
      data = rhs.data;
      return *this;
    }

    bool operator==
      (const RawString<CH>& rhs)
      const
    {
      return (length == rhs.length) &&
             !memcmp(data, rhs.data, sizeof(CH)  * length);
    }

    bool operator!=
      (const RawString<CH>& rhs)
      const
    {
      return !(*this == rhs);
    }

    bool operator>
      (const RawString<CH>& rhs)
      const
    {
      int cmp(memcmp(data, rhs.data, sizeof(CH) * std::min(length, rhs.length)));
      if (cmp > 0)
        return true;
      if (cmp < 0)
        return false;
      return length > rhs.length;
    }

    bool operator<
      (const RawString<CH>& rhs)
      const
    {
      int cmp(memcmp(data, rhs.data, sizeof(CH) * std::min(length, rhs.length)));
      if (cmp < 0)
        return true;
      if (cmp > 0)
        return false;
      return length < rhs.length;
    }
  };

  typedef RawString<utf8_t>  String8;
  typedef RawString<utf16_t> String16;

  /// A string, Unicode UTF-16 and reference-counted
  class XPACE_EXPORT String
  {
  public:
    /// Construct a String from a UTF-8 array of 8-bit chars
    /// @param s the array of chars
    /// @param len if != 0, the length of the array; if 0, array is 0-terminated
    String
      (const utf8_t* s,
       size_t len = 0);  
 
    /// Construct a String from a UTF-16 array of 16-bit chars
    /// @param s the array of chars
    /// @param len if != 0, the length of the array; if 0, array is 0-terminated
    String
      (const utf16_t* s,
       size_t len = 0);  

    /// Construct a String from an array of 8-bit chars
    /// @param s the array of chars
    /// @param len if != 0, the length of the array; if 0, array is 0-terminated
    String
      (const char* s,
       size_t len = 0); 

    /// Construct a String from a String8
    /// @param s the String8
    String
      (const String8& s);

    /// @return the length of the string, in chars
    size_t getLength
      ()
      const;

    /// convert a String into a (null-terminated) UTF-8 string, writing it into a buffer
    /// @param buf the buffer into which to write
    /// @param bufLen the lemgth of the buffer
    /// @return the buffer
    utf8_t* toUtf8
      (utf8_t* buf,
       size_t bufLen)
      const;

    /// convert a String into a (null-terminated) UTF-8 string, writing it into a vector
    std::vector<utf8_t> toUtf8
      ()
      const;
    
    /// @return the (null-terminated) UTF-16 representation of the string 
    const utf16_t* toUtf16
      ()
      const;

    #if defined QSTRING_H || defined DOCUMENTATION
    /// Convert a QString to a String
    /// @param s the source QString
    String
      (const QString& s);
    /// Convert a (const) String into a (const) QString
    /// @return the QString
    operator const QString
      ()
      const;
    /// Convert a String into a QString
    /// @return the QString
    operator QString
      ();
    #endif

    #if defined _STRING_ || defined DOCUMENTATION
    /// Convert a std::string to a String
    /// param s the std::string
    String
      (const std::string& s);
    /// Convert a std::string to a String
    /// param s the std::string
    String 
      (const std::wstring& s);
    /// Convert a String into a std::string
    /// return the std::string
    std::string toStdString
      ()
      const;
    /// Convert a String into a std::string
    /// return the std::string
    std::wstring toStdWString
      ()
      const;
    #endif

    /// Construct an empty string
    String
      ();
    String
      (const String&);
    String& operator=
      (const String&);
    ~String
      ();

    /// Make a string empty
    void clear
      ();

    /// Make a string from a number
    /// @param n the source number
    /// @return the string
    static String setNum
      (int64 n);

    /// Get a number from a (base-10) string
    /// @param fillin true if the string could be converted, false if not
    /// @return value converted
    int64 getInt
      (bool* ok = 0)
      const;

    /// @return true is String is empty
    bool operator!
      ()
      const;

    /// @return true if this String matches rhs
    bool operator==
      (const String& rhs)
      const;

    /// @return true if this String does not match rhs
    bool operator!=
      (const String& rhs)
      const
    { 
      return !(*this == rhs); 
    };

    /// @return true if this String is less than rhs
    bool operator<
      (const String& rhs)
      const;

    /// @return true if theis String matches rhs w/o case sensitvity
    bool matchNoCase
      (const String& rhs)
      const;

    /// concatenate rhs to this string
    /// @param rhs the char to concatenate
    /// @return *this
    String& operator+=
      (utf16_t rhs);

    /// concatenate rhs to this string
    /// @param rhs the string to concatenate
    /// @return *this
    String& operator+=
      (const String& rhs);

  private :
    friend class access;
    intptr_t impl;
  };

  #if defined _STRING_ || defined DOCUMENTATION
  /// Output a String to a narrow char stream
  XPACE_EXPORT std::ostream& operator<<
    (std::ostream& ostr,
     const String& str);

  /// Output a String to a wide char stream
  XPACE_EXPORT std::wostream& operator<<
    (std::wostream& ostr,
     const String& str);
  #endif

  // ================================ REVEAL CONTENTS OF A STRING

  #ifdef NDEBUG
  #define REVEAL_STRING(s, Str)
  #elif defined QSTRING_H
  #define REVEAL_STRING(s, Str) const std::wstring s(reinterpret_cast<const wchar_t*>(QString(Str).utf16()))
  #endif

  // ================================ STATUS CALLBACK ---------

  // 
  /// A status callback passed to operations that could be time-consuming
  /// @param val a number indicating the operation's progress 
  /// @return the desired interval before the next call to this function, 0 to avoid being called, -1 to abort
  typedef std::function<int64(uint64 val)> StatusCallback;

  /// Default status function
  /// @return 0 so we're never called again
  static StatusCallback defaultStatus = [](int64 doc){ return 0; };


  // ================================ POWERS OF 10 ============

  //inline
  uint32 XPACE_EXPORT pow10_32
    (uint p);

  //inline  won't work in VS 2012
  uint64 XPACE_EXPORT pow10_64
    (uint p);


  // ================================ TRACE ===================

  /// debugging
  class XPACE_EXPORT Trace
  {
  public:
    Trace
      (const char* ID,
       const char* format = 0,
       ...);
    ~Trace
      ();

    static void Msg
      (const char* format = 0,
       ...);

  #if defined _TRACE || defined DOCUMENTATION
  private:
    String id;
  #endif
  };

  // ================================ CHECKED TYPE CONVERSION ===

  /// checked loss-of-precision cast
  template <typename TO, typename FROM>
  inline TO narrow_to
    (FROM from)
  {
    assert(FROM(TO(from)) == from);
    return TO(from);
  }

  // ============================================================
  // ============================================================
  // ============================================================

  template <typename T>
  inline
  Ref<T>::Ref
    (const T* d,
     size_t len) :
      data(d), 
      length(len)
  {
  }

  template <typename T>
  inline
  Buf<T>::Buf
    (T* d,
     size_t len) :
      data(d), 
      length(len)
  {
  }

  #ifndef _TRACE
  inline
  Trace::Trace
    (const char* /*ID*/,
     const char*,
     ...)
  {
  }

  inline
  Trace::~Trace
    ()
  {
  }

  inline
  void Trace::Msg
    (const char*,
     ...)
  {
  }
  #endif

#if !defined(_WIN32)
  // nonstandard MS library functions supplied in namespace
  // Xpace on other platforms
  typedef int errno_t;
  int64 _atoi64(const char*);
  int64 _wtoi64(const wchar_t*);
  int sprintf_s(char*, size_t, const char*, ...);
  int swprintf_s(wchar_t*, size_t, const wchar_t*, ...);
  char* strtok_s(char*, const char*, char**);
  errno_t strncpy_s(char*, size_t, const char*, size_t);
  errno_t _itoa_s(int, char*, size_t, int);
  errno_t _itow_s(int, wchar_t*, size_t, int);
  errno_t _i64toa_s(int64, char*, size_t, int);
  errno_t _i64tow_s(int64, wchar_t*, size_t, int);
  errno_t wmemmove_s(wchar_t*, size_t, const wchar_t*, size_t);
  #define _strdup(s) strdup(s)

  enum { _CVTBUFSIZE = 349 };
#endif

} //  namespace Xpace

#endif