Show CFBase.h syntax highlighted
/*
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__ */
See more files for this project here