Bentley.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once


/************************************************************************************/

#if !defined (__cplusplus)
#error "This file is for C++ compilands only"
#endif

#if !defined (_WIN32)
#error "Windows is the only platform supported"
#endif
#ifndef BENTLEY_WIN32
#define BENTLEY_WIN32
#endif
 
#define BENTLEYCONFIG_GRAPHICS_DIRECTX



    #include "suppress_warnings.h"

    #define DLLPUBLIC_ATTRIBUTE
    #define EXPORT_ATTRIBUTE        __declspec(dllexport)
    #define IMPORT_ATTRIBUTE        __declspec(dllimport)
    #define DLLLOCAL_ATTRIBUTE        /* For MSVC, a symbol is not visible outside of the DLL unless it is marked as EXPORT_ATTRIBUTE. */
    #define DLLPUBLIC_ATTRIBUTE       /* DLLPUBLIC_ATTRIBUTE is a GCC concept. For MSVC, we let EXPORT_ATTRIBUTE identify the members that must be exported */
    #define EXPORT_VTABLE_ATTRIBUTE   /* This is a GCC concept. In MSVC, it appears that the vtable and typeinfo of a class are always exported if the class contains any exported methods. */
    #define CDECL_ATTRIBUTE         __cdecl
    #define STDCALL_ATTRIBUTE       __stdcall
    #define ENUM_UNDERLYING_TYPE(T)   : T

    #if (_MSC_VER < 1600) // INTPTR_MIN et al are defined in stdint.h. Microsoft started delivering stdint.h as of VS2010
        #include <limits.h>
        #if defined(_M_X64)
            #define INTPTR_MIN      _I64_MIN
            #define INTPTR_MAX      _I64_MAX
            #define UINTPTR_MAX     _UI64_MAX
        #else /* !_M_X64 */
            #define INTPTR_MIN      _I32_MIN
            #define INTPTR_MAX      _I32_MAX
            #define UINTPTR_MAX     _UI32_MAX
        #endif
    #endif

    #define HAVE_TR1
    #define STD_TR1 std::tr1

    // The following is *NOT* equivalent to uintptr_t
    #if defined(_M_X64)
        typedef unsigned __int64    ULONG_PTR;
    #else /* !_M_X64 */
        typedef __w64 unsigned long  ULONG_PTR;
    #endif // WIN64

    #define DECLARE_KEY_METHOD


#ifdef CREATE_STATIC_LIBRARIES
    #undef EXPORT_ATTRIBUTE
    #undef IMPORT_ATTRIBUTE
    #define EXPORT_ATTRIBUTE
    #define IMPORT_ATTRIBUTE
#endif

//  Define the standard integer types, plus some Bentley aliases for them

// Bentley.r.h includes stdint.h (or does the equivalent).
#include "Bentley.r.h"

// Define standard macros and types for integer limits
#include <limits.h>

// We define these alias macros to clarify what symbol to use for a given fixed-size type. For example, if you use Int32, use INT32_MIN/MAX.
#ifndef INT32_MAX
#define INT32_MAX   INT_MAX
#endif
#ifndef UINT32_MAX
#define UINT32_MAX  UINT_MAX
#endif
#ifndef INT64_MAX
#define INT64_MAX   LLONG_MAX
#endif
#ifndef UINT64_MAX
#define UINT64_MAX  ULLONG_MAX
#endif
#ifndef INT32_MIN
#define INT32_MIN   INT_MIN
#endif
#ifndef INT64_MIN
#define INT64_MIN   LLONG_MIN
#endif

#define USING_NAMESPACE_BENTLEY using namespace BENTLEY_NAMESPACE_NAME;

// Define standard pointer types (P, CP, R, CR) in the current namespace for the specified struct
#define DEFINE_POINTER_SUFFIX_TYPEDEFS(_structname_) \
      struct _structname_; \
      typedef _structname_* _structname_##P, &_structname_##R; \
      typedef _structname_ const* _structname_##CP; \
      typedef _structname_ const& _structname_##CR; 

//  These macros make it easy to put typedefs in the Bentley namespace
#define ADD_BENTLEY_TYPEDEFS1(_namespace_,_sourceName_,_name_,structclass) \
    namespace BENTLEY_NAMESPACE_NAME {\
    typedef structclass _namespace_ :: _sourceName_*          _name_##P, &_name_##R;  \
    typedef structclass _namespace_ :: _sourceName_ const*    _name_##CP; \
    typedef structclass _namespace_ :: _sourceName_ const&    _name_##CR; }

#define ADD_BENTLEY_TYPEDEFS(_namespace_,_name_) ADD_BENTLEY_TYPEDEFS1(_namespace_,_name_,_name_,struct)
#define ADD_BENTLEY_ENUM_TYPEDEF(_namespace_,_name_,_tEnum_) namespace BENTLEY_NAMESPACE_NAME {typedef enum _namespace_ :: _name_ _tEnum_;}
#define BENTLEY_TYPEDEF(t,tP)    namespace BENTLEY_NAMESPACE_NAME {struct t; typedef struct BENTLEY_NAMESPACE_NAME::t*   tP;}
#define BENTLEY_TYPEDEFS(_name_) namespace BENTLEY_NAMESPACE_NAME {struct _name_;} ADD_BENTLEY_TYPEDEFS(BENTLEY_NAMESPACE_NAME,_name_)
#define BENTLEY_REF_COUNTED_PTR(_sname_) namespace BENTLEY_NAMESPACE_NAME {struct _sname_; typedef RefCountedPtr<_sname_> _sname_##Ptr;} 


#if !defined (NULL)
    #define NULL    0
#endif

#if !defined (NO_BENTLEY_PUBLIC)
#define Public
#endif

#define BEGIN_EXTERN_C extern "C" {
#define END_EXTERN_C              }
#define ALLOW_NULL_OUTPUT(var,out) _t_##var, &var(out?*out:_t_##var)
#define DEFINE_T_SUPER(B) private: typedef B T_Super; public:

/*---------------------------------------------------------------------------------**/
#if !defined (_WINGDI_)
    #define NOGDI       // Do NOT let WinGDI.h define ERROR to 0 !!!!
#endif                                            

#ifdef  TRUE
    #undef TRUE
#endif
#ifdef  FALSE
    #undef FALSE
#endif
#ifdef  ERROR
    #undef ERROR
#endif
#ifdef  SUCCESS
    #undef SUCCESS
#endif

BEGIN_BENTLEY_NAMESPACE
enum BentleyTrueFalse
    {
    TRUE  = 1,
    FALSE = 0
    };

enum BentleyStatus
    {
    SUCCESS     = 0,
    BSISUCCESS  = 0,
    ERROR       = 0x8000,
    BSIERROR    = 0x8000,
    };

enum class BentleyCharEncoding
    {
    Locale = 0,
    Utf8   = 1
    };

typedef int                 StatusInt;      // zero always means SUCCESS
typedef wchar_t             WChar;          // Note: do not use this type to declare, read, or write a stored string. Strings must be stored as UTF-16 or UTF-8.
typedef wchar_t const*      WCharCP;
typedef wchar_t*            WCharP;
typedef char const*         CharCP;
typedef char*               CharP;
typedef Utf8Char*           Utf8P;
typedef Utf8Char const*     Utf8CP;
typedef Utf16Char*          Utf16P;
typedef Utf16Char const*    Utf16CP;

typedef void*               UserDataP;
typedef void const*         UserDataCP;
typedef void*               CallbackArgP;

END_BENTLEY_NAMESPACE

BENTLEY_TYPEDEFS (WString)
BENTLEY_TYPEDEFS (AString)
BENTLEY_TYPEDEFS (Utf8String)
BENTLEY_TYPEDEFS (BeFileName)
BENTLEY_TYPEDEFS (BeTextFile)
BENTLEY_TYPEDEFS (BeIcon)
                                   
#if !defined (NO_USING_NAMESPACE_BENTLEY)
    USING_NAMESPACE_BENTLEY
#endif
        #define BENTLEYDLL_EXPORT IMPORT_ATTRIBUTE