/*
     File:       CFBase.h
 
     Contains:   CoreFoundation base types
 
     Version:    Technology: Mac OS X
                 Release:    QuickTime 6.0.2
 
     Copyright:  (c) 1999-2001 by Apple Computer, Inc., all rights reserved
 
     Bugs?:      For bug reports, consult the following page on
                 the World Wide Web:
 
                     http://developer.apple.com/bugreporter/
 
*/
#ifndef __CFBASE__
#define __CFBASE__

#ifndef __MACTYPES__
#include <MacTypes.h>
#endif



#if !defined(TRUE)
    #define TRUE    1
#endif
   
#if !defined(FALSE)
    #define FALSE  0
#endif


#if defined(__WIN32__)
    #undef CF_EXPORT
    #if defined(CF_BUILDING_CF)
        #define CF_EXPORT __declspec(dllexport) extern
    #else
        #define CF_EXPORT __declspec(dllimport) extern
    #endif
#elif defined(macintosh)
    #if defined(__MWERKS__)
        #define CF_EXPORT __declspec(export) extern
    #endif
#endif

#if !defined(CF_EXPORT)
    #define CF_EXPORT extern
#endif


#if !defined(CF_INLINE)
    #if defined(__GNUC__)
        #define CF_INLINE static __inline__
    #elif defined(__MWERKS__)
        #define CF_INLINE static inline
    #endif
#endif



#if PRAGMA_ONCE
#pragma once
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if PRAGMA_IMPORT
#pragma import on
#endif

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
    #pragma pack(2)
#endif

#if PRAGMA_ENUM_ALWAYSINT
    #if defined(__fourbyteints__) && !__fourbyteints__ 
        #define __CFBASE__RESTORE_TWOBYTEINTS
        #pragma fourbyteints on
    #endif
    #pragma enumsalwaysint on
#elif PRAGMA_ENUM_OPTIONS
    #pragma option enum=int
#elif PRAGMA_ENUM_PACK
    #if __option(pack_enums)
        #define __CFBASE__RESTORE_PACKED_ENUMS
        #pragma options(!pack_enums)
    #endif
#endif

typedef UInt32                          CFTypeID;
typedef UInt32                          CFOptionFlags;
typedef UInt32                          CFHashCode;
typedef SInt32                          CFIndex;
#if !defined(__CFSTRING_STRUCT__)
    #define __CFSTRING_STRUCT__ 1
    typedef const struct __CFString * CFStringRef;
    typedef struct __CFString * CFMutableStringRef;
#endif
/* Values returned from comparison functions */

enum CFComparisonResult {
    kCFCompareLessThan          = -1,
    kCFCompareEqualTo           = 0,
    kCFCompareGreaterThan       = 1
};
typedef enum CFComparisonResult CFComparisonResult;

/* A standard comparison function */
typedef CALLBACK_API_C( CFComparisonResult , CFComparatorFunction )(const void *val1, const void *val2, void *context);
/* Constant used by some functions to indicate failed searches. */
/* This is of type CFIndex. */
enum {
    kCFNotFound                 = -1
};

/* Range type */

struct CFRange {
    CFIndex                         location;
    CFIndex                         length;
};
typedef struct CFRange                  CFRange;

#if defined(CF_INLINE)
CF_INLINE CFRange CFRangeMake(CFIndex loc, CFIndex len) {
    CFRange range;
    range.location = loc;
    range.length = len;
    return range;
}
#else
#define CFRangeMake(LOC, LEN) __CFRangeMake(LOC, LEN)
#endif

EXTERN_API_C( CFRange )
__CFRangeMake                   (CFIndex                loc,
                                 CFIndex                len);

/* Private; do not use */
/* Allocator API

   Most of the time when specifying an allocator to Create functions, the NULL 
   argument indicates "use the default"; this is the same as using kCFAllocatorDefault 
   or the return value from CFAllocatorGetDefault().  This assures that you will use 
   the allocator in effect at that time.
   
   You should rarely use kCFAllocatorSystemDefault, the default default allocator.
*/
typedef const struct __CFAllocator * CFAllocatorRef;
/* This is a synonym for NULL, if you'd rather use a named constant. */
extern const CFAllocatorRef kCFAllocatorDefault;
/* Default system allocator. */
extern const CFAllocatorRef kCFAllocatorSystemDefault;
/* Null allocator which does nothing and allocates no memory. */
extern const CFAllocatorRef kCFAllocatorNull;
/* Special allocator argument to CFAllocatorCreate() which means
   "use the functions given in the context to allocate the allocator itself as well". 
*/
extern const CFAllocatorRef kCFAllocatorUseContext;
typedef CALLBACK_API_C( const void *, CFAllocatorRetainCallBack )(const void *info);
typedef CALLBACK_API_C( void , CFAllocatorReleaseCallBack )(const void *info);
typedef CALLBACK_API_C( CFStringRef , CFAllocatorCopyDescriptionCallBack )(const void *info);
typedef CALLBACK_API_C( void *, CFAllocatorAllocateCallBack )(CFIndex allocSize, CFOptionFlags hint, void *info);
typedef CALLBACK_API_C( void *, CFAllocatorReallocateCallBack )(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info);
typedef CALLBACK_API_C( void , CFAllocatorDeallocateCallBack )(void *ptr, void *info);
typedef CALLBACK_API_C( CFIndex , CFAllocatorPreferredSizeCallBack )(CFIndex size, CFOptionFlags hint, void *info);

struct CFAllocatorContext {
    CFIndex                         version;
    void *                          info;
    CFAllocatorRetainCallBack       retain;
    CFAllocatorReleaseCallBack      release;
    CFAllocatorCopyDescriptionCallBack  copyDescription;
    CFAllocatorAllocateCallBack     allocate;
    CFAllocatorReallocateCallBack   reallocate;
    CFAllocatorDeallocateCallBack   deallocate;
    CFAllocatorPreferredSizeCallBack  preferredSize;
};
typedef struct CFAllocatorContext       CFAllocatorContext;
EXTERN_API_C( CFTypeID )
CFAllocatorGetTypeID            (void);


/* CFAllocatorSetDefault() sets the allocator that is used in the current thread
   whenever NULL is specified as an allocator argument. This means that most, if
   not all allocations will go through this allocator. It also means that any
   allocator set as the default needs to be ready to deal with arbitrary memory
   allocation requests; in addition, the size and number of requests will change
   between releases.

   If you wish to use a custom allocator in a context, it's best to provide it as
   the argument to the various creation functions rather than setting it as the
   default. Setting the default allocator is not encouraged.

   If you do set an allocator as the default, either do it for all time in your
   app, or do it in a nested fashion (by restoring the previous allocator when
   you exit your context). The latter might be appropriate for plug-ins or
   libraries that wish to set the default allocator.
*/
EXTERN_API_C( void )
CFAllocatorSetDefault           (CFAllocatorRef         allocator);

EXTERN_API_C( CFAllocatorRef )
CFAllocatorGetDefault           (void);


EXTERN_API_C( CFAllocatorRef )
CFAllocatorCreate               (CFAllocatorRef         allocator,
                                 CFAllocatorContext *   context);


EXTERN_API_C( void *)
CFAllocatorAllocate             (CFAllocatorRef         allocator,
                                 CFIndex                size,
                                 CFOptionFlags          hint);

EXTERN_API_C( void *)
CFAllocatorReallocate           (CFAllocatorRef         allocator,
                                 void *                 ptr,
                                 CFIndex                newsize,
                                 CFOptionFlags          hint);

EXTERN_API_C( void )
CFAllocatorDeallocate           (CFAllocatorRef         allocator,
                                 void *                 ptr);

EXTERN_API_C( CFIndex )
CFAllocatorGetPreferredSizeForSize (CFAllocatorRef      allocator,
                                 CFIndex                size,
                                 CFOptionFlags          hint);

EXTERN_API_C( void )
CFAllocatorGetContext           (CFAllocatorRef         allocator,
                                 CFAllocatorContext *   context);

/* Base "type" of all "CF objects", and polymorphic functions on them */

typedef const void *                    CFTypeRef;
EXTERN_API_C( CFTypeID )
CFGetTypeID                     (CFTypeRef              cf);

EXTERN_API_C( CFStringRef )
CFCopyTypeIDDescription         (CFTypeID               theType);


EXTERN_API_C( CFTypeRef )
CFRetain                        (CFTypeRef              cf);

EXTERN_API_C( void )
CFRelease                       (CFTypeRef              cf);

EXTERN_API_C( CFIndex )
CFGetRetainCount                (CFTypeRef              cf);

EXTERN_API_C( Boolean )
CFEqual                         (CFTypeRef              cf1,
                                 CFTypeRef              cf2);

EXTERN_API_C( CFHashCode )
CFHash                          (CFTypeRef              cf);

EXTERN_API_C( CFStringRef )
CFCopyDescription               (CFTypeRef              cf);

EXTERN_API_C( CFAllocatorRef )
CFGetAllocator                  (CFTypeRef              cf);


#if PRAGMA_ENUM_ALWAYSINT
    #pragma enumsalwaysint reset
    #ifdef __CFBASE__RESTORE_TWOBYTEINTS
        #pragma fourbyteints off
    #endif
#elif PRAGMA_ENUM_OPTIONS
    #pragma option enum=reset
#elif defined(__CFBASE__RESTORE_PACKED_ENUMS)
    #pragma options(pack_enums)
#endif

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
    #pragma pack()
#endif

#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif

#ifdef __cplusplus
}
#endif

#endif /* __CFBASE__ */