base_types.h

Go to the documentation of this file.

#ifndef SDK_BASE_BASE_TYPES_H_
#define SDK_BASE_BASE_TYPES_H_
 
#include "platform.h"
#include <float.h>
#if !defined(SDK_CC_MSVC)
# include <math.h>
#endif
#if /*defined(SDK_CC_GCC) || */defined(SDK_CC_CLANG) || defined(_PUSHPOP_SUPPORTED)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragma-pack"
#endif
#include "sdk_pshpack1.h"
 
struct SDKTimeStruct;
struct SDKString;
struct SDKAny;
struct SDKArray;
 
#ifndef SDK_NAMESPACE
#define SDK_NAMESPACE sdk
#endif // SDK_NAMESPACE
 
#ifndef SDK_BEGIN_NAMESPACE
#define SDK_BEGIN_NAMESPACE namespace SDK_NAMESPACE {
#endif // SDK_BEGIN_NAMESPACE
 
#ifndef SDK_END_NAMESPACE
#define SDK_END_NAMESPACE }
#endif // SDK_END_NAMESPACE
 
#ifndef SDK_BASE_NAMESPACE
#define SDK_BASE_NAMESPACE SDK_NAMESPACE::base
#endif // SDK_BASE_NAMESPACE
 
#ifndef SDK_BASE_BEGIN_NAMESPACE
#define SDK_BASE_BEGIN_NAMESPACE namespace SDK_NAMESPACE { \
                                 namespace base {
#endif // SDK_BASE_BEGIN_NAMESPACE
 
#ifndef SDK_BASE_END_NAMESPACE
#define SDK_BASE_END_NAMESPACE SDK_END_NAMESPACE }
#endif // SDK_BASE_END_NAMESPACE
 
SDK_BEGIN_NAMESPACE
 
class ISDKComponent; 
 
SDK_END_NAMESPACE // see sdk_component_interface.h
 
typedef SDKInt64 SDKTime; 
typedef SDKInt64 SDKTimeDelta; 
static const SDKTime kInvalidSDKTime = SDK_MAX_INT64; 
static const SDKTimeDelta kInvalidSDKTimeDelta = SDK_MAX_INT64; 
static const SDKUInt16 kUnixEpoch = 1970; 
static const SDKUInt16 kMillisecondsInSecond = 1000; 
 
SDK_PACK(struct SDKTimeStruct {
  SDKInt16  year;     
  SDKUInt8  month;    
  SDKUInt16 yday;     
  SDKUInt8  mday;     
  SDKUInt8  wday;     
  SDKUInt8  hour;     
  SDKUInt8  minute;   
  SDKUInt8  second;   
  SDKUInt16 millisec; 
});
 
static const SDKUInt16 kSDKTimeStruct_Year_Min = 1970;    
static const SDKUInt16 kSDKTimeStruct_Year_Max = 3000;    
static const SDKUInt8 kSDKTimeStruct_Month_Min = 1;       
static const SDKUInt8 kSDKTimeStruct_Month_Max = 12;      
static const SDKUInt16 kSDKTimeStruct_Yday_Min = 1;       
static const SDKUInt16 kSDKTimeStruct_Yday_Max = 366;     
static const SDKUInt8 kSDKTimeStruct_Mday_Min = 1;        
static const SDKUInt8 kSDKTimeStruct_Mday_Max = 31;       
static const SDKUInt8 kSDKTimeStruct_Wday_Min = 1;        
static const SDKUInt8 kSDKTimeStruct_Wday_Max = 7;        
static const SDKUInt8 kSDKTimeStruct_Hour_Min = 0;        
static const SDKUInt8 kSDKTimeStruct_Hour_Max = 23;       
static const SDKUInt8 kSDKTimeStruct_Minute_Min = 0;      
static const SDKUInt8 kSDKTimeStruct_Minute_Max = 59;     
static const SDKUInt8 kSDKTimeStruct_Second_Min = 0;      
static const SDKUInt8 kSDKTimeStruct_Second_Max = 59;     
static const SDKUInt16 kSDKTimeStruct_Millisec_Min = 0;   
static const SDKUInt16 kSDKTimeStruct_Millisec_Max = 999; 
 
SDK_PACK(struct SDKString {
  SDKUInt32  length; 
  SDKUInt16* data;   
});
 
#if defined(__cplusplus)
inline bool IsNullSDKString(const SDKString& str) {
  return (str.data == NULL);
}
#else
#define IsNullSDKString(str) (str.data == NULL)
#endif
#if defined(__cplusplus)
inline bool IsEmptySDKString(const SDKString& str) {
  return ((str.data == NULL) || (str.length == 0));
}
#else
#define IsEmptySDKString(str) ((str.data == NULL) || (str.length == 0))
#endif // #if defined(__cplusplus)
 
 
enum SDKAnyTypeEnum {
  kSDKAnyType_Empty           = 0,   
  kSDKAnyType_Null            = 1,   
  kSDKAnyType_Uint8           = 2,   
  kSDKAnyType_Uint16          = 3,   
  kSDKAnyType_Uint32          = 4,   
  kSDKAnyType_Uint64          = 5,   
  kSDKAnyType_Int8            = 6,   
  kSDKAnyType_Int16           = 7,   
  kSDKAnyType_Int32           = 8,   
  kSDKAnyType_GeoInt          = kSDKAnyType_Int32,   
  kSDKAnyType_Int64           = 9,   
  kSDKAnyType_Float           = 10,  
  kSDKAnyType_Double          = 11,  
  kSDKAnyType_Geo             = kSDKAnyType_Double,  
  kSDKAnyType_Bool            = 12,  
  kSDKAnyType_SDKTime         = 13,  
  kSDKAnyType_SDKStringPtr    = 14,  
  kSDKAnyType_SDKAnyPtr       = 15,  
  kSDKAnyType_SDKArrayPtr     = 16,  
  kSDKAnyType_SDKComponentPtr = 17,  
  kSDKAnyType_SDKTimePacked   = 18,  
  kSDKAnyType_SDKTimeDelta    = 19,  
  kSDKAnyType_3DGeoInt        = 20,  
  kSDKAnyType_3DGeo           = 21,  
  kSDKAnyType_3DFloat         = 22,  
  kSDKAnyType_UserPtr         = 255  
};
 
typedef SDKUInt16 SDKAnyType16;
typedef SDKUInt32 SDKAnyType;
SDK_PACK(struct SDKAny {
  SDKAnyType any_type;
  union
  {
    SDKInt8             i8;   
    SDKUInt8            ui8;  
    SDKInt16            i16;  
    SDKUInt16           ui16; 
    SDKInt32            i32;  
    SDKUInt32           ui32; 
    SDKInt64            i64;  
    SDKUInt64           ui64; 
    float               flt;  
    double              dbl;  
    SDKInt8             bl;   
    SDKTime             time; 
    SDKTimeDelta        dtime; 
    SDKString*          str;  
    SDKAny*             any;  
    SDKArray*           arr;  
    sdk::ISDKComponent* obj;  
    void*               vd;   
    union {
      SDKUInt64 time_packed;  
      struct {
        SDKInt64  year :    16; 
        SDKUInt64 month:    4;  
        SDKUInt64 mday:     6;  
        SDKUInt64 hour:     5;  
        SDKUInt64 minute:   6;  
        SDKUInt64 second:   6;  
        SDKUInt64 millisec: 10; 
      };  
    };
  };
});
#define ANY_UNION(X, Y)     ((X)->Y)
#define ANY_TYPE(X)         ((X)->any_type)
#define ANY_EMPTY(X)        (ANY_TYPE(X) == kSDKAnyType_Empty)
#define ANY_IS_EMPTY(X)     (ANY_TYPE(X) == kSDKAnyType_Empty)
#define ANY_IS_NULL(X)      (ANY_TYPE(X) == kSDKAnyType_Null)
#define ANY_IS_STR(X)       ((ANY_TYPE(X) == kSDKAnyType_SDKStringPtr) && \
                            ANY_UNION(X, str))
#define ANY_IS_ARRAY(X)     ((ANY_TYPE(X) == kSDKAnyType_SDKArrayPtr) && \
                            ANY_UNION(X, arr))
#define ANY_IS_COMPONENT(X) ((ANY_TYPE(X) == kSDKAnyType_SDKComponentPtr) && \
                            ANY_UNION(X, obj))
#define ANY_IS_TIME(X)      ((ANY_TYPE(X) == kSDKAnyType_SDKTime) || \
                            (ANY_TYPE(X) == kSDKAnyType_Int64))
#define ANY_IS_TIME_DELTA(X)  ((ANY_TYPE(X) == kSDKAnyType_SDKTimeDelta) || \
                            (ANY_TYPE(X) == kSDKAnyType_Int64))
#define ANY_IS_TIME_PACKED(X)  (ANY_TYPE(X) == kSDKAnyType_SDKTimePacked)
 
#define ANY_IS_SCALAR(X)  ((ANY_TYPE(X) == kSDKAnyType_Uint8) || \
                           (ANY_TYPE(X) == kSDKAnyType_Uint16) || \
                           (ANY_TYPE(X) == kSDKAnyType_Uint32) || \
                           (ANY_TYPE(X) == kSDKAnyType_Uint64) || \
                           (ANY_TYPE(X) == kSDKAnyType_Int8) || \
                           (ANY_TYPE(X) == kSDKAnyType_Int16) || \
                           (ANY_TYPE(X) == kSDKAnyType_Int32) || \
                           (ANY_TYPE(X) == kSDKAnyType_Int64) || \
                           (ANY_TYPE(X) == kSDKAnyType_Float) || \
                           (ANY_TYPE(X) == kSDKAnyType_Double) || \
                           (ANY_TYPE(X) == kSDKAnyType_Bool) || \
                           (ANY_TYPE(X) == kSDKAnyType_SDKTime) || \
                           (ANY_TYPE(X) == kSDKAnyType_SDKTimeDelta))
 
#define ANY_UI8(X)         ANY_UNION(X, ui8)
#define ANY_UI16(X)        ANY_UNION(X, ui16)
#define ANY_UI32(X)        ANY_UNION(X, ui32)
#define ANY_UI64(X)        ANY_UNION(X, ui64)
#define ANY_I8(X)          ANY_UNION(X, i8)
#define ANY_I16(X)         ANY_UNION(X, i16)
#define ANY_I32(X)         ANY_UNION(X, i32)
#define ANY_I64(X)         ANY_UNION(X, i64)
#define ANY_FLOAT(X)       ANY_UNION(X, flt)
#define ANY_DOUBLE(X)      ANY_UNION(X, dbl)
#define ANY_BOOL(X)        ANY_UNION(X, bl)
#define ANY_bool(X)        (ANY_UNION(X, bl) ? true : false)
#define ANY_DATE(X)        ANY_UNION(X, time)
#define ANY_TIME(X)        ANY_UNION(X, time)
#define ANY_TIME_DELTA(X)  ANY_UNION(X, dtime)
#define ANY_STR(X)         ANY_UNION(X, str)
#define ANY_ANY(X)         ANY_UNION(X, any)
#define ANY_ARRAY(X)       ANY_UNION(X, arr)
#define ANY_COMPONENT(X)   ANY_UNION(X, obj)
#define ANY_PTR(X)         ANY_UNION(X, vd)
#define ANY_TIME_PACKED(X) ANY_UNION(X, time_packed)
#define ANY_TIME_PACKED_YEAR(X)     ANY_UNION(X, year)
#define ANY_TIME_PACKED_MONTH(X)    ANY_UNION(X, month)
#define ANY_TIME_PACKED_MDAY(X)     ANY_UNION(X, mday)
#define ANY_TIME_PACKED_HOUR(X)     ANY_UNION(X, hour)
#define ANY_TIME_PACKED_MINUTE(X)   ANY_UNION(X, minute)
#define ANY_TIME_PACKED_SECOND(X)   ANY_UNION(X, second)
#define ANY_TIME_PACKED_MILLISEC(X) ANY_UNION(X, millisec)
#define ANY_IS_NUMERIC(X) \
  (ANY_TYPE(X) >= kSDKAnyType_Uint8 && ANY_TYPE(X) <= kSDKAnyType_Bool)
 
#ifndef SDKAnyTimePackedDateToSDKTimeStruct
#define SDKAnyTimePackedDateToSDKTimeStruct(T,V) \
  T.year = ANY_TIME_PACKED_YEAR(&V); \
  T.month = ANY_TIME_PACKED_MONTH(&V); \
  T.mday = ANY_TIME_PACKED_MDAY(&V);
#endif // SDKAnyTimePackedDateToSDKTimeStruct
#ifndef SDKAnyTimePackedTimeToSDKTimeStruct
#define SDKAnyTimePackedTimeToSDKTimeStruct(T,V) \
  T.hour = ANY_TIME_PACKED_HOUR(&V); \
  T.minute = ANY_TIME_PACKED_MINUTE(&V); \
  T.second = ANY_TIME_PACKED_SECOND(&V); \
  T.millisec = ANY_TIME_PACKED_MILLISEC(&V);
#endif // SDKAnyTimePackedTimeToSDKTimeStruct
#ifndef SDKAnyTimePackedToSDKTimeStruct
#define SDKAnyTimePackedToSDKTimeStruct(T,V) \
  SDKAnyTimePackedDateToSDKTimeStruct(T,V) \
  SDKAnyTimePackedTimeToSDKTimeStruct(T,V)
#endif // SDKAnyTimePackedToSDKTimeStruct
 
#ifndef SDKAnyTimePackedDateFromSDKTimeStruct
#define SDKAnyTimePackedDateFromSDKTimeStruct(V,T) \
  ANY_TIME_PACKED_YEAR(&V) = T.year; \
  ANY_TIME_PACKED_MONTH(&V) = T.month; \
  ANY_TIME_PACKED_MDAY(&V) = T.mday;
#endif // SDKAnyTimePackedDateFromSDKTimeStruct
#ifndef SDKAnyTimePackedTimeFromSDKTimeStruct
#define SDKAnyTimePackedTimeFromSDKTimeStruct(V,T) \
  ANY_TIME_PACKED_HOUR(&V) = T.hour; \
  ANY_TIME_PACKED_MINUTE(&V) = T.minute; \
  ANY_TIME_PACKED_SECOND(&V) = T.second; \
  ANY_TIME_PACKED_MILLISEC(&V) = T.millisec;
#endif // SDKAnyTimePackedTimeFromSDKTimeStruct
#ifndef SDKAnyTimePackedFromSDKTimeStruct
#define SDKAnyTimePackedFromSDKTimeStruct(V,T) \
  SDKAnyTimePackedDateFromSDKTimeStruct(V,T) \
  SDKAnyTimePackedTimeFromSDKTimeStruct(V,T)
#endif // SDKAnyTimePackedFromSDKTimeStruct
 
#ifndef kSDK_PACKED_TIME_INVALID_YEAR
#define kSDK_PACKED_TIME_INVALID_YEAR 0
#endif // kSDK_PACKED_TIME_INVALID_YEAR
#ifndef kSDK_PACKED_TIME_INVALID_MONTH
#define kSDK_PACKED_TIME_INVALID_MONTH 0
#endif // kSDK_PACKED_TIME_INVALID_MONTH
#ifndef kSDK_PACKED_TIME_INVALID_MDAY
#define kSDK_PACKED_TIME_INVALID_MDAY 0
#endif // kSDK_PACKED_TIME_INVALID_MDAY
#ifndef kSDK_PACKED_TIME_INVALID_HOUR
#define kSDK_PACKED_TIME_INVALID_HOUR (kSDKTimeStruct_Hour_Max + 1)
#endif // kSDK_PACKED_TIME_INVALID_HOUR
#ifndef kSDK_PACKED_TIME_INVALID_MINUTE
#define kSDK_PACKED_TIME_INVALID_MINUTE (kSDKTimeStruct_Minute_Max + 1)
#endif // kSDK_PACKED_TIME_INVALID_MINUTE
#ifndef kSDK_PACKED_TIME_INVALID_SECOND
#define kSDK_PACKED_TIME_INVALID_SECOND (kSDKTimeStruct_Second_Max + 1)
#endif // kSDK_PACKED_TIME_INVALID_SECOND
#ifndef kSDK_PACKED_TIME_INVALID_MILLISEC
#define kSDK_PACKED_TIME_INVALID_MILLISEC (kSDKTimeStruct_Millisec_Max + 1)
#endif // kSDK_PACKED_TIME_INVALID_MILLISEC
 
#ifndef SDK_TIME_IS_VALID
#define SDK_TIME_IS_VALID(T) (T != kInvalidSDKTime)
#endif // SDK_TIME_IS_VALID
#ifndef SDK_TIME_IS_INVALID
#define SDK_TIME_IS_INVALID(T) !SDK_TIME_IS_VALID(T)
#endif // SDK_TIME_IS_INVALID
#ifndef SDK_TIME_IS_VALID_YEAR
#define SDK_TIME_IS_VALID_YEAR(Y) (Y > 0)
#endif // SDK_TIME_IS_VALID_YEAR
#define SDK_TIME_IS_INVALID_YEAR(Y) !SDK_TIME_IS_VALID_YEAR(Y)
#ifndef SDK_TIME_IS_VALID_MONTH
#define SDK_TIME_IS_VALID_MONTH(M) ((M > 0) && (M <= 12))
#endif // SDK_TIME_IS_VALID_MONTH
#define SDK_TIME_IS_INVALID_MONTH(M) !SDK_TIME_IS_VALID_MONTH(M)
#ifndef SDK_TIME_IS_VALID_MDAY
#define SDK_TIME_IS_VALID_MDAY(D) ((D > 0) && (D <= 31))
#endif // SDK_TIME_IS_VALID_MDAY
#define SDK_TIME_IS_INVALID_MDAY(D) !SDK_TIME_IS_VALID_MDAY(D)
#ifndef SDK_TIME_IS_VALID_WDAY
#define SDK_TIME_IS_VALID_WDAY(D) ((D > 0) && (D <= 7))
#endif // SDK_TIME_IS_VALID_WDAY
#define SDK_TIME_IS_INVALID_WDAY(D) !SDK_TIME_IS_VALID_WDAY(D)
#ifndef ANY_TIME_IS_VALID_DATE
#define ANY_TIME_IS_VALID_DATE(D) ( \
  SDK_TIME_IS_VALID_YEAR(ANY_TIME_PACKED_YEAR(D)) && \
  SDK_TIME_IS_VALID_MONTH(ANY_TIME_PACKED_MONTH(D)) && \
  SDK_TIME_IS_VALID_MDAY(ANY_TIME_PACKED_MDAY(D)))
#endif // ANY_TIME_IS_VALID_DATE
#define ANY_TIME_IS_INVALID_DATE(D) !ANY_TIME_IS_VALID_DATE(D)
 
#ifndef SDK_TIME_IS_VALID_HOUR
#define SDK_TIME_IS_VALID_HOUR(H) (H < 24)
#endif // SDK_TIME_IS_VALID_HOUR
#define SDK_TIME_IS_INVALID_HOUR(H) !SDK_TIME_IS_VALID_HOUR(H)
#ifndef SDK_TIME_IS_VALID_MINUTE
#define SDK_TIME_IS_VALID_MINUTE(M) (M < 60)
#endif // SDK_TIME_IS_VALID_MINUTE
#define SDK_TIME_IS_INVALID_MINUTE(M) !SDK_TIME_IS_VALID_MINUTE(M)
#ifndef SDK_TIME_IS_VALID_SECOND
#define SDK_TIME_IS_VALID_SECOND(S) (S < 60)
#endif // SDK_TIME_IS_VALID_SECOND
#define SDK_TIME_IS_INVALID_SECOND(S) !SDK_TIME_IS_VALID_SECOND(S)
#ifndef SDK_TIME_IS_VALID_MILLISECOND
#define SDK_TIME_IS_VALID_MILLISECOND(S) (S < 1000)
#endif // SDK_TIME_IS_VALID_MILLISECOND
#define SDK_TIME_IS_INVALID_MILLISECOND(S) !SDK_TIME_IS_VALID_MILLISECOND(S)
#ifndef ANY_TIME_IS_VALID_TIME
#define ANY_TIME_IS_VALID_TIME(D) ( \
  SDK_TIME_IS_VALID_HOUR(ANY_TIME_PACKED_HOUR(D)) && \
  SDK_TIME_IS_VALID_MINUTE(ANY_TIME_PACKED_MINUTE(D)) && \
  SDK_TIME_IS_VALID_SECOND(ANY_TIME_PACKED_SECOND(D)))
#endif // SDK_TIME_IS_VALID_TIME
#define ANY_TIME_IS_INVALID_TIME(D) !ANY_TIME_IS_VALID_TIME(D)
 
 
typedef SDKUInt16 SDKArrayElementType;
SDK_PACK(struct SDKArray {
  SDKUInt64 num_of_elements; 
  SDKArrayElementType element_type;    
  SDKUInt32 element_size;    
  SDKUInt8* data;            
});
 
typedef SDKUInt32 SDKCRC32;
 
#ifndef membsize
#  define membsize(s, m) (sizeof((s *)0)->m)
#endif
 
template <typename Int, typename Rnd>
static inline Int RoundUp(Int N, Rnd R) {
  return Int(N + R - 1) & ~Int(R - 1);
}
 
template <typename Int, typename Rnd>
static inline Int RoundToNearest(Rnd V) {
  static double D[2] = {-0.5, +0.5};
  return static_cast<Int>(V + D[V >= 0]);
}
 
template <typename T>
inline T RoundToNearest(T r, double precision) {
  double res = (r >= 0.0) ? floor(r * precision + 0.5) : ceil(r * precision - 0.5);
  res = res / precision;
  return static_cast<T>(res);
}
 
// This should be used in the private: declarations for a class
#define DENY_COPY_AND_ASSIGN(T) \
  T(const T&); \
  void operator=(const T&)
 
// A macro to disallow all the implicit constructors, namely the
// default constructor, copy constructor and operator= functions.
//
// This should be used in the private: declarations for a class
// that wants to prevent anyone from instantiating it. This is
// especially useful for classes containing only static methods.
#define DENY_IMPLICIT_CONSTRUCTORS(T) \
  T(); \
  DENY_COPY_AND_ASSIGN(T)
 
 
template<class _InIt, class _OutIt, class _Fn1>
inline _OutIt unsafe_transform(_InIt _First, _InIt _Last,
  _OutIt _Dest, _Fn1 _Func) {   // transform [_First, _Last) with _Func
  for (; _First != _Last; ++_First, ++_Dest)
    *_Dest = _Func(*_First);
  return (_Dest);
}
 
// copy reversing elements in [_First, _Last)
template<class _BidIt, class _OutIt, class _Fn1>
inline _OutIt unsafe_reverse_copy(
  _BidIt _First, _BidIt _Last, _OutIt _Dest) {
  for (; _First != _Last; ++_Dest)
    *_Dest = *--_Last;
  return (_Dest);
}
 
template<class _BidIt, class _OutIt, class _Fn1>
inline _OutIt unsafe_reverse_copy_pred(
  _BidIt _First, _BidIt _Last, _OutIt _Dest, _Fn1 _Func) {
  for (; _First != _Last; ++_Dest)
    *_Dest = _Func(*--_Last);
  return (_Dest);
}
 
// Used to explicitly mark the return value of a function as unused. If you are
// really sure you don't want to do anything with the return value of a function
// that has been marked WARN_UNUSED_RESULT, wrap it with this. Example:
//
//   std::unique_ptr<MyType> my_var = ...;
//   if (TakeOwnership(my_var.get()) == SUCCESS)
//     ignore_result(my_var.release());
//
template<typename T>
inline void ignore_result_t(const T&) {
}
 
#include "sdk_poppack.h"
#if /*defined(SDK_CC_GCC) || */defined(SDK_CC_CLANG) || defined(_PUSHPOP_SUPPORTED)
# pragma GCC diagnostic pop
#endif
 
#endif // SDK_BASE_BASE_TYPES_H_