Package apple.corefoundation.c

Class CoreFoundation

  • public final class CoreFoundation
extends java.lang.Object

    • Field Detail

      • kCFNotFound

        public static final long kCFNotFound
        Constant used by some functions to indicate failed searches.
        See Also:
        Constant Field Values

    • Method Detail

      • CFRangeMake

        public static CFRange CFRangeMake​(long loc,
                                  long len)

      • __CFRangeMake

        public static CFRange __CFRangeMake​(long loc,
                                    long len)
        Private; do not use

      • CFNullGetTypeID

        public static long CFNullGetTypeID()

      • CFAllocatorGetTypeID

        public static long CFAllocatorGetTypeID()

      • CFAllocatorSetDefault

        public static void CFAllocatorSetDefault​(CFAllocatorRef allocator)
        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. An allocator set as the default will never be released, even if later another allocator replaces it as the default. Not only is it impractical for it to be released (as there might be caches created under the covers that refer to the allocator), in general it's also safer and more efficient to keep it around. 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.

      • CFAllocatorGetDefault

        public static CFAllocatorRef CFAllocatorGetDefault()

      • CFAllocatorAllocate

        public static org.moe.natj.general.ptr.VoidPtr CFAllocatorAllocate​(CFAllocatorRef allocator,
                                                                   long size,
                                                                   long hint)

      • CFAllocatorReallocate

        public static org.moe.natj.general.ptr.VoidPtr CFAllocatorReallocate​(CFAllocatorRef allocator,
                                                                     org.moe.natj.general.ptr.VoidPtr ptr,
                                                                     long newsize,
                                                                     long hint)

      • CFAllocatorDeallocate

        public static void CFAllocatorDeallocate​(CFAllocatorRef allocator,
                                         org.moe.natj.general.ptr.VoidPtr ptr)

      • CFAllocatorGetPreferredSizeForSize

        public static long CFAllocatorGetPreferredSizeForSize​(CFAllocatorRef allocator,
                                                      long size,
                                                      long hint)

      • CFGetTypeID

        public static long CFGetTypeID​(org.moe.natj.general.ptr.ConstVoidPtr cf)
        Polymorphic CF functions

      • CFCopyTypeIDDescription

        public static CFStringRef CFCopyTypeIDDescription​(long type_id)

      • CFRetain

        public static org.moe.natj.general.ptr.ConstVoidPtr CFRetain​(org.moe.natj.general.ptr.ConstVoidPtr cf)

      • CFRelease

        public static void CFRelease​(org.moe.natj.general.ptr.ConstVoidPtr cf)

      • CFAutorelease

        public static org.moe.natj.general.ptr.ConstVoidPtr CFAutorelease​(org.moe.natj.general.ptr.ConstVoidPtr arg)

      • CFGetRetainCount

        public static long CFGetRetainCount​(org.moe.natj.general.ptr.ConstVoidPtr cf)

      • CFEqual

        public static byte CFEqual​(org.moe.natj.general.ptr.ConstVoidPtr cf1,
                           org.moe.natj.general.ptr.ConstVoidPtr cf2)

      • CFHash

        public static long CFHash​(org.moe.natj.general.ptr.ConstVoidPtr cf)

      • CFCopyDescription

        public static CFStringRef CFCopyDescription​(org.moe.natj.general.ptr.ConstVoidPtr cf)

      • CFGetAllocator

        public static CFAllocatorRef CFGetAllocator​(org.moe.natj.general.ptr.ConstVoidPtr cf)

      • CFDictionaryGetTypeID

        public static long CFDictionaryGetTypeID()
        [@function] CFDictionaryGetTypeID Returns the type identifier of all CFDictionary instances.

      • CFDictionaryCreate

        public static CFDictionaryRef CFDictionaryCreate​(CFAllocatorRef allocator,
                                                 org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> keys,
                                                 org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values,
                                                 long numValues,
                                                 CFDictionaryKeyCallBacks keyCallBacks,
                                                 CFDictionaryValueCallBacks valueCallBacks)
        [@function] CFDictionaryCreate Creates a new immutable dictionary with the given values.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the dictionary and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        keys - A C array of the pointer-sized keys to be used for the parallel C array of values to be put into the dictionary. This parameter may be NULL if the numValues parameter is 0. This C array is not changed or freed by this function. If this parameter is not a valid pointer to a C array of at least numValues pointers, the behavior is undefined.
        values - A C array of the pointer-sized values to be in the dictionary. This parameter may be NULL if the numValues parameter is 0. This C array is not changed or freed by this function. If this parameter is not a valid pointer to a C array of at least numValues pointers, the behavior is undefined.
        numValues - The number of values to copy from the keys and values C arrays into the CFDictionary. This number will be the count of the dictionary. If this parameter is negative, or greater than the number of values actually in the keys or values C arrays, the behavior is undefined.
        keyCallBacks - A pointer to a CFDictionaryKeyCallBacks structure initialized with the callbacks for the dictionary to use on each key in the dictionary. The retain callback will be used within this function, for example, to retain all of the new keys from the keys C array. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple dictionary creations. If the version field of this callbacks structure is not one of the defined ones for CFDictionary, the behavior is undefined. The retain field may be NULL, in which case the CFDictionary will do nothing to add a retain to the keys of the contained values. The release field may be NULL, in which case the CFDictionary will do nothing to remove the dictionary's retain (if any) on the keys when the dictionary is destroyed or a key-value pair is removed. If the copyDescription field is NULL, the dictionary will create a simple description for a key. If the equal field is NULL, the dictionary will use pointer equality to test for equality of keys. If the hash field is NULL, a key will be converted from a pointer to an integer to compute the hash code. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFDictionaryKeyCallBacks callbacks structure, the behavior is undefined. If any of the keys put into the dictionary is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        valueCallBacks - A pointer to a CFDictionaryValueCallBacks structure initialized with the callbacks for the dictionary to use on each value in the dictionary. The retain callback will be used within this function, for example, to retain all of the new values from the values C array. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple dictionary creations. If the version field of this callbacks structure is not one of the defined ones for CFDictionary, the behavior is undefined. The retain field may be NULL, in which case the CFDictionary will do nothing to add a retain to values as they are put into the dictionary. The release field may be NULL, in which case the CFDictionary will do nothing to remove the dictionary's retain (if any) on the values when the dictionary is destroyed or a key-value pair is removed. If the copyDescription field is NULL, the dictionary will create a simple description for a value. If the equal field is NULL, the dictionary will use pointer equality to test for equality of values. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFDictionaryValueCallBacks callbacks structure, the behavior is undefined. If any of the values put into the dictionary is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        Returns:
        A reference to the new immutable CFDictionary.

      • CFDictionaryCreateCopy

        public static CFDictionaryRef CFDictionaryCreateCopy​(CFAllocatorRef allocator,
                                                     CFDictionaryRef theDict)
        [@function] CFDictionaryCreateCopy Creates a new immutable dictionary with the key-value pairs from the given dictionary.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the dictionary and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theDict - The dictionary which is to be copied. The keys and values from the dictionary are copied as pointers into the new dictionary (that is, the values themselves are copied, not that which the values point to, if anything). However, the keys and values are also retained by the new dictionary using the retain function of the original dictionary. The count of the new dictionary will be the same as the given dictionary. The new dictionary uses the same callbacks as the dictionary to be copied. If this parameter is not a valid CFDictionary, the behavior is undefined.
        Returns:
        A reference to the new immutable CFDictionary.

      • CFDictionaryCreateMutable

        public static CFMutableDictionaryRef CFDictionaryCreateMutable​(CFAllocatorRef allocator,
                                                               long capacity,
                                                               CFDictionaryKeyCallBacks keyCallBacks,
                                                               CFDictionaryValueCallBacks valueCallBacks)
        [@function] CFDictionaryCreateMutable Creates a new mutable dictionary.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the dictionary and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFDictionary. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A dictionary's actual capacity is only limited by address space and available memory constraints). If this parameter is negative, the behavior is undefined.
        keyCallBacks - A pointer to a CFDictionaryKeyCallBacks structure initialized with the callbacks for the dictionary to use on each key in the dictionary. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple dictionary creations. If the version field of this callbacks structure is not one of the defined ones for CFDictionary, the behavior is undefined. The retain field may be NULL, in which case the CFDictionary will do nothing to add a retain to the keys of the contained values. The release field may be NULL, in which case the CFDictionary will do nothing to remove the dictionary's retain (if any) on the keys when the dictionary is destroyed or a key-value pair is removed. If the copyDescription field is NULL, the dictionary will create a simple description for a key. If the equal field is NULL, the dictionary will use pointer equality to test for equality of keys. If the hash field is NULL, a key will be converted from a pointer to an integer to compute the hash code. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFDictionaryKeyCallBacks callbacks structure, the behavior is undefined. If any of the keys put into the dictionary is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        valueCallBacks - A pointer to a CFDictionaryValueCallBacks structure initialized with the callbacks for the dictionary to use on each value in the dictionary. The retain callback will be used within this function, for example, to retain all of the new values from the values C array. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple dictionary creations. If the version field of this callbacks structure is not one of the defined ones for CFDictionary, the behavior is undefined. The retain field may be NULL, in which case the CFDictionary will do nothing to add a retain to values as they are put into the dictionary. The release field may be NULL, in which case the CFDictionary will do nothing to remove the dictionary's retain (if any) on the values when the dictionary is destroyed or a key-value pair is removed. If the copyDescription field is NULL, the dictionary will create a simple description for a value. If the equal field is NULL, the dictionary will use pointer equality to test for equality of values. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFDictionaryValueCallBacks callbacks structure, the behavior is undefined. If any of the values put into the dictionary is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        Returns:
        A reference to the new mutable CFDictionary.

      • CFDictionaryCreateMutableCopy

        public static CFMutableDictionaryRef CFDictionaryCreateMutableCopy​(CFAllocatorRef allocator,
                                                                   long capacity,
                                                                   CFDictionaryRef theDict)
        [@function] CFDictionaryCreateMutableCopy Creates a new mutable dictionary with the key-value pairs from the given dictionary.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the dictionary and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFDictionary. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A dictionary's actual capacity is only limited by address space and available memory constraints). This parameter must be greater than or equal to the count of the dictionary which is to be copied, or the behavior is undefined. If this parameter is negative, the behavior is undefined.
        theDict - The dictionary which is to be copied. The keys and values from the dictionary are copied as pointers into the new dictionary (that is, the values themselves are copied, not that which the values point to, if anything). However, the keys and values are also retained by the new dictionary using the retain function of the original dictionary. The count of the new dictionary will be the same as the given dictionary. The new dictionary uses the same callbacks as the dictionary to be copied. If this parameter is not a valid CFDictionary, the behavior is undefined.
        Returns:
        A reference to the new mutable CFDictionary.

      • CFDictionaryGetCount

        public static long CFDictionaryGetCount​(CFDictionaryRef theDict)
        [@function] CFDictionaryGetCount Returns the number of values currently in the dictionary.
        Parameters:
        theDict - The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.
        Returns:
        The number of values in the dictionary.

      • CFDictionaryGetCountOfKey

        public static long CFDictionaryGetCountOfKey​(CFDictionaryRef theDict,
                                             org.moe.natj.general.ptr.ConstVoidPtr key)
        [@function] CFDictionaryGetCountOfKey Counts the number of times the given key occurs in the dictionary.
        Parameters:
        theDict - The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.
        key - The key for which to find matches in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        Returns 1 if a matching key is used by the dictionary, 0 otherwise.

      • CFDictionaryGetCountOfValue

        public static long CFDictionaryGetCountOfValue​(CFDictionaryRef theDict,
                                               org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFDictionaryGetCountOfValue Counts the number of times the given value occurs in the dictionary.
        Parameters:
        theDict - The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.
        value - The value for which to find matches in the dictionary. The equal() callback provided when the dictionary was created is used to compare. If the equal() value callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the dictionary, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        The number of times the given value occurs in the dictionary.

      • CFDictionaryContainsKey

        public static byte CFDictionaryContainsKey​(CFDictionaryRef theDict,
                                           org.moe.natj.general.ptr.ConstVoidPtr key)
        [@function] CFDictionaryContainsKey Reports whether or not the key is in the dictionary.
        Parameters:
        theDict - The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.
        key - The key for which to find matches in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        true, if the key is in the dictionary, otherwise false.

      • CFDictionaryContainsValue

        public static byte CFDictionaryContainsValue​(CFDictionaryRef theDict,
                                             org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFDictionaryContainsValue Reports whether or not the value is in the dictionary.
        Parameters:
        theDict - The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.
        value - The value for which to find matches in the dictionary. The equal() callback provided when the dictionary was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the dictionary, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        true, if the value is in the dictionary, otherwise false.

      • CFDictionaryGetValue

        public static org.moe.natj.general.ptr.ConstVoidPtr CFDictionaryGetValue​(CFDictionaryRef theDict,
                                                                         org.moe.natj.general.ptr.ConstVoidPtr key)
        [@function] CFDictionaryGetValue Retrieves the value associated with the given key.
        Parameters:
        theDict - The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.
        key - The key for which to find a match in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        The value with the given key in the dictionary, or NULL if no key-value pair with a matching key exists. Since NULL can be a valid value in some dictionaries, the function CFDictionaryGetValueIfPresent() must be used to distinguish NULL-no-found from NULL-is-the-value.

      • CFDictionaryGetValueIfPresent

        public static byte CFDictionaryGetValueIfPresent​(CFDictionaryRef theDict,
                                                 org.moe.natj.general.ptr.ConstVoidPtr key,
                                                 org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> value)
        [@function] CFDictionaryGetValueIfPresent Retrieves the value associated with the given key.
        Parameters:
        theDict - The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.
        key - The key for which to find a match in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.
        value - A pointer to memory which should be filled with the pointer-sized value if a matching key is found. If no key match is found, the contents of the storage pointed to by this parameter are undefined. This parameter may be NULL, in which case the value from the dictionary is not returned (but the return value of this function still indicates whether or not the key-value pair was present).
        Returns:
        true, if a matching key was found, false otherwise.

      • CFDictionaryGetKeysAndValues

        public static void CFDictionaryGetKeysAndValues​(CFDictionaryRef theDict,
                                                org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> keys,
                                                org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values)
        [@function] CFDictionaryGetKeysAndValues Fills the two buffers with the keys and values from the dictionary.
        Parameters:
        theDict - The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.
        keys - A C array of pointer-sized values to be filled with keys from the dictionary. The keys and values C arrays are parallel to each other (that is, the items at the same indices form a key-value pair from the dictionary). This parameter may be NULL if the keys are not desired. If this parameter is not a valid pointer to a C array of at least CFDictionaryGetCount() pointers, or NULL, the behavior is undefined.
        values - A C array of pointer-sized values to be filled with values from the dictionary. The keys and values C arrays are parallel to each other (that is, the items at the same indices form a key-value pair from the dictionary). This parameter may be NULL if the values are not desired. If this parameter is not a valid pointer to a C array of at least CFDictionaryGetCount() pointers, or NULL, the behavior is undefined.

      • CFDictionaryApplyFunction

        public static void CFDictionaryApplyFunction​(CFDictionaryRef theDict,
                                             CoreFoundation.Function_CFDictionaryApplyFunction applier,
                                             org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFDictionaryApplyFunction Calls a function once for each value in the dictionary.
        Parameters:
        theDict - The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.
        applier - The callback function to call once for each value in the dictionary. If this parameter is not a pointer to a function of the correct prototype, the behavior is undefined. If there are keys or values which the applier function does not expect or cannot properly apply to, the behavior is undefined.
        context - A pointer-sized user-defined value, which is passed as the third parameter to the applier function, but is otherwise unused by this function. If the context is not what is expected by the applier function, the behavior is undefined.

      • CFDictionaryAddValue

        public static void CFDictionaryAddValue​(CFMutableDictionaryRef theDict,
                                        org.moe.natj.general.ptr.ConstVoidPtr key,
                                        org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFDictionaryAddValue Adds the key-value pair to the dictionary if no such key already exists.
        Parameters:
        theDict - The dictionary to which the value is to be added. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.
        key - The key of the value to add to the dictionary. The key is retained by the dictionary using the retain callback provided when the dictionary was created. If the key is not of the sort expected by the retain callback, the behavior is undefined. If a key which matches this key is already present in the dictionary, this function does nothing ("add if absent").
        value - The value to add to the dictionary. The value is retained by the dictionary using the retain callback provided when the dictionary was created. If the value is not of the sort expected by the retain callback, the behavior is undefined.

      • CFDictionarySetValue

        public static void CFDictionarySetValue​(CFMutableDictionaryRef theDict,
                                        org.moe.natj.general.ptr.ConstVoidPtr key,
                                        org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFDictionarySetValue Sets the value of the key in the dictionary.
        Parameters:
        theDict - The dictionary to which the value is to be set. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.
        key - The key of the value to set into the dictionary. If a key which matches this key is already present in the dictionary, only the value is changed ("add if absent, replace if present"). If no key matches the given key, the key-value pair is added to the dictionary. If added, the key is retained by the dictionary, using the retain callback provided when the dictionary was created. If the key is not of the sort expected by the key retain callback, the behavior is undefined.
        value - The value to add to or replace into the dictionary. The value is retained by the dictionary using the retain callback provided when the dictionary was created, and the previous value if any is released. If the value is not of the sort expected by the retain or release callbacks, the behavior is undefined.

      • CFDictionaryReplaceValue

        public static void CFDictionaryReplaceValue​(CFMutableDictionaryRef theDict,
                                            org.moe.natj.general.ptr.ConstVoidPtr key,
                                            org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFDictionaryReplaceValue Replaces the value of the key in the dictionary.
        Parameters:
        theDict - The dictionary to which the value is to be replaced. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.
        key - The key of the value to replace in the dictionary. If a key which matches this key is present in the dictionary, the value is changed to the given value, otherwise this function does nothing ("replace if present").
        value - The value to replace into the dictionary. The value is retained by the dictionary using the retain callback provided when the dictionary was created, and the previous value is released. If the value is not of the sort expected by the retain or release callbacks, the behavior is undefined.

      • CFDictionaryRemoveValue

        public static void CFDictionaryRemoveValue​(CFMutableDictionaryRef theDict,
                                           org.moe.natj.general.ptr.ConstVoidPtr key)
        [@function] CFDictionaryRemoveValue Removes the value of the key from the dictionary.
        Parameters:
        theDict - The dictionary from which the value is to be removed. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.
        key - The key of the value to remove from the dictionary. If a key which matches this key is present in the dictionary, the key-value pair is removed from the dictionary, otherwise this function does nothing ("remove if present").

      • CFDictionaryRemoveAllValues

        public static void CFDictionaryRemoveAllValues​(CFMutableDictionaryRef theDict)
        [@function] CFDictionaryRemoveAllValues Removes all the values from the dictionary, making it empty.
        Parameters:
        theDict - The dictionary from which all of the values are to be removed. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.

      • CFDataGetTypeID

        public static long CFDataGetTypeID()

      • CFDataCreate

        public static CFDataRef CFDataCreate​(CFAllocatorRef allocator,
                                     java.lang.String bytes,
                                     long length)

      • CFDataCreateWithBytesNoCopy

        public static CFDataRef CFDataCreateWithBytesNoCopy​(CFAllocatorRef allocator,
                                                    java.lang.String bytes,
                                                    long length,
                                                    CFAllocatorRef bytesDeallocator)

      • CFDataCreateCopy

        public static CFDataRef CFDataCreateCopy​(CFAllocatorRef allocator,
                                         CFDataRef theData)
        Pass kCFAllocatorNull as bytesDeallocator to assure the bytes aren't freed

      • CFDataGetLength

        public static long CFDataGetLength​(CFDataRef theData)

      • CFDataGetBytePtr

        public static java.lang.String CFDataGetBytePtr​(CFDataRef theData)

      • CFDataGetMutableBytePtr

        public static org.moe.natj.general.ptr.BytePtr CFDataGetMutableBytePtr​(CFMutableDataRef theData)

      • CFDataGetBytes

        public static void CFDataGetBytes​(CFDataRef theData,
                                  CFRange range,
                                  org.moe.natj.general.ptr.BytePtr buffer)

      • CFDataSetLength

        public static void CFDataSetLength​(CFMutableDataRef theData,
                                   long length)

      • CFDataIncreaseLength

        public static void CFDataIncreaseLength​(CFMutableDataRef theData,
                                        long extraLength)

      • CFDataAppendBytes

        public static void CFDataAppendBytes​(CFMutableDataRef theData,
                                     java.lang.String bytes,
                                     long length)

      • CFDataReplaceBytes

        public static void CFDataReplaceBytes​(CFMutableDataRef theData,
                                      CFRange range,
                                      java.lang.String newBytes,
                                      long newLength)

      • CFArrayGetTypeID

        public static long CFArrayGetTypeID()
        [@function] CFArrayGetTypeID Returns the type identifier of all CFArray instances.

      • CFArrayCreate

        public static CFArrayRef CFArrayCreate​(CFAllocatorRef allocator,
                                       org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values,
                                       long numValues,
                                       CFArrayCallBacks callBacks)
        [@function] CFArrayCreate Creates a new immutable array with the given values.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        values - A C array of the pointer-sized values to be in the array. The values in the array are ordered in the same order in which they appear in this C array. This parameter may be NULL if the numValues parameter is 0. This C array is not changed or freed by this function. If this parameter is not a valid pointer to a C array of at least numValues pointers, the behavior is undefined.
        numValues - The number of values to copy from the values C array into the CFArray. This number will be the count of the array. If this parameter is negative, or greater than the number of values actually in the value's C array, the behavior is undefined.
        callBacks - A pointer to a CFArrayCallBacks structure initialized with the callbacks for the array to use on each value in the array. The retain callback will be used within this function, for example, to retain all of the new values from the values C array. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple array creations. If the version field of this callbacks structure is not one of the defined ones for CFArray, the behavior is undefined. The retain field may be NULL, in which case the CFArray will do nothing to add a retain to the contained values for the array. The release field may be NULL, in which case the CFArray will do nothing to remove the array's retain (if any) on the values when the array is destroyed. If the copyDescription field is NULL, the array will create a simple description for the value. If the equal field is NULL, the array will use pointer equality to test for equality of values. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFArrayCallBacks callbacks structure, the behavior is undefined. If any of the values put into the array is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        Returns:
        A reference to the new immutable CFArray.

      • CFArrayCreateCopy

        public static CFArrayRef CFArrayCreateCopy​(CFAllocatorRef allocator,
                                           CFArrayRef theArray)
        [@function] CFArrayCreateCopy Creates a new immutable array with the values from the given array.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theArray - The array which is to be copied. The values from the array are copied as pointers into the new array (that is, the values themselves are copied, not that which the values point to, if anything). However, the values are also retained by the new array. The count of the new array will be the same as the given array. The new array uses the same callbacks as the array to be copied. If this parameter is not a valid CFArray, the behavior is undefined.
        Returns:
        A reference to the new immutable CFArray.

      • CFArrayCreateMutable

        public static CFMutableArrayRef CFArrayCreateMutable​(CFAllocatorRef allocator,
                                                     long capacity,
                                                     CFArrayCallBacks callBacks)
        [@function] CFArrayCreateMutable Creates a new empty mutable array.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFArray. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. An array's actual capacity is only limited by address space and available memory constraints). If this parameter is negative, the behavior is undefined.
        callBacks - A pointer to a CFArrayCallBacks structure initialized with the callbacks for the array to use on each value in the array. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple array creations. If the version field of this callbacks structure is not one of the defined ones for CFArray, the behavior is undefined. The retain field may be NULL, in which case the CFArray will do nothing to add a retain to the contained values for the array. The release field may be NULL, in which case the CFArray will do nothing to remove the array's retain (if any) on the values when the array is destroyed. If the copyDescription field is NULL, the array will create a simple description for the value. If the equal field is NULL, the array will use pointer equality to test for equality of values. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFArrayCallBacks callbacks structure, the behavior is undefined. If any of the values put into the array is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        Returns:
        A reference to the new mutable CFArray.

      • CFArrayCreateMutableCopy

        public static CFMutableArrayRef CFArrayCreateMutableCopy​(CFAllocatorRef allocator,
                                                         long capacity,
                                                         CFArrayRef theArray)
        [@function] CFArrayCreateMutableCopy Creates a new mutable array with the values from the given array.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFArray. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. An array's actual capacity is only limited by address space and available memory constraints). This parameter must be greater than or equal to the count of the array which is to be copied, or the behavior is undefined. If this parameter is negative, the behavior is undefined.
        theArray - The array which is to be copied. The values from the array are copied as pointers into the new array (that is, the values themselves are copied, not that which the values point to, if anything). However, the values are also retained by the new array. The count of the new array will be the same as the given array. The new array uses the same callbacks as the array to be copied. If this parameter is not a valid CFArray, the behavior is undefined.
        Returns:
        A reference to the new mutable CFArray.

      • CFArrayGetCount

        public static long CFArrayGetCount​(CFArrayRef theArray)
        [@function] CFArrayGetCount Returns the number of values currently in the array.
        Parameters:
        theArray - The array to be queried. If this parameter is not a valid CFArray, the behavior is undefined.
        Returns:
        The number of values in the array.

      • CFArrayGetCountOfValue

        public static long CFArrayGetCountOfValue​(CFArrayRef theArray,
                                          CFRange range,
                                          org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFArrayGetCountOfValue Counts the number of times the given value occurs in the array.
        Parameters:
        theArray - The array to be searched. If this parameter is not a valid CFArray, the behavior is undefined.
        range - The range within the array to search. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0).
        value - The value for which to find matches in the array. The equal() callback provided when the array was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the array, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        The number of times the given value occurs in the array, within the specified range.

      • CFArrayContainsValue

        public static byte CFArrayContainsValue​(CFArrayRef theArray,
                                        CFRange range,
                                        org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFArrayContainsValue Reports whether or not the value is in the array.
        Parameters:
        theArray - The array to be searched. If this parameter is not a valid CFArray, the behavior is undefined.
        range - The range within the array to search. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0).
        value - The value for which to find matches in the array. The equal() callback provided when the array was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the array, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        true, if the value is in the specified range of the array, otherwise false.

      • CFArrayGetValueAtIndex

        public static org.moe.natj.general.ptr.ConstVoidPtr CFArrayGetValueAtIndex​(CFArrayRef theArray,
                                                                           long idx)
        [@function] CFArrayGetValueAtIndex Retrieves the value at the given index.
        Parameters:
        theArray - The array to be queried. If this parameter is not a valid CFArray, the behavior is undefined.
        idx - The index of the value to retrieve. If the index is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined.
        Returns:
        The value with the given index in the array.

      • CFArrayGetValues

        public static void CFArrayGetValues​(CFArrayRef theArray,
                                    CFRange range,
                                    org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values)
        [@function] CFArrayGetValues Fills the buffer with values from the array.
        Parameters:
        theArray - The array to be queried. If this parameter is not a valid CFArray, the behavior is undefined.
        range - The range of values within the array to retrieve. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0), in which case no values are put into the buffer.
        values - A C array of pointer-sized values to be filled with values from the array. The values in the C array are ordered in the same order in which they appear in the array. If this parameter is not a valid pointer to a C array of at least range.length pointers, the behavior is undefined.

      • CFArrayApplyFunction

        public static void CFArrayApplyFunction​(CFArrayRef theArray,
                                        CFRange range,
                                        CoreFoundation.Function_CFArrayApplyFunction applier,
                                        org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFArrayApplyFunction Calls a function once for each value in the array.
        Parameters:
        theArray - The array to be operated upon. If this parameter is not a valid CFArray, the behavior is undefined.
        range - The range of values within the array to which to apply the function. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0).
        applier - The callback function to call once for each value in the given range in the array. If this parameter is not a pointer to a function of the correct prototype, the behavior is undefined. If there are values in the range which the applier function does not expect or cannot properly apply to, the behavior is undefined.
        context - A pointer-sized user-defined value, which is passed as the second parameter to the applier function, but is otherwise unused by this function. If the context is not what is expected by the applier function, the behavior is undefined.

      • CFArrayGetFirstIndexOfValue

        public static long CFArrayGetFirstIndexOfValue​(CFArrayRef theArray,
                                               CFRange range,
                                               org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFArrayGetFirstIndexOfValue Searches the array for the value.
        Parameters:
        theArray - The array to be searched. If this parameter is not a valid CFArray, the behavior is undefined.
        range - The range within the array to search. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0). The search progresses from the smallest index defined by the range to the largest.
        value - The value for which to find a match in the array. The equal() callback provided when the array was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the array, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        The lowest index of the matching values in the range, or kCFNotFound if no value in the range matched.

      • CFArrayGetLastIndexOfValue

        public static long CFArrayGetLastIndexOfValue​(CFArrayRef theArray,
                                              CFRange range,
                                              org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFArrayGetLastIndexOfValue Searches the array for the value.
        Parameters:
        theArray - The array to be searched. If this parameter is not a valid CFArray, the behavior is undefined.
        range - The range within the array to search. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0). The search progresses from the largest index defined by the range to the smallest.
        value - The value for which to find a match in the array. The equal() callback provided when the array was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the array, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        The highest index of the matching values in the range, or kCFNotFound if no value in the range matched.

      • CFArrayBSearchValues

        public static long CFArrayBSearchValues​(CFArrayRef theArray,
                                        CFRange range,
                                        org.moe.natj.general.ptr.ConstVoidPtr value,
                                        CoreFoundation.Function_CFArrayBSearchValues comparator,
                                        org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFArrayBSearchValues Searches the array for the value using a binary search algorithm.
        Parameters:
        theArray - The array to be searched. If this parameter is not a valid CFArray, the behavior is undefined. If the array is not sorted from least to greatest according to the comparator function, the behavior is undefined.
        range - The range within the array to search. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0).
        value - The value for which to find a match in the array. If value, or any of the values in the array, are not understood by the comparator callback, the behavior is undefined.
        comparator - The function with the comparator function type signature which is used in the binary search operation to compare values in the array with the given value. If this parameter is not a pointer to a function of the correct prototype, the behavior is undefined. If there are values in the range which the comparator function does not expect or cannot properly compare, the behavior is undefined.
        context - A pointer-sized user-defined value, which is passed as the third parameter to the comparator function, but is otherwise unused by this function. If the context is not what is expected by the comparator function, the behavior is undefined.
        Returns:
        The return value is either 1) the index of a value that matched, if the target value matches one or more in the range, 2) greater than or equal to the end point of the range, if the value is greater than all the values in the range, or 3) the index of the value greater than the target value, if the value lies between two of (or less than all of) the values in the range.

      • CFArrayAppendValue

        public static void CFArrayAppendValue​(CFMutableArrayRef theArray,
                                      org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFArrayAppendValue Adds the value to the array giving it a new largest index.
        Parameters:
        theArray - The array to which the value is to be added. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        value - The value to add to the array. The value is retained by the array using the retain callback provided when the array was created. If the value is not of the sort expected by the retain callback, the behavior is undefined. The value is assigned to the index one larger than the previous largest index, and the count of the array is increased by one.

      • CFArrayInsertValueAtIndex

        public static void CFArrayInsertValueAtIndex​(CFMutableArrayRef theArray,
                                             long idx,
                                             org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFArrayInsertValueAtIndex Adds the value to the array, giving it the given index.
        Parameters:
        theArray - The array to which the value is to be added. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        idx - The index to which to add the new value. If the index is outside the index space of the array (0 to N inclusive, where N is the count of the array before the operation), the behavior is undefined. If the index is the same as N, this function has the same effect as CFArrayAppendValue().
        value - The value to add to the array. The value is retained by the array using the retain callback provided when the array was created. If the value is not of the sort expected by the retain callback, the behavior is undefined. The value is assigned to the given index, and all values with equal and larger indices have their indexes increased by one.

      • CFArraySetValueAtIndex

        public static void CFArraySetValueAtIndex​(CFMutableArrayRef theArray,
                                          long idx,
                                          org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFArraySetValueAtIndex Changes the value with the given index in the array.
        Parameters:
        theArray - The array in which the value is to be changed. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        idx - The index to which to set the new value. If the index is outside the index space of the array (0 to N inclusive, where N is the count of the array before the operation), the behavior is undefined. If the index is the same as N, this function has the same effect as CFArrayAppendValue().
        value - The value to set in the array. The value is retained by the array using the retain callback provided when the array was created, and the previous value with that index is released. If the value is not of the sort expected by the retain callback, the behavior is undefined. The indices of other values is not affected.

      • CFArrayRemoveValueAtIndex

        public static void CFArrayRemoveValueAtIndex​(CFMutableArrayRef theArray,
                                             long idx)
        [@function] CFArrayRemoveValueAtIndex Removes the value with the given index from the array.
        Parameters:
        theArray - The array from which the value is to be removed. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        idx - The index from which to remove the value. If the index is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array before the operation), the behavior is undefined.

      • CFArrayRemoveAllValues

        public static void CFArrayRemoveAllValues​(CFMutableArrayRef theArray)
        [@function] CFArrayRemoveAllValues Removes all the values from the array, making it empty.
        Parameters:
        theArray - The array from which all of the values are to be removed. If this parameter is not a valid mutable CFArray, the behavior is undefined.

      • CFArrayReplaceValues

        public static void CFArrayReplaceValues​(CFMutableArrayRef theArray,
                                        CFRange range,
                                        org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> newValues,
                                        long newCount)
        [@function] CFArrayReplaceValues Replaces a range of values in the array.
        Parameters:
        theArray - The array from which all of the values are to be removed. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        range - The range of values within the array to replace. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0), in which case the new values are merely inserted at the range location.
        newValues - A C array of the pointer-sized values to be placed into the array. The new values in the array are ordered in the same order in which they appear in this C array. This parameter may be NULL if the newCount parameter is 0. This C array is not changed or freed by this function. If this parameter is not a valid pointer to a C array of at least newCount pointers, the behavior is undefined.
        newCount - The number of values to copy from the values C array into the CFArray. If this parameter is different than the range length, the excess newCount values will be inserted after the range, or the excess range values will be deleted. This parameter may be 0, in which case no new values are replaced into the array and the values in the range are simply removed. If this parameter is negative, or greater than the number of values actually in the newValues C array, the behavior is undefined.

      • CFArrayExchangeValuesAtIndices

        public static void CFArrayExchangeValuesAtIndices​(CFMutableArrayRef theArray,
                                                  long idx1,
                                                  long idx2)
        [@function] CFArrayExchangeValuesAtIndices Exchanges the values at two indices of the array.
        Parameters:
        theArray - The array of which the values are to be swapped. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        idx1 - The first index whose values should be swapped. If the index is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array before the operation), the behavior is undefined.
        idx2 - The second index whose values should be swapped. If the index is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array before the operation), the behavior is undefined.

      • CFArraySortValues

        public static void CFArraySortValues​(CFMutableArrayRef theArray,
                                     CFRange range,
                                     CoreFoundation.Function_CFArraySortValues comparator,
                                     org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFArraySortValues Sorts the values in the array using the given comparison function.
        Parameters:
        theArray - The array whose values are to be sorted. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        range - The range of values within the array to sort. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the array (0 to N-1 inclusive, where N is the count of the array), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0).
        comparator - The function with the comparator function type signature which is used in the sort operation to compare values in the array with the given value. If this parameter is not a pointer to a function of the correct prototype, the the behavior is undefined. If there are values in the array which the comparator function does not expect or cannot properly compare, the behavior is undefined. The values in the range are sorted from least to greatest according to this function.
        context - A pointer-sized user-defined value, which is passed as the third parameter to the comparator function, but is otherwise unused by this function. If the context is not what is expected by the comparator function, the behavior is undefined.

      • CFArrayAppendArray

        public static void CFArrayAppendArray​(CFMutableArrayRef theArray,
                                      CFArrayRef otherArray,
                                      CFRange otherRange)
        [@function] CFArrayAppendArray Adds the values from an array to another array.
        Parameters:
        theArray - The array to which values from the otherArray are to be added. If this parameter is not a valid mutable CFArray, the behavior is undefined.
        otherArray - The array providing the values to be added to the array. If this parameter is not a valid CFArray, the behavior is undefined.
        otherRange - The range within the otherArray from which to add the values to the array. If the range location or end point (defined by the location plus length minus 1) is outside the index space of the otherArray (0 to N-1 inclusive, where N is the count of the otherArray), the behavior is undefined. The new values are retained by the array using the retain callback provided when the array was created. If the values are not of the sort expected by the retain callback, the behavior is undefined. The values are assigned to the indices one larger than the previous largest index in the array, and beyond, and the count of the array is increased by range.length. The values are assigned new indices in the array from smallest to largest index in the order in which they appear in the otherArray.

      • CFCharacterSetGetTypeID

        public static long CFCharacterSetGetTypeID()
        [@function] CFCharacterSetGetTypeID Returns the type identifier of all CFCharacterSet instances.

      • CFCharacterSetGetPredefined

        public static CFCharacterSetRef CFCharacterSetGetPredefined​(long theSetIdentifier)
        [@function] CFCharacterSetGetPredefined Returns a predefined CFCharacterSet instance.
        Parameters:
        theSetIdentifier - The CFCharacterSetPredefinedSet selector which specifies the predefined character set. If the value is not in CFCharacterSetPredefinedSet, the behavior is undefined.
        Returns:
        A reference to the predefined immutable CFCharacterSet. This instance is owned by CF.

      • CFCharacterSetCreateWithCharactersInRange

        public static CFCharacterSetRef CFCharacterSetCreateWithCharactersInRange​(CFAllocatorRef alloc,
                                                                          CFRange theRange)
        [@function] CFCharacterSetCreateWithCharactersInRange Creates a new immutable character set with the values from the given range.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theRange - The CFRange which should be used to specify the Unicode range the character set is filled with. It accepts the range in 32-bit in the UTF-32 format. The valid character point range is from 0x00000 to 0x10FFFF. If the range is outside of the valid Unicode character point, the behavior is undefined.
        Returns:
        A reference to the new immutable CFCharacterSet.

      • CFCharacterSetCreateWithCharactersInString

        public static CFCharacterSetRef CFCharacterSetCreateWithCharactersInString​(CFAllocatorRef alloc,
                                                                           CFStringRef theString)
        [@function] CFCharacterSetCreateWithCharactersInString Creates a new immutable character set with the values in the given string.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theString - The CFString which should be used to specify the Unicode characters the character set is filled with. If this parameter is not a valid CFString, the behavior is undefined.
        Returns:
        A reference to the new immutable CFCharacterSet.

      • CFCharacterSetCreateWithBitmapRepresentation

        public static CFCharacterSetRef CFCharacterSetCreateWithBitmapRepresentation​(CFAllocatorRef alloc,
                                                                             CFDataRef theData)
        [@function] CFCharacterSetCreateWithBitmapRepresentation Creates a new immutable character set with the bitmap representtion in the given data.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theData - The CFData which should be used to specify the bitmap representation of the Unicode character points the character set is filled with. The bitmap representation could contain all the Unicode character range starting from BMP to Plane 16. The first 8192 bytes of the data represent the BMP range. The BMP range 8192 bytes can be followed by zero to sixteen 8192 byte bitmaps, each one with the plane index byte prepended. For example, the bitmap representing the BMP and Plane 2 has the size of 16385 bytes (8192 bytes for BMP, 1 byte index + 8192 bytes bitmap for Plane 2). The plane index byte, in this case, contains the integer value two. If this parameter is not a valid CFData or it contains a Plane index byte outside of the valid Plane range (1 to 16), the behavior is undefined.
        Returns:
        A reference to the new immutable CFCharacterSet.

      • CFCharacterSetCreateInvertedSet

        public static CFCharacterSetRef CFCharacterSetCreateInvertedSet​(CFAllocatorRef alloc,
                                                                CFCharacterSetRef theSet)
        [@function] CFCharacterSetCreateInvertedSet Creates a new immutable character set that is the invert of the specified character set.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theSet - The CFCharacterSet which is to be inverted. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        Returns:
        A reference to the new immutable CFCharacterSet.

      • CFCharacterSetIsSupersetOfSet

        public static byte CFCharacterSetIsSupersetOfSet​(CFCharacterSetRef theSet,
                                                 CFCharacterSetRef theOtherset)
        [@function] CFCharacterSetIsSupersetOfSet Reports whether or not the character set is a superset of the character set specified as the second parameter.
        Parameters:
        theSet - The character set to be checked for the membership of theOtherSet. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        theOtherset - The character set to be checked whether or not it is a subset of theSet. If this parameter is not a valid CFCharacterSet, the behavior is undefined.

      • CFCharacterSetHasMemberInPlane

        public static byte CFCharacterSetHasMemberInPlane​(CFCharacterSetRef theSet,
                                                  long thePlane)
        [@function] CFCharacterSetHasMemberInPlane Reports whether or not the character set contains at least one member character in the specified plane.
        Parameters:
        theSet - The character set to be checked for the membership. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        thePlane - The plane number to be checked for the membership. The valid value range is from 0 to 16. If the value is outside of the valid plane number range, the behavior is undefined.

      • CFCharacterSetCreateMutable

        public static CFMutableCharacterSetRef CFCharacterSetCreateMutable​(CFAllocatorRef alloc)
        [@function] CFCharacterSetCreateMutable Creates a new empty mutable character set.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        Returns:
        A reference to the new mutable CFCharacterSet.

      • CFCharacterSetCreateCopy

        public static CFCharacterSetRef CFCharacterSetCreateCopy​(CFAllocatorRef alloc,
                                                         CFCharacterSetRef theSet)
        [@function] CFCharacterSetCreateCopy Creates a new character set with the values from the given character set. This function tries to compact the backing store where applicable.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theSet - The CFCharacterSet which is to be copied. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        Returns:
        A reference to the new CFCharacterSet.

      • CFCharacterSetCreateMutableCopy

        public static CFMutableCharacterSetRef CFCharacterSetCreateMutableCopy​(CFAllocatorRef alloc,
                                                                       CFCharacterSetRef theSet)
        [@function] CFCharacterSetCreateMutableCopy Creates a new mutable character set with the values from the given character set.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theSet - The CFCharacterSet which is to be copied. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        Returns:
        A reference to the new mutable CFCharacterSet.

      • CFCharacterSetIsCharacterMember

        public static byte CFCharacterSetIsCharacterMember​(CFCharacterSetRef theSet,
                                                   char theChar)
        [@function] CFCharacterSetIsCharacterMember Reports whether or not the Unicode character is in the character set.
        Parameters:
        theSet - The character set to be searched. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        theChar - The Unicode character for which to test against the character set. Note that this function takes 16-bit Unicode character value; hence, it does not support access to the non-BMP planes.
        Returns:
        true, if the value is in the character set, otherwise false.

      • CFCharacterSetIsLongCharacterMember

        public static byte CFCharacterSetIsLongCharacterMember​(CFCharacterSetRef theSet,
                                                       int theChar)
        [@function] CFCharacterSetIsLongCharacterMember Reports whether or not the UTF-32 character is in the character set.
        Parameters:
        theSet - The character set to be searched. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        theChar - The UTF-32 character for which to test against the character set.
        Returns:
        true, if the value is in the character set, otherwise false.

      • CFCharacterSetCreateBitmapRepresentation

        public static CFDataRef CFCharacterSetCreateBitmapRepresentation​(CFAllocatorRef alloc,
                                                                 CFCharacterSetRef theSet)
        [@function] CFCharacterSetCreateBitmapRepresentation Creates a new immutable data with the bitmap representation from the given character set.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the array and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theSet - The CFCharacterSet which is to be used create the bitmap representation from. Refer to the comments for CFCharacterSetCreateWithBitmapRepresentation for the detailed discussion of the bitmap representation format. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        Returns:
        A reference to the new immutable CFData.

      • CFCharacterSetAddCharactersInRange

        public static void CFCharacterSetAddCharactersInRange​(CFMutableCharacterSetRef theSet,
                                                      CFRange theRange)
        [@function] CFCharacterSetAddCharactersInRange Adds the given range to the charaacter set.
        Parameters:
        theSet - The character set to which the range is to be added. If this parameter is not a valid mutable CFCharacterSet, the behavior is undefined.
        theRange - The range to add to the character set. It accepts the range in 32-bit in the UTF-32 format. The valid character point range is from 0x00000 to 0x10FFFF. If the range is outside of the valid Unicode character point, the behavior is undefined.

      • CFCharacterSetRemoveCharactersInRange

        public static void CFCharacterSetRemoveCharactersInRange​(CFMutableCharacterSetRef theSet,
                                                         CFRange theRange)
        [@function] CFCharacterSetRemoveCharactersInRange Removes the given range from the charaacter set.
        Parameters:
        theSet - The character set from which the range is to be removed. If this parameter is not a valid mutable CFCharacterSet, the behavior is undefined.
        theRange - The range to remove from the character set. It accepts the range in 32-bit in the UTF-32 format. The valid character point range is from 0x00000 to 0x10FFFF. If the range is outside of the valid Unicode character point, the behavior is undefined.

      • CFCharacterSetAddCharactersInString

        public static void CFCharacterSetAddCharactersInString​(CFMutableCharacterSetRef theSet,
                                                       CFStringRef theString)
        [@function] CFCharacterSetAddCharactersInString Adds the characters in the given string to the charaacter set.
        Parameters:
        theSet - The character set to which the characters in the string are to be added. If this parameter is not a valid mutable CFCharacterSet, the behavior is undefined.
        theString - The string to add to the character set. If this parameter is not a valid CFString, the behavior is undefined.

      • CFCharacterSetRemoveCharactersInString

        public static void CFCharacterSetRemoveCharactersInString​(CFMutableCharacterSetRef theSet,
                                                          CFStringRef theString)
        [@function] CFCharacterSetRemoveCharactersInString Removes the characters in the given string from the charaacter set.
        Parameters:
        theSet - The character set from which the characters in the string are to be remove. If this parameter is not a valid mutable CFCharacterSet, the behavior is undefined.
        theString - The string to remove from the character set. If this parameter is not a valid CFString, the behavior is undefined.

      • CFCharacterSetUnion

        public static void CFCharacterSetUnion​(CFMutableCharacterSetRef theSet,
                                       CFCharacterSetRef theOtherSet)
        [@function] CFCharacterSetUnion Forms the union with the given character set.
        Parameters:
        theSet - The destination character set into which the union of the two character sets is stored. If this parameter is not a valid mutable CFCharacterSet, the behavior is undefined.
        theOtherSet - The character set with which the union is formed. If this parameter is not a valid CFCharacterSet, the behavior is undefined.

      • CFCharacterSetIntersect

        public static void CFCharacterSetIntersect​(CFMutableCharacterSetRef theSet,
                                           CFCharacterSetRef theOtherSet)
        [@function] CFCharacterSetIntersect Forms the intersection with the given character set.
        Parameters:
        theSet - The destination character set into which the intersection of the two character sets is stored. If this parameter is not a valid mutable CFCharacterSet, the behavior is undefined.
        theOtherSet - The character set with which the intersection is formed. If this parameter is not a valid CFCharacterSet, the behavior is undefined.

      • CFCharacterSetInvert

        public static void CFCharacterSetInvert​(CFMutableCharacterSetRef theSet)
        [@function] CFCharacterSetInvert Inverts the content of the given character set.
        Parameters:
        theSet - The character set to be inverted. If this parameter is not a valid mutable CFCharacterSet, the behavior is undefined.

      • CFNotificationCenterGetTypeID

        public static long CFNotificationCenterGetTypeID()

      • CFNotificationCenterGetDarwinNotifyCenter

        public static CFNotificationCenterRef CFNotificationCenterGetDarwinNotifyCenter()

      • CFNotificationCenterAddObserver

        public static void CFNotificationCenterAddObserver​(CFNotificationCenterRef center,
                                                   org.moe.natj.general.ptr.ConstVoidPtr observer,
                                                   CoreFoundation.Function_CFNotificationCenterAddObserver callBack,
                                                   CFStringRef name,
                                                   org.moe.natj.general.ptr.ConstVoidPtr object,
                                                   long suspensionBehavior)
        The Darwin Notify Center is based on the API. For this center, there are limitations in the API. There are no notification "objects", "userInfo" cannot be passed in the notification, and there are no suspension behaviors (always "deliver immediately"). Other limitations in the API as described in that header will also apply. - In the CFNotificationCallback, the 'object' and 'userInfo' parameters must be ignored. - CFNotificationCenterAddObserver(): the 'object' and 'suspensionBehavior' arguments are ignored. - CFNotificationCenterAddObserver(): the 'name' argument may not be NULL (for this center). - CFNotificationCenterRemoveObserver(): the 'object' argument is ignored. - CFNotificationCenterPostNotification(): the 'object', 'userInfo', and 'deliverImmediately' arguments are ignored. - CFNotificationCenterPostNotificationWithOptions(): the 'object', 'userInfo', and 'options' arguments are ignored. The Darwin Notify Center has no notion of per-user sessions, all notifications are system-wide. As with distributed notifications, the main thread's run loop must be running in one of the common modes (usually kCFRunLoopDefaultMode) for Darwin-style notifications to be delivered. NOTE: NULL or 0 should be passed for all ignored arguments to ensure future compatibility.

      • CFNotificationCenterRemoveObserver

        public static void CFNotificationCenterRemoveObserver​(CFNotificationCenterRef center,
                                                      org.moe.natj.general.ptr.ConstVoidPtr observer,
                                                      CFStringRef name,
                                                      org.moe.natj.general.ptr.ConstVoidPtr object)

      • CFNotificationCenterRemoveEveryObserver

        public static void CFNotificationCenterRemoveEveryObserver​(CFNotificationCenterRef center,
                                                           org.moe.natj.general.ptr.ConstVoidPtr observer)

      • CFNotificationCenterPostNotification

        public static void CFNotificationCenterPostNotification​(CFNotificationCenterRef center,
                                                        CFStringRef name,
                                                        org.moe.natj.general.ptr.ConstVoidPtr object,
                                                        CFDictionaryRef userInfo,
                                                        byte deliverImmediately)

      • CFNotificationCenterPostNotificationWithOptions

        public static void CFNotificationCenterPostNotificationWithOptions​(CFNotificationCenterRef center,
                                                                   CFStringRef name,
                                                                   org.moe.natj.general.ptr.ConstVoidPtr object,
                                                                   CFDictionaryRef userInfo,
                                                                   long options)

      • CFLocaleGetTypeID

        public static long CFLocaleGetTypeID()

      • CFLocaleGetSystem

        public static CFLocaleRef CFLocaleGetSystem()

      • CFLocaleCopyCurrent

        public static CFLocaleRef CFLocaleCopyCurrent()
        Returns the "root", canonical locale. Contains fixed "backstop" settings.

      • CFLocaleCopyAvailableLocaleIdentifiers

        public static CFArrayRef CFLocaleCopyAvailableLocaleIdentifiers()
        Returns the logical "user" locale for the current user. [This is Copy in the sense that you get a retain you have to release, but we may return the same cached object over and over.] Settings you get from this locale do not change under you as CFPreferences are changed (for safety and correctness). Generally you would not grab this and hold onto it forever, but use it to do the operations you need to do at the moment, then throw it away. (The non-changing ensures that all the results of your operations are consistent.)

      • CFLocaleCopyISOLanguageCodes

        public static CFArrayRef CFLocaleCopyISOLanguageCodes()
        Returns an array of CFStrings that represents all locales for which locale data is available.

      • CFLocaleCopyISOCountryCodes

        public static CFArrayRef CFLocaleCopyISOCountryCodes()
        Returns an array of CFStrings that represents all known legal ISO language codes. Note: many of these will not have any supporting locale data in Mac OS X.

      • CFLocaleCopyISOCurrencyCodes

        public static CFArrayRef CFLocaleCopyISOCurrencyCodes()
        Returns an array of CFStrings that represents all known legal ISO country codes. Note: many of these will not have any supporting locale data in Mac OS X.

      • CFLocaleCopyCommonISOCurrencyCodes

        public static CFArrayRef CFLocaleCopyCommonISOCurrencyCodes()
        Returns an array of CFStrings that represents all known legal ISO currency codes. Note: some of these currencies may be obsolete, or represent other financial instruments.

      • CFLocaleCopyPreferredLanguages

        public static CFArrayRef CFLocaleCopyPreferredLanguages()
        Returns an array of CFStrings that represents ISO currency codes for currencies in common use.

      • CFLocaleCreateCanonicalLanguageIdentifierFromString

        public static CFStringRef CFLocaleCreateCanonicalLanguageIdentifierFromString​(CFAllocatorRef allocator,
                                                                              CFStringRef localeIdentifier)
        Returns the array of canonicalized CFString locale IDs that the user prefers.

      • CFLocaleCreateCanonicalLocaleIdentifierFromString

        public static CFStringRef CFLocaleCreateCanonicalLocaleIdentifierFromString​(CFAllocatorRef allocator,
                                                                            CFStringRef localeIdentifier)
        Map an arbitrary language identification string (something close at least) to a canonical language identifier.

      • CFLocaleCreateCanonicalLocaleIdentifierFromScriptManagerCodes

        public static CFStringRef CFLocaleCreateCanonicalLocaleIdentifierFromScriptManagerCodes​(CFAllocatorRef allocator,
                                                                                        short lcode,
                                                                                        short rcode)
        Map an arbitrary locale identification string (something close at least) to the canonical identifier.

      • CFLocaleCreateLocaleIdentifierFromWindowsLocaleCode

        public static CFStringRef CFLocaleCreateLocaleIdentifierFromWindowsLocaleCode​(CFAllocatorRef allocator,
                                                                              int lcid)
        Map a Mac OS LangCode and RegionCode to the canonical locale identifier.

      • CFLocaleGetWindowsLocaleCodeFromLocaleIdentifier

        public static int CFLocaleGetWindowsLocaleCodeFromLocaleIdentifier​(CFStringRef localeIdentifier)
        Map a Windows LCID to the canonical locale identifier.

      • CFLocaleGetLanguageCharacterDirection

        public static long CFLocaleGetLanguageCharacterDirection​(CFStringRef isoLangCode)

      • CFLocaleGetLanguageLineDirection

        public static long CFLocaleGetLanguageLineDirection​(CFStringRef isoLangCode)

      • CFLocaleCreateLocaleIdentifierFromComponents

        public static CFStringRef CFLocaleCreateLocaleIdentifierFromComponents​(CFAllocatorRef allocator,
                                                                       CFDictionaryRef dictionary)
        Parses a locale ID consisting of language, script, country, variant, and keyword/value pairs into a dictionary. The keys are the constant CFStrings corresponding to the locale ID components, and the values will correspond to constants where available. Example: "en_US@calendar=japanese" yields a dictionary with three entries: kCFLocaleLanguageCode=en, kCFLocaleCountryCode=US, and kCFLocaleCalendarIdentifier=kCFJapaneseCalendar.

      • CFLocaleCreate

        public static CFLocaleRef CFLocaleCreate​(CFAllocatorRef allocator,
                                         CFStringRef localeIdentifier)
        Reverses the actions of CFLocaleCreateDictionaryFromLocaleIdentifier, creating a single string from the data in the dictionary. The dictionary {kCFLocaleLanguageCode=en, kCFLocaleCountryCode=US, kCFLocaleCalendarIdentifier=kCFJapaneseCalendar} becomes "en_US@calendar=japanese".

      • CFLocaleCreateCopy

        public static CFLocaleRef CFLocaleCreateCopy​(CFAllocatorRef allocator,
                                             CFLocaleRef locale)
        Returns a CFLocaleRef for the locale named by the "arbitrary" locale identifier.

      • CFLocaleGetIdentifier

        public static CFStringRef CFLocaleGetIdentifier​(CFLocaleRef locale)
        Having gotten a CFLocale from somebody, code should make a copy if it is going to use it for several operations or hold onto it. In the future, there may be mutable locales.

      • CFLocaleGetValue

        public static org.moe.natj.general.ptr.ConstVoidPtr CFLocaleGetValue​(CFLocaleRef locale,
                                                                     CFStringRef key)
        Returns the locale's identifier. This may not be the same string that the locale was created with (CFLocale may canonicalize it).

      • CFLocaleCopyDisplayNameForPropertyValue

        public static CFStringRef CFLocaleCopyDisplayNameForPropertyValue​(CFLocaleRef displayLocale,
                                                                  CFStringRef key,
                                                                  CFStringRef value)
        Returns the value for the given key. This is how settings and state are accessed via a CFLocale. Values might be of any CF type.

      • CFStringGetTypeID

        public static long CFStringGetTypeID()
        CFString type ID

      • CFStringCreateWithPascalString

        public static CFStringRef CFStringCreateWithPascalString​(CFAllocatorRef alloc,
                                                         java.lang.String pStr,
                                                         int encoding)
        The following four functions copy the provided buffer into CFString's internal storage.

      • CFStringCreateWithCString

        public static CFStringRef CFStringCreateWithCString​(CFAllocatorRef alloc,
                                                    java.lang.String cStr,
                                                    int encoding)

      • CFStringCreateWithBytes

        public static CFStringRef CFStringCreateWithBytes​(CFAllocatorRef alloc,
                                                  java.lang.String bytes,
                                                  long numBytes,
                                                  int encoding,
                                                  byte isExternalRepresentation)
        The following takes an explicit length, and allows you to specify whether the data is an external format --- that is, whether to pay attention to the BOM character (if any) and do byte swapping if necessary

      • CFStringCreateWithCharacters

        public static CFStringRef CFStringCreateWithCharacters​(CFAllocatorRef alloc,
                                                       org.moe.natj.general.ptr.ConstCharPtr chars,
                                                       long numChars)

      • CFStringCreateWithPascalStringNoCopy

        public static CFStringRef CFStringCreateWithPascalStringNoCopy​(CFAllocatorRef alloc,
                                                               java.lang.String pStr,
                                                               int encoding,
                                                               CFAllocatorRef contentsDeallocator)
        These functions try not to copy the provided buffer. The buffer will be deallocated with the provided contentsDeallocator when it's no longer needed; to not free the buffer, specify kCFAllocatorNull here. As usual, NULL means default allocator. NOTE: Do not count on these buffers as being used by the string; in some cases the CFString might free the buffer and use something else (for instance if it decides to always use Unicode encoding internally). NOTE: If you are not transferring ownership of the buffer to the CFString (for instance, you supplied contentsDeallocator = kCFAllocatorNull), it is your responsibility to assure the buffer does not go away during the lifetime of the string. If the string is retained or copied, its lifetime might extend in ways you cannot predict. So, for strings created with buffers whose lifetimes you cannot guarantee, you need to be extremely careful --- do not hand it out to any APIs which might retain or copy the strings.

      • CFStringCreateWithCStringNoCopy

        public static CFStringRef CFStringCreateWithCStringNoCopy​(CFAllocatorRef alloc,
                                                          java.lang.String cStr,
                                                          int encoding,
                                                          CFAllocatorRef contentsDeallocator)

      • CFStringCreateWithBytesNoCopy

        public static CFStringRef CFStringCreateWithBytesNoCopy​(CFAllocatorRef alloc,
                                                        java.lang.String bytes,
                                                        long numBytes,
                                                        int encoding,
                                                        byte isExternalRepresentation,
                                                        CFAllocatorRef contentsDeallocator)
        The following takes an explicit length, and allows you to specify whether the data is an external format --- that is, whether to pay attention to the BOM character (if any) and do byte swapping if necessary

      • CFStringCreateWithCharactersNoCopy

        public static CFStringRef CFStringCreateWithCharactersNoCopy​(CFAllocatorRef alloc,
                                                             org.moe.natj.general.ptr.ConstCharPtr chars,
                                                             long numChars,
                                                             CFAllocatorRef contentsDeallocator)

      • CFStringCreateWithFormat

        public static CFStringRef CFStringCreateWithFormat​(CFAllocatorRef alloc,
                                                   CFDictionaryRef formatOptions,
                                                   CFStringRef format,
                                                   java.lang.Object... varargs)
        These functions create a CFString from the provided printf-like format string and arguments.

      • CFStringCreateMutable

        public static CFMutableStringRef CFStringCreateMutable​(CFAllocatorRef alloc,
                                                       long maxLength)
        Functions to create mutable strings. "maxLength", if not 0, is a hard bound on the length of the string. If 0, there is no limit on the length.

      • CFStringCreateMutableWithExternalCharactersNoCopy

        public static CFMutableStringRef CFStringCreateMutableWithExternalCharactersNoCopy​(CFAllocatorRef alloc,
                                                                                   org.moe.natj.general.ptr.CharPtr chars,
                                                                                   long numChars,
                                                                                   long capacity,
                                                                                   CFAllocatorRef externalCharactersAllocator)
        This function creates a mutable string that has a developer supplied and directly editable backing store. The string will be manipulated within the provided buffer (if any) until it outgrows capacity; then the externalCharactersAllocator will be consulted for more memory. When the CFString is deallocated, the buffer will be freed with the externalCharactersAllocator. If you provide kCFAllocatorNull here, and the buffer needs to grow, then CFString will switch to using the default allocator. See comments at top of this file for more info.

      • CFStringGetLength

        public static long CFStringGetLength​(CFStringRef theString)
        Number of 16-bit Unicode characters in the string.

      • CFStringGetCharacterAtIndex

        public static char CFStringGetCharacterAtIndex​(CFStringRef theString,
                                               long idx)
        Extracting the contents of the string. For obtaining multiple characters, calling CFStringGetCharacters() is more efficient than multiple calls to CFStringGetCharacterAtIndex(). If the length of the string is not known (so you can't use a fixed size buffer for CFStringGetCharacters()), another method is to use is CFStringGetCharacterFromInlineBuffer() (see further below).

      • CFStringGetCharacters

        public static void CFStringGetCharacters​(CFStringRef theString,
                                         CFRange range,
                                         org.moe.natj.general.ptr.CharPtr buffer)

      • CFStringGetPascalString

        public static byte CFStringGetPascalString​(CFStringRef theString,
                                           org.moe.natj.general.ptr.BytePtr buffer,
                                           long bufferSize,
                                           int encoding)
        These two convert into the provided buffer; they return false if conversion isn't possible (due to conversion error, or not enough space in the provided buffer). These functions do zero-terminate or put the length byte; the provided bufferSize should include space for this (so pass 256 for Str255). More sophisticated usages can go through CFStringGetBytes(). These functions are equivalent to calling CFStringGetBytes() with the range of the string; lossByte = 0; and isExternalRepresentation = false; if successful, they then insert the leading length or terminating zero, as desired.

      • CFStringGetCString

        public static byte CFStringGetCString​(CFStringRef theString,
                                      org.moe.natj.general.ptr.BytePtr buffer,
                                      long bufferSize,
                                      int encoding)

      • CFStringGetPascalStringPtr

        public static java.lang.String CFStringGetPascalStringPtr​(CFStringRef theString,
                                                          int encoding)
        These functions attempt to return in O(1) time the desired format for the string. Note that although this means a pointer to the internal structure is being returned, this can't always be counted on. Please see note at the top of the file for more details.

      • CFStringGetCStringPtr

        public static java.lang.String CFStringGetCStringPtr​(CFStringRef theString,
                                                     int encoding)

      • CFStringGetCharactersPtr

        public static org.moe.natj.general.ptr.ConstCharPtr CFStringGetCharactersPtr​(CFStringRef theString)

      • CFStringGetBytes

        public static long CFStringGetBytes​(CFStringRef theString,
                                    CFRange range,
                                    int encoding,
                                    byte lossByte,
                                    byte isExternalRepresentation,
                                    org.moe.natj.general.ptr.BytePtr buffer,
                                    long maxBufLen,
                                    org.moe.natj.general.ptr.NIntPtr usedBufLen)
        The primitive conversion routine; allows you to convert a string piece at a time into a fixed size buffer. Returns number of characters converted. Characters that cannot be converted to the specified encoding are represented with the byte specified by lossByte; if lossByte is 0, then lossy conversion is not allowed and conversion stops, returning partial results. Pass buffer==NULL if you don't care about the converted string (but just the convertability, or number of bytes required). maxBufLength indicates the maximum number of bytes to generate. It is ignored when buffer==NULL. Does not zero-terminate. If you want to create Pascal or C string, allow one extra byte at start or end. Setting isExternalRepresentation causes any extra bytes that would allow the data to be made persistent to be included; for instance, the Unicode BOM. Note that CFString prepends UTF encoded data with the Unicode BOM when generating external representation if the target encoding allows. It's important to note that only UTF-8, UTF-16, and UTF-32 define the handling of the byte order mark character, and the "LE" and "BE" variants of UTF-16 and UTF-32 don't.

      • CFStringCreateFromExternalRepresentation

        public static CFStringRef CFStringCreateFromExternalRepresentation​(CFAllocatorRef alloc,
                                                                   CFDataRef data,
                                                                   int encoding)
        Convenience functions String <-> Data. These generate "external" formats, that is, formats that can be written out to disk. For instance, if the encoding is Unicode, CFStringCreateFromExternalRepresentation() pays attention to the BOM character (if any) and does byte swapping if necessary. Similarly CFStringCreateExternalRepresentation() will include a BOM character if appropriate. See CFStringGetBytes() for more on this and lossByte.

      • CFStringCreateExternalRepresentation

        public static CFDataRef CFStringCreateExternalRepresentation​(CFAllocatorRef alloc,
                                                             CFStringRef theString,
                                                             int encoding,
                                                             byte lossByte)

      • CFStringGetSmallestEncoding

        public static int CFStringGetSmallestEncoding​(CFStringRef theString)
        Hints about the contents of a string

      • CFStringGetFastestEncoding

        public static int CFStringGetFastestEncoding​(CFStringRef theString)

      • CFStringGetSystemEncoding

        public static int CFStringGetSystemEncoding()
        General encoding info

      • CFStringGetMaximumSizeForEncoding

        public static long CFStringGetMaximumSizeForEncoding​(long length,
                                                     int encoding)

      • CFStringGetFileSystemRepresentation

        public static byte CFStringGetFileSystemRepresentation​(CFStringRef string,
                                                       org.moe.natj.general.ptr.BytePtr buffer,
                                                       long maxBufLen)
        Extract the contents of the string as a NULL-terminated 8-bit string appropriate for passing to POSIX APIs (for example, normalized for HFS+). The string is zero-terminated. false will be returned if the conversion results don't fit into the buffer. Use CFStringGetMaximumSizeOfFileSystemRepresentation() if you want to make sure the buffer is of sufficient length.

      • CFStringGetMaximumSizeOfFileSystemRepresentation

        public static long CFStringGetMaximumSizeOfFileSystemRepresentation​(CFStringRef string)
        Get the upper bound on the number of bytes required to hold the file system representation for the string. This result is returned quickly as a very rough approximation, and could be much larger than the actual space required. The result includes space for the zero termination. If you are allocating a buffer for long-term keeping, it's recommended that you reallocate it smaller (to be the right size) after calling CFStringGetFileSystemRepresentation().

      • CFStringCreateWithFileSystemRepresentation

        public static CFStringRef CFStringCreateWithFileSystemRepresentation​(CFAllocatorRef alloc,
                                                                     java.lang.String buffer)
        Create a CFString from the specified zero-terminated POSIX file system representation. If the conversion fails (possible due to bytes in the buffer not being a valid sequence of bytes for the appropriate character encoding), NULL is returned.

      • CFStringCompareWithOptionsAndLocale

        public static long CFStringCompareWithOptionsAndLocale​(CFStringRef theString1,
                                                       CFStringRef theString2,
                                                       CFRange rangeToCompare,
                                                       long compareOptions,
                                                       CFLocaleRef locale)
        The main comparison routine; compares specified range of the first string to (the full range of) the second string. locale == NULL indicates canonical locale (the return value from CFLocaleGetSystem()). kCFCompareNumerically, added in 10.2, does not work if kCFCompareLocalized is specified on systems before 10.3 kCFCompareBackwards and kCFCompareAnchored are not applicable. rangeToCompare applies to the first string; that is, only the substring of theString1 specified by rangeToCompare is compared against all of theString2.

      • CFStringCompareWithOptions

        public static long CFStringCompareWithOptions​(CFStringRef theString1,
                                              CFStringRef theString2,
                                              CFRange rangeToCompare,
                                              long compareOptions)
        Comparison convenience. Uses the current user locale (the return value from CFLocaleCopyCurrent()) if kCFCompareLocalized. Refer to CFStringCompareWithOptionsAndLocale() for more info.

      • CFStringCompare

        public static long CFStringCompare​(CFStringRef theString1,
                                   CFStringRef theString2,
                                   long compareOptions)
        Comparison convenience suitable for passing as sorting functions. kCFCompareNumerically, added in 10.2, does not work if kCFCompareLocalized is specified on systems before 10.3 kCFCompareBackwards and kCFCompareAnchored are not applicable.

      • CFStringFindWithOptionsAndLocale

        public static byte CFStringFindWithOptionsAndLocale​(CFStringRef theString,
                                                    CFStringRef stringToFind,
                                                    CFRange rangeToSearch,
                                                    long searchOptions,
                                                    CFLocaleRef locale,
                                                    CFRange result)
        CFStringFindWithOptionsAndLocale() returns the found range in the CFRange * argument; you can pass NULL for simple discovery check. locale == NULL indicates canonical locale (the return value from CFLocaleGetSystem()). If stringToFind is the empty string (zero length), nothing is found. Ignores the kCFCompareNumerically option. Only the substring of theString specified by rangeToSearch is searched for stringToFind.

      • CFStringFindWithOptions

        public static byte CFStringFindWithOptions​(CFStringRef theString,
                                           CFStringRef stringToFind,
                                           CFRange rangeToSearch,
                                           long searchOptions,
                                           CFRange result)
        Find convenience. Uses the current user locale (the return value from CFLocaleCopyCurrent()) if kCFCompareLocalized. Refer to CFStringFindWithOptionsAndLocale() for more info.

      • CFStringCreateArrayWithFindResults

        public static CFArrayRef CFStringCreateArrayWithFindResults​(CFAllocatorRef alloc,
                                                            CFStringRef theString,
                                                            CFStringRef stringToFind,
                                                            CFRange rangeToSearch,
                                                            long compareOptions)
        CFStringCreateArrayWithFindResults() returns an array of CFRange pointers, or NULL if there are no matches. Overlapping instances are not found; so looking for "AA" in "AAA" finds just one range. Post 10.1: If kCFCompareBackwards is provided, the scan is done from the end (which can give a different result), and the results are stored in the array backwards (last found range in slot 0). If stringToFind is the empty string (zero length), nothing is found. kCFCompareAnchored causes just the consecutive instances at start (or end, if kCFCompareBackwards) to be reported. So, searching for "AB" in "ABABXAB..." you just get the first two occurrences. Ignores the kCFCompareNumerically option. Only the substring of theString specified by rangeToSearch is searched for stringToFind.

      • CFStringFind

        public static CFRange CFStringFind​(CFStringRef theString,
                                   CFStringRef stringToFind,
                                   long compareOptions)
        Find conveniences; see comments above concerning empty string and options.

      • CFStringGetRangeOfComposedCharactersAtIndex

        public static CFRange CFStringGetRangeOfComposedCharactersAtIndex​(CFStringRef theString,
                                                                  long theIndex)
        [@function] CFStringGetRangeOfComposedCharactersAtIndex Returns the range of the composed character sequence at the specified index.
        Parameters:
        theString - The CFString which is to be searched. If this parameter is not a valid CFString, the behavior is undefined.
        theIndex - The index of the character contained in the composed character sequence. If the index is outside the index space of the string (0 to N-1 inclusive, where N is the length of the string), the behavior is undefined.
        Returns:
        The range of the composed character sequence.

      • CFStringFindCharacterFromSet

        public static byte CFStringFindCharacterFromSet​(CFStringRef theString,
                                                CFCharacterSetRef theSet,
                                                CFRange rangeToSearch,
                                                long searchOptions,
                                                CFRange result)
        [@function] CFStringFindCharacterFromSet Query the range of the first character contained in the specified character set.
        Parameters:
        theString - The CFString which is to be searched. If this parameter is not a valid CFString, the behavior is undefined.
        theSet - The CFCharacterSet against which the membership of characters is checked. If this parameter is not a valid CFCharacterSet, the behavior is undefined.
        rangeToSearch - The range of characters within the string to search. If the range location or end point (defined by the location plus length minus 1) are outside the index space of the string (0 to N-1 inclusive, where N is the length of the string), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0), in which case no search is performed.
        searchOptions - The bitwise-or'ed option flags to control the search behavior. The supported options are kCFCompareBackwards andkCFCompareAnchored. If other option flags are specified, the behavior is undefined.
        result - The pointer to a CFRange supplied by the caller in which the search result is stored. Note that the length of this range can be more than 1, if for instance the result is a composed character. If a pointer to an invalid memory is specified, the behavior is undefined.
        Returns:
        true, if at least a character which is a member of the character set is found and result is filled, otherwise, false.

      • CFStringGetLineBounds

        public static void CFStringGetLineBounds​(CFStringRef theString,
                                         CFRange range,
                                         org.moe.natj.general.ptr.NIntPtr lineBeginIndex,
                                         org.moe.natj.general.ptr.NIntPtr lineEndIndex,
                                         org.moe.natj.general.ptr.NIntPtr contentsEndIndex)
        Find range of bounds of the line(s) that span the indicated range (startIndex, numChars), taking into account various possible line separator sequences (CR, CRLF, LF, and Unicode NextLine, LineSeparator, ParagraphSeparator). All return values are "optional" (provide NULL if you don't want them) lineBeginIndex: index of first character in line lineEndIndex: index of first character of the next line (including terminating line separator characters) contentsEndIndex: index of the first line separator character Thus, lineEndIndex - lineBeginIndex is the number of chars in the line, including the line separators contentsEndIndex - lineBeginIndex is the number of chars in the line w/out the line separators

      • CFStringGetParagraphBounds

        public static void CFStringGetParagraphBounds​(CFStringRef string,
                                              CFRange range,
                                              org.moe.natj.general.ptr.NIntPtr parBeginIndex,
                                              org.moe.natj.general.ptr.NIntPtr parEndIndex,
                                              org.moe.natj.general.ptr.NIntPtr contentsEndIndex)
        Same as CFStringGetLineBounds(), however, will only look for paragraphs. Won't stop at Unicode NextLine or LineSeparator characters.

      • CFStringGetHyphenationLocationBeforeIndex

        public static long CFStringGetHyphenationLocationBeforeIndex​(CFStringRef string,
                                                             long location,
                                                             CFRange limitRange,
                                                             long options,
                                                             CFLocaleRef locale,
                                                             org.moe.natj.general.ptr.IntPtr character)
        [@function] CFStringGetHyphenationLocationBeforeIndex Retrieve the first potential hyphenation location found before the specified location.
        Parameters:
        string - The CFString which is to be hyphenated. If this parameter is not a valid CFString, the behavior is undefined.
        location - An index in the string. If a valid hyphen index is returned, it will be before this index.
        limitRange - The range of characters within the string to search. If the range location or end point (defined by the location plus length minus 1) are outside the index space of the string (0 to N-1 inclusive, where N is the length of the string), the behavior is undefined. If the range length is negative, the behavior is undefined. The range may be empty (length 0), in which case no hyphen location is generated.
        options - Reserved for future use.
        locale - Specifies which language's hyphenation conventions to use. This must be a valid locale. Hyphenation data is not available for all locales. You can use CFStringIsHyphenationAvailableForLocale to test for availability of hyphenation data.
        character - The suggested hyphen character to insert. Pass NULL if you do not need this information.
        Returns:
        an index in the string where it is appropriate to insert a hyphen, if one exists; else kCFNotFound

      • CFStringIsHyphenationAvailableForLocale

        public static byte CFStringIsHyphenationAvailableForLocale​(CFLocaleRef locale)

      • CFStringCreateByCombiningStrings

        public static CFStringRef CFStringCreateByCombiningStrings​(CFAllocatorRef alloc,
                                                           CFArrayRef theArray,
                                                           CFStringRef separatorString)
        Exploding and joining strings with a separator string **

      • CFStringGetIntValue

        public static int CFStringGetIntValue​(CFStringRef str)
        Parsing non-localized numbers from strings **

      • CFStringGetDoubleValue

        public static double CFStringGetDoubleValue​(CFStringRef str)

      • CFStringAppend

        public static void CFStringAppend​(CFMutableStringRef theString,
                                  CFStringRef appendedString)
        CFStringAppend("abcdef", "xxxxx") -> "abcdefxxxxx" CFStringDelete("abcdef", CFRangeMake(2, 3)) -> "abf" CFStringReplace("abcdef", CFRangeMake(2, 3), "xxxxx") -> "abxxxxxf" CFStringReplaceAll("abcdef", "xxxxx") -> "xxxxx"

      • CFStringAppendCharacters

        public static void CFStringAppendCharacters​(CFMutableStringRef theString,
                                            org.moe.natj.general.ptr.ConstCharPtr chars,
                                            long numChars)

      • CFStringAppendPascalString

        public static void CFStringAppendPascalString​(CFMutableStringRef theString,
                                              java.lang.String pStr,
                                              int encoding)

      • CFStringAppendCString

        public static void CFStringAppendCString​(CFMutableStringRef theString,
                                         java.lang.String cStr,
                                         int encoding)

      • CFStringAppendFormatAndArguments

        public static void CFStringAppendFormatAndArguments​(CFMutableStringRef theString,
                                                    CFDictionaryRef formatOptions,
                                                    CFStringRef format,
                                                    org.moe.natj.general.ptr.BytePtr arguments)

      • CFStringFindAndReplace

        public static long CFStringFindAndReplace​(CFMutableStringRef theString,
                                          CFStringRef stringToFind,
                                          CFStringRef replacementString,
                                          CFRange rangeToSearch,
                                          long compareOptions)
        Replace all occurrences of target in rangeToSearch of theString with replacement. Pays attention to kCFCompareCaseInsensitive, kCFCompareBackwards, kCFCompareNonliteral, and kCFCompareAnchored. kCFCompareBackwards can be used to do the replacement starting from the end, which could give a different result. ex. AAAAA, replace AA with B -> BBA or ABB; latter if kCFCompareBackwards kCFCompareAnchored assures only anchored but multiple instances are found (the instances must be consecutive at start or end) ex. AAXAA, replace A with B -> BBXBB or BBXAA; latter if kCFCompareAnchored Returns number of replacements performed.

      • CFStringSetExternalCharactersNoCopy

        public static void CFStringSetExternalCharactersNoCopy​(CFMutableStringRef theString,
                                                       org.moe.natj.general.ptr.CharPtr chars,
                                                       long length,
                                                       long capacity)
        This function will make the contents of a mutable CFString point directly at the specified UniChar array. It works only with CFStrings created with CFStringCreateMutableWithExternalCharactersNoCopy(). This function does not free the previous buffer. The string will be manipulated within the provided buffer (if any) until it outgrows capacity; then the externalCharactersAllocator will be consulted for more memory. See comments at the top of this file for more info.

      • CFStringPad

        public static void CFStringPad​(CFMutableStringRef theString,
                               CFStringRef padString,
                               long length,
                               long indexIntoPad)
        CFStringPad() will pad or cut down a string to the specified size. The pad string is used as the fill string; indexIntoPad specifies which character to start with. CFStringPad("abc", " ", 9, 0) -> "abc " CFStringPad("abc", ". ", 9, 1) -> "abc . . ." CFStringPad("abcdef", ?, 3, ?) -> "abc" CFStringTrim() will trim the specified string from both ends of the string. CFStringTrimWhitespace() will do the same with white space characters (tab, newline, etc) CFStringTrim(" abc ", " ") -> "abc" CFStringTrim("* * * *abc * ", "* ") -> "*abc "

      • CFStringTrimWhitespace

        public static void CFStringTrimWhitespace​(CFMutableStringRef theString)

      • CFStringNormalize

        public static void CFStringNormalize​(CFMutableStringRef theString,
                                     long theForm)
        [@function] CFStringNormalize Normalizes the string into the specified form as described in Unicode Technical Report #15.
        Parameters:
        theString - The string which is to be normalized. If this parameter is not a valid mutable CFString, the behavior is undefined.
        theForm - The form into which the string is to be normalized. If this parameter is not a valid CFStringNormalizationForm value, the behavior is undefined.

      • CFStringFold

        public static void CFStringFold​(CFMutableStringRef theString,
                                long theFlags,
                                CFLocaleRef theLocale)
        [@function] CFStringFold Folds the string into the form specified by the flags. Character foldings are operations that convert any of a set of characters sharing similar semantics into a single representative from that set. This function can be used to preprocess strings that are to be compared, searched, or indexed. Note that folding does not include normalization, so it is necessary to use CFStringNormalize in addition to CFStringFold in order to obtain the effect of kCFCompareNonliteral.
        Parameters:
        theString - The string which is to be folded. If this parameter is not a valid mutable CFString, the behavior is undefined.
        theFlags - The equivalency flags which describes the character folding form. Only those flags containing the word "insensitive" are recognized here; other flags are ignored. Folding with kCFCompareCaseInsensitive removes case distinctions in accordance with the mapping specified by ftp://ftp.unicode.org/Public/UNIDATA/CaseFolding.txt. Folding with kCFCompareDiacriticInsensitive removes distinctions of accents and other diacritics. Folding with kCFCompareWidthInsensitive removes character width distinctions by mapping characters in the range U+FF00-U+FFEF to their ordinary equivalents.
        theLocale - The locale tailoring the character folding behavior. If NULL, it's considered to be the system locale returned from CFLocaleGetSystem(). If non-NULL and not a valid CFLocale object, the behavior is undefined.

      • CFStringTransform

        public static byte CFStringTransform​(CFMutableStringRef string,
                                     CFRange range,
                                     CFStringRef transform,
                                     byte reverse)
        Perform string transliteration. The transformation represented by transform is applied to the given range of string, modifying it in place. Only the specified range will be modified, but the transform may look at portions of the string outside that range for context. NULL range pointer causes the whole string to be transformed. On return, range is modified to reflect the new range corresponding to the original range. reverse indicates that the inverse transform should be used instead, if it exists. If the transform is successful, true is returned; if unsuccessful, false. Reasons for the transform being unsuccessful include an invalid transform identifier, or attempting to reverse an irreversible transform. You can pass one of the predefined transforms below, or any valid ICU transform ID as defined in the ICU User Guide. Note that we do not support arbitrary set of ICU transform rules.

      • CFStringIsEncodingAvailable

        public static byte CFStringIsEncodingAvailable​(int encoding)
        This returns availability of the encoding on the system

      • CFStringGetListOfAvailableEncodings

        public static org.moe.natj.general.ptr.ConstIntPtr CFStringGetListOfAvailableEncodings()
        This function returns list of available encodings. The returned list is terminated with kCFStringEncodingInvalidId and owned by the system.

      • CFStringGetNameOfEncoding

        public static CFStringRef CFStringGetNameOfEncoding​(int encoding)
        Returns name of the encoding; non-localized.

      • CFStringConvertEncodingToNSStringEncoding

        public static long CFStringConvertEncodingToNSStringEncoding​(int encoding)
        ID mapping functions from/to Cocoa NSStringEncoding. Returns kCFStringEncodingInvalidId if no mapping exists.

      • CFStringConvertNSStringEncodingToEncoding

        public static int CFStringConvertNSStringEncodingToEncoding​(long encoding)

      • CFStringConvertEncodingToWindowsCodepage

        public static int CFStringConvertEncodingToWindowsCodepage​(int encoding)
        ID mapping functions from/to Microsoft Windows codepage (covers both OEM & ANSI). Returns kCFStringEncodingInvalidId if no mapping exists.

      • CFStringConvertWindowsCodepageToEncoding

        public static int CFStringConvertWindowsCodepageToEncoding​(int codepage)

      • CFStringConvertIANACharSetNameToEncoding

        public static int CFStringConvertIANACharSetNameToEncoding​(CFStringRef theString)
        ID mapping functions from/to IANA registery charset names. Returns kCFStringEncodingInvalidId if no mapping exists.

      • CFStringConvertEncodingToIANACharSetName

        public static CFStringRef CFStringConvertEncodingToIANACharSetName​(int encoding)

      • CFStringGetMostCompatibleMacStringEncoding

        public static int CFStringGetMostCompatibleMacStringEncoding​(int encoding)
        Returns the most compatible MacOS script value for the input encoding i.e. kCFStringEncodingMacRoman -> kCFStringEncodingMacRoman kCFStringEncodingWindowsLatin1 -> kCFStringEncodingMacRoman kCFStringEncodingISO_2022_JP -> kCFStringEncodingMacJapanese

      • CFStringGetCharacterFromInlineBuffer

        public static char CFStringGetCharacterFromInlineBuffer​(CFStringInlineBuffer buf,
                                                        long idx)

      • CFStringIsSurrogateHighCharacter

        public static byte CFStringIsSurrogateHighCharacter​(char character)
        UTF-16 surrogate support

      • CFStringIsSurrogateLowCharacter

        public static byte CFStringIsSurrogateLowCharacter​(char character)

      • CFStringGetLongCharacterForSurrogatePair

        public static int CFStringGetLongCharacterForSurrogatePair​(char surrogateHigh,
                                                           char surrogateLow)

      • CFStringGetSurrogatePairForLongCharacter

        public static byte CFStringGetSurrogatePairForLongCharacter​(int character,
                                                            org.moe.natj.general.ptr.CharPtr surrogates)
        Maps a UTF-32 character to a pair of UTF-16 surrogate characters. The buffer pointed by surrogates has to have space for at least 2 UTF-16 characters. Returns true if mapped to a surrogate pair.

      • CFShow

        public static void CFShow​(org.moe.natj.general.ptr.ConstVoidPtr obj)
        Rest of the stuff in this file is private and should not be used directly For debugging only; output goes to stderr Use CFShow() to printf the description of any CFType; Use CFShowStr() to printf detailed info about a CFString

      • CFShowStr

        public static void CFShowStr​(CFStringRef str)

      • __CFStringMakeConstantString

        public static CFStringRef __CFStringMakeConstantString​(java.lang.String cStr)
        This function is private and should not be used directly

      • CFErrorGetTypeID

        public static long CFErrorGetTypeID()
        [@function] CFErrorGetTypeID Returns the type identifier of all CFError instances.

      • CFErrorCreate

        public static CFErrorRef CFErrorCreate​(CFAllocatorRef allocator,
                                       CFStringRef domain,
                                       long code,
                                       CFDictionaryRef userInfo)
        [@function] CFErrorCreate Creates a new CFError.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the error. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        domain - A CFString identifying the error domain. If this reference is NULL or is otherwise not a valid CFString, the behavior is undefined.
        code - A CFIndex identifying the error code. The code is interpreted within the context of the error domain.
        userInfo - A CFDictionary created with kCFCopyStringDictionaryKeyCallBacks and kCFTypeDictionaryValueCallBacks. It will be copied with CFDictionaryCreateCopy(). If no userInfo dictionary is desired, NULL may be passed in as a convenience, in which case an empty userInfo dictionary will be assigned.
        Returns:
        A reference to the new CFError.

      • CFErrorCreateWithUserInfoKeysAndValues

        public static CFErrorRef CFErrorCreateWithUserInfoKeysAndValues​(CFAllocatorRef allocator,
                                                                CFStringRef domain,
                                                                long code,
                                                                org.moe.natj.general.ptr.ConstPtr<org.moe.natj.general.ptr.ConstVoidPtr> userInfoKeys,
                                                                org.moe.natj.general.ptr.ConstPtr<org.moe.natj.general.ptr.ConstVoidPtr> userInfoValues,
                                                                long numUserInfoValues)
        [@function] CFErrorCreateWithUserInfoKeysAndValues Creates a new CFError without having to create an intermediate userInfo dictionary.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the error. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        domain - A CFString identifying the error domain. If this reference is NULL or is otherwise not a valid CFString, the behavior is undefined.
        code - A CFIndex identifying the error code. The code is interpreted within the context of the error domain.
        userInfoKeys - An array of numUserInfoValues CFStrings used as keys in creating the userInfo dictionary. NULL is valid only if numUserInfoValues is 0.
        userInfoValues - An array of numUserInfoValues CF types used as values in creating the userInfo dictionary. NULL is valid only if numUserInfoValues is 0.
        numUserInfoValues - CFIndex representing the number of keys and values in the userInfoKeys and userInfoValues arrays.
        Returns:
        A reference to the new CFError. numUserInfoValues CF types are gathered from each of userInfoKeys and userInfoValues to create the userInfo dictionary.

      • CFErrorGetDomain

        public static CFStringRef CFErrorGetDomain​(CFErrorRef err)
        [@function] CFErrorGetDomain Returns the error domain the CFError was created with.
        Parameters:
        err - The CFError whose error domain is to be returned. If this reference is not a valid CFError, the behavior is undefined.
        Returns:
        The error domain of the CFError. Since this is a "Get" function, the caller shouldn't CFRelease the return value.

      • CFErrorGetCode

        public static long CFErrorGetCode​(CFErrorRef err)
        [@function] CFErrorGetCode Returns the error code the CFError was created with.
        Parameters:
        err - The CFError whose error code is to be returned. If this reference is not a valid CFError, the behavior is undefined.
        Returns:
        The error code of the CFError (not an error return for the current call).

      • CFErrorCopyUserInfo

        public static CFDictionaryRef CFErrorCopyUserInfo​(CFErrorRef err)
        [@function] CFErrorCopyUserInfo Returns CFError userInfo dictionary. Returns a dictionary containing the same keys and values as in the userInfo dictionary the CFError was created with. Returns an empty dictionary if NULL was supplied to CFErrorCreate().
        Parameters:
        err - The CFError whose error user info is to be returned. If this reference is not a valid CFError, the behavior is undefined.
        Returns:
        The user info of the CFError.

      • CFErrorCopyDescription

        public static CFStringRef CFErrorCopyDescription​(CFErrorRef err)
        [@function] CFErrorCopyDescription Returns a human-presentable description for the error. CFError creators should strive to make sure the return value is human-presentable and localized by providing a value for kCFErrorLocalizedDescriptionKey at the time of CFError creation. This is a complete sentence or two which says what failed and why it failed. Please refer to header comments for -[NSError localizedDescription] for details on the steps used to compute this; but roughly: - Use value of kCFErrorLocalizedDescriptionKey as-is if provided. - Use value of kCFErrorLocalizedFailureKey if provided, optionally followed by kCFErrorLocalizedFailureReasonKey if available. - Use value of kCFErrorLocalizedFailureReasonKey, combining with a generic failure message such as: "Operation code not be completed. " + kCFErrorLocalizedFailureReasonKey. - If all of the above fail, generate a semi-user presentable string from kCFErrorDescriptionKey, the domain, and code. Something like: "Operation could not be completed. Error domain/code occurred. " or "Operation could not be completed. " + kCFErrorDescriptionKey + " (Error domain/code)" Toll-free bridged NSError instances might provide additional behaviors for manufacturing a description string. Do not count on the exact contents or format of the returned string, it might change.
        Parameters:
        err - The CFError whose description is to be returned. If this reference is not a valid CFError, the behavior is undefined.
        Returns:
        A CFString with human-presentable description of the CFError. Never NULL.

      • CFErrorCopyFailureReason

        public static CFStringRef CFErrorCopyFailureReason​(CFErrorRef err)
        [@function] CFErrorCopyFailureReason Returns a human-presentable failure reason for the error. May return NULL. CFError creators should strive to make sure the return value is human-presentable and localized by providing a value for kCFErrorLocalizedFailureReasonKey at the time of CFError creation. This is a complete sentence which describes why the operation failed. In many cases this will be just the "because" part of the description (but as a complete sentence, which makes localization easier). By default this looks for kCFErrorLocalizedFailureReasonKey in the user info. Toll-free bridged NSError instances might provide additional behaviors for manufacturing this value. If no user-presentable string is available, returns NULL. Example Description: "Could not save file 'Letter' in folder 'Documents' because the volume 'MyDisk' doesn't have enough space." Corresponding FailureReason: "The volume 'MyDisk' doesn't have enough space."
        Parameters:
        err - The CFError whose failure reason is to be returned. If this reference is not a valid CFError, the behavior is undefined.
        Returns:
        A CFString with the localized, end-user presentable failure reason of the CFError, or NULL.

      • CFErrorCopyRecoverySuggestion

        public static CFStringRef CFErrorCopyRecoverySuggestion​(CFErrorRef err)
        [@function] CFErrorCopyRecoverySuggestion Returns a human presentable recovery suggestion for the error. May return NULL. CFError creators should strive to make sure the return value is human-presentable and localized by providing a value for kCFErrorLocalizedRecoverySuggestionKey at the time of CFError creation. This is the string that can be displayed as the "informative" (aka "secondary") message on an alert panel. By default this looks for kCFErrorLocalizedRecoverySuggestionKey in the user info. Toll-free bridged NSError instances might provide additional behaviors for manufacturing this value. If no user-presentable string is available, returns NULL. Example Description: "Could not save file 'Letter' in folder 'Documents' because the volume 'MyDisk' doesn't have enough space." Corresponding RecoverySuggestion: "Remove some files from the volume and try again."
        Parameters:
        err - The CFError whose recovery suggestion is to be returned. If this reference is not a valid CFError, the behavior is undefined.
        Returns:
        A CFString with the localized, end-user presentable recovery suggestion of the CFError, or NULL.

      • CFURLGetTypeID

        public static long CFURLGetTypeID()
        CFURLs are composed of two fundamental pieces - their string, and a (possibly NULL) base URL. A relative URL is one in which the string by itself does not fully specify the URL (for instance "myDir/image.tiff"); an absolute URL is one in which the string does fully specify the URL ("file://localhost/myDir/image.tiff"). Absolute URLs always have NULL base URLs; however, it is possible for a URL to have a NULL base, and still not be absolute. Such a URL has only a relative string, and cannot be resolved. Two CFURLs are considered equal if and only if their strings are equal and their bases are equal. In other words, "file://localhost/myDir/image.tiff" is NOT equal to the URL with relative string "myDir/image.tiff" and base URL "file://localhost/". Clients that need these less strict form of equality should convert all URLs to their absolute form via CFURLCopyAbsoluteURL(), then compare the absolute forms.

      • CFURLCreateWithBytes

        public static CFURLRef CFURLCreateWithBytes​(CFAllocatorRef allocator,
                                            java.lang.String URLBytes,
                                            long length,
                                            int encoding,
                                            CFURLRef baseURL)
        encoding will be used both to interpret the bytes of URLBytes, and to interpret any percent-escapes within the bytes. Using a string encoding which isn't a superset of ASCII encoding is not supported because CFURLGetBytes and CFURLGetByteRangeForComponent require 7-bit ASCII characters to be stored in a single 8-bit byte. CFStringEncodings which are a superset of ASCII encoding include MacRoman, WindowsLatin1, ISOLatin1, NextStepLatin, ASCII, and UTF8.

      • CFURLCreateData

        public static CFDataRef CFURLCreateData​(CFAllocatorRef allocator,
                                        CFURLRef url,
                                        int encoding,
                                        byte escapeWhitespace)
        Escapes any character that is not 7-bit ASCII with the byte-code for the given encoding. If escapeWhitespace is true, whitespace characters (' ', '\t', '\r', '\n') will be escaped also (desirable if embedding the URL into a larger text stream like HTML)

      • CFURLCreateWithString

        public static CFURLRef CFURLCreateWithString​(CFAllocatorRef allocator,
                                             CFStringRef URLString,
                                             CFURLRef baseURL)
        Any percent-escape sequences in URLString will be interpreted via UTF-8. URLString must be a valid URL string.

      • CFURLCreateAbsoluteURLWithBytes

        public static CFURLRef CFURLCreateAbsoluteURLWithBytes​(CFAllocatorRef alloc,
                                                       java.lang.String relativeURLBytes,
                                                       long length,
                                                       int encoding,
                                                       CFURLRef baseURL,
                                                       byte useCompatibilityMode)
        Create an absolute URL directly, without requiring the extra step of calling CFURLCopyAbsoluteURL(). If useCompatibilityMode is true, the rules historically used on the web are used to resolve relativeString against baseURL - these rules are generally listed in the RFC as optional or alternate interpretations. Otherwise, the strict rules from the RFC are used. The major differences are that in compatibility mode, we are lenient of the scheme appearing in relative portion, leading "../" components are removed from the final URL's path, and if the relative portion contains only resource specifier pieces (query, parameters, and fragment), then the last path component of the base URL will not be deleted. Using a string encoding which isn't a superset of ASCII encoding is not supported because CFURLGetBytes and CFURLGetByteRangeForComponent require 7-bit ASCII characters to be stored in a single 8-bit byte. CFStringEncodings which are a superset of ASCII encoding include MacRoman, WindowsLatin1, ISOLatin1, NextStepLatin, ASCII, and UTF8.

      • CFURLCreateWithFileSystemPath

        public static CFURLRef CFURLCreateWithFileSystemPath​(CFAllocatorRef allocator,
                                                     CFStringRef filePath,
                                                     long pathStyle,
                                                     byte isDirectory)
        filePath should be the URL's path expressed as a path of the type fsType. If filePath is not absolute, the resulting URL will be considered relative to the current working directory (evaluated at creation time). isDirectory determines whether filePath is treated as a directory path when resolving against relative path components

      • CFURLCreateFromFileSystemRepresentation

        public static CFURLRef CFURLCreateFromFileSystemRepresentation​(CFAllocatorRef allocator,
                                                               java.lang.String buffer,
                                                               long bufLen,
                                                               byte isDirectory)

      • CFURLCreateWithFileSystemPathRelativeToBase

        public static CFURLRef CFURLCreateWithFileSystemPathRelativeToBase​(CFAllocatorRef allocator,
                                                                   CFStringRef filePath,
                                                                   long pathStyle,
                                                                   byte isDirectory,
                                                                   CFURLRef baseURL)
        The path style of the baseURL must match the path style of the relative url or the results are undefined. If the provided filePath looks like an absolute path ( starting with '/' if pathStyle is kCFURLPosixPathStyle, not starting with ':' for kCFURLHFSPathStyle, or starting with what looks like a drive letter and colon for kCFURLWindowsPathStyle ) then the baseURL is ignored.

      • CFURLCreateFromFileSystemRepresentationRelativeToBase

        public static CFURLRef CFURLCreateFromFileSystemRepresentationRelativeToBase​(CFAllocatorRef allocator,
                                                                             java.lang.String buffer,
                                                                             long bufLen,
                                                                             byte isDirectory,
                                                                             CFURLRef baseURL)

      • CFURLGetFileSystemRepresentation

        public static byte CFURLGetFileSystemRepresentation​(CFURLRef url,
                                                    byte resolveAgainstBase,
                                                    org.moe.natj.general.ptr.BytePtr buffer,
                                                    long maxBufLen)
        Fills buffer with the file system's native representation of url's path. No more than maxBufLen bytes are written to buffer. The buffer should be at least the maximum path length for the file system in question to avoid failures for insufficiently large buffers. If resolveAgainstBase is true, the url's relative portion is resolved against its base before the path is computed. Returns success or failure.

      • CFURLCopyAbsoluteURL

        public static CFURLRef CFURLCopyAbsoluteURL​(CFURLRef relativeURL)
        Creates a new URL by resolving the relative portion of relativeURL against its base.

      • CFURLGetString

        public static CFStringRef CFURLGetString​(CFURLRef anURL)
        Returns the URL's string. Percent-escape sequences are not removed.

      • CFURLGetBaseURL

        public static CFURLRef CFURLGetBaseURL​(CFURLRef anURL)
        Returns the base URL if it exists

      • CFURLCanBeDecomposed

        public static byte CFURLCanBeDecomposed​(CFURLRef anURL)
        Returns true if anURL conforms to RFC 1808

      • CFURLCopyNetLocation

        public static CFStringRef CFURLCopyNetLocation​(CFURLRef anURL)
        Percent-escape sequences are not removed. NULL if CFURLCanBeDecomposed(anURL) is false

      • CFURLCopyPath

        public static CFStringRef CFURLCopyPath​(CFURLRef anURL)
        Percent-escape sequences are not removed.

      • CFURLCopyStrictPath

        public static CFStringRef CFURLCopyStrictPath​(CFURLRef anURL,
                                              org.moe.natj.general.ptr.BytePtr isAbsolute)
        Percent-escape sequences are not removed.

      • CFURLCopyFileSystemPath

        public static CFStringRef CFURLCopyFileSystemPath​(CFURLRef anURL,
                                                  long pathStyle)
        CFURLCopyFileSystemPath() returns the URL's path as a file system path for the given path style. All percent-escape sequences are removed. The URL is not resolved against its base before computing the path.

      • CFURLHasDirectoryPath

        public static byte CFURLHasDirectoryPath​(CFURLRef anURL)
        Returns whether anURL's path represents a directory (true returned) or a simple file (false returned)

      • CFURLCopyResourceSpecifier

        public static CFStringRef CFURLCopyResourceSpecifier​(CFURLRef anURL)
        Any additional resource specifiers after the path. For URLs that cannot be decomposed, this is everything except the scheme itself. Percent-escape sequences are not removed.

      • CFURLCopyHostName

        public static CFStringRef CFURLCopyHostName​(CFURLRef anURL)
        Percent-escape sequences are removed.

      • CFURLGetPortNumber

        public static int CFURLGetPortNumber​(CFURLRef anURL)

      • CFURLCopyUserName

        public static CFStringRef CFURLCopyUserName​(CFURLRef anURL)
        Percent-escape sequences are removed.

      • CFURLCopyPassword

        public static CFStringRef CFURLCopyPassword​(CFURLRef anURL)
        Percent-escape sequences are removed.

      • CFURLCopyParameterString

        public static CFStringRef CFURLCopyParameterString​(CFURLRef anURL,
                                                   CFStringRef charactersToLeaveEscaped)
        CFURLCopyParameterString, CFURLCopyQueryString, and CFURLCopyFragment remove all percent-escape sequences except those for characters in charactersToLeaveEscaped. If charactersToLeaveEscaped is empty (""), all percent-escape sequences are replaced by their corresponding characters. If charactersToLeaveEscaped is NULL, then no escape sequences are removed at all

      • CFURLCopyLastPathComponent

        public static CFStringRef CFURLCopyLastPathComponent​(CFURLRef url)
        Percent-escape sequences are removed.

      • CFURLCopyPathExtension

        public static CFStringRef CFURLCopyPathExtension​(CFURLRef url)
        Percent-escape sequences are removed.

      • CFURLCreateCopyDeletingLastPathComponent

        public static CFURLRef CFURLCreateCopyDeletingLastPathComponent​(CFAllocatorRef allocator,
                                                                CFURLRef url)

      • CFURLGetBytes

        public static long CFURLGetBytes​(CFURLRef url,
                                 org.moe.natj.general.ptr.BytePtr buffer,
                                 long bufferLength)
        Fills buffer with the bytes for url, returning the number of bytes filled. If buffer is of insufficient size, returns -1 and no bytes are placed in buffer. If buffer is NULL, the needed length is computed and returned. The returned bytes are the original bytes from which the URL was created; if the URL was created from a string, the bytes will be the bytes of the string encoded via UTF-8. Note: Due to incompatibilities between encodings, it might be impossible to generate bytes from the base URL in the encoding of the relative URL or relative bytes, which will cause this method to fail and return -1, even if a NULL buffer is passed. To avoid this scenario, use UTF-8, UTF-16, or UTF-32 encodings exclusively, or use one non-Unicode encoding exclusively.

      • CFURLGetByteRangeForComponent

        public static CFRange CFURLGetByteRangeForComponent​(CFURLRef url,
                                                    long component,
                                                    CFRange rangeIncludingSeparators)
        Gets the range of the requested component in the bytes of url, as returned by CFURLGetBytes(). This range is only good for use in the bytes returned by CFURLGetBytes! If non-NULL, rangeIncludingSeparators gives the range of component including the sequences that separate component from the previous and next components. If there is no previous or next component, that end of rangeIncludingSeparators will match the range of the component itself. If url does not contain the given component type, (kCFNotFound, 0) is returned, and rangeIncludingSeparators is set to the location where the component would be inserted. Some examples - For the URL http://www.apple.com/hotnews/ Component returned range rangeIncludingSeparators scheme (0, 4) (0, 7) net location (7, 13) (4, 16) path (20, 9) (20, 9) resource specifier (kCFNotFound, 0) (29, 0) user (kCFNotFound, 0) (7, 0) password (kCFNotFound, 0) (7, 0) user info (kCFNotFound, 0) (7, 0) host (7, 13) (4, 16) port (kCFNotFound, 0) (20, 0) parameter (kCFNotFound, 0) (29, 0) query (kCFNotFound, 0) (29, 0) fragment (kCFNotFound, 0) (29, 0) For the URL ./relPath/file.html#fragment Component returned range rangeIncludingSeparators scheme (kCFNotFound, 0) (0, 0) net location (kCFNotFound, 0) (0, 0) path (0, 19) (0, 20) resource specifier (20, 8) (19, 9) user (kCFNotFound, 0) (0, 0) password (kCFNotFound, 0) (0, 0) user info (kCFNotFound, 0) (0, 0) host (kCFNotFound, 0) (0, 0) port (kCFNotFound, 0) (0, 0) parameter (kCFNotFound, 0) (19, 0) query (kCFNotFound, 0) (19, 0) fragment (20, 8) (19, 9) For the URL scheme://user:pass@host:1/path/path2/file.html;params?query#fragment Component returned range rangeIncludingSeparators scheme (0, 6) (0, 9) net location (9, 16) (6, 19) path (25, 21) (25, 22) resource specifier (47, 21) (46, 22) user (9, 4) (6, 8) password (14, 4) (13, 6) user info (9, 9) (6, 13) host (19, 4) (18, 6) port (24, 1) (23, 2) parameter (47, 6) (46, 8) query (54, 5) (53, 7) fragment (60, 8) (59, 9)

      • CFURLCreateStringByReplacingPercentEscapes

        public static CFStringRef CFURLCreateStringByReplacingPercentEscapes​(CFAllocatorRef allocator,
                                                                     CFStringRef originalString,
                                                                     CFStringRef charactersToLeaveEscaped)
        Returns a string with any percent-escape sequences that do NOT correspond to characters in charactersToLeaveEscaped with their equivalent. Returns NULL on failure (if an invalid percent-escape sequence is encountered), or the original string (retained) if no characters need to be replaced. Pass NULL to request that no percent-escapes be replaced, or the empty string (CFSTR("")) to request that all percent- escapes be replaced. Uses UTF8 to interpret percent-escapes.

      • CFURLCreateStringByReplacingPercentEscapesUsingEncoding

        @Deprecated
public static CFStringRef CFURLCreateStringByReplacingPercentEscapesUsingEncoding​(CFAllocatorRef allocator,
                                                                                  CFStringRef origString,
                                                                                  CFStringRef charsToLeaveEscaped,
                                                                                  int encoding)
        Deprecated.
        As above, but allows you to specify the encoding to use when interpreting percent-escapes

      • CFURLCreateStringByAddingPercentEscapes

        @Deprecated
public static CFStringRef CFURLCreateStringByAddingPercentEscapes​(CFAllocatorRef allocator,
                                                                  CFStringRef originalString,
                                                                  CFStringRef charactersToLeaveUnescaped,
                                                                  CFStringRef legalURLCharactersToBeEscaped,
                                                                  int encoding)
        Deprecated.
        Creates a copy or originalString, replacing certain characters with the equivalent percent-escape sequence based on the encoding specified. If the originalString does not need to be modified (no percent-escape sequences are missing), may retain and return originalString. If you are uncertain of the correct encoding, you should use UTF-8, which is the encoding designated by RFC 2396 as the correct encoding for use in URLs. The characters so escaped are all characters that are not legal URL characters (based on RFC 2396), plus any characters in legalURLCharactersToBeEscaped, less any characters in charactersToLeaveUnescaped. To simply correct any non-URL characters in an otherwise correct URL string, do: newString = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, origString, NULL, NULL, kCFStringEncodingUTF8);

      • CFURLIsFileReferenceURL

        public static byte CFURLIsFileReferenceURL​(CFURLRef url)
        CFURLIsFileReferenceURL Returns whether the URL is a file reference URL. Parameters url The URL specifying the resource.

      • CFURLCreateFileReferenceURL

        public static CFURLRef CFURLCreateFileReferenceURL​(CFAllocatorRef allocator,
                                                   CFURLRef url,
                                                   org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLCreateFileReferenceURL Returns a new file reference URL that refers to the same resource as a specified URL. Parameters allocator The memory allocator for creating the new URL. url The file URL specifying the resource. error On output when the result is NULL, the error that occurred. This parameter is optional; if you do not wish the error returned, pass NULL here. The caller is responsible for releasing a valid output error. Return Value The new file reference URL, or NULL if an error occurs. Discussion File reference URLs use a URL path syntax that identifies a file system object by reference, not by path. This form of file URL remains valid when the file system path of the URL’s underlying resource changes. An error will occur if the url parameter is not a file URL. File reference URLs cannot be created to file system objects which do not exist or are not reachable. In some areas of the file system hierarchy, file reference URLs cannot be generated to the leaf node of the URL path. A file reference URL's path should never be persistently stored because is not valid across system restarts, and across remounts of volumes -- if you want to create a persistent reference to a file system object, use a bookmark (see CFURLCreateBookmarkData). If this function returns NULL, the optional error is populated. This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLCreateFilePathURL

        public static CFURLRef CFURLCreateFilePathURL​(CFAllocatorRef allocator,
                                              CFURLRef url,
                                              org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLCreateFilePathURL Returns a new file path URL that refers to the same resource as a specified URL. Parameters allocator The memory allocator for creating the new URL. url The file URL specifying the resource. error On output when the result is NULL, the error that occurred. This parameter is optional; if you do not wish the error returned, pass NULL here. The caller is responsible for releasing a valid output error. Return Value The new file path URL, or NULL if an error occurs. Discussion File path URLs use a file system style path. An error will occur if the url parameter is not a file URL. A file reference URL's resource must exist and be reachable to be converted to a file path URL. If this function returns NULL, the optional error is populated. This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLCreateFromFSRef

        @Deprecated
public static CFURLRef CFURLCreateFromFSRef​(CFAllocatorRef allocator,
                                            org.moe.natj.general.ptr.VoidPtr fsRef)
        Deprecated.
        Note: CFURLCreateFromFSRef and CFURLGetFSRef have never been functional on iOS because the Carbon File Manager is not on iOS.

      • CFURLGetFSRef

        @Deprecated
public static byte CFURLGetFSRef​(CFURLRef url,
                                 org.moe.natj.general.ptr.VoidPtr fsRef)
        Deprecated.

      • CFURLCopyResourcePropertyForKey

        public static byte CFURLCopyResourcePropertyForKey​(CFURLRef url,
                                                   CFStringRef key,
                                                   org.moe.natj.general.ptr.VoidPtr propertyValueTypeRefPtr,
                                                   org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLCopyResourcePropertyForKey Returns the resource value identified by a given resource key. Parameters url The URL specifying the resource. key The resource key that identifies the resource property. propertyValueTypeRefPtr On output when the result is true, the resource value or NULL. error On output when the result is false, the error that occurred. This parameter is optional; if you do not wish the error returned, pass NULL here. The caller is responsible for releasing a valid output error. Return Value true if propertyValueTypeRefPtr is successfully populated; false if an error occurs. Discussion CFURLCopyResourcePropertyForKey first checks if the URL object already caches the resource value. If so, it returns the cached resource value to the caller. If not, then CFURLCopyResourcePropertyForKey synchronously obtains the resource value from the backing store, adds the resource value to the URL object's cache, and returns the resource value to the caller. The type of the resource value varies by resource property (see resource key definitions). If this function returns true and propertyValueTypeRefPtr is populated with NULL, it means the resource property is not available for the specified resource and no errors occurred when determining the resource property was not available. If this function returns false, the optional error is populated. This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLCopyResourcePropertiesForKeys

        public static CFDictionaryRef CFURLCopyResourcePropertiesForKeys​(CFURLRef url,
                                                                 CFArrayRef keys,
                                                                 org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLCopyResourcePropertiesForKeys Returns the resource values identified by specified array of resource keys. Parameters url The URL specifying the resource. keys An array of resource keys that identify the resource properties. error On output when the result is NULL, the error that occurred. This parameter is optional; if you do not wish the error returned, pass NULL here. The caller is responsible for releasing a valid output error. Return Value A dictionary of resource values indexed by resource key; NULL if an error occurs. Discussion CFURLCopyResourcePropertiesForKeys first checks if the URL object already caches the resource values. If so, it returns the cached resource values to the caller. If not, then CFURLCopyResourcePropertyForKey synchronously obtains the resource values from the backing store, adds the resource values to the URL object's cache, and returns the resource values to the caller. The type of the resource values vary by property (see resource key definitions). If the result dictionary does not contain a resource value for one or more of the requested resource keys, it means those resource properties are not available for the specified resource and no errors occurred when determining those resource properties were not available. If this function returns NULL, the optional error is populated. This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLSetResourcePropertyForKey

        public static byte CFURLSetResourcePropertyForKey​(CFURLRef url,
                                                  CFStringRef key,
                                                  org.moe.natj.general.ptr.ConstVoidPtr propertyValue,
                                                  org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLSetResourcePropertyForKey Sets the resource value identified by a given resource key. Parameters url The URL specifying the resource. key The resource key that identifies the resource property. propertyValue The resource value. error On output when the result is false, the error that occurred. This parameter is optional; if you do not wish the error returned, pass NULL here. The caller is responsible for releasing a valid output error. Return Value true if the attempt to set the resource value completed with no errors; otherwise, false. Discussion CFURLSetResourcePropertyForKey writes the new resource value out to the backing store. Attempts to set a read-only resource property or to set a resource property not supported by the resource are ignored and are not considered errors. If this function returns false, the optional error is populated. This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLSetResourcePropertiesForKeys

        public static byte CFURLSetResourcePropertiesForKeys​(CFURLRef url,
                                                     CFDictionaryRef keyedPropertyValues,
                                                     org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLSetResourcePropertiesForKeys Sets any number of resource values of a URL's resource. Parameters url The URL specifying the resource. keyedPropertyValues A dictionary of resource values indexed by resource keys. error On output when the result is false, the error that occurred. This parameter is optional; if you do not wish the error returned, pass NULL here. The caller is responsible for releasing a valid output error. Return Value true if the attempt to set the resource values completed with no errors; otherwise, false. Discussion CFURLSetResourcePropertiesForKeys writes the new resource values out to the backing store. Attempts to set read-only resource properties or to set resource properties not supported by the resource are ignored and are not considered errors. If an error occurs after some resource properties have been successfully changed, the userInfo dictionary in the returned error contains an array of resource keys that were not set with the key kCFURLKeysOfUnsetValuesKey. The order in which the resource values are set is not defined. If you need to guarantee the order resource values are set, you should make multiple requests to CFURLSetResourcePropertiesForKeys or CFURLSetResourcePropertyForKey to guarantee the order. If this function returns false, the optional error is populated. This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLClearResourcePropertyCacheForKey

        public static void CFURLClearResourcePropertyCacheForKey​(CFURLRef url,
                                                         CFStringRef key)
        CFURLClearResourcePropertyCacheForKey Discards a cached resource value of a URL. Parameters url The URL specifying the resource. key The resource key that identifies the resource property. Discussion Discarding a cached resource value may discard other cached resource values, because some resource values are cached as a set of values and because some resource values depend on other resource values (temporary properties have no dependencies). This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLClearResourcePropertyCache

        public static void CFURLClearResourcePropertyCache​(CFURLRef url)
        CFURLClearResourcePropertyCache Discards all cached resource values of a URL. Parameters url The URL specifying the resource. Discussion All temporary properties are also cleared from the URL object's cache. This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLSetTemporaryResourcePropertyForKey

        public static void CFURLSetTemporaryResourcePropertyForKey​(CFURLRef url,
                                                           CFStringRef key,
                                                           org.moe.natj.general.ptr.ConstVoidPtr propertyValue)
        CFURLSetTemporaryResourcePropertyForKey Sets a temporary resource value on the URL object. Parameters url The URL object. key The resource key that identifies the temporary resource property. propertyValue The resource value. Discussion Temporary properties are for client use. Temporary properties exist only in memory and are never written to the resource's backing store. Once set, a temporary value can be copied from the URL object with CFURLCopyResourcePropertyForKey and CFURLCopyResourcePropertiesForKeys. To remove a temporary value from the URL object, use CFURLClearResourcePropertyCacheForKey. Temporary values must be valid Core Foundation types, and will be retained by CFURLSetTemporaryResourcePropertyForKey. Care should be taken to ensure the key that identifies a temporary resource property is unique and does not conflict with system defined keys (using reverse domain name notation in your temporary resource property keys is recommended). This function is currently applicable only to URLs for file system resources. Symbol is present in iOS 4, but performs no operation.

      • CFURLResourceIsReachable

        public static byte CFURLResourceIsReachable​(CFURLRef url,
                                            org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLResourceIsReachable Returns whether the URL's resource exists and is reachable. Parameters url The URL object. error On output when the result is false, the error that occurred. This parameter is optional; if you do not wish the error returned, pass NULL here. The caller is responsible for releasing a valid output error. Return Value true if the resource is reachable; otherwise, false. Discussion CFURLResourceIsReachable synchronously checks if the resource's backing store is reachable. Checking reachability is appropriate when making decisions that do not require other immediate operations on the resource, e.g. periodic maintenance of UI state that depends on the existence of a specific document. When performing operations such as opening a file or copying resource properties, it is more efficient to simply try the operation and handle failures. This function is currently applicable only to URLs for file system resources. If this function returns false, the optional error is populated. For other URL types, false is returned. Symbol is present in iOS 4, but performs no operation.

      • CFURLCreateBookmarkData

        public static CFDataRef CFURLCreateBookmarkData​(CFAllocatorRef allocator,
                                                CFURLRef url,
                                                long options,
                                                CFArrayRef resourcePropertiesToInclude,
                                                CFURLRef relativeToURL,
                                                org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        Returns bookmark data for the URL, created with specified options and resource properties. If this function returns NULL, the optional error is populated.

      • CFURLCreateByResolvingBookmarkData

        public static CFURLRef CFURLCreateByResolvingBookmarkData​(CFAllocatorRef allocator,
                                                          CFDataRef bookmark,
                                                          long options,
                                                          CFURLRef relativeToURL,
                                                          CFArrayRef resourcePropertiesToInclude,
                                                          org.moe.natj.general.ptr.BytePtr isStale,
                                                          org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        Return a URL that refers to a location specified by resolving bookmark data. If this function returns NULL, the optional error is populated.

      • CFURLCreateResourcePropertiesForKeysFromBookmarkData

        public static CFDictionaryRef CFURLCreateResourcePropertiesForKeysFromBookmarkData​(CFAllocatorRef allocator,
                                                                                   CFArrayRef resourcePropertiesToReturn,
                                                                                   CFDataRef bookmark)
        Returns the resource propertyies identified by a specified array of keys contained in specified bookmark data. If the result dictionary does not contain a resource value for one or more of the requested resource keys, it means those resource properties are not available in the bookmark data.

      • CFURLCreateResourcePropertyForKeyFromBookmarkData

        public static org.moe.natj.general.ptr.ConstVoidPtr CFURLCreateResourcePropertyForKeyFromBookmarkData​(CFAllocatorRef allocator,
                                                                                                      CFStringRef resourcePropertyKey,
                                                                                                      CFDataRef bookmark)
        Returns the resource property identified by a given resource key contained in specified bookmark data. If this function returns NULL, it means the resource property is not available in the bookmark data.

      • CFURLCreateBookmarkDataFromFile

        public static CFDataRef CFURLCreateBookmarkDataFromFile​(CFAllocatorRef allocator,
                                                        CFURLRef fileURL,
                                                        org.moe.natj.general.ptr.Ptr<CFErrorRef> errorRef)
        Returns bookmark data derived from an alias file referred to by fileURL. If fileURL refers to an alias file created prior to OS X v10.6 that contains Alias Manager information but no bookmark data, this method synthesizes bookmark data for the file. If this method returns NULL, the optional error is populated.

      • CFURLWriteBookmarkDataToFile

        public static byte CFURLWriteBookmarkDataToFile​(CFDataRef bookmarkRef,
                                                CFURLRef fileURL,
                                                long options,
                                                org.moe.natj.general.ptr.Ptr<CFErrorRef> errorRef)
        Creates an alias file on disk at a specified location with specified bookmark data. The bookmark data must have been created with the kCFURLBookmarkCreationSuitableForBookmarkFile option. fileURL must either refer to an existing file (which will be overwritten), or to location in an existing directory. If this method returns FALSE, the optional error is populated.

      • CFURLStartAccessingSecurityScopedResource

        public static byte CFURLStartAccessingSecurityScopedResource​(CFURLRef url)
        Given a CFURLRef created by resolving a bookmark data created with security scope, make the resource referenced by the url accessible to the process. When access to this resource is no longer needed the client must call CFURLStopAccessingSecurityScopedResource(). Each call to CFURLStartAccessingSecurityScopedResource() must be balanced with a call to CFURLStopAccessingSecurityScopedResource() (Note: this is not reference counted).

      • CFURLStopAccessingSecurityScopedResource

        public static void CFURLStopAccessingSecurityScopedResource​(CFURLRef url)
        Revokes the access granted to the url by a prior successful call to CFURLStartAccessingSecurityScopedResource().

      • CFAbsoluteTimeGetCurrent

        public static double CFAbsoluteTimeGetCurrent()
        absolute time is the time interval since the reference date the reference date (epoch) is 00:00:00 1 January 2001.

      • CFDateGetTypeID

        public static long CFDateGetTypeID()

      • CFDateGetAbsoluteTime

        public static double CFDateGetAbsoluteTime​(CFDateRef theDate)

      • CFDateGetTimeIntervalSinceDate

        public static double CFDateGetTimeIntervalSinceDate​(CFDateRef theDate,
                                                    CFDateRef otherDate)

      • CFDateCompare

        public static long CFDateCompare​(CFDateRef theDate,
                                 CFDateRef otherDate,
                                 org.moe.natj.general.ptr.VoidPtr context)

      • CFGregorianDateIsValid

        @Deprecated
public static byte CFGregorianDateIsValid​(CFGregorianDate gdate,
                                          long unitFlags)
        Deprecated.

      • CFGregorianDateGetAbsoluteTime

        @Deprecated
public static double CFGregorianDateGetAbsoluteTime​(CFGregorianDate gdate,
                                                    CFTimeZoneRef tz)
        Deprecated.

      • CFAbsoluteTimeGetGregorianDate

        @Deprecated
public static CFGregorianDate CFAbsoluteTimeGetGregorianDate​(double at,
                                                             CFTimeZoneRef tz)
        Deprecated.

      • CFAbsoluteTimeAddGregorianUnits

        @Deprecated
public static double CFAbsoluteTimeAddGregorianUnits​(double at,
                                                     CFTimeZoneRef tz,
                                                     CFGregorianUnits units)
        Deprecated.

      • CFAbsoluteTimeGetDifferenceAsGregorianUnits

        @Deprecated
public static CFGregorianUnits CFAbsoluteTimeGetDifferenceAsGregorianUnits​(double at1,
                                                                           double at2,
                                                                           CFTimeZoneRef tz,
                                                                           long unitFlags)
        Deprecated.

      • CFAbsoluteTimeGetDayOfWeek

        @Deprecated
public static int CFAbsoluteTimeGetDayOfWeek​(double at,
                                             CFTimeZoneRef tz)
        Deprecated.

      • CFAbsoluteTimeGetDayOfYear

        @Deprecated
public static int CFAbsoluteTimeGetDayOfYear​(double at,
                                             CFTimeZoneRef tz)
        Deprecated.

      • CFAbsoluteTimeGetWeekOfYear

        @Deprecated
public static int CFAbsoluteTimeGetWeekOfYear​(double at,
                                              CFTimeZoneRef tz)
        Deprecated.

      • CFBagGetTypeID

        public static long CFBagGetTypeID()

      • CFBagCreate

        public static CFBagRef CFBagCreate​(CFAllocatorRef allocator,
                                   org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values,
                                   long numValues,
                                   CFBagCallBacks callBacks)

      • CFBagGetCount

        public static long CFBagGetCount​(CFBagRef theBag)

      • CFBagGetCountOfValue

        public static long CFBagGetCountOfValue​(CFBagRef theBag,
                                        org.moe.natj.general.ptr.ConstVoidPtr value)

      • CFBagContainsValue

        public static byte CFBagContainsValue​(CFBagRef theBag,
                                      org.moe.natj.general.ptr.ConstVoidPtr value)

      • CFBagGetValue

        public static org.moe.natj.general.ptr.ConstVoidPtr CFBagGetValue​(CFBagRef theBag,
                                                                  org.moe.natj.general.ptr.ConstVoidPtr value)

      • CFBagGetValueIfPresent

        public static byte CFBagGetValueIfPresent​(CFBagRef theBag,
                                          org.moe.natj.general.ptr.ConstVoidPtr candidate,
                                          org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> value)

      • CFBagGetValues

        public static void CFBagGetValues​(CFBagRef theBag,
                                  org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values)

      • CFBagAddValue

        public static void CFBagAddValue​(CFMutableBagRef theBag,
                                 org.moe.natj.general.ptr.ConstVoidPtr value)

      • CFBagReplaceValue

        public static void CFBagReplaceValue​(CFMutableBagRef theBag,
                                     org.moe.natj.general.ptr.ConstVoidPtr value)

      • CFBagSetValue

        public static void CFBagSetValue​(CFMutableBagRef theBag,
                                 org.moe.natj.general.ptr.ConstVoidPtr value)

      • CFBagRemoveValue

        public static void CFBagRemoveValue​(CFMutableBagRef theBag,
                                    org.moe.natj.general.ptr.ConstVoidPtr value)

      • CFBagRemoveAllValues

        public static void CFBagRemoveAllValues​(CFMutableBagRef theBag)

      • CFBinaryHeapGetTypeID

        public static long CFBinaryHeapGetTypeID()
        [@function] CFBinaryHeapGetTypeID Returns the type identifier of all CFBinaryHeap instances.

      • CFBinaryHeapCreate

        public static CFBinaryHeapRef CFBinaryHeapCreate​(CFAllocatorRef allocator,
                                                 long capacity,
                                                 CFBinaryHeapCallBacks callBacks,
                                                 CFBinaryHeapCompareContext compareContext)
        [@function] CFBinaryHeapCreate Creates a new mutable binary heap with the given values.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the binary heap and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFBinaryHeap. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A heap's actual capacity is only limited by address space and available memory constraints). If this parameter is negative, the behavior is undefined.
        callBacks - A pointer to a CFBinaryHeapCallBacks structure initialized with the callbacks for the binary heap to use on each value in the binary heap. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple binary heap creations. If the version field of this callbacks structure is not one of the defined ones for CFBinaryHeap, the behavior is undefined. The retain field may be NULL, in which case the CFBinaryHeap will do nothing to add a retain to values as they are put into the binary heap. The release field may be NULL, in which case the CFBinaryHeap will do nothing to remove the binary heap's retain (if any) on the values when the heap is destroyed or a key-value pair is removed. If the copyDescription field is NULL, the binary heap will create a simple description for a value. If the equal field is NULL, the binary heap will use pointer equality to test for equality of values. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFBinaryHeapCallBacks callbacks structure, the behavior is undefined. If any of the values put into the binary heap is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        compareContext - A pointer to a CFBinaryHeapCompareContext structure.
        Returns:
        A reference to the new CFBinaryHeap.

      • CFBinaryHeapCreateCopy

        public static CFBinaryHeapRef CFBinaryHeapCreateCopy​(CFAllocatorRef allocator,
                                                     long capacity,
                                                     CFBinaryHeapRef heap)
        [@function] CFBinaryHeapCreateCopy Creates a new mutable binary heap with the values from the given binary heap.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the binary heap and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFBinaryHeap. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A heap's actual capacity is only limited by address space and available memory constraints). This parameter must be greater than or equal to the count of the heap which is to be copied, or the behavior is undefined. If this parameter is negative, the behavior is undefined.
        heap - The binary heap which is to be copied. The values from the binary heap are copied as pointers into the new binary heap (that is, the values themselves are copied, not that which the values point to, if anything). However, the values are also retained by the new binary heap. The count of the new binary will be the same as the given binary heap. The new binary heap uses the same callbacks as the binary heap to be copied. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        Returns:
        A reference to the new mutable binary heap.

      • CFBinaryHeapGetCount

        public static long CFBinaryHeapGetCount​(CFBinaryHeapRef heap)
        [@function] CFBinaryHeapGetCount Returns the number of values currently in the binary heap.
        Parameters:
        heap - The binary heap to be queried. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        Returns:
        The number of values in the binary heap.

      • CFBinaryHeapGetCountOfValue

        public static long CFBinaryHeapGetCountOfValue​(CFBinaryHeapRef heap,
                                               org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFBinaryHeapGetCountOfValue Counts the number of times the given value occurs in the binary heap.
        Parameters:
        heap - The binary heap to be searched. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        value - The value for which to find matches in the binary heap. The compare() callback provided when the binary heap was created is used to compare. If the compare() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the binary heap, are not understood by the compare() callback, the behavior is undefined.
        Returns:
        The number of times the given value occurs in the binary heap.

      • CFBinaryHeapContainsValue

        public static byte CFBinaryHeapContainsValue​(CFBinaryHeapRef heap,
                                             org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFBinaryHeapContainsValue Reports whether or not the value is in the binary heap.
        Parameters:
        heap - The binary heap to be searched. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        value - The value for which to find matches in the binary heap. The compare() callback provided when the binary heap was created is used to compare. If the compare() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the binary heap, are not understood by the compare() callback, the behavior is undefined.
        Returns:
        true, if the value is in the specified binary heap, otherwise false.

      • CFBinaryHeapGetMinimum

        public static org.moe.natj.general.ptr.ConstVoidPtr CFBinaryHeapGetMinimum​(CFBinaryHeapRef heap)
        [@function] CFBinaryHeapGetMinimum Returns the minimum value is in the binary heap. If the heap contains several equal minimum values, any one may be returned.
        Parameters:
        heap - The binary heap to be searched. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        Returns:
        A reference to the minimum value in the binary heap, or NULL if the binary heap contains no values.

      • CFBinaryHeapGetMinimumIfPresent

        public static byte CFBinaryHeapGetMinimumIfPresent​(CFBinaryHeapRef heap,
                                                   org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> value)
        [@function] CFBinaryHeapGetMinimumIfPresent Returns the minimum value is in the binary heap, if present. If the heap contains several equal minimum values, any one may be returned.
        Parameters:
        heap - The binary heap to be searched. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        value - A C pointer to pointer-sized storage to be filled with the minimum value in the binary heap. If this value is not a valid C pointer to a pointer-sized block of storage, the result is undefined. If the result of the function is false, the value stored at this address is undefined.
        Returns:
        true, if a minimum value was found in the specified binary heap, otherwise false.

      • CFBinaryHeapGetValues

        public static void CFBinaryHeapGetValues​(CFBinaryHeapRef heap,
                                         org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values)
        [@function] CFBinaryHeapGetValues Fills the buffer with values from the binary heap.
        Parameters:
        heap - The binary heap to be queried. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        values - A C array of pointer-sized values to be filled with values from the binary heap. The values in the C array are ordered from least to greatest. If this parameter is not a valid pointer to a C array of at least CFBinaryHeapGetCount() pointers, the behavior is undefined.

      • CFBinaryHeapApplyFunction

        public static void CFBinaryHeapApplyFunction​(CFBinaryHeapRef heap,
                                             CoreFoundation.Function_CFBinaryHeapApplyFunction applier,
                                             org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFBinaryHeapApplyFunction Calls a function once for each value in the binary heap.
        Parameters:
        heap - The binary heap to be operated upon. If this parameter is not a valid CFBinaryHeap, the behavior is undefined.
        applier - The callback function to call once for each value in the given binary heap. If this parameter is not a pointer to a function of the correct prototype, the behavior is undefined. If there are values in the binary heap which the applier function does not expect or cannot properly apply to, the behavior is undefined.
        context - A pointer-sized user-defined value, which is passed as the second parameter to the applier function, but is otherwise unused by this function. If the context is not what is expected by the applier function, the behavior is undefined.

      • CFBinaryHeapAddValue

        public static void CFBinaryHeapAddValue​(CFBinaryHeapRef heap,
                                        org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFBinaryHeapAddValue Adds the value to the binary heap.
        Parameters:
        heap - The binary heap to which the value is to be added. If this parameter is not a valid mutable CFBinaryHeap, the behavior is undefined.
        value - The value to add to the binary heap. The value is retained by the binary heap using the retain callback provided when the binary heap was created. If the value is not of the sort expected by the retain callback, the behavior is undefined.

      • CFBinaryHeapRemoveMinimumValue

        public static void CFBinaryHeapRemoveMinimumValue​(CFBinaryHeapRef heap)
        [@function] CFBinaryHeapRemoveMinimumValue Removes the minimum value from the binary heap.
        Parameters:
        heap - The binary heap from which the minimum value is to be removed. If this parameter is not a valid mutable CFBinaryHeap, the behavior is undefined.

      • CFBinaryHeapRemoveAllValues

        public static void CFBinaryHeapRemoveAllValues​(CFBinaryHeapRef heap)
        [@function] CFBinaryHeapRemoveAllValues Removes all the values from the binary heap, making it empty.
        Parameters:
        heap - The binary heap from which all of the values are to be removed. If this parameter is not a valid mutable CFBinaryHeap, the behavior is undefined.

      • CFBitVectorGetTypeID

        public static long CFBitVectorGetTypeID()

      • CFBitVectorGetCount

        public static long CFBitVectorGetCount​(CFBitVectorRef bv)

      • CFBitVectorGetCountOfBit

        public static long CFBitVectorGetCountOfBit​(CFBitVectorRef bv,
                                            CFRange range,
                                            int value)

      • CFBitVectorContainsBit

        public static byte CFBitVectorContainsBit​(CFBitVectorRef bv,
                                          CFRange range,
                                          int value)

      • CFBitVectorGetBitAtIndex

        public static int CFBitVectorGetBitAtIndex​(CFBitVectorRef bv,
                                           long idx)

      • CFBitVectorGetBits

        public static void CFBitVectorGetBits​(CFBitVectorRef bv,
                                      CFRange range,
                                      org.moe.natj.general.ptr.BytePtr bytes)

      • CFBitVectorGetFirstIndexOfBit

        public static long CFBitVectorGetFirstIndexOfBit​(CFBitVectorRef bv,
                                                 CFRange range,
                                                 int value)

      • CFBitVectorGetLastIndexOfBit

        public static long CFBitVectorGetLastIndexOfBit​(CFBitVectorRef bv,
                                                CFRange range,
                                                int value)

      • CFBitVectorSetCount

        public static void CFBitVectorSetCount​(CFMutableBitVectorRef bv,
                                       long count)

      • CFBitVectorFlipBitAtIndex

        public static void CFBitVectorFlipBitAtIndex​(CFMutableBitVectorRef bv,
                                             long idx)

      • CFBitVectorSetBitAtIndex

        public static void CFBitVectorSetBitAtIndex​(CFMutableBitVectorRef bv,
                                            long idx,
                                            int value)

      • CFBitVectorSetAllBits

        public static void CFBitVectorSetAllBits​(CFMutableBitVectorRef bv,
                                         int value)

      • CFByteOrderGetCurrent

        public static long CFByteOrderGetCurrent()

      • CFSwapInt16

        public static char CFSwapInt16​(char arg)

      • CFSwapInt32

        public static int CFSwapInt32​(int arg)

      • CFSwapInt64

        public static long CFSwapInt64​(long arg)

      • CFSwapInt16BigToHost

        public static char CFSwapInt16BigToHost​(char arg)

      • CFSwapInt32BigToHost

        public static int CFSwapInt32BigToHost​(int arg)

      • CFSwapInt64BigToHost

        public static long CFSwapInt64BigToHost​(long arg)

      • CFSwapInt16HostToBig

        public static char CFSwapInt16HostToBig​(char arg)

      • CFSwapInt32HostToBig

        public static int CFSwapInt32HostToBig​(int arg)

      • CFSwapInt64HostToBig

        public static long CFSwapInt64HostToBig​(long arg)

      • CFSwapInt16LittleToHost

        public static char CFSwapInt16LittleToHost​(char arg)

      • CFSwapInt32LittleToHost

        public static int CFSwapInt32LittleToHost​(int arg)

      • CFSwapInt64LittleToHost

        public static long CFSwapInt64LittleToHost​(long arg)

      • CFSwapInt16HostToLittle

        public static char CFSwapInt16HostToLittle​(char arg)

      • CFSwapInt32HostToLittle

        public static int CFSwapInt32HostToLittle​(int arg)

      • CFSwapInt64HostToLittle

        public static long CFSwapInt64HostToLittle​(long arg)

      • CFConvertFloat32HostToSwapped

        public static CFSwappedFloat32 CFConvertFloat32HostToSwapped​(float arg)

      • CFConvertFloat32SwappedToHost

        public static float CFConvertFloat32SwappedToHost​(CFSwappedFloat32 arg)

      • CFConvertFloat64HostToSwapped

        public static CFSwappedFloat64 CFConvertFloat64HostToSwapped​(double arg)

      • CFConvertFloat64SwappedToHost

        public static double CFConvertFloat64SwappedToHost​(CFSwappedFloat64 arg)

      • CFConvertFloatHostToSwapped

        public static CFSwappedFloat32 CFConvertFloatHostToSwapped​(float arg)

      • CFConvertFloatSwappedToHost

        public static float CFConvertFloatSwappedToHost​(CFSwappedFloat32 arg)

      • CFConvertDoubleHostToSwapped

        public static CFSwappedFloat64 CFConvertDoubleHostToSwapped​(double arg)

      • CFConvertDoubleSwappedToHost

        public static double CFConvertDoubleSwappedToHost​(CFSwappedFloat64 arg)

      • CFTimeZoneGetTypeID

        public static long CFTimeZoneGetTypeID()

      • CFTimeZoneCopySystem

        public static CFTimeZoneRef CFTimeZoneCopySystem()

      • CFTimeZoneResetSystem

        public static void CFTimeZoneResetSystem()

      • CFTimeZoneCopyDefault

        public static CFTimeZoneRef CFTimeZoneCopyDefault()

      • CFTimeZoneSetDefault

        public static void CFTimeZoneSetDefault​(CFTimeZoneRef tz)

      • CFTimeZoneCopyKnownNames

        public static CFArrayRef CFTimeZoneCopyKnownNames()

      • CFTimeZoneCopyAbbreviationDictionary

        public static CFDictionaryRef CFTimeZoneCopyAbbreviationDictionary()

      • CFTimeZoneSetAbbreviationDictionary

        public static void CFTimeZoneSetAbbreviationDictionary​(CFDictionaryRef dict)

      • CFTimeZoneCreateWithTimeIntervalFromGMT

        public static CFTimeZoneRef CFTimeZoneCreateWithTimeIntervalFromGMT​(CFAllocatorRef allocator,
                                                                    double ti)

      • CFTimeZoneGetSecondsFromGMT

        public static double CFTimeZoneGetSecondsFromGMT​(CFTimeZoneRef tz,
                                                 double at)

      • CFTimeZoneIsDaylightSavingTime

        public static byte CFTimeZoneIsDaylightSavingTime​(CFTimeZoneRef tz,
                                                  double at)

      • CFTimeZoneGetDaylightSavingTimeOffset

        public static double CFTimeZoneGetDaylightSavingTimeOffset​(CFTimeZoneRef tz,
                                                           double at)

      • CFTimeZoneGetNextDaylightSavingTimeTransition

        public static double CFTimeZoneGetNextDaylightSavingTimeTransition​(CFTimeZoneRef tz,
                                                                   double at)

      • CFCalendarGetTypeID

        public static long CFCalendarGetTypeID()

      • CFCalendarCopyCurrent

        public static CFCalendarRef CFCalendarCopyCurrent()

      • CFCalendarGetIdentifier

        public static CFStringRef CFCalendarGetIdentifier​(CFCalendarRef calendar)
        Create a calendar. The identifiers are the kCF*Calendar constants in CFLocale.h.

      • CFCalendarCopyLocale

        public static CFLocaleRef CFCalendarCopyLocale​(CFCalendarRef calendar)
        Returns the calendar's identifier.

      • CFCalendarGetFirstWeekday

        public static long CFCalendarGetFirstWeekday​(CFCalendarRef calendar)

      • CFCalendarSetFirstWeekday

        public static void CFCalendarSetFirstWeekday​(CFCalendarRef calendar,
                                             long wkdy)

      • CFCalendarGetMinimumDaysInFirstWeek

        public static long CFCalendarGetMinimumDaysInFirstWeek​(CFCalendarRef calendar)

      • CFCalendarSetMinimumDaysInFirstWeek

        public static void CFCalendarSetMinimumDaysInFirstWeek​(CFCalendarRef calendar,
                                                       long mwd)

      • CFCalendarGetMinimumRangeOfUnit

        public static CFRange CFCalendarGetMinimumRangeOfUnit​(CFCalendarRef calendar,
                                                      long unit)

      • CFCalendarGetMaximumRangeOfUnit

        public static CFRange CFCalendarGetMaximumRangeOfUnit​(CFCalendarRef calendar,
                                                      long unit)

      • CFCalendarGetRangeOfUnit

        public static CFRange CFCalendarGetRangeOfUnit​(CFCalendarRef calendar,
                                               long smallerUnit,
                                               long biggerUnit,
                                               double at)

      • CFCalendarGetOrdinalityOfUnit

        public static long CFCalendarGetOrdinalityOfUnit​(CFCalendarRef calendar,
                                                 long smallerUnit,
                                                 long biggerUnit,
                                                 double at)

      • CFCalendarGetTimeRangeOfUnit

        public static byte CFCalendarGetTimeRangeOfUnit​(CFCalendarRef calendar,
                                                long unit,
                                                double at,
                                                org.moe.natj.general.ptr.DoublePtr startp,
                                                org.moe.natj.general.ptr.DoublePtr tip)

      • CFCalendarComposeAbsoluteTime

        public static byte CFCalendarComposeAbsoluteTime​(CFCalendarRef calendar,
                                                 org.moe.natj.general.ptr.DoublePtr at,
                                                 java.lang.String componentDesc,
                                                 java.lang.Object... varargs)

      • CFCalendarDecomposeAbsoluteTime

        public static byte CFCalendarDecomposeAbsoluteTime​(CFCalendarRef calendar,
                                                   double at,
                                                   java.lang.String componentDesc,
                                                   java.lang.Object... varargs)

      • CFCalendarAddComponents

        public static byte CFCalendarAddComponents​(CFCalendarRef calendar,
                                           org.moe.natj.general.ptr.DoublePtr at,
                                           long options,
                                           java.lang.String componentDesc,
                                           java.lang.Object... varargs)

      • CFCalendarGetComponentDifference

        public static byte CFCalendarGetComponentDifference​(CFCalendarRef calendar,
                                                    double startingAT,
                                                    double resultAT,
                                                    long options,
                                                    java.lang.String componentDesc,
                                                    java.lang.Object... varargs)

      • CFDateFormatterCreateDateFormatFromTemplate

        public static CFStringRef CFDateFormatterCreateDateFormatFromTemplate​(CFAllocatorRef allocator,
                                                                      CFStringRef tmplate,
                                                                      long options,
                                                                      CFLocaleRef locale)
        CFDateFormatters are not thread-safe. Do not use one from multiple threads!

      • CFDateFormatterGetTypeID

        public static long CFDateFormatterGetTypeID()
        no options defined, pass 0 for now

      • CFDateFormatterCreateISO8601Formatter

        public static CFDateFormatterRef CFDateFormatterCreateISO8601Formatter​(CFAllocatorRef allocator,
                                                                       long formatOptions)

      • CFDateFormatterGetLocale

        public static CFLocaleRef CFDateFormatterGetLocale​(CFDateFormatterRef formatter)
        Returns a CFDateFormatter, localized to the given locale, which will format dates to the given date and time styles.

      • CFDateFormatterGetDateStyle

        public static long CFDateFormatterGetDateStyle​(CFDateFormatterRef formatter)

      • CFDateFormatterGetTimeStyle

        public static long CFDateFormatterGetTimeStyle​(CFDateFormatterRef formatter)

      • CFDateFormatterGetFormat

        public static CFStringRef CFDateFormatterGetFormat​(CFDateFormatterRef formatter)
        Get the properties with which the date formatter was created.

      • CFDateFormatterCreateStringWithDate

        public static CFStringRef CFDateFormatterCreateStringWithDate​(CFAllocatorRef allocator,
                                                              CFDateFormatterRef formatter,
                                                              CFDateRef date)
        Set the format description string of the date formatter. This overrides the style settings. The format of the format string is as defined by the ICU library. The date formatter starts with a default format string defined by the style arguments with which it was created.

      • CFDateFormatterCreateDateFromString

        public static CFDateRef CFDateFormatterCreateDateFromString​(CFAllocatorRef allocator,
                                                            CFDateFormatterRef formatter,
                                                            CFStringRef string,
                                                            CFRange rangep)
        Create a string representation of the given date or CFAbsoluteTime using the current state of the date formatter.

      • CFDateFormatterGetAbsoluteTimeFromString

        public static byte CFDateFormatterGetAbsoluteTimeFromString​(CFDateFormatterRef formatter,
                                                            CFStringRef string,
                                                            CFRange rangep,
                                                            org.moe.natj.general.ptr.DoublePtr atp)

      • CFDateFormatterSetProperty

        public static void CFDateFormatterSetProperty​(CFDateFormatterRef formatter,
                                              CFStringRef key,
                                              org.moe.natj.general.ptr.ConstVoidPtr value)
        Parse a string representation of a date using the current state of the date formatter. The range parameter specifies the range of the string in which the parsing should occur in input, and on output indicates the extent that was used; this parameter can be NULL, in which case the whole string may be used. The return value indicates whether some date was computed and (if atp is not NULL) stored at the location specified by atp.

      • CFDateFormatterCopyProperty

        public static org.moe.natj.general.ptr.ConstVoidPtr CFDateFormatterCopyProperty​(CFDateFormatterRef formatter,
                                                                                CFStringRef key)

      • CFBooleanGetTypeID

        public static long CFBooleanGetTypeID()

      • CFBooleanGetValue

        public static byte CFBooleanGetValue​(CFBooleanRef boolean_)

      • CFNumberGetTypeID

        public static long CFNumberGetTypeID()

      • CFNumberCreate

        public static CFNumberRef CFNumberCreate​(CFAllocatorRef allocator,
                                         long theType,
                                         org.moe.natj.general.ptr.ConstVoidPtr valuePtr)
        Creates a CFNumber with the given value. The type of number pointed to by the valuePtr is specified by type. If type is a floating point type and the value represents one of the infinities or NaN, the well-defined CFNumber for that value is returned. If either of valuePtr or type is an invalid value, the result is undefined.

      • CFNumberGetType

        public static long CFNumberGetType​(CFNumberRef number)
        Returns the storage format of the CFNumber's value. Note that this is not necessarily the type provided in CFNumberCreate().

      • CFNumberGetByteSize

        public static long CFNumberGetByteSize​(CFNumberRef number)
        Returns the size in bytes of the type of the number.

      • CFNumberIsFloatType

        public static byte CFNumberIsFloatType​(CFNumberRef number)
        Returns true if the type of the CFNumber's value is one of the defined floating point types.

      • CFNumberGetValue

        public static byte CFNumberGetValue​(CFNumberRef number,
                                    long theType,
                                    org.moe.natj.general.ptr.VoidPtr valuePtr)
        Copies the CFNumber's value into the space pointed to by valuePtr, as the specified type. If conversion needs to take place, the conversion rules follow human expectation and not C's promotion and truncation rules. If the conversion is lossy, or the value is out of range, false is returned. Best attempt at conversion will still be in *valuePtr.

      • CFNumberCompare

        public static long CFNumberCompare​(CFNumberRef number,
                                   CFNumberRef otherNumber,
                                   org.moe.natj.general.ptr.VoidPtr context)
        Compares the two CFNumber instances. If conversion of the types of the values is needed, the conversion and comparison follow human expectations and not C's promotion and comparison rules. Negative zero compares less than positive zero. Positive infinity compares greater than everything except itself, to which it compares equal. Negative infinity compares less than everything except itself, to which it compares equal. Unlike standard practice, if both numbers are NaN, then they compare equal; if only one of the numbers is NaN, then the NaN compares greater than the other number if it is negative, and smaller than the other number if it is positive. (Note that in CFEqual() with two CFNumbers, if either or both of the numbers is NaN, true is returned.)

      • CFNumberFormatterGetTypeID

        public static long CFNumberFormatterGetTypeID()
        CFNumberFormatters are not thread-safe. Do not use one from multiple threads!

      • CFNumberFormatterGetLocale

        public static CFLocaleRef CFNumberFormatterGetLocale​(CFNumberFormatterRef formatter)
        Returns a CFNumberFormatter, localized to the given locale, which will format numbers to the given style.

      • CFNumberFormatterGetStyle

        public static long CFNumberFormatterGetStyle​(CFNumberFormatterRef formatter)

      • CFNumberFormatterGetFormat

        public static CFStringRef CFNumberFormatterGetFormat​(CFNumberFormatterRef formatter)
        Get the properties with which the number formatter was created.

      • CFNumberFormatterCreateStringWithNumber

        public static CFStringRef CFNumberFormatterCreateStringWithNumber​(CFAllocatorRef allocator,
                                                                  CFNumberFormatterRef formatter,
                                                                  CFNumberRef number)
        Set the format description string of the number formatter. This overrides the style settings. The format of the format string is as defined by the ICU library, and is similar to that found in Microsoft Excel and NSNumberFormatter. The number formatter starts with a default format string defined by the style argument with which it was created.

      • CFNumberFormatterCreateStringWithValue

        public static CFStringRef CFNumberFormatterCreateStringWithValue​(CFAllocatorRef allocator,
                                                                 CFNumberFormatterRef formatter,
                                                                 long numberType,
                                                                 org.moe.natj.general.ptr.ConstVoidPtr valuePtr)

      • CFNumberFormatterGetValueFromString

        public static byte CFNumberFormatterGetValueFromString​(CFNumberFormatterRef formatter,
                                                       CFStringRef string,
                                                       CFRange rangep,
                                                       long numberType,
                                                       org.moe.natj.general.ptr.VoidPtr valuePtr)

      • CFNumberFormatterSetProperty

        public static void CFNumberFormatterSetProperty​(CFNumberFormatterRef formatter,
                                                CFStringRef key,
                                                org.moe.natj.general.ptr.ConstVoidPtr value)
        Parse a string representation of a number using the current state of the number formatter. The range parameter specifies the range of the string in which the parsing should occur in input, and on output indicates the extent that was used; this parameter can be NULL, in which case the whole string may be used. The return value indicates whether some number was computed and (if valuePtr is not NULL) stored at the location specified by valuePtr. The numberType indicates the type of value pointed to by valuePtr.

      • CFNumberFormatterCopyProperty

        public static org.moe.natj.general.ptr.ConstVoidPtr CFNumberFormatterCopyProperty​(CFNumberFormatterRef formatter,
                                                                                  CFStringRef key)

      • CFNumberFormatterGetDecimalInfoForCurrencyCode

        public static byte CFNumberFormatterGetDecimalInfoForCurrencyCode​(CFStringRef currencyCode,
                                                                  org.moe.natj.general.ptr.IntPtr defaultFractionDigits,
                                                                  org.moe.natj.general.ptr.DoublePtr roundingIncrement)

      • CFPreferencesCopyAppValue

        public static org.moe.natj.general.ptr.ConstVoidPtr CFPreferencesCopyAppValue​(CFStringRef key,
                                                                              CFStringRef applicationID)
        Searches the various sources of application defaults to find the value for the given key. key must not be NULL. If a value is found, it returns it; otherwise returns NULL. Caller must release the returned value

      • CFPreferencesGetAppBooleanValue

        public static byte CFPreferencesGetAppBooleanValue​(CFStringRef key,
                                                   CFStringRef applicationID,
                                                   org.moe.natj.general.ptr.BytePtr keyExistsAndHasValidFormat)
        Convenience to interpret a preferences value as a boolean directly. Returns false if the key doesn't exist, or has an improper format; under those conditions, keyExistsAndHasValidFormat (if non-NULL) is set to false

      • CFPreferencesGetAppIntegerValue

        public static long CFPreferencesGetAppIntegerValue​(CFStringRef key,
                                                   CFStringRef applicationID,
                                                   org.moe.natj.general.ptr.BytePtr keyExistsAndHasValidFormat)
        Convenience to interpret a preferences value as an integer directly. Returns 0 if the key doesn't exist, or has an improper format; under those conditions, keyExistsAndHasValidFormat (if non-NULL) is set to false

      • CFPreferencesSetAppValue

        public static void CFPreferencesSetAppValue​(CFStringRef key,
                                            org.moe.natj.general.ptr.ConstVoidPtr value,
                                            CFStringRef applicationID)
        Sets the given value for the given key in the "normal" place for application preferences. key must not be NULL. If value is NULL, key is removed instead.

      • CFPreferencesAddSuitePreferencesToApp

        public static void CFPreferencesAddSuitePreferencesToApp​(CFStringRef applicationID,
                                                         CFStringRef suiteID)
        Adds the preferences for the given suite to the app preferences for the specified application. To write to the suite domain, use CFPreferencesSetValue(), below, using the suiteName in place of the appName

      • CFPreferencesRemoveSuitePreferencesFromApp

        public static void CFPreferencesRemoveSuitePreferencesFromApp​(CFStringRef applicationID,
                                                              CFStringRef suiteID)

      • CFPreferencesAppSynchronize

        public static byte CFPreferencesAppSynchronize​(CFStringRef applicationID)
        Writes all changes in all sources of application defaults. Returns success or failure.

      • CFPreferencesCopyValue

        public static org.moe.natj.general.ptr.ConstVoidPtr CFPreferencesCopyValue​(CFStringRef key,
                                                                           CFStringRef applicationID,
                                                                           CFStringRef userName,
                                                                           CFStringRef hostName)
        The primitive get mechanism; all arguments must be non-NULL (use the constants above for common values). Only the exact location specified by app-user-host is searched. The returned CFType must be released by the caller when it is finished with it.

      • CFPreferencesCopyMultiple

        public static CFDictionaryRef CFPreferencesCopyMultiple​(CFArrayRef keysToFetch,
                                                        CFStringRef applicationID,
                                                        CFStringRef userName,
                                                        CFStringRef hostName)
        Convenience to fetch multiple keys at once. Keys in keysToFetch that are not present in the returned dictionary are not present in the domain. If keysToFetch is NULL, all keys are fetched.

      • CFPreferencesSetValue

        public static void CFPreferencesSetValue​(CFStringRef key,
                                         org.moe.natj.general.ptr.ConstVoidPtr value,
                                         CFStringRef applicationID,
                                         CFStringRef userName,
                                         CFStringRef hostName)
        The primitive set function; all arguments except value must be non-NULL. If value is NULL, the given key is removed

      • CFPreferencesSetMultiple

        public static void CFPreferencesSetMultiple​(CFDictionaryRef keysToSet,
                                            CFArrayRef keysToRemove,
                                            CFStringRef applicationID,
                                            CFStringRef userName,
                                            CFStringRef hostName)
        Convenience to set multiple values at once. Behavior is undefined if a key is in both keysToSet and keysToRemove

      • CFPreferencesCopyApplicationList

        @Deprecated
public static CFArrayRef CFPreferencesCopyApplicationList​(CFStringRef userName,
                                                          CFStringRef hostName)
        Deprecated.
        Constructs and returns the list of the name of all applications which have preferences in the scope of the given user and host, or NULL if no applications are there. The returned value must be released by the caller; neither argument may be NULL. Does not supported sandboxed applications.

      • CFPreferencesCopyKeyList

        public static CFArrayRef CFPreferencesCopyKeyList​(CFStringRef applicationID,
                                                  CFStringRef userName,
                                                  CFStringRef hostName)
        Constructs and returns the list of all keys set in the given location, or NULL if no keys are set. The returned value must be released by the caller; all arguments must be non-NULL

      • CFPreferencesAppValueIsForced

        public static byte CFPreferencesAppValueIsForced​(CFStringRef key,
                                                 CFStringRef applicationID)
        Function to determine whether or not a given key has been imposed on the user - In cases where machines and/or users are under some kind of management, callers should use this function to determine whether or not to disable UI elements corresponding to those preference keys.

      • CFRunLoopGetTypeID

        public static long CFRunLoopGetTypeID()

      • CFRunLoopGetCurrent

        public static CFRunLoopRef CFRunLoopGetCurrent()

      • CFRunLoopGetMain

        public static CFRunLoopRef CFRunLoopGetMain()

      • CFRunLoopGetNextTimerFireDate

        public static double CFRunLoopGetNextTimerFireDate​(CFRunLoopRef rl,
                                                   CFStringRef mode)

      • CFRunLoopRun

        public static void CFRunLoopRun()

      • CFRunLoopRunInMode

        public static int CFRunLoopRunInMode​(CFStringRef mode,
                                     double seconds,
                                     byte returnAfterSourceHandled)

      • CFRunLoopIsWaiting

        public static byte CFRunLoopIsWaiting​(CFRunLoopRef rl)

      • CFRunLoopWakeUp

        public static void CFRunLoopWakeUp​(CFRunLoopRef rl)

      • CFRunLoopStop

        public static void CFRunLoopStop​(CFRunLoopRef rl)

      • CFRunLoopSourceGetTypeID

        public static long CFRunLoopSourceGetTypeID()

      • CFRunLoopSourceGetOrder

        public static long CFRunLoopSourceGetOrder​(CFRunLoopSourceRef source)

      • CFRunLoopSourceInvalidate

        public static void CFRunLoopSourceInvalidate​(CFRunLoopSourceRef source)

      • CFRunLoopSourceIsValid

        public static byte CFRunLoopSourceIsValid​(CFRunLoopSourceRef source)

      • CFRunLoopSourceSignal

        public static void CFRunLoopSourceSignal​(CFRunLoopSourceRef source)

      • CFRunLoopObserverGetTypeID

        public static long CFRunLoopObserverGetTypeID()

      • CFRunLoopObserverGetActivities

        public static long CFRunLoopObserverGetActivities​(CFRunLoopObserverRef observer)

      • CFRunLoopObserverDoesRepeat

        public static byte CFRunLoopObserverDoesRepeat​(CFRunLoopObserverRef observer)

      • CFRunLoopObserverGetOrder

        public static long CFRunLoopObserverGetOrder​(CFRunLoopObserverRef observer)

      • CFRunLoopObserverInvalidate

        public static void CFRunLoopObserverInvalidate​(CFRunLoopObserverRef observer)

      • CFRunLoopObserverIsValid

        public static byte CFRunLoopObserverIsValid​(CFRunLoopObserverRef observer)

      • CFRunLoopTimerGetTypeID

        public static long CFRunLoopTimerGetTypeID()

      • CFRunLoopTimerGetNextFireDate

        public static double CFRunLoopTimerGetNextFireDate​(CFRunLoopTimerRef timer)

      • CFRunLoopTimerSetNextFireDate

        public static void CFRunLoopTimerSetNextFireDate​(CFRunLoopTimerRef timer,
                                                 double fireDate)

      • CFRunLoopTimerGetInterval

        public static double CFRunLoopTimerGetInterval​(CFRunLoopTimerRef timer)

      • CFRunLoopTimerDoesRepeat

        public static byte CFRunLoopTimerDoesRepeat​(CFRunLoopTimerRef timer)

      • CFRunLoopTimerGetOrder

        public static long CFRunLoopTimerGetOrder​(CFRunLoopTimerRef timer)

      • CFRunLoopTimerInvalidate

        public static void CFRunLoopTimerInvalidate​(CFRunLoopTimerRef timer)

      • CFRunLoopTimerIsValid

        public static byte CFRunLoopTimerIsValid​(CFRunLoopTimerRef timer)

      • CFRunLoopTimerGetTolerance

        public static double CFRunLoopTimerGetTolerance​(CFRunLoopTimerRef timer)
        Setting a tolerance for a timer allows it to fire later than the scheduled fire date, improving the ability of the system to optimize for increased power savings and responsiveness. The timer may fire at any time between its scheduled fire date and the scheduled fire date plus the tolerance. The timer will not fire before the scheduled fire date. For repeating timers, the next fire date is calculated from the original fire date regardless of tolerance applied at individual fire times, to avoid drift. The default value is zero, which means no additional tolerance is applied. The system reserves the right to apply a small amount of tolerance to certain timers regardless of the value of this property. As the user of the timer, you will have the best idea of what an appropriate tolerance for a timer may be. A general rule of thumb, though, is to set the tolerance to at least 10% of the interval, for a repeating timer. Even a small amount of tolerance will have a significant positive impact on the power usage of your application. The system may put a maximum value of the tolerance.

      • CFRunLoopTimerSetTolerance

        public static void CFRunLoopTimerSetTolerance​(CFRunLoopTimerRef timer,
                                              double tolerance)

      • CFSocketGetTypeID

        public static long CFSocketGetTypeID()

      • CFSocketSetAddress

        public static long CFSocketSetAddress​(CFSocketRef s,
                                      CFDataRef address)
        CFSocketCreateConnectedToSocketSignature() creates a socket suitable for connecting to the requested type and address, and connects it (using CFSocketConnectToAddress()). If this fails, it returns NULL.

      • CFSocketConnectToAddress

        public static long CFSocketConnectToAddress​(CFSocketRef s,
                                            CFDataRef address,
                                            double timeout)

      • CFSocketInvalidate

        public static void CFSocketInvalidate​(CFSocketRef s)

      • CFSocketIsValid

        public static byte CFSocketIsValid​(CFSocketRef s)

      • CFSocketGetNative

        public static int CFSocketGetNative​(CFSocketRef s)

      • CFSocketGetSocketFlags

        public static long CFSocketGetSocketFlags​(CFSocketRef s)

      • CFSocketSetSocketFlags

        public static void CFSocketSetSocketFlags​(CFSocketRef s,
                                          long flags)

      • CFSocketDisableCallBacks

        public static void CFSocketDisableCallBacks​(CFSocketRef s,
                                            long callBackTypes)

      • CFSocketEnableCallBacks

        public static void CFSocketEnableCallBacks​(CFSocketRef s,
                                           long callBackTypes)

      • CFSocketSendData

        public static long CFSocketSendData​(CFSocketRef s,
                                    CFDataRef address,
                                    CFDataRef data,
                                    double timeout)
        For convenience, a function is provided to send data using the socket with a timeout. The timeout will be used only if the specified value is positive. The address should be left NULL if the socket is already connected.

      • CFSocketRegisterValue

        public static long CFSocketRegisterValue​(CFSocketSignature nameServerSignature,
                                         double timeout,
                                         CFStringRef name,
                                         org.moe.natj.general.ptr.ConstVoidPtr value)
        Generic name registry functionality (CFSocketRegisterValue, CFSocketCopyRegisteredValue) allows the registration of any property list type. Functions specific to CFSockets (CFSocketRegisterSocketData, CFSocketCopyRegisteredSocketData) register a CFData containing the components of a socket signature (protocol family, socket type, protocol, and address). In each function the nameServerSignature may be NULL, or any component of it may be 0, to use default values (TCP, INADDR_LOOPBACK, port as set). Name registration servers might not allow registration with other than TCP and INADDR_LOOPBACK. The actual address of the server responding to a query may be obtained by using the nameServerAddress argument. This address, the address returned by CFSocketCopyRegisteredSocketSignature, and the value returned by CFSocketCopyRegisteredValue must (if non-null) be released by the caller. CFSocketUnregister removes any registration associated with the specified name.

      • CFSocketCopyRegisteredValue

        public static long CFSocketCopyRegisteredValue​(CFSocketSignature nameServerSignature,
                                               double timeout,
                                               CFStringRef name,
                                               org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> value,
                                               org.moe.natj.general.ptr.Ptr<CFDataRef> nameServerAddress)

      • CFSocketSetDefaultNameRegistryPortNumber

        public static void CFSocketSetDefaultNameRegistryPortNumber​(char port)

      • CFSocketGetDefaultNameRegistryPortNumber

        public static char CFSocketGetDefaultNameRegistryPortNumber()

      • CFReadStreamGetTypeID

        public static long CFReadStreamGetTypeID()

      • CFWriteStreamGetTypeID

        public static long CFWriteStreamGetTypeID()

      • CFReadStreamCreateWithBytesNoCopy

        public static CFReadStreamRef CFReadStreamCreateWithBytesNoCopy​(CFAllocatorRef alloc,
                                                                java.lang.String bytes,
                                                                long length,
                                                                CFAllocatorRef bytesDeallocator)
        Pass kCFAllocatorNull for bytesDeallocator to prevent CFReadStream from deallocating bytes; otherwise, CFReadStream will deallocate bytes when the stream is destroyed

      • CFWriteStreamCreateWithBuffer

        public static CFWriteStreamRef CFWriteStreamCreateWithBuffer​(CFAllocatorRef alloc,
                                                             org.moe.natj.general.ptr.BytePtr buffer,
                                                             long bufferCapacity)
        The stream writes into the buffer given; when bufferCapacity is exhausted, the stream is exhausted (status becomes kCFStreamStatusAtEnd)

      • CFWriteStreamCreateWithAllocatedBuffers

        public static CFWriteStreamRef CFWriteStreamCreateWithAllocatedBuffers​(CFAllocatorRef alloc,
                                                                       CFAllocatorRef bufferAllocator)
        New buffers are allocated from bufferAllocator as bytes are written to the stream. At any point, you can recover the bytes thusfar written by asking for the property kCFStreamPropertyDataWritten, above

      • CFStreamCreateBoundPair

        public static void CFStreamCreateBoundPair​(CFAllocatorRef alloc,
                                           org.moe.natj.general.ptr.Ptr<CFReadStreamRef> readStream,
                                           org.moe.natj.general.ptr.Ptr<CFWriteStreamRef> writeStream,
                                           long transferBufferSize)

      • CFStreamCreatePairWithSocket

        public static void CFStreamCreatePairWithSocket​(CFAllocatorRef alloc,
                                                int sock,
                                                org.moe.natj.general.ptr.Ptr<CFReadStreamRef> readStream,
                                                org.moe.natj.general.ptr.Ptr<CFWriteStreamRef> writeStream)
        Socket streams; the returned streams are paired such that they use the same socket; pass NULL if you want only the read stream or the write stream

      • CFReadStreamGetStatus

        public static long CFReadStreamGetStatus​(CFReadStreamRef stream)
        Returns the current state of the stream

      • CFWriteStreamGetStatus

        public static long CFWriteStreamGetStatus​(CFWriteStreamRef stream)

      • CFReadStreamCopyError

        public static CFErrorRef CFReadStreamCopyError​(CFReadStreamRef stream)
        Returns NULL if no error has occurred; otherwise returns the error.

      • CFReadStreamOpen

        public static byte CFReadStreamOpen​(CFReadStreamRef stream)
        Returns success/failure. Opening a stream causes it to reserve all the system resources it requires. If the stream can open non-blocking, this will always return TRUE; listen to the run loop source to find out when the open completes and whether it was successful, or poll using CFRead/WriteStreamGetStatus(), waiting for a status of kCFStreamStatusOpen or kCFStreamStatusError.

      • CFWriteStreamOpen

        public static byte CFWriteStreamOpen​(CFWriteStreamRef stream)

      • CFReadStreamClose

        public static void CFReadStreamClose​(CFReadStreamRef stream)
        Terminates the flow of bytes; releases any system resources required by the stream. The stream may not fail to close. You may call CFStreamClose() to effectively abort a stream.

      • CFWriteStreamClose

        public static void CFWriteStreamClose​(CFWriteStreamRef stream)

      • CFReadStreamHasBytesAvailable

        public static byte CFReadStreamHasBytesAvailable​(CFReadStreamRef stream)
        Whether there is data currently available for reading; returns TRUE if it's impossible to tell without trying

      • CFReadStreamRead

        public static long CFReadStreamRead​(CFReadStreamRef stream,
                                    org.moe.natj.general.ptr.BytePtr buffer,
                                    long bufferLength)
        Returns the number of bytes read, or -1 if an error occurs preventing any bytes from being read, or 0 if the stream's end was encountered. It is an error to try and read from a stream that hasn't been opened first. This call will block until at least one byte is available; it will NOT block until the entire buffer can be filled. To avoid blocking, either poll using CFReadStreamHasBytesAvailable() or use the run loop and listen for the kCFStreamEventHasBytesAvailable event for notification of data available.

      • CFReadStreamGetBuffer

        public static java.lang.String CFReadStreamGetBuffer​(CFReadStreamRef stream,
                                                     long maxBytesToRead,
                                                     org.moe.natj.general.ptr.NIntPtr numBytesRead)
        Returns a pointer to an internal buffer if possible (setting *numBytesRead to the length of the returned buffer), otherwise returns NULL; guaranteed to return in O(1). Bytes returned in the buffer are considered read from the stream; if maxBytesToRead is greater than 0, not more than maxBytesToRead will be returned. If maxBytesToRead is less than or equal to zero, as many bytes as are readily available will be returned. The returned buffer is good only until the next stream operation called on the stream. Caller should neither change the contents of the returned buffer nor attempt to deallocate the buffer; it is still owned by the stream.

      • CFWriteStreamCanAcceptBytes

        public static byte CFWriteStreamCanAcceptBytes​(CFWriteStreamRef stream)
        Whether the stream can currently be written to without blocking; returns TRUE if it's impossible to tell without trying

      • CFWriteStreamWrite

        public static long CFWriteStreamWrite​(CFWriteStreamRef stream,
                                      java.lang.String buffer,
                                      long bufferLength)
        Returns the number of bytes successfully written, -1 if an error has occurred, or 0 if the stream has been filled to capacity (for fixed-length streams). If the stream is not full, this call will block until at least one byte is written. To avoid blocking, either poll via CFWriteStreamCanAcceptBytes or use the run loop and listen for the kCFStreamEventCanAcceptBytes event.

      • CFReadStreamCopyProperty

        public static org.moe.natj.general.ptr.ConstVoidPtr CFReadStreamCopyProperty​(CFReadStreamRef stream,
                                                                             CFStringRef propertyName)
        Particular streams can name properties and assign meanings to them; you access these properties through the following calls. A property is any interesting information about the stream other than the data being transmitted itself. Examples include the headers from an HTTP transmission, or the expected number of bytes, or permission information, etc. Properties that can be set configure the behavior of the stream, and may only be settable at particular times (like before the stream has been opened). See the documentation for particular properties to determine their get- and set-ability.

      • CFWriteStreamCopyProperty

        public static org.moe.natj.general.ptr.ConstVoidPtr CFWriteStreamCopyProperty​(CFWriteStreamRef stream,
                                                                              CFStringRef propertyName)

      • CFReadStreamSetProperty

        public static byte CFReadStreamSetProperty​(CFReadStreamRef stream,
                                           CFStringRef propertyName,
                                           org.moe.natj.general.ptr.ConstVoidPtr propertyValue)
        Returns TRUE if the stream recognizes and accepts the given property-value pair; FALSE otherwise.

      • CFWriteStreamSetProperty

        public static byte CFWriteStreamSetProperty​(CFWriteStreamRef stream,
                                            CFStringRef propertyName,
                                            org.moe.natj.general.ptr.ConstVoidPtr propertyValue)

      • CFReadStreamSetClient

        public static byte CFReadStreamSetClient​(CFReadStreamRef stream,
                                         long streamEvents,
                                         CoreFoundation.Function_CFReadStreamSetClient clientCB,
                                         CFStreamClientContext clientContext)
        Asynchronous processing - If you wish to neither poll nor block, you may register a client to hear about interesting events that occur on a stream. Only one client per stream is allowed; registering a new client replaces the previous one. Once you have set a client, the stream must be scheduled to provide the context in which the client will be called. Streams may be scheduled on a single dispatch queue or on one or more run loops. If scheduled on a run loop, it is the caller's responsibility to ensure that at least one of the scheduled run loops is being run. NOTE: Unlike other CoreFoundation APIs, pasing a NULL clientContext here will remove the client. If you do not care about the client context (i.e. your only concern is that your callback be called), you should pass in a valid context where every entry is 0 or NULL.

      • CFReadStreamSetDispatchQueue

        public static void CFReadStreamSetDispatchQueue​(CFReadStreamRef stream,
                                                NSObject q)
        Specify the dispatch queue upon which the client callbacks will be invoked. Passing NULL for the queue will prevent future callbacks from being invoked. Specifying a dispatch queue using this API will unschedule the stream from any run loops it had previously been scheduled upon - similarly, scheduling with a runloop will disassociate the stream from any existing dispatch queue.

      • CFWriteStreamSetDispatchQueue

        public static void CFWriteStreamSetDispatchQueue​(CFWriteStreamRef stream,
                                                 NSObject q)

      • CFReadStreamCopyDispatchQueue

        public static NSObject CFReadStreamCopyDispatchQueue​(CFReadStreamRef stream)
        Returns the previously set dispatch queue with an incremented retain count. Note that the stream's queue may have been set to NULL if the stream was scheduled on a runloop subsequent to it having had a dispatch queue set.

      • CFPropertyListCreateFromXMLData

        @Deprecated
public static org.moe.natj.general.ptr.ConstVoidPtr CFPropertyListCreateFromXMLData​(CFAllocatorRef allocator,
                                                                                    CFDataRef xmlData,
                                                                                    long mutabilityOption,
                                                                                    org.moe.natj.general.ptr.Ptr<CFStringRef> errorString)
        Deprecated.
        Creates a property list object from its XML description; xmlData should be the raw bytes of that description, possibly the contents of an XML file. Returns NULL if the data cannot be parsed; if the parse fails and errorString is non-NULL, a human-readable description of the failure is returned in errorString. It is the caller's responsibility to release either the returned object or the error string, whichever is applicable. This function is deprecated. See CFPropertyListCreateWithData() for a replacement.

      • CFPropertyListCreateXMLData

        @Deprecated
public static CFDataRef CFPropertyListCreateXMLData​(CFAllocatorRef allocator,
                                                    org.moe.natj.general.ptr.ConstVoidPtr propertyList)
        Deprecated.
        Returns the XML description of the given object; propertyList must be one of the supported property list types, and (for composite types like CFArray and CFDictionary) must not contain any elements that are not themselves of a property list type. If a non-property list type is encountered, NULL is returned. The returned data is appropriate for writing out to an XML file. Note that a data, not a string, is returned because the bytes contain in them a description of the string encoding used. This function is deprecated. See CFPropertyListCreateData() for a replacement.

      • CFPropertyListCreateDeepCopy

        public static org.moe.natj.general.ptr.ConstVoidPtr CFPropertyListCreateDeepCopy​(CFAllocatorRef allocator,
                                                                                 org.moe.natj.general.ptr.ConstVoidPtr propertyList,
                                                                                 long mutabilityOption)
        Recursively creates a copy of the given property list (so nested arrays and dictionaries are copied as well as the top-most container). The resulting property list has the mutability characteristics determined by mutabilityOption.

      • CFPropertyListIsValid

        public static byte CFPropertyListIsValid​(org.moe.natj.general.ptr.ConstVoidPtr plist,
                                         long format)
        Returns true if the object graph rooted at plist is a valid property list graph -- that is, no cycles, containing only plist objects, and dictionary keys are strings. The debugging library version spits out some messages to be helpful. The plist structure which is to be allowed is given by the format parameter.

      • CFPropertyListWriteToStream

        @Deprecated
public static long CFPropertyListWriteToStream​(org.moe.natj.general.ptr.ConstVoidPtr propertyList,
                                               CFWriteStreamRef stream,
                                               long format,
                                               org.moe.natj.general.ptr.Ptr<CFStringRef> errorString)
        Deprecated.
        Writes the bytes of a plist serialization out to the stream. The stream must be opened and configured -- the function simply writes a bunch of bytes to the stream. The output plist format can be chosen. Leaves the stream open, but note that reading a plist expects the reading stream to end wherever the writing ended, so that the end of the plist data can be identified. Returns the number of bytes written, or 0 on error. Error messages are not currently localized, but may be in the future, so they are not suitable for comparison. This function is deprecated. See CFPropertyListWrite() for a replacement.

      • CFPropertyListCreateFromStream

        @Deprecated
public static org.moe.natj.general.ptr.ConstVoidPtr CFPropertyListCreateFromStream​(CFAllocatorRef allocator,
                                                                                   CFReadStreamRef stream,
                                                                                   long streamLength,
                                                                                   long mutabilityOption,
                                                                                   org.moe.natj.general.ptr.NIntPtr format,
                                                                                   org.moe.natj.general.ptr.Ptr<CFStringRef> errorString)
        Deprecated.
        Same as current function CFPropertyListCreateFromXMLData() but takes a stream instead of data, and works on any plist file format. CFPropertyListCreateFromXMLData() also works on any plist file format. The stream must be open and configured -- the function simply reads a bunch of bytes from it starting at the current location in the stream, to the END of the stream, which is expected to be the end of the plist, or up to the number of bytes given by the length parameter if it is not 0. Error messages are not currently localized, but may be in the future, so they are not suitable for comparison. This function is deprecated. See CFPropertyListCreateWithStream() for a replacement.

      • CFPropertyListCreateWithData

        public static org.moe.natj.general.ptr.ConstVoidPtr CFPropertyListCreateWithData​(CFAllocatorRef allocator,
                                                                                 CFDataRef data,
                                                                                 long options,
                                                                                 org.moe.natj.general.ptr.NIntPtr format,
                                                                                 org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        Create a property list with a CFData input. If the format parameter is non-NULL, it will be set to the format of the data after parsing is complete. The options parameter is used to specify CFPropertyListMutabilityOptions. If an error occurs while parsing the data, the return value will be NULL. Additionally, if an error occurs and the error parameter is non-NULL, the error parameter will be set to a CFError describing the problem, which the caller must release. If the parse succeeds, the returned value is a reference to the new property list. It is the responsibility of the caller to release this value.

      • CFPropertyListCreateWithStream

        public static org.moe.natj.general.ptr.ConstVoidPtr CFPropertyListCreateWithStream​(CFAllocatorRef allocator,
                                                                                   CFReadStreamRef stream,
                                                                                   long streamLength,
                                                                                   long options,
                                                                                   org.moe.natj.general.ptr.NIntPtr format,
                                                                                   org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        Create and return a property list with a CFReadStream input. If the format parameter is non-NULL, it will be set to the format of the data after parsing is complete. The options parameter is used to specify CFPropertyListMutabilityOptions. The streamLength parameter specifies the number of bytes to read from the stream. Set streamLength to 0 to read until the end of the stream is detected. If an error occurs while parsing the data, the return value will be NULL. Additionally, if an error occurs and the error parameter is non-NULL, the error parameter will be set to a CFError describing the problem, which the caller must release. If the parse succeeds, the returned value is a reference to the new property list. It is the responsibility of the caller to release this value.

      • CFPropertyListWrite

        public static long CFPropertyListWrite​(org.moe.natj.general.ptr.ConstVoidPtr propertyList,
                                       CFWriteStreamRef stream,
                                       long format,
                                       long options,
                                       org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        Write the bytes of a serialized property list out to a stream. The stream must be opened and configured. The format of the property list can be chosen with the format parameter. The options parameter is currently unused and should be set to 0. The return value is the number of bytes written or 0 in the case of an error. If an error occurs and the error parameter is non-NULL, the error parameter will be set to a CFError describing the problem, which the caller must release.

      • CFPropertyListCreateData

        public static CFDataRef CFPropertyListCreateData​(CFAllocatorRef allocator,
                                                 org.moe.natj.general.ptr.ConstVoidPtr propertyList,
                                                 long format,
                                                 long options,
                                                 org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        Create a CFData with the bytes of a serialized property list. The format of the property list can be chosen with the format parameter. The options parameter is currently unused and should be set to 0. If an error occurs while parsing the data, the return value will be NULL. Additionally, if an error occurs and the error parameter is non-NULL, the error parameter will be set to a CFError describing the problem, which the caller must release. If the conversion succeeds, the returned value is a reference to the created data. It is the responsibility of the caller to release this value.

      • CFSetGetTypeID

        public static long CFSetGetTypeID()
        [@function] CFSetGetTypeID Returns the type identifier of all CFSet instances.

      • CFSetCreate

        public static CFSetRef CFSetCreate​(CFAllocatorRef allocator,
                                   org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values,
                                   long numValues,
                                   CFSetCallBacks callBacks)
        [@function] CFSetCreate Creates a new immutable set with the given values.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the set and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        values - A C array of the pointer-sized values to be in the set. This C array is not changed or freed by this function. If this parameter is not a valid pointer to a C array of at least numValues pointers, the behavior is undefined.
        numValues - The number of values to copy from the values C array into the CFSet. This number will be the count of the set. If this parameter is zero, negative, or greater than the number of values actually in the values C array, the behavior is undefined.
        callBacks - A C pointer to a CFSetCallBacks structure initialized with the callbacks for the set to use on each value in the set. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple set creations. If the version field of this callbacks structure is not one of the defined ones for CFSet, the behavior is undefined. The retain field may be NULL, in which case the CFSet will do nothing to add a retain to the contained values for the set. The release field may be NULL, in which case the CFSet will do nothing to remove the set's retain (if any) on the values when the set is destroyed. If the copyDescription field is NULL, the set will create a simple description for the value. If the equal field is NULL, the set will use pointer equality to test for equality of values. The hash field may be NULL, in which case the CFSet will determine uniqueness by pointer equality. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFSetCallBacks callbacks structure, the behavior is undefined. If any of the values put into the set is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        Returns:
        A reference to the new immutable CFSet.

      • CFSetCreateCopy

        public static CFSetRef CFSetCreateCopy​(CFAllocatorRef allocator,
                                       CFSetRef theSet)
        [@function] CFSetCreateCopy Creates a new immutable set with the values from the given set.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the set and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        theSet - The set which is to be copied. The values from the set are copied as pointers into the new set (that is, the values themselves are copied, not that which the values point to, if anything). However, the values are also retained by the new set. The count of the new set will be the same as the copied set. The new set uses the same callbacks as the set to be copied. If this parameter is not a valid CFSet, the behavior is undefined.
        Returns:
        A reference to the new immutable CFSet.

      • CFSetCreateMutable

        public static CFMutableSetRef CFSetCreateMutable​(CFAllocatorRef allocator,
                                                 long capacity,
                                                 CFSetCallBacks callBacks)
        [@function] CFSetCreateMutable Creates a new empty mutable set.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the set and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFSet. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A set's actual capacity is only limited by address space and available memory constraints). If this parameter is negative, the behavior is undefined.
        callBacks - A C pointer to a CFSetCallBacks structure initialized with the callbacks for the set to use on each value in the set. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple set creations. If the version field of this callbacks structure is not one of the defined ones for CFSet, the behavior is undefined. The retain field may be NULL, in which case the CFSet will do nothing to add a retain to the contained values for the set. The release field may be NULL, in which case the CFSet will do nothing to remove the set's retain (if any) on the values when the set is destroyed. If the copyDescription field is NULL, the set will create a simple description for the value. If the equal field is NULL, the set will use pointer equality to test for equality of values. The hash field may be NULL, in which case the CFSet will determine uniqueness by pointer equality. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFSetCallBacks callbacks structure, the behavior is undefined. If any of the values put into the set is not one understood by one of the callback functions the behavior when that callback function is used is undefined.
        Returns:
        A reference to the new mutable CFSet.

      • CFSetCreateMutableCopy

        public static CFMutableSetRef CFSetCreateMutableCopy​(CFAllocatorRef allocator,
                                                     long capacity,
                                                     CFSetRef theSet)
        [@function] CFSetCreateMutableCopy Creates a new immutable set with the values from the given set.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the set and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        capacity - A hint about the number of values that will be held by the CFSet. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A set's actual capacity is only limited by address space and available memory constraints). This parameter must be greater than or equal to the count of the set which is to be copied, or the behavior is undefined. If this parameter is negative, the behavior is undefined.
        theSet - The set which is to be copied. The values from the set are copied as pointers into the new set (that is, the values themselves are copied, not that which the values point to, if anything). However, the values are also retained by the new set. The count of the new set will be the same as the copied set. The new set uses the same callbacks as the set to be copied. If this parameter is not a valid CFSet, the behavior is undefined.
        Returns:
        A reference to the new mutable CFSet.

      • CFSetGetCount

        public static long CFSetGetCount​(CFSetRef theSet)
        [@function] CFSetGetCount Returns the number of values currently in the set.
        Parameters:
        theSet - The set to be queried. If this parameter is not a valid CFSet, the behavior is undefined.
        Returns:
        The number of values in the set.

      • CFSetGetCountOfValue

        public static long CFSetGetCountOfValue​(CFSetRef theSet,
                                        org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFSetGetCountOfValue Counts the number of times the given value occurs in the set. Since sets by definition contain only one instance of a value, this function is synonymous to CFSetContainsValue.
        Parameters:
        theSet - The set to be searched. If this parameter is not a valid CFSet, the behavior is undefined.
        value - The value for which to find matches in the set. The equal() callback provided when the set was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the set, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        The number of times the given value occurs in the set.

      • CFSetContainsValue

        public static byte CFSetContainsValue​(CFSetRef theSet,
                                      org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFSetContainsValue Reports whether or not the value is in the set.
        Parameters:
        theSet - The set to be searched. If this parameter is not a valid CFSet, the behavior is undefined.
        value - The value for which to find matches in the set. The equal() callback provided when the set was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the set, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        true, if the value is in the set, otherwise false.

      • CFSetGetValue

        public static org.moe.natj.general.ptr.ConstVoidPtr CFSetGetValue​(CFSetRef theSet,
                                                                  org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFSetGetValue Retrieves a value in the set which hashes the same as the specified value.
        Parameters:
        theSet - The set to be queried. If this parameter is not a valid CFSet, the behavior is undefined.
        value - The value to retrieve. The equal() callback provided when the set was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If a value, or any of the values in the set, are not understood by the equal() callback, the behavior is undefined.
        Returns:
        The value in the set with the given hash.

      • CFSetGetValueIfPresent

        public static byte CFSetGetValueIfPresent​(CFSetRef theSet,
                                          org.moe.natj.general.ptr.ConstVoidPtr candidate,
                                          org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> value)
        [@function] CFSetGetValueIfPresent Retrieves a value in the set which hashes the same as the specified value, if present.
        Parameters:
        theSet - The set to be queried. If this parameter is not a valid CFSet, the behavior is undefined.
        candidate - This value is hashed and compared with values in the set to determine which value to retrieve. The equal() callback provided when the set was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If a value, or any of the values in the set, are not understood by the equal() callback, the behavior is undefined.
        value - A pointer to memory which should be filled with the pointer-sized value if a matching value is found. If no match is found, the contents of the storage pointed to by this parameter are undefined. This parameter may be NULL, in which case the value from the dictionary is not returned (but the return value of this function still indicates whether or not the value was present).
        Returns:
        True if the value was present in the set, otherwise false.

      • CFSetGetValues

        public static void CFSetGetValues​(CFSetRef theSet,
                                  org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> values)
        [@function] CFSetGetValues Fills the buffer with values from the set.
        Parameters:
        theSet - The set to be queried. If this parameter is not a valid CFSet, the behavior is undefined.
        values - A C array of pointer-sized values to be filled with values from the set. The values in the C array are ordered in the same order in which they appear in the set. If this parameter is not a valid pointer to a C array of at least CFSetGetCount() pointers, the behavior is undefined.

      • CFSetApplyFunction

        public static void CFSetApplyFunction​(CFSetRef theSet,
                                      CoreFoundation.Function_CFSetApplyFunction applier,
                                      org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFSetApplyFunction Calls a function once for each value in the set.
        Parameters:
        theSet - The set to be operated upon. If this parameter is not a valid CFSet, the behavior is undefined.
        applier - The callback function to call once for each value in the given set. If this parameter is not a pointer to a function of the correct prototype, the behavior is undefined. If there are values in the set which the applier function does not expect or cannot properly apply to, the behavior is undefined.
        context - A pointer-sized user-defined value, which is passed as the second parameter to the applier function, but is otherwise unused by this function. If the context is not what is expected by the applier function, the behavior is undefined.

      • CFSetAddValue

        public static void CFSetAddValue​(CFMutableSetRef theSet,
                                 org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFSetAddValue Adds the value to the set if it is not already present.
        Parameters:
        theSet - The set to which the value is to be added. If this parameter is not a valid mutable CFSet, the behavior is undefined.
        value - The value to add to the set. The value is retained by the set using the retain callback provided when the set was created. If the value is not of the sort expected by the retain callback, the behavior is undefined. The count of the set is increased by one.

      • CFSetReplaceValue

        public static void CFSetReplaceValue​(CFMutableSetRef theSet,
                                     org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFSetReplaceValue Replaces the value in the set if it is present.
        Parameters:
        theSet - The set to which the value is to be replaced. If this parameter is not a valid mutable CFSet, the behavior is undefined.
        value - The value to replace in the set. The equal() callback provided when the set was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If a value, or any of the values in the set, are not understood by the equal() callback, the behavior is undefined. The value is retained by the set using the retain callback provided when the set was created. If the value is not of the sort expected by the retain callback, the behavior is undefined. The count of the set is increased by one.

      • CFSetSetValue

        public static void CFSetSetValue​(CFMutableSetRef theSet,
                                 org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFSetSetValue Replaces the value in the set if it is present, or adds the value to the set if it is absent.
        Parameters:
        theSet - The set to which the value is to be replaced. If this parameter is not a valid mutable CFSet, the behavior is undefined.
        value - The value to set in the CFSet. The equal() callback provided when the set was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If a value, or any of the values in the set, are not understood by the equal() callback, the behavior is undefined. The value is retained by the set using the retain callback provided when the set was created. If the value is not of the sort expected by the retain callback, the behavior is undefined. The count of the set is increased by one.

      • CFSetRemoveValue

        public static void CFSetRemoveValue​(CFMutableSetRef theSet,
                                    org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFSetRemoveValue Removes the specified value from the set.
        Parameters:
        theSet - The set from which the value is to be removed. If this parameter is not a valid mutable CFSet, the behavior is undefined.
        value - The value to remove. The equal() callback provided when the set was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If a value, or any of the values in the set, are not understood by the equal() callback, the behavior is undefined.

      • CFSetRemoveAllValues

        public static void CFSetRemoveAllValues​(CFMutableSetRef theSet)
        [@function] CFSetRemoveAllValues Removes all the values from the set, making it empty.
        Parameters:
        theSet - The set from which all of the values are to be removed. If this parameter is not a valid mutable CFSet, the behavior is undefined.

      • CFTreeGetTypeID

        public static long CFTreeGetTypeID()
        [@function] CFTreeGetTypeID Returns the type identifier of all CFTree instances.

      • CFTreeCreate

        public static CFTreeRef CFTreeCreate​(CFAllocatorRef allocator,
                                     CFTreeContext context)
        [@function] CFTreeCreate Creates a new mutable tree.
        Parameters:
        allocator - The CFAllocator which should be used to allocate memory for the tree and storage for its children. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.
        context - A C pointer to a CFTreeContext structure to be copied and used as the context of the new tree. The info parameter will be retained by the tree if a retain function is provided. If this value is not a valid C pointer to a CFTreeContext structure-sized block of storage, the result is undefined. If the version number of the storage is not a valid CFTreeContext version number, the result is undefined.
        Returns:
        A reference to the new CFTree.

      • CFTreeGetParent

        public static CFTreeRef CFTreeGetParent​(CFTreeRef tree)
        [@function] CFTreeGetParent Returns the parent of the specified tree.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        Returns:
        The parent of the tree.

      • CFTreeGetNextSibling

        public static CFTreeRef CFTreeGetNextSibling​(CFTreeRef tree)
        [@function] CFTreeGetNextSibling Returns the sibling after the specified tree in the parent tree's list.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        Returns:
        The next sibling of the tree.

      • CFTreeGetFirstChild

        public static CFTreeRef CFTreeGetFirstChild​(CFTreeRef tree)
        [@function] CFTreeGetFirstChild Returns the first child of the tree.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        Returns:
        The first child of the tree.

      • CFTreeGetContext

        public static void CFTreeGetContext​(CFTreeRef tree,
                                    CFTreeContext context)
        [@function] CFTreeGetContext Returns the context of the specified tree.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        context - A C pointer to a CFTreeContext structure to be filled in with the context of the specified tree. If this value is not a valid C pointer to a CFTreeContext structure-sized block of storage, the result is undefined. If the version number of the storage is not a valid CFTreeContext version number, the result is undefined.

      • CFTreeGetChildCount

        public static long CFTreeGetChildCount​(CFTreeRef tree)
        [@function] CFTreeGetChildCount Returns the number of children of the specified tree.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        Returns:
        The number of children.

      • CFTreeGetChildAtIndex

        public static CFTreeRef CFTreeGetChildAtIndex​(CFTreeRef tree,
                                              long idx)
        [@function] CFTreeGetChildAtIndex Returns the nth child of the specified tree.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        idx - The index of the child tree to be returned. If this parameter is less than zero or greater than the number of children of the tree, the result is undefined.
        Returns:
        A reference to the specified child tree.

      • CFTreeGetChildren

        public static void CFTreeGetChildren​(CFTreeRef tree,
                                     org.moe.natj.general.ptr.Ptr<CFTreeRef> children)
        [@function] CFTreeGetChildren Fills the buffer with children from the tree.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        children - A C array of pointer-sized values to be filled with children from the tree. If this parameter is not a valid pointer to a C array of at least CFTreeGetChildCount() pointers, the behavior is undefined.

      • CFTreeApplyFunctionToChildren

        public static void CFTreeApplyFunctionToChildren​(CFTreeRef tree,
                                                 CoreFoundation.Function_CFTreeApplyFunctionToChildren applier,
                                                 org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFTreeApplyFunctionToChildren Calls a function once for each child of the tree. Note that the applier only operates one level deep, and does not operate on descendents further removed than the immediate children of the tree.
        Parameters:
        tree - The tree to be operated upon. If this parameter is not a valid CFTree, the behavior is undefined.
        applier - The callback function to call once for each child of the given tree. If this parameter is not a pointer to a function of the correct prototype, the behavior is undefined. If there are values in the tree which the applier function does not expect or cannot properly apply to, the behavior is undefined.
        context - A pointer-sized user-defined value, which is passed as the second parameter to the applier function, but is otherwise unused by this function. If the context is not what is expected by the applier function, the behavior is undefined.

      • CFTreeFindRoot

        public static CFTreeRef CFTreeFindRoot​(CFTreeRef tree)
        [@function] CFTreeFindRoot Returns the root tree of which the specified tree is a descendent.
        Parameters:
        tree - The tree to be queried. If this parameter is not a valid CFTree, the behavior is undefined.
        Returns:
        A reference to the root of the tree.

      • CFTreeSetContext

        public static void CFTreeSetContext​(CFTreeRef tree,
                                    CFTreeContext context)
        [@function] CFTreeSetContext Replaces the context of a tree. The tree releases its retain on the info of the previous context, and retains the info of the new context.
        Parameters:
        tree - The tree to be operated on. If this parameter is not a valid CFTree, the behavior is undefined.
        context - A C pointer to a CFTreeContext structure to be copied and used as the context of the new tree. The info parameter will be retained by the tree if a retain function is provided. If this value is not a valid C pointer to a CFTreeContext structure-sized block of storage, the result is undefined. If the version number of the storage is not a valid CFTreeContext version number, the result is undefined.

      • CFTreePrependChild

        public static void CFTreePrependChild​(CFTreeRef tree,
                                      CFTreeRef newChild)
        [@function] CFTreePrependChild Adds the newChild to the specified tree as the first in its list of children.
        Parameters:
        tree - The tree to be operated on. If this parameter is not a valid CFTree, the behavior is undefined.
        newChild - The child to be added. If this parameter is not a valid CFTree, the behavior is undefined. If this parameter is a tree which is already a child of any tree, the behavior is undefined.

      • CFTreeAppendChild

        public static void CFTreeAppendChild​(CFTreeRef tree,
                                     CFTreeRef newChild)
        [@function] CFTreeAppendChild Adds the newChild to the specified tree as the last in its list of children.
        Parameters:
        tree - The tree to be operated on. If this parameter is not a valid CFTree, the behavior is undefined.
        newChild - The child to be added. If this parameter is not a valid CFTree, the behavior is undefined. If this parameter is a tree which is already a child of any tree, the behavior is undefined.

      • CFTreeInsertSibling

        public static void CFTreeInsertSibling​(CFTreeRef tree,
                                       CFTreeRef newSibling)
        [@function] CFTreeInsertSibling Inserts newSibling into the the parent tree's linked list of children after tree. The newSibling will have the same parent as tree.
        Parameters:
        tree - The tree to insert newSibling after. If this parameter is not a valid CFTree, the behavior is undefined. If the tree does not have a parent, the behavior is undefined.
        newSibling - The sibling to be added. If this parameter is not a valid CFTree, the behavior is undefined. If this parameter is a tree which is already a child of any tree, the behavior is undefined.

      • CFTreeRemove

        public static void CFTreeRemove​(CFTreeRef tree)
        [@function] CFTreeRemove Removes the tree from its parent.
        Parameters:
        tree - The tree to be removed. If this parameter is not a valid CFTree, the behavior is undefined.

      • CFTreeRemoveAllChildren

        public static void CFTreeRemoveAllChildren​(CFTreeRef tree)
        [@function] CFTreeRemoveAllChildren Removes all the children of the tree.
        Parameters:
        tree - The tree to remove all children from. If this parameter is not a valid CFTree, the behavior is undefined.

      • CFTreeSortChildren

        public static void CFTreeSortChildren​(CFTreeRef tree,
                                      CoreFoundation.Function_CFTreeSortChildren comparator,
                                      org.moe.natj.general.ptr.VoidPtr context)
        [@function] CFTreeSortChildren Sorts the children of the specified tree using the specified comparator function.
        Parameters:
        tree - The tree to be operated on. If this parameter is not a valid CFTree, the behavior is undefined.
        comparator - The function with the comparator function type signature which is used in the sort operation to compare children of the tree with the given value. If this parameter is not a pointer to a function of the correct prototype, the the behavior is undefined. The children of the tree are sorted from least to greatest according to this function.
        context - A pointer-sized user-defined value, which is passed as the third parameter to the comparator function, but is otherwise unused by this function. If the context is not what is expected by the comparator function, the behavior is undefined.

      • CFURLCreateDataAndPropertiesFromResource

        @Deprecated
public static byte CFURLCreateDataAndPropertiesFromResource​(CFAllocatorRef alloc,
                                                            CFURLRef url,
                                                            org.moe.natj.general.ptr.Ptr<CFDataRef> resourceData,
                                                            org.moe.natj.general.ptr.Ptr<CFDictionaryRef> properties,
                                                            CFArrayRef desiredProperties,
                                                            org.moe.natj.general.ptr.IntPtr errorCode)
        Deprecated.
        Attempts to read the data and properties for the given URL. If only interested in one of the resourceData and properties, pass NULL for the other. If properties is non-NULL and desiredProperties is NULL, then all properties are fetched. Returns success or failure; note that as much work as possible is done even if false is returned. So for instance if one property is not available, the others are fetched anyway. errorCode is set to 0 on success, and some other value on failure. If non-NULL, it is the caller 's responsibility to release resourceData and properties. Apple reserves for its use all negative error code values; these values represent errors common to any scheme. Scheme-specific error codes should be positive, non-zero, and should be used only if one of the predefined Apple error codes does not apply. Error codes should be publicized and documented with the scheme-specific properties. NOTE: When asking for the resource data, this call will allocate the entire resource in memory. This can be very expensive, depending on the size of the resource (file). Please use CFStream or other techniques if you are downloading large files. Deprecated -- see top of this file for suggested replacement classes

      • CFURLWriteDataAndPropertiesToResource

        @Deprecated
public static byte CFURLWriteDataAndPropertiesToResource​(CFURLRef url,
                                                         CFDataRef dataToWrite,
                                                         CFDictionaryRef propertiesToWrite,
                                                         org.moe.natj.general.ptr.IntPtr errorCode)
        Deprecated.
        Attempts to write the given data and properties to the given URL. If dataToWrite is NULL, only properties are written out (use CFURLDestroyResource() to delete a resource). Properties not present in propertiesToWrite are left unchanged, hence if propertiesToWrite is NULL or empty, the URL's properties are not changed at all. Returns success or failure; errorCode is set as for CFURLCreateDataAndPropertiesFromResource(), above. Deprecated -- see top of this file for suggested replacement classes

      • CFURLDestroyResource

        @Deprecated
public static byte CFURLDestroyResource​(CFURLRef url,
                                        org.moe.natj.general.ptr.IntPtr errorCode)
        Deprecated.
        Destroys the resource indicated by url. Returns success or failure; errorCode set as above. Deprecated -- see top of this file for suggested replacement classes

      • CFURLCreatePropertyFromResource

        @Deprecated
public static org.moe.natj.general.ptr.ConstVoidPtr CFURLCreatePropertyFromResource​(CFAllocatorRef alloc,
                                                                                    CFURLRef url,
                                                                                    CFStringRef property,
                                                                                    org.moe.natj.general.ptr.IntPtr errorCode)
        Deprecated.
        Convenience method which calls through to CFURLCreateDataAndPropertiesFromResource(). Returns NULL on error and sets errorCode accordingly. Deprecated -- see top of this file for suggested replacement classes

      • CFUUIDGetTypeID

        public static long CFUUIDGetTypeID()
        The CFUUIDBytes struct is a 128-bit struct that contains the raw UUID. A CFUUIDRef can provide such a struct from the CFUUIDGetUUIDBytes() function. This struct is suitable for passing to APIs that expect a raw UUID.

      • CFUUIDCreateWithBytes

        public static CFUUIDRef CFUUIDCreateWithBytes​(CFAllocatorRef alloc,
                                              byte byte0,
                                              byte byte1,
                                              byte byte2,
                                              byte byte3,
                                              byte byte4,
                                              byte byte5,
                                              byte byte6,
                                              byte byte7,
                                              byte byte8,
                                              byte byte9,
                                              byte byte10,
                                              byte byte11,
                                              byte byte12,
                                              byte byte13,
                                              byte byte14,
                                              byte byte15)
        Create and return a brand new unique identifier

      • CFUUIDCreateFromString

        public static CFUUIDRef CFUUIDCreateFromString​(CFAllocatorRef alloc,
                                               CFStringRef uuidStr)
        Create and return an identifier with the given contents. This may return an existing instance with its ref count bumped because of uniquing.

      • CFUUIDCreateString

        public static CFStringRef CFUUIDCreateString​(CFAllocatorRef alloc,
                                             CFUUIDRef uuid)
        Converts from a string representation to the UUID. This may return an existing instance with its ref count bumped because of uniquing.

      • CFUUIDGetConstantUUIDWithBytes

        public static CFUUIDRef CFUUIDGetConstantUUIDWithBytes​(CFAllocatorRef alloc,
                                                       byte byte0,
                                                       byte byte1,
                                                       byte byte2,
                                                       byte byte3,
                                                       byte byte4,
                                                       byte byte5,
                                                       byte byte6,
                                                       byte byte7,
                                                       byte byte8,
                                                       byte byte9,
                                                       byte byte10,
                                                       byte byte11,
                                                       byte byte12,
                                                       byte byte13,
                                                       byte byte14,
                                                       byte byte15)
        Converts from a UUID to its string representation.

      • CFUUIDGetUUIDBytes

        public static CFUUIDBytes CFUUIDGetUUIDBytes​(CFUUIDRef uuid)
        This returns an immortal CFUUIDRef that should not be released. It can be used in headers to declare UUID constants with #define.

      • CFCopyHomeDirectoryURL

        public static CFURLRef CFCopyHomeDirectoryURL()

      • CFBundleGetMainBundle

        public static CFBundleRef CFBundleGetMainBundle()
        ===================== Finding Bundles =====================

      • CFBundleGetBundleWithIdentifier

        public static CFBundleRef CFBundleGetBundleWithIdentifier​(CFStringRef bundleID)

      • CFBundleGetAllBundles

        public static CFArrayRef CFBundleGetAllBundles()
        A bundle can name itself by providing a key in the info dictionary. This facility is meant to allow bundle-writers to get hold of their bundle from their code without having to know where it was on the disk. This is meant to be a replacement mechanism for +bundleForClass: users. Note that this does not search for bundles on the disk; it will locate only bundles already loaded or otherwise known to the current process.

      • CFBundleGetTypeID

        public static long CFBundleGetTypeID()
        ===================== Creating Bundles =====================

      • CFBundleCreateBundlesFromDirectory

        public static CFArrayRef CFBundleCreateBundlesFromDirectory​(CFAllocatorRef allocator,
                                                            CFURLRef directoryURL,
                                                            CFStringRef bundleType)
        Might return an existing instance with the ref-count bumped.

      • CFBundleCopyBundleURL

        public static CFURLRef CFBundleCopyBundleURL​(CFBundleRef bundle)
        ==================== Basic Bundle Info ====================

      • CFBundleGetValueForInfoDictionaryKey

        public static org.moe.natj.general.ptr.ConstVoidPtr CFBundleGetValueForInfoDictionaryKey​(CFBundleRef bundle,
                                                                                         CFStringRef key)

      • CFBundleGetInfoDictionary

        public static CFDictionaryRef CFBundleGetInfoDictionary​(CFBundleRef bundle)
        Returns a localized value if available, otherwise the global value. This is the recommended function for examining the info dictionary.

      • CFBundleGetLocalInfoDictionary

        public static CFDictionaryRef CFBundleGetLocalInfoDictionary​(CFBundleRef bundle)
        This is the global info dictionary. Note that CFBundle may add extra keys to the dictionary for its own use.

      • CFBundleGetPackageInfo

        public static void CFBundleGetPackageInfo​(CFBundleRef bundle,
                                          org.moe.natj.general.ptr.IntPtr packageType,
                                          org.moe.natj.general.ptr.IntPtr packageCreator)
        This is the localized info dictionary.

      • CFBundleGetVersionNumber

        public static int CFBundleGetVersionNumber​(CFBundleRef bundle)

      • CFBundleGetDevelopmentRegion

        public static CFStringRef CFBundleGetDevelopmentRegion​(CFBundleRef bundle)

      • CFBundleCopySupportFilesDirectoryURL

        public static CFURLRef CFBundleCopySupportFilesDirectoryURL​(CFBundleRef bundle)

      • CFBundleCopyResourcesDirectoryURL

        public static CFURLRef CFBundleCopyResourcesDirectoryURL​(CFBundleRef bundle)

      • CFBundleCopyPrivateFrameworksURL

        public static CFURLRef CFBundleCopyPrivateFrameworksURL​(CFBundleRef bundle)

      • CFBundleCopySharedFrameworksURL

        public static CFURLRef CFBundleCopySharedFrameworksURL​(CFBundleRef bundle)

      • CFBundleCopySharedSupportURL

        public static CFURLRef CFBundleCopySharedSupportURL​(CFBundleRef bundle)

      • CFBundleCopyBuiltInPlugInsURL

        public static CFURLRef CFBundleCopyBuiltInPlugInsURL​(CFBundleRef bundle)

      • CFBundleCopyInfoDictionaryInDirectory

        public static CFDictionaryRef CFBundleCopyInfoDictionaryInDirectory​(CFURLRef bundleURL)
        ------------- Basic Bundle Info without a CFBundle instance ------------- This API is provided to enable developers to retrieve basic information about a bundle without having to create an instance of CFBundle. Because of caching behavior when a CFBundle instance exists, it will be faster to actually create a CFBundle if you need to retrieve multiple pieces of info.

      • CFBundleGetPackageInfoInDirectory

        public static byte CFBundleGetPackageInfoInDirectory​(CFURLRef url,
                                                     org.moe.natj.general.ptr.IntPtr packageType,
                                                     org.moe.natj.general.ptr.IntPtr packageCreator)

      • CFBundleCopyResourceURLInDirectory

        public static CFURLRef CFBundleCopyResourceURLInDirectory​(CFURLRef bundleURL,
                                                          CFStringRef resourceName,
                                                          CFStringRef resourceType,
                                                          CFStringRef subDirName)
        ------------- Resource Handling without a CFBundle instance ------------- This API is provided to enable developers to use the CFBundle resource searching policy without having to create an instance of CFBundle. Because of caching behavior when a CFBundle instance exists, it will be faster to actually create a CFBundle if you need to access several resources.

      • CFBundleCopyBundleLocalizations

        public static CFArrayRef CFBundleCopyBundleLocalizations​(CFBundleRef bundle)
        =========== Localization-specific Resource Handling API =========== This API allows finer-grained control over specific localizations, as distinguished from the above API, which always uses the user's preferred localizations for the bundle in the current app context.

      • CFBundleCopyPreferredLocalizationsFromArray

        public static CFArrayRef CFBundleCopyPreferredLocalizationsFromArray​(CFArrayRef locArray)
        Lists the localizations that a bundle contains.

      • CFBundleCopyLocalizationsForPreferences

        public static CFArrayRef CFBundleCopyLocalizationsForPreferences​(CFArrayRef locArray,
                                                                 CFArrayRef prefArray)
        Given an array of possible localizations, returns the one or more of them that CFBundle would use in the current application context. To determine the localizations that would be used for a particular bundle in the current application context, apply this function to the result of CFBundleCopyBundleLocalizations().

      • CFBundleCopyResourceURLForLocalization

        public static CFURLRef CFBundleCopyResourceURLForLocalization​(CFBundleRef bundle,
                                                              CFStringRef resourceName,
                                                              CFStringRef resourceType,
                                                              CFStringRef subDirName,
                                                              CFStringRef localizationName)
        Given an array of possible localizations, returns the one or more of them that CFBundle would use, without reference to the current application context, if the user's preferred localizations were given by prefArray. If prefArray is NULL, the current user's actual preferred localizations will be used. This is not the same as CFBundleCopyPreferredLocalizationsFromArray(), because that function takes the current application context into account. To determine the localizations that another application would use, apply this function to the result of CFBundleCopyBundleLocalizations().

      • CFBundleCopyInfoDictionaryForURL

        public static CFDictionaryRef CFBundleCopyInfoDictionaryForURL​(CFURLRef url)
        =================== Unbundled application info ===================== This API is provided to enable developers to retrieve bundle-related information about an application that may be bundled or unbundled.

      • CFBundleCopyLocalizationsForURL

        public static CFArrayRef CFBundleCopyLocalizationsForURL​(CFURLRef url)
        For a directory URL, this is equivalent to CFBundleCopyInfoDictionaryInDirectory(). For a plain file URL representing an unbundled executable, this will attempt to read an info dictionary from the (__TEXT, __info_plist) section, if it is a Mach-o file.

      • CFBundleCopyExecutableArchitecturesForURL

        public static CFArrayRef CFBundleCopyExecutableArchitecturesForURL​(CFURLRef url)
        For a directory URL, this is equivalent to calling CFBundleCopyBundleLocalizations() on the corresponding bundle. For a plain file URL representing an unbundled executable, this will attempt to determine its localizations using the CFBundleLocalizations and CFBundleDevelopmentRegion keys in the dictionary returned by CFBundleCopyInfoDictionaryForURL.

      • CFBundleCopyExecutableURL

        public static CFURLRef CFBundleCopyExecutableURL​(CFBundleRef bundle)
        ==================== Primitive Code Loading API ==================== This API abstracts the various different executable formats supported on various platforms. It can load DYLD, CFM, or DLL shared libraries (on their appropriate platforms) and gives a uniform API for looking up functions.

      • CFBundleCopyExecutableArchitectures

        public static CFArrayRef CFBundleCopyExecutableArchitectures​(CFBundleRef bundle)

      • CFBundlePreflightExecutable

        public static byte CFBundlePreflightExecutable​(CFBundleRef bundle,
                                               org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        If the bundle's executable exists and is a Mach-o file, this function will return an array of CFNumbers whose values are integers representing the architectures the file provides. The values currently in use are those listed in the enum above, but others may be added in the future. If the executable is not a Mach-o file, this function returns NULL.

      • CFBundleLoadExecutableAndReturnError

        public static byte CFBundleLoadExecutableAndReturnError​(CFBundleRef bundle,
                                                        org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        This function will return true if the bundle is loaded, or if the bundle appears to be loadable upon inspection. This does not mean that the bundle is definitively loadable, since it may fail to load due to link errors or other problems not readily detectable. If this function detects problems, it will return false, and return a CFError by reference. It is the responsibility of the caller to release the CFError.

      • CFBundleLoadExecutable

        public static byte CFBundleLoadExecutable​(CFBundleRef bundle)
        If the bundle is already loaded, this function will return true. Otherwise, it will attempt to load the bundle, and it will return true if that attempt succeeds. If the bundle fails to load, this function will return false, and it will return a CFError by reference. It is the responsibility of the caller to release the CFError.

      • CFBundleIsExecutableLoaded

        public static byte CFBundleIsExecutableLoaded​(CFBundleRef bundle)

      • CFBundleUnloadExecutable

        public static void CFBundleUnloadExecutable​(CFBundleRef bundle)

      • CFBundleGetFunctionPointerForName

        public static org.moe.natj.general.ptr.VoidPtr CFBundleGetFunctionPointerForName​(CFBundleRef bundle,
                                                                                 CFStringRef functionName)

      • CFBundleGetFunctionPointersForNames

        public static void CFBundleGetFunctionPointersForNames​(CFBundleRef bundle,
                                                       CFArrayRef functionNames,
                                                       org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.VoidPtr> ftbl)

      • CFBundleGetDataPointerForName

        public static org.moe.natj.general.ptr.VoidPtr CFBundleGetDataPointerForName​(CFBundleRef bundle,
                                                                             CFStringRef symbolName)

      • CFBundleGetDataPointersForNames

        public static void CFBundleGetDataPointersForNames​(CFBundleRef bundle,
                                                   CFArrayRef symbolNames,
                                                   org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.VoidPtr> stbl)

      • CFBundleGetPlugIn

        public static CFPlugInRef CFBundleGetPlugIn​(CFBundleRef bundle)
        ==================== Getting a bundle's plugIn ====================

      • CFMessagePortGetTypeID

        public static long CFMessagePortGetTypeID()

      • CFMessagePortIsRemote

        public static byte CFMessagePortIsRemote​(CFMessagePortRef ms)

      • CFMessagePortInvalidate

        public static void CFMessagePortInvalidate​(CFMessagePortRef ms)

      • CFMessagePortIsValid

        public static byte CFMessagePortIsValid​(CFMessagePortRef ms)

      • CFMessagePortSendRequest

        public static int CFMessagePortSendRequest​(CFMessagePortRef remote,
                                           int msgid,
                                           CFDataRef data,
                                           double sendTimeout,
                                           double rcvTimeout,
                                           CFStringRef replyMode,
                                           org.moe.natj.general.ptr.Ptr<CFDataRef> returnData)
        NULL replyMode argument means no return value expected, don't wait for it

      • CFMessagePortSetDispatchQueue

        public static void CFMessagePortSetDispatchQueue​(CFMessagePortRef ms,
                                                 NSObject queue)

      • CFPlugInGetTypeID

        public static long CFPlugInGetTypeID()
        ================= Creating PlugIns =================

      • CFPlugInGetBundle

        public static CFBundleRef CFPlugInGetBundle​(CFPlugInRef plugIn)
        Might return an existing instance with the ref-count bumped.

      • CFPlugInSetLoadOnDemand

        public static void CFPlugInSetLoadOnDemand​(CFPlugInRef plugIn,
                                           byte flag)
        ================= Controlling load on demand ================= For plugIns. PlugIns that do static registration are load on demand by default. PlugIns that do dynamic registration are not load on demand by default. A dynamic registration function can call CFPlugInSetLoadOnDemand().

      • CFPlugInIsLoadOnDemand

        public static byte CFPlugInIsLoadOnDemand​(CFPlugInRef plugIn)

      • CFPlugInFindFactoriesForPlugInType

        public static CFArrayRef CFPlugInFindFactoriesForPlugInType​(CFUUIDRef typeUUID)
        This function finds all the factories from any plugin for the given type. Returns an array that the caller must release.

      • CFPlugInFindFactoriesForPlugInTypeInPlugIn

        public static CFArrayRef CFPlugInFindFactoriesForPlugInTypeInPlugIn​(CFUUIDRef typeUUID,
                                                                    CFPlugInRef plugIn)
        This function restricts the result to factories from the given plug-in that can create the given type. Returns an array that the caller must release.

      • CFPlugInInstanceCreate

        public static org.moe.natj.general.ptr.VoidPtr CFPlugInInstanceCreate​(CFAllocatorRef allocator,
                                                                      CFUUIDRef factoryUUID,
                                                                      CFUUIDRef typeUUID)
        This function returns the IUnknown interface for the new instance.

      • CFPlugInRegisterFactoryFunction

        public static byte CFPlugInRegisterFactoryFunction​(CFUUIDRef factoryUUID,
                                                   CoreFoundation.Function_CFPlugInRegisterFactoryFunction func)
        ================= Registering factories and types ================= For plugIn writers who must dynamically register things. Functions to register factory functions and to associate factories with types.

      • CFPlugInRegisterFactoryFunctionByName

        public static byte CFPlugInRegisterFactoryFunctionByName​(CFUUIDRef factoryUUID,
                                                         CFPlugInRef plugIn,
                                                         CFStringRef functionName)

      • CFPlugInUnregisterFactory

        public static byte CFPlugInUnregisterFactory​(CFUUIDRef factoryUUID)

      • CFPlugInRegisterPlugInType

        public static byte CFPlugInRegisterPlugInType​(CFUUIDRef factoryUUID,
                                              CFUUIDRef typeUUID)

      • CFPlugInUnregisterPlugInType

        public static byte CFPlugInUnregisterPlugInType​(CFUUIDRef factoryUUID,
                                                CFUUIDRef typeUUID)

      • CFPlugInAddInstanceForFactory

        public static void CFPlugInAddInstanceForFactory​(CFUUIDRef factoryID)
        ================= Registering instances ================= When a new instance of a type is created, the instance is responsible for registering itself with the factory that created it and unregistering when it deallocates. This means that an instance must keep track of the CFUUIDRef of the factory that created it so it can unregister when it goes away.

      • CFPlugInRemoveInstanceForFactory

        public static void CFPlugInRemoveInstanceForFactory​(CFUUIDRef factoryID)

      • CFPlugInInstanceGetInterfaceFunctionTable

        public static byte CFPlugInInstanceGetInterfaceFunctionTable​(CFPlugInInstanceRef instance,
                                                             CFStringRef interfaceName,
                                                             org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.VoidPtr> ftbl)

      • CFPlugInInstanceGetFactoryName

        public static CFStringRef CFPlugInInstanceGetFactoryName​(CFPlugInInstanceRef instance)
        This function returns a retained object on 10.8 or later.

      • CFPlugInInstanceGetInstanceData

        public static org.moe.natj.general.ptr.VoidPtr CFPlugInInstanceGetInstanceData​(CFPlugInInstanceRef instance)

      • CFPlugInInstanceGetTypeID

        public static long CFPlugInInstanceGetTypeID()

      • CFMachPortGetTypeID

        public static long CFMachPortGetTypeID()

      • CFMachPortGetPort

        public static int CFMachPortGetPort​(CFMachPortRef port)

      • CFMachPortInvalidate

        public static void CFMachPortInvalidate​(CFMachPortRef port)

      • CFMachPortIsValid

        public static byte CFMachPortIsValid​(CFMachPortRef port)

      • CFAttributedStringGetTypeID

        public static long CFAttributedStringGetTypeID()
        [@function] CFAttributedStringGetTypeID Returns the type identifier of all CFAttributedString instances.

      • CFAttributedStringCreateWithSubstring

        public static CFAttributedStringRef CFAttributedStringCreateWithSubstring​(CFAllocatorRef alloc,
                                                                          CFAttributedStringRef aStr,
                                                                          CFRange range)
        [@function] CFAttributedStringCreateWithSubstring Creates a sub-attributed string from the specified range. It's a programming error for range to specify characters outside the bounds of aStr.

      • CFAttributedStringGetString

        public static CFStringRef CFAttributedStringGetString​(CFAttributedStringRef aStr)
        [@function] CFAttributedStringGetString Returns the string for the attributed string. For performance reasons, this will often point at the backing store of the attributed string, and it might change if the attributed string is edited. However, this is an implementation detail, and definitely not something that should be counted on.

      • CFAttributedStringGetLength

        public static long CFAttributedStringGetLength​(CFAttributedStringRef aStr)
        [@function] CFAttributedStringGetLength Returns the length of the attributed string in characters; same as CFStringGetLength(CFAttributedStringGetString(aStr))

      • CFAttributedStringGetAttributes

        public static CFDictionaryRef CFAttributedStringGetAttributes​(CFAttributedStringRef aStr,
                                                              long loc,
                                                              CFRange effectiveRange)
        [@function] CFAttributedStringGetAttributes Returns the attributes at the specified location. If effectiveRange is not NULL, upon return *effectiveRange contains a range over which the exact same set of attributes apply. Note that for performance reasons, the returned effectiveRange is not necessarily the maximal range - for that, use CFAttributedStringGetAttributesAndLongestEffectiveRange(). It's a programming error for loc to specify a location outside the bounds of the attributed string. Note that the returned attribute dictionary might change in unpredictable ways from under the caller if the attributed string is edited after this call. If you wish to hang on to the dictionary long-term, you should make an actual copy of it rather than just retaining it. Also, no assumptions should be made about the relationship of the actual CFDictionaryRef returned by this call and the dictionary originally used to set the attributes, other than the fact that the values stored in the dictionary will be identical (that is, ==) to those originally specified.

      • CFAttributedStringGetAttribute

        public static org.moe.natj.general.ptr.ConstVoidPtr CFAttributedStringGetAttribute​(CFAttributedStringRef aStr,
                                                                                   long loc,
                                                                                   CFStringRef attrName,
                                                                                   CFRange effectiveRange)
        [@function] CFAttributedStringGetAttribute Returns the value of a single attribute at the specified location. If the specified attribute doesn't exist at the location, returns NULL. If effectiveRange is not NULL, upon return *effectiveRange contains a range over which the exact same attribute value applies. Note that for performance reasons, the returned effectiveRange is not necessarily the maximal range - for that, use CFAttributedStringGetAttributeAndLongestEffectiveRange(). It's a programming error for loc to specify a location outside the bounds of the attributed string.

      • CFAttributedStringGetAttributesAndLongestEffectiveRange

        public static CFDictionaryRef CFAttributedStringGetAttributesAndLongestEffectiveRange​(CFAttributedStringRef aStr,
                                                                                      long loc,
                                                                                      CFRange inRange,
                                                                                      CFRange longestEffectiveRange)
        [@function] CFAttributedStringGetAttributesAndLongestEffectiveRange Returns the attributes at the specified location. If longestEffectiveRange is not NULL, upon return *longestEffectiveRange contains the maximal range within inRange over which the exact same set of attributes apply. The returned range is clipped to inRange. It's a programming error for loc or inRange to specify locations outside the bounds of the attributed string.

      • CFAttributedStringGetAttributeAndLongestEffectiveRange

        public static org.moe.natj.general.ptr.ConstVoidPtr CFAttributedStringGetAttributeAndLongestEffectiveRange​(CFAttributedStringRef aStr,
                                                                                                           long loc,
                                                                                                           CFStringRef attrName,
                                                                                                           CFRange inRange,
                                                                                                           CFRange longestEffectiveRange)
        [@function] CFAttributedStringGetAttributeAndLongestEffectiveRange Returns the value of a single attribute at the specified location. If longestEffectiveRange is not NULL, upon return *longestEffectiveRange contains the maximal range within inRange over which the exact same attribute value applies. The returned range is clipped to inRange. It's a programming error for loc or inRange to specify locations outside the bounds of the attributed string.

      • CFAttributedStringCreateMutableCopy

        public static CFMutableAttributedStringRef CFAttributedStringCreateMutableCopy​(CFAllocatorRef alloc,
                                                                               long maxLength,
                                                                               CFAttributedStringRef aStr)
        [@function] CFAttributedStringCreateMutableCopy Creates a mutable attributed string copy. maxLength, if not 0, is a hard bound on the length of the attributed string; exceeding this size limit during any editing operation is a programming error. If 0, there is no limit on the length.

      • CFAttributedStringCreateMutable

        public static CFMutableAttributedStringRef CFAttributedStringCreateMutable​(CFAllocatorRef alloc,
                                                                           long maxLength)
        [@function] CFAttributedStringCreateMutable Creates a mutable empty attributed string. maxLength, if not 0, is a hard bound on the length of the attributed string; exceeding this size limit during any editing operation is a programming error. If 0, there is no limit on the length.

      • CFAttributedStringReplaceString

        public static void CFAttributedStringReplaceString​(CFMutableAttributedStringRef aStr,
                                                   CFRange range,
                                                   CFStringRef replacement)
        [@function] CFAttributedStringReplaceString Modifies the string for the attributed string, much like CFStringReplace(). It's an error for range to specify characters outside the bounds of aStr. (Note: This function is a convenience on CFAttributedStringGetMutableString(); however, until CFAttributedStringGetMutableString() is implemented, it remains the only way to edit the string of the attributed string.)

      • CFAttributedStringGetMutableString

        public static CFMutableStringRef CFAttributedStringGetMutableString​(CFMutableAttributedStringRef aStr)
        [@function] CFAttributedStringGetMutableString Gets the string for the attributed string as a mutable string, allowing editing the character contents of the string as if it were an CFMutableString. Attributes corresponding to the edited range are appropriately modified. If, as a result of the edit, new characters are introduced into the string, they inherit the attributes of the first replaced character from range. If no existing characters are replaced by the edit, the new characters inherit the attributes of the character preceding range if it has any, otherwise of the character following range. If the initial string is empty, the attributes for the new characters are also empty. (Note: This function is not yet implemented and will return NULL except for toll-free bridged instances.)

      • CFAttributedStringSetAttributes

        public static void CFAttributedStringSetAttributes​(CFMutableAttributedStringRef aStr,
                                                   CFRange range,
                                                   CFDictionaryRef replacement,
                                                   byte clearOtherAttributes)
        [@function] CFAttributedStringSetAttributes Sets the value of multiple attributes over the specified range, which should be valid. If clearOtherAttributes is false, existing attributes (which aren't being replaced) are left alone; otherwise they are cleared. The dictionary should be setup for "usual" CF type usage --- CFString keys, and arbitrary CFType values. Note that after this call, further mutations to the replacement dictionary argument by the caller will not affect the contents of the attributed string.

      • CFAttributedStringSetAttribute

        public static void CFAttributedStringSetAttribute​(CFMutableAttributedStringRef aStr,
                                                  CFRange range,
                                                  CFStringRef attrName,
                                                  org.moe.natj.general.ptr.ConstVoidPtr value)
        [@function] CFAttributedStringSetAttribute Sets the value of a single attribute over the specified range, which should be valid. value should not be NULL.

      • CFAttributedStringRemoveAttribute

        public static void CFAttributedStringRemoveAttribute​(CFMutableAttributedStringRef aStr,
                                                     CFRange range,
                                                     CFStringRef attrName)
        [@function] CFAttributedStringRemoveAttribute Removes the value of a single attribute over the specified range, which should be valid. It's OK for the attribute not the exist over the specified range.

      • CFAttributedStringReplaceAttributedString

        public static void CFAttributedStringReplaceAttributedString​(CFMutableAttributedStringRef aStr,
                                                             CFRange range,
                                                             CFAttributedStringRef replacement)
        [@function] CFAttributedStringReplaceAttributedString Replaces the attributed substring over the specified range with the attributed string specified in replacement. range should be valid. To delete a range of the attributed string, call CFAttributedStringReplaceString() with empty string and specified range.

      • CFAttributedStringBeginEditing

        public static void CFAttributedStringBeginEditing​(CFMutableAttributedStringRef aStr)
        [@function] CFAttributedStringBeginEditing In cases where attributed string might do a bunch of work to assure self-consistency, CFAttributedStringBeginEditing/CFAttributedStringEndEditing allow disabling that to allow deferring and coalescing any work. It's a good idea to call these around a set of related mutation calls which don't require the string to be in consistent state in between. These calls can be nested.

      • CFAttributedStringEndEditing

        public static void CFAttributedStringEndEditing​(CFMutableAttributedStringRef aStr)
        [@function] CFAttributedStringEndEditing In cases where attributed string might do a bunch of work to assure self-consistency, CFAttributedStringBeginEditing/CFAttributedStringEndEditing allow disabling that to allow deferring and coalescing any work. It's a good idea to call these around a set of related mutation calls which don't require the string to be in consistent state in between. These calls can be nested.

      • CFURLEnumeratorGetTypeID

        public static long CFURLEnumeratorGetTypeID()
        CFURLEnumeratorGetTypeID - Returns the CFURLEnumerator CFTypeID.

      • CFURLEnumeratorCreateForDirectoryURL

        public static CFURLEnumeratorRef CFURLEnumeratorCreateForDirectoryURL​(CFAllocatorRef alloc,
                                                                      CFURLRef directoryURL,
                                                                      long option,
                                                                      CFArrayRef propertyKeys)
        CFURLEnumeratorCreateForDirectoryURL - Creates a directory enumerator, flat or recursive. Client specifies the directory URL to enumerate, a bit array of options, and an optional array of property keys to pre-fetch for the found URLs. Specifying pre-fetch properties allows the implementation to optimize device access by using bulk operations when available. Pre-fetching more properties than are actually needed may degrade performance. A directory enumerator generates URLs with the same type as the directory URL being enumerated. If the directoryURL input parameter is a file reference URL, then generated URLs will be file reference URLs. If the directoryURL input parameter is a file path URL, then generated URLs will be file path URLs. The kCFURLEnumeratorGenerateFileReferenceURLs option is ignored by CFURLEnumeratorCreateForDirectoryURL.

      • CFURLEnumeratorCreateForMountedVolumes

        public static CFURLEnumeratorRef CFURLEnumeratorCreateForMountedVolumes​(CFAllocatorRef alloc,
                                                                        long option,
                                                                        CFArrayRef propertyKeys)
        CFURLEnumeratorCreateForMountedVolumes - Creates an enumerator for mounted filesystem volumes. Client specifies an allocator, a bit array of options, and an optional array of property keys to pre-fetch for the volume URLs. Specifying pre-fetch properties allows the implementation to optimize device access by using bulk operations when available. Pre-fetching more properties than are actually needed may degrade performance. A volume enumerator generates file path URLs. If you want a volume enumerator to generate file reference URLs, pass the kCFURLEnumeratorGenerateFileReferenceURLs option. The kCFURLEnumeratorDescendRecursively and kCFURLEnumeratorSkipPackageContents options are ignored by CFURLEnumeratorCreateForMountedVolumes.

      • CFURLEnumeratorGetNextURL

        public static long CFURLEnumeratorGetNextURL​(CFURLEnumeratorRef enumerator,
                                             org.moe.natj.general.ptr.Ptr<CFURLRef> url,
                                             org.moe.natj.general.ptr.Ptr<CFErrorRef> error)
        CFURLEnumeratorGetNextURL - Advances the enumerator. If kCFURLEnumeratorSuccess is returned, the url output parameter returns the next URL found. If kCFURLEnumeratorError is returned, an error has occured and the error output parameter describes the error. If kCFURLEnumeratorEnd, the enumeration is finished. The url output parameter, if returned, is not retained. The error output parameter, if returned, is retained and must be released.

      • CFURLEnumeratorSkipDescendents

        public static void CFURLEnumeratorSkipDescendents​(CFURLEnumeratorRef enumerator)
        CFURLEnumeratorSkipDescendents - Tells a recursive CFURLEnumerator not to descend into the directory of the last CFURLRef returned by CFURLEnumeratorGetNextURL. Calls to CFURLEnumeratorSkipDescendents are ignored if: * CFURLEnumeratorGetNextURL has never been called with the CFURLEnumerator. * The last CFURL returned by CFURLEnumeratorGetNextURL is not a directory. * The CFURLEnumerator was not created with CFURLEnumeratorCreateForDirectoryURL using the kCFURLEnumeratorDescendRecursively option.

      • CFURLEnumeratorGetDescendentLevel

        public static long CFURLEnumeratorGetDescendentLevel​(CFURLEnumeratorRef enumerator)
        CFURLEnumeratorGetDescendentLevel - Returns the number of levels a directory enumerator has descended down into the directory hierarchy from the starting directory. The children of the starting directory are at level 1. Each time a recursive enumerator descends into a subdirectory, it adds one to the descendent level. It then subtracts one from the level when it finishes a subdirectory and continues enumerating the parent directory.

      • CFURLEnumeratorGetSourceDidChange

        @Deprecated
public static byte CFURLEnumeratorGetSourceDidChange​(CFURLEnumeratorRef enumerator)
        Deprecated.
        CFURLEnumeratorGetSourceDidChange is deprecated. If your program is interested in directory hierarchy changes during enumeration (and most programs are not interested), you should use the File System Events API. CFURLEnumeratorGetSourceDidChange does nothing and always returns false.

      • CFFileSecurityGetTypeID

        public static long CFFileSecurityGetTypeID()
        Returns the type identifier for the CFFileSecurity opaque type. Return Value The type identifier for the CFFileSecurity opaque type.

      • CFFileSecurityCreate

        public static CFFileSecurityRef CFFileSecurityCreate​(CFAllocatorRef allocator)
        Creates an CFFileSecurity object. Parameters allocator The allocator to use to allocate memory for the new object. Pass NULL or kCFAllocatorDefault to use the current default allocator. Return Value A new CFFileSecurity object, or NULL if there was a problem creating the object. Ownership follows the Create Rule.

      • CFFileSecurityCreateCopy

        public static CFFileSecurityRef CFFileSecurityCreateCopy​(CFAllocatorRef allocator,
                                                         CFFileSecurityRef fileSec)
        Creates a copy of a CFFileSecurity object. Parameters allocator The allocator to use to allocate memory for the new object. Pass NULL or kCFAllocatorDefault to use the current default allocator. fileSec The CFFileSecurity object to copy. Return Value A copy of fileSec, or NULL if there was a problem creating the object. Ownership follows the Create Rule.

      • CFFileSecurityCopyOwnerUUID

        public static byte CFFileSecurityCopyOwnerUUID​(CFFileSecurityRef fileSec,
                                               org.moe.natj.general.ptr.Ptr<CFUUIDRef> ownerUUID)
        This routine copies the owner UUID associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. ownerUUID A pointer to storage for the owner UUID. Return Value true if ownerUUID is successfully returned; false if there is no owner UUID property associated with an CFFileSecurity object.

      • CFFileSecuritySetOwnerUUID

        public static byte CFFileSecuritySetOwnerUUID​(CFFileSecurityRef fileSec,
                                              CFUUIDRef ownerUUID)
        This routine sets the owner UUID associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. ownerUUID The owner UUID. Return Value true if the owner UUID was successfully set; otherwise, false.

      • CFFileSecurityCopyGroupUUID

        public static byte CFFileSecurityCopyGroupUUID​(CFFileSecurityRef fileSec,
                                               org.moe.natj.general.ptr.Ptr<CFUUIDRef> groupUUID)
        This routine copies the group UUID associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. groupUUID A pointer to storage for the group UUID. Return Value true if groupUUID is successfully returned; false if there is no group UUID property associated with an CFFileSecurity object.

      • CFFileSecuritySetGroupUUID

        public static byte CFFileSecuritySetGroupUUID​(CFFileSecurityRef fileSec,
                                              CFUUIDRef groupUUID)
        This routine sets the group UUID associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. groupUUID The group UUID. Return Value true if the group UUID was successfully set; otherwise, false.

      • CFFileSecurityCopyAccessControlList

        public static byte CFFileSecurityCopyAccessControlList​(CFFileSecurityRef fileSec,
                                                       org.moe.natj.general.ptr.Ptr<acl_t> accessControlList)
        This routine copies the access control list (acl_t) associated with an CFFileSecurity object. The acl_t returned by this routine is a copy and must be released using acl_free(3). The acl_t is meant to be manipulated using the acl calls defined in . Parameters fileSec The CFFileSecurity object. accessControlList A pointer to storage for an acl_t. The acl_t be released using acl_free(3) Return Value true if the access control list is successfully copied; false if there is no access control list property associated with the CFFileSecurity object.

      • CFFileSecuritySetAccessControlList

        public static byte CFFileSecuritySetAccessControlList​(CFFileSecurityRef fileSec,
                                                      acl_t accessControlList)
        This routine will set the access control list (acl_t) associated with an CFFileSecurityRef. To request removal of an access control list from a filesystem object, pass in kCFFileSecurityRemoveACL as the acl_t and set the fileSec on the target object using CFURLSetResourcePropertyForKey and the kCFURLFileSecurityKey. Setting the accessControlList to NULL will result in the property being unset. Parameters fileSec The CFFileSecurity object. accessControlList The acl_t to set, or kCFFileSecurityRemoveACL to remove the access control list, or NULL to unset the accessControlList. Return Value true if the access control list is successfully set; otherwise, false.

      • CFFileSecurityGetOwner

        public static byte CFFileSecurityGetOwner​(CFFileSecurityRef fileSec,
                                          org.moe.natj.general.ptr.IntPtr owner)
        This routine gets the owner uid_t associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. owner A pointer to where the owner uid_t will be put. Return Value true if owner uid_t is successfully obtained; false if there is no owner property associated with an CFFileSecurity object.

      • CFFileSecuritySetOwner

        public static byte CFFileSecuritySetOwner​(CFFileSecurityRef fileSec,
                                          int owner)
        This routine sets the owner uid_t associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. owner The owner uid_t. Return Value true if the owner uid_t was successfully set; otherwise, false.

      • CFFileSecurityGetGroup

        public static byte CFFileSecurityGetGroup​(CFFileSecurityRef fileSec,
                                          org.moe.natj.general.ptr.IntPtr group)
        This routine gets the group gid_t associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. owner A pointer to where the group gid_t will be put. Return Value true if group gid_t is successfully obtained; false if there is no group property associated with an CFFileSecurity object.

      • CFFileSecuritySetGroup

        public static byte CFFileSecuritySetGroup​(CFFileSecurityRef fileSec,
                                          int group)
        This routine sets the group gid_t associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. owner The group gid_t. Return Value true if the group gid_t was successfully set; otherwise, false.

      • CFFileSecurityGetMode

        public static byte CFFileSecurityGetMode​(CFFileSecurityRef fileSec,
                                         org.moe.natj.general.ptr.CharPtr mode)
        This routine gets the mode_t associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. owner A pointer to where the mode_t will be put. Return Value true if mode_t is successfully obtained; false if there is no mode property associated with an CFFileSecurity object.

      • CFFileSecuritySetMode

        public static byte CFFileSecuritySetMode​(CFFileSecurityRef fileSec,
                                         char mode)
        This routine sets the mode_t associated with an CFFileSecurity object. Parameters fileSec The CFFileSecurity object. owner The mode_t. Return Value true if the mode_t was successfully set; otherwise, false.

      • CFFileSecurityClearProperties

        public static byte CFFileSecurityClearProperties​(CFFileSecurityRef fileSec,
                                                 long clearPropertyMask)
        This routine clears file security properties in the CFFileSecurity object. Parameters clearPropertyMask The file security properties to clear. Return Value true if the file security properties were successfully cleared; otherwise, false.

      • CFStringTokenizerCopyBestStringLanguage

        public static CFStringRef CFStringTokenizerCopyBestStringLanguage​(CFStringRef string,
                                                                  CFRange range)
        [@function] CFStringTokenizerCopyBestStringLanguage Guesses the language of a string and returns the BCP 47 string of the language. The result is not guaranteed to be accurate. Typically 200-400 characters are required to reliably guess the language of a string.
        Parameters:
        string - The string whose language is to be guessed.
        range - The range of characters in string whose language to be guessed. The specified range must not exceed the bounds of the string.
        Returns:
        A language represented in BCP 47 string. NULL is returned either if string is NULL, the location of range is negative, the length of range is 0, or the language of the string cannot be guessed.

      • CFStringTokenizerGetTypeID

        public static long CFStringTokenizerGetTypeID()
        [@function] CFStringTokenizerGetTypeID Get the type identifier.
        Returns:
        the type identifier of all CFStringTokenizer instances.

      • CFStringTokenizerCreate

        public static CFStringTokenizerRef CFStringTokenizerCreate​(CFAllocatorRef alloc,
                                                           CFStringRef string,
                                                           CFRange range,
                                                           long options,
                                                           CFLocaleRef locale)
        [@function] CFStringTokenizerCreate Creates a tokenizer instance.
        Parameters:
        alloc - The CFAllocator which should be used to allocate memory for the tokenizer and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used.
        string - The string to tokenize.
        range - The range of characters within the string to be tokenized. The specified range must not exceed the length of the string.
        options - Use one of the Tokenization Unit options to specify how the string should be tokenized. Optionally specify one or more attribute specifiers to tell the tokenizer to prepare specified attributes when it tokenizes the string.
        locale - The locale to specify language or region specific behavior. Pass NULL if you want tokenizer to identify the locale automatically.
        Returns:
        A reference to the new CFStringTokenizer.

      • CFStringTokenizerSetString

        public static void CFStringTokenizerSetString​(CFStringTokenizerRef tokenizer,
                                              CFStringRef string,
                                              CFRange range)
        [@function] CFStringTokenizerSetString Set the string to tokenize.
        Parameters:
        tokenizer - The reference to CFStringTokenizer returned by CFStringTokenizerCreate.
        string - The string to tokenize.
        range - The range of characters within the string to be tokenized. The specified range must not exceed the length of the string.

      • CFStringTokenizerGoToTokenAtIndex

        public static long CFStringTokenizerGoToTokenAtIndex​(CFStringTokenizerRef tokenizer,
                                                     long index)
        [@function] CFStringTokenizerGoToTokenAtIndex Random access to a token. Find a token that includes the character specified by character index, and set it as the current token. The range and attribute of the token can be obtained by calling CFStringTokenizerGetCurrentTokenRange and CFStringTokenizerCopyCurrentTokenAttribute. If the token is a compound (with type kCFStringTokenizerTokenHasSubTokensMask or kCFStringTokenizerTokenHasDerivedSubTokensMask), its subtokens and (or) derived subtokens can be obtained by calling CFStringTokenizerGetCurrentSubTokens.
        Parameters:
        tokenizer - The reference to CFStringTokenizer returned by CFStringTokenizerCreate.
        index - The index of the Unicode character in the CFString.
        Returns:
        Type of the token if succeeded in finding a token and setting it as current token. kCFStringTokenizerTokenNone if failed in finding a token.

      • CFStringTokenizerAdvanceToNextToken

        public static long CFStringTokenizerAdvanceToNextToken​(CFStringTokenizerRef tokenizer)
        [@function] CFStringTokenizerAdvanceToNextToken Token enumerator. If there is no preceding call to CFStringTokenizerGoToTokenAtIndex or CFStringTokenizerAdvanceToNextToken, it finds the first token in the range specified to CFStringTokenizerCreate. If there is a current token after successful call to CFStringTokenizerGoToTokenAtIndex or CFStringTokenizerAdvanceToNextToken, it proceeds to the next token. If succeeded in finding a token, set it as current token and return its token type. Otherwise invalidate current token and return kCFStringTokenizerTokenNone. The range and attribute of the token can be obtained by calling CFStringTokenizerGetCurrentTokenRange and CFStringTokenizerCopyCurrentTokenAttribute. If the token is a compound (with type kCFStringTokenizerTokenHasSubTokensMask or kCFStringTokenizerTokenHasDerivedSubTokensMask), its subtokens and (or) derived subtokens can be obtained by calling CFStringTokenizerGetCurrentSubTokens.
        Parameters:
        tokenizer - The reference to CFStringTokenizer returned by CFStringTokenizerCreate.
        Returns:
        Type of the token if succeeded in finding a token and setting it as current token. kCFStringTokenizerTokenNone if failed in finding a token.

      • CFStringTokenizerGetCurrentTokenRange

        public static CFRange CFStringTokenizerGetCurrentTokenRange​(CFStringTokenizerRef tokenizer)
        [@function] CFStringTokenizerGetCurrentTokenRange Returns the range of current token.
        Parameters:
        tokenizer - The reference to CFStringTokenizer returned by CFStringTokenizerCreate.
        Returns:
        Range of current token, or {kCFNotFound,0} if there is no current token.

      • CFStringTokenizerCopyCurrentTokenAttribute

        public static org.moe.natj.general.ptr.ConstVoidPtr CFStringTokenizerCopyCurrentTokenAttribute​(CFStringTokenizerRef tokenizer,
                                                                                               long attribute)
        [@function] CFStringTokenizerCopyCurrentTokenAttribute Copies the specified attribute of current token.
        Parameters:
        tokenizer - The reference to CFStringTokenizer returned by CFStringTokenizerCreate.
        attribute - Specify a token attribute you want to obtain. The value is one of kCFStringTokenizerAttributeLatinTranscription or kCFStringTokenizerAttributeLanguage.
        Returns:
        Token attribute, or NULL if current token does not have the specified attribute or if there is no current token.

      • CFStringTokenizerGetCurrentSubTokens

        public static long CFStringTokenizerGetCurrentSubTokens​(CFStringTokenizerRef tokenizer,
                                                        CFRange ranges,
                                                        long maxRangeLength,
                                                        CFMutableArrayRef derivedSubTokens)
        [@function] CFStringTokenizerGetCurrentSubTokens Retrieves the subtokens or derived subtokens contained in the compound token. If token type is kCFStringTokenizerTokenNone, the ranges array and derivedSubTokens array are untouched and the return value is 0. If token type is kCFStringTokenizerTokenNormal, the ranges array has one item filled in with the entire range of the token (if maxRangeLength >= 1) and a string taken from the entire token range is added to the derivedSubTokens array and the return value is 1. If token type is kCFStringTokenizerTokenHasSubTokensMask or kCFStringTokenizerTokenHasDerivedSubTokensMask, the ranges array is filled in with as many items as there are subtokens (up to a limit of maxRangeLength). The derivedSubTokens array will have sub tokens added even when the sub token is a substring of the token. If token type is kCFStringTokenizerTokenHasSubTokensMask, the ordinary non-derived subtokens are added to the derivedSubTokens array.
        Parameters:
        tokenizer - The reference to CFStringTokenizer returned by CFStringTokenizerCreate.
        ranges - An array of CFRange to fill in with the ranges of subtokens. The filled in ranges are relative to the string specified to CFStringTokenizerCreate. This parameter can be NULL.
        maxRangeLength - The maximum number of ranges to return.
        derivedSubTokens - An array of CFMutableArray to which the derived subtokens are to be added. This parameter can be NULL.
        Returns:
        number of subtokens.

      • CFFileDescriptorGetTypeID

        public static long CFFileDescriptorGetTypeID()

      • CFFileDescriptorGetNativeDescriptor

        public static int CFFileDescriptorGetNativeDescriptor​(CFFileDescriptorRef f)

      • CFFileDescriptorEnableCallBacks

        public static void CFFileDescriptorEnableCallBacks​(CFFileDescriptorRef f,
                                                   long callBackTypes)

      • CFFileDescriptorDisableCallBacks

        public static void CFFileDescriptorDisableCallBacks​(CFFileDescriptorRef f,
                                                    long callBackTypes)

      • CFFileDescriptorInvalidate

        public static void CFFileDescriptorInvalidate​(CFFileDescriptorRef f)

      • CFFileDescriptorIsValid

        public static byte CFFileDescriptorIsValid​(CFFileDescriptorRef f)

      • kCFCoreFoundationVersionNumber

        public static double kCFCoreFoundationVersionNumber()

      • kCFNull

        public static CFNullRef kCFNull()
        the singleton null instance

      • kCFAllocatorDefault

        public static CFAllocatorRef kCFAllocatorDefault()
        This is a synonym for NULL, if you'd rather use a named constant.

      • kCFAllocatorSystemDefault

        public static CFAllocatorRef kCFAllocatorSystemDefault()
        Default system allocator; you rarely need to use this.

      • kCFAllocatorMalloc

        public static CFAllocatorRef kCFAllocatorMalloc()
        This allocator uses malloc(), realloc(), and free(). This should not be generally used; stick to kCFAllocatorDefault whenever possible. This allocator is useful as the "bytesDeallocator" in CFData or "contentsDeallocator" in CFString where the memory was obtained as a result of malloc() type functions.

      • kCFAllocatorMallocZone

        public static CFAllocatorRef kCFAllocatorMallocZone()
        This allocator explicitly uses the default malloc zone, returned by malloc_default_zone(). It should only be used when an object is safe to be allocated in non-scanned memory.

      • kCFAllocatorNull

        public static CFAllocatorRef kCFAllocatorNull()
        Null allocator which does nothing and allocates no memory. This allocator is useful as the "bytesDeallocator" in CFData or "contentsDeallocator" in CFString where the memory should not be freed.

      • kCFAllocatorUseContext

        public static CFAllocatorRef kCFAllocatorUseContext()
        Special allocator argument to CFAllocatorCreate() which means "use the functions given in the context to allocate the allocator itself as well".

      • kCFTypeDictionaryKeyCallBacks

        public static CFDictionaryKeyCallBacks kCFTypeDictionaryKeyCallBacks()
        [@constant] kCFTypeDictionaryKeyCallBacks Predefined CFDictionaryKeyCallBacks structure containing a set of callbacks appropriate for use when the keys of a CFDictionary are all CFTypes.

      • kCFCopyStringDictionaryKeyCallBacks

        public static CFDictionaryKeyCallBacks kCFCopyStringDictionaryKeyCallBacks()
        [@constant] kCFCopyStringDictionaryKeyCallBacks Predefined CFDictionaryKeyCallBacks structure containing a set of callbacks appropriate for use when the keys of a CFDictionary are all CFStrings, which may be mutable and need to be copied in order to serve as constant keys for the values in the dictionary.

      • kCFTypeDictionaryValueCallBacks

        public static CFDictionaryValueCallBacks kCFTypeDictionaryValueCallBacks()
        [@constant] kCFTypeDictionaryValueCallBacks Predefined CFDictionaryValueCallBacks structure containing a set of callbacks appropriate for use when the values in a CFDictionary are all CFTypes.

      • kCFTypeArrayCallBacks

        public static CFArrayCallBacks kCFTypeArrayCallBacks()
        [@constant] kCFTypeArrayCallBacks Predefined CFArrayCallBacks structure containing a set of callbacks appropriate for use when the values in a CFArray are all CFTypes.

      • kCFLocaleCurrentLocaleDidChangeNotification

        public static CFStringRef kCFLocaleCurrentLocaleDidChangeNotification()
        Returns the display name for the given value. The key tells what the value is, and is one of the usual locale property keys, though not all locale property keys have values with display name values.

      • kCFLocaleIdentifier

        public static CFStringRef kCFLocaleIdentifier()
        Locale Keys

      • kCFLocaleLanguageCode

        public static CFStringRef kCFLocaleLanguageCode()

      • kCFLocaleCountryCode

        public static CFStringRef kCFLocaleCountryCode()

      • kCFLocaleScriptCode

        public static CFStringRef kCFLocaleScriptCode()

      • kCFLocaleVariantCode

        public static CFStringRef kCFLocaleVariantCode()

      • kCFLocaleExemplarCharacterSet

        public static CFStringRef kCFLocaleExemplarCharacterSet()

      • kCFLocaleCalendarIdentifier

        public static CFStringRef kCFLocaleCalendarIdentifier()

      • kCFLocaleCalendar

        public static CFStringRef kCFLocaleCalendar()

      • kCFLocaleCollationIdentifier

        public static CFStringRef kCFLocaleCollationIdentifier()

      • kCFLocaleUsesMetricSystem

        public static CFStringRef kCFLocaleUsesMetricSystem()

      • kCFLocaleMeasurementSystem

        public static CFStringRef kCFLocaleMeasurementSystem()
        "Metric", "U.S." or "U.K."

      • kCFLocaleDecimalSeparator

        public static CFStringRef kCFLocaleDecimalSeparator()

      • kCFLocaleGroupingSeparator

        public static CFStringRef kCFLocaleGroupingSeparator()

      • kCFLocaleCurrencySymbol

        public static CFStringRef kCFLocaleCurrencySymbol()

      • kCFLocaleCurrencyCode

        public static CFStringRef kCFLocaleCurrencyCode()
        ISO 3-letter currency code

      • kCFLocaleCollatorIdentifier

        public static CFStringRef kCFLocaleCollatorIdentifier()

      • kCFLocaleQuotationBeginDelimiterKey

        public static CFStringRef kCFLocaleQuotationBeginDelimiterKey()

      • kCFLocaleQuotationEndDelimiterKey

        public static CFStringRef kCFLocaleQuotationEndDelimiterKey()

      • kCFLocaleAlternateQuotationBeginDelimiterKey

        public static CFStringRef kCFLocaleAlternateQuotationBeginDelimiterKey()

      • kCFLocaleAlternateQuotationEndDelimiterKey

        public static CFStringRef kCFLocaleAlternateQuotationEndDelimiterKey()

      • kCFGregorianCalendar

        public static CFStringRef kCFGregorianCalendar()

      • kCFBuddhistCalendar

        public static CFStringRef kCFBuddhistCalendar()

      • kCFChineseCalendar

        public static CFStringRef kCFChineseCalendar()

      • kCFHebrewCalendar

        public static CFStringRef kCFHebrewCalendar()

      • kCFIslamicCalendar

        public static CFStringRef kCFIslamicCalendar()

      • kCFIslamicCivilCalendar

        public static CFStringRef kCFIslamicCivilCalendar()

      • kCFJapaneseCalendar

        public static CFStringRef kCFJapaneseCalendar()

      • kCFRepublicOfChinaCalendar

        public static CFStringRef kCFRepublicOfChinaCalendar()

      • kCFPersianCalendar

        public static CFStringRef kCFPersianCalendar()

      • kCFIndianCalendar

        public static CFStringRef kCFIndianCalendar()

      • kCFISO8601Calendar

        public static CFStringRef kCFISO8601Calendar()

      • kCFIslamicTabularCalendar

        public static CFStringRef kCFIslamicTabularCalendar()

      • kCFIslamicUmmAlQuraCalendar

        public static CFStringRef kCFIslamicUmmAlQuraCalendar()

      • kCFStringTransformStripCombiningMarks

        public static CFStringRef kCFStringTransformStripCombiningMarks()
        Transform identifiers for CFStringTransform()

      • kCFStringTransformToLatin

        public static CFStringRef kCFStringTransformToLatin()

      • kCFStringTransformFullwidthHalfwidth

        public static CFStringRef kCFStringTransformFullwidthHalfwidth()

      • kCFStringTransformLatinKatakana

        public static CFStringRef kCFStringTransformLatinKatakana()

      • kCFStringTransformLatinHiragana

        public static CFStringRef kCFStringTransformLatinHiragana()

      • kCFStringTransformHiraganaKatakana

        public static CFStringRef kCFStringTransformHiraganaKatakana()

      • kCFStringTransformMandarinLatin

        public static CFStringRef kCFStringTransformMandarinLatin()

      • kCFStringTransformLatinHangul

        public static CFStringRef kCFStringTransformLatinHangul()

      • kCFStringTransformLatinArabic

        public static CFStringRef kCFStringTransformLatinArabic()

      • kCFStringTransformLatinHebrew

        public static CFStringRef kCFStringTransformLatinHebrew()

      • kCFStringTransformLatinThai

        public static CFStringRef kCFStringTransformLatinThai()

      • kCFStringTransformLatinCyrillic

        public static CFStringRef kCFStringTransformLatinCyrillic()

      • kCFStringTransformLatinGreek

        public static CFStringRef kCFStringTransformLatinGreek()

      • kCFStringTransformToXMLHex

        public static CFStringRef kCFStringTransformToXMLHex()

      • kCFStringTransformToUnicodeName

        public static CFStringRef kCFStringTransformToUnicodeName()

      • kCFStringTransformStripDiacritics

        public static CFStringRef kCFStringTransformStripDiacritics()

      • kCFErrorDomainPOSIX

        public static CFStringRef kCFErrorDomainPOSIX()
        Predefined domains; value of "code" will correspond to preexisting values in these domains.

      • kCFErrorDomainOSStatus

        public static CFStringRef kCFErrorDomainOSStatus()

      • kCFErrorDomainMach

        public static CFStringRef kCFErrorDomainMach()

      • kCFErrorDomainCocoa

        public static CFStringRef kCFErrorDomainCocoa()

      • kCFErrorLocalizedDescriptionKey

        public static CFStringRef kCFErrorLocalizedDescriptionKey()
        Key to identify the end user-presentable description in userInfo. Should be one or more complete sentence(s) describing both what failed and why. For instance 'You can't save the file "To Do List" because the volume "Macintosh HD" is out of space.'

      • kCFErrorLocalizedFailureReasonKey

        public static CFStringRef kCFErrorLocalizedFailureReasonKey()
        Key to identify the end user-presentable failure reason ("why it failed") description in userInfo. Should be one or more complete sentence(s), for instance 'The volume "Macintosh HD" is out of space.'

      • kCFErrorLocalizedRecoverySuggestionKey

        public static CFStringRef kCFErrorLocalizedRecoverySuggestionKey()
        Key to identify the end user-presentable recovery suggestion in userInfo. Should be one or more complete sentence(s), for instance 'Remove some files from the volume, and then try again.'

      • kCFErrorDescriptionKey

        public static CFStringRef kCFErrorDescriptionKey()
        Key to identify the description in the userInfo dictionary. Should be a complete sentence if possible. Should not contain domain name or error code.

      • kCFErrorUnderlyingErrorKey

        public static CFStringRef kCFErrorUnderlyingErrorKey()
        Key to identify the underlying error in userInfo.

      • kCFErrorURLKey

        public static CFStringRef kCFErrorURLKey()
        Key to identify associated URL in userInfo. Typically one of this or kCFErrorFilePathKey is provided.

      • kCFErrorFilePathKey

        public static CFStringRef kCFErrorFilePathKey()
        Key to identify associated file path in userInfo. Typically one of this or kCFErrorURLKey is provided.

      • kCFURLKeysOfUnsetValuesKey

        public static CFStringRef kCFURLKeysOfUnsetValuesKey()

      • kCFURLNameKey

        public static CFStringRef kCFURLNameKey()
        Properties of File System Resources

      • kCFURLLocalizedNameKey

        public static CFStringRef kCFURLLocalizedNameKey()
        The resource name provided by the file system (Read-write, value type CFString)

      • kCFURLIsRegularFileKey

        public static CFStringRef kCFURLIsRegularFileKey()
        Localized or extension-hidden name as displayed to users (Read-only, value type CFString)

      • kCFURLIsDirectoryKey

        public static CFStringRef kCFURLIsDirectoryKey()
        True for regular files (Read-only, value type CFBoolean)

      • kCFURLIsSymbolicLinkKey

        public static CFStringRef kCFURLIsSymbolicLinkKey()
        True for directories (Read-only, CFBoolean)

      • kCFURLIsVolumeKey

        public static CFStringRef kCFURLIsVolumeKey()
        True for symlinks (Read-only, value type CFBoolean)

      • kCFURLIsPackageKey

        public static CFStringRef kCFURLIsPackageKey()
        True for the root directory of a volume (Read-only, value type CFBoolean)

      • kCFURLIsApplicationKey

        public static CFStringRef kCFURLIsApplicationKey()
        True for packaged directories (Read-only 10_6 and 10_7, read-write 10_8, value type CFBoolean). Note: You can only set or clear this property on directories; if you try to set this property on non-directory objects, the property is ignored. If the directory is a package for some other reason (extension type, etc), setting this property to false will have no effect.

      • kCFURLIsSystemImmutableKey

        public static CFStringRef kCFURLIsSystemImmutableKey()
        True if the resource is scriptable. Only applies to applications. (Read-only, value type CFBoolean)

      • kCFURLIsUserImmutableKey

        public static CFStringRef kCFURLIsUserImmutableKey()
        True for system-immutable resources (Read-write, value type CFBoolean)

      • kCFURLIsHiddenKey

        public static CFStringRef kCFURLIsHiddenKey()
        True for user-immutable resources (Read-write, value type CFBoolean)

      • kCFURLHasHiddenExtensionKey

        public static CFStringRef kCFURLHasHiddenExtensionKey()
        True for resources normally not displayed to users (Read-write, value type CFBoolean). Note: If the resource is a hidden because its name starts with a period, setting this property to false will not change the property.

      • kCFURLCreationDateKey

        public static CFStringRef kCFURLCreationDateKey()
        True for resources whose filename extension is removed from the localized name property (Read-write, value type CFBoolean)

      • kCFURLContentAccessDateKey

        public static CFStringRef kCFURLContentAccessDateKey()
        The date the resource was created (Read-write, value type CFDate)

      • kCFURLContentModificationDateKey

        public static CFStringRef kCFURLContentModificationDateKey()
        The date the resource was last accessed (Read-write, value type CFDate)

      • kCFURLAttributeModificationDateKey

        public static CFStringRef kCFURLAttributeModificationDateKey()
        The time the resource content was last modified (Read-write, value type CFDate)

      • kCFURLLinkCountKey

        public static CFStringRef kCFURLLinkCountKey()
        True if the file has sparse regions. (CFBoolean)

      • kCFURLParentDirectoryURLKey

        public static CFStringRef kCFURLParentDirectoryURLKey()
        Number of hard links to the resource (Read-only, value type CFNumber)

      • kCFURLVolumeURLKey

        public static CFStringRef kCFURLVolumeURLKey()
        The resource's parent directory, if any (Read-only, value type CFURL)

      • kCFURLTypeIdentifierKey

        public static CFStringRef kCFURLTypeIdentifierKey()
        URL of the volume on which the resource is stored (Read-only, value type CFURL)

      • kCFURLLocalizedTypeDescriptionKey

        public static CFStringRef kCFURLLocalizedTypeDescriptionKey()
        Uniform type identifier (UTI) for the resource (Read-only, value type CFString)

      • kCFURLLabelNumberKey

        public static CFStringRef kCFURLLabelNumberKey()
        User-visible type or "kind" description (Read-only, value type CFString)

      • kCFURLLabelColorKey

        public static CFStringRef kCFURLLabelColorKey()
        The label number assigned to the resource (Read-write, value type CFNumber)

      • kCFURLLocalizedLabelKey

        public static CFStringRef kCFURLLocalizedLabelKey()
        not implemented

      • kCFURLEffectiveIconKey

        public static CFStringRef kCFURLEffectiveIconKey()
        The user-visible label text (Read-only, value type CFString)

      • kCFURLCustomIconKey

        public static CFStringRef kCFURLCustomIconKey()
        not implemented

      • kCFURLFileResourceIdentifierKey

        public static CFStringRef kCFURLFileResourceIdentifierKey()
        not implemented

      • kCFURLVolumeIdentifierKey

        public static CFStringRef kCFURLVolumeIdentifierKey()
        An identifier which can be used to compare two file system objects for equality using CFEqual (i.e, two object identifiers are equal if they have the same file system path or if the paths are linked to same inode on the same file system). This identifier is not persistent across system restarts. (Read-only, value type CFType)

      • kCFURLPreferredIOBlockSizeKey

        public static CFStringRef kCFURLPreferredIOBlockSizeKey()
        An identifier that can be used to identify the volume the file system object is on. Other objects on the same volume will have the same volume identifier and can be compared using for equality using CFEqual. This identifier is not persistent across system restarts. (Read-only, value type CFType)

      • kCFURLIsReadableKey

        public static CFStringRef kCFURLIsReadableKey()
        The optimal block size when reading or writing this file's data, or NULL if not available. (Read-only, value type CFNumber)

      • kCFURLIsWritableKey

        public static CFStringRef kCFURLIsWritableKey()
        true if this process (as determined by EUID) can read the resource. (Read-only, value type CFBoolean)

      • kCFURLIsExecutableKey

        public static CFStringRef kCFURLIsExecutableKey()
        true if this process (as determined by EUID) can write to the resource. (Read-only, value type CFBoolean)

      • kCFURLFileSecurityKey

        public static CFStringRef kCFURLFileSecurityKey()
        true if this process (as determined by EUID) can execute a file resource or search a directory resource. (Read-only, value type CFBoolean)

      • kCFURLIsExcludedFromBackupKey

        public static CFStringRef kCFURLIsExcludedFromBackupKey()
        The file system object's security information encapsulated in a CFFileSecurity object. (Read-write, value type CFFileSecurity)

      • kCFURLPathKey

        public static CFStringRef kCFURLPathKey()
        The array of Tag names (Read-write, value type CFArray of CFString)

      • kCFURLCanonicalPathKey

        public static CFStringRef kCFURLCanonicalPathKey()
        the URL's path as a file system path (Read-only, value type CFString)

      • kCFURLIsMountTriggerKey

        public static CFStringRef kCFURLIsMountTriggerKey()
        the URL's path as a canonical absolute file system path (Read-only, value type CFString)

      • kCFURLGenerationIdentifierKey

        public static CFStringRef kCFURLGenerationIdentifierKey()
        true if this URL is a file system trigger directory. Traversing or opening a file system trigger will cause an attempt to mount a file system on the trigger directory. (Read-only, value type CFBoolean)

      • kCFURLDocumentIdentifierKey

        public static CFStringRef kCFURLDocumentIdentifierKey()
        An opaque generation identifier which can be compared using CFEqual() to determine if the data in a document has been modified. For URLs which refer to the same file inode, the generation identifier will change when the data in the file's data fork is changed (changes to extended attributes or other file system metadata do not change the generation identifier). For URLs which refer to the same directory inode, the generation identifier will change when direct children of that directory are added, removed or renamed (changes to the data of the direct children of that directory will not change the generation identifier). The generation identifier is persistent across system restarts. The generation identifier is tied to a specific document on a specific volume and is not transferred when the document is copied to another volume. This property is not supported by all volumes. (Read-only, value type CFType)

      • kCFURLAddedToDirectoryDateKey

        public static CFStringRef kCFURLAddedToDirectoryDateKey()
        The document identifier -- a value assigned by the kernel to a document (which can be either a file or directory) and is used to identify the document regardless of where it gets moved on a volume. The document identifier survives "safe save” operations; i.e it is sticky to the path it was assigned to (-replaceItemAtURL:withItemAtURL:backupItemName:options:resultingItemURL:error: is the preferred safe-save API). The document identifier is persistent across system restarts. The document identifier is not transferred when the file is copied. Document identifiers are only unique within a single volume. This property is not supported by all volumes. (Read-only, value type CFNumber)

      • kCFURLFileResourceTypeKey

        public static CFStringRef kCFURLFileResourceTypeKey()
        The quarantine properties as defined in LSQuarantine.h. To remove quarantine information from a file, pass kCFNull as the value when setting this property. (Read-write, value type CFDictionary)

      • kCFURLFileResourceTypeNamedPipe

        public static CFStringRef kCFURLFileResourceTypeNamedPipe()
        The file system object type values returned for the kCFURLFileResourceTypeKey

      • kCFURLFileResourceTypeCharacterSpecial

        public static CFStringRef kCFURLFileResourceTypeCharacterSpecial()

      • kCFURLFileResourceTypeDirectory

        public static CFStringRef kCFURLFileResourceTypeDirectory()

      • kCFURLFileResourceTypeBlockSpecial

        public static CFStringRef kCFURLFileResourceTypeBlockSpecial()

      • kCFURLFileResourceTypeRegular

        public static CFStringRef kCFURLFileResourceTypeRegular()

      • kCFURLFileResourceTypeSymbolicLink

        public static CFStringRef kCFURLFileResourceTypeSymbolicLink()

      • kCFURLFileResourceTypeSocket

        public static CFStringRef kCFURLFileResourceTypeSocket()

      • kCFURLFileResourceTypeUnknown

        public static CFStringRef kCFURLFileResourceTypeUnknown()

      • kCFURLFileSizeKey

        public static CFStringRef kCFURLFileSizeKey()
        File Properties

      • kCFURLFileAllocatedSizeKey

        public static CFStringRef kCFURLFileAllocatedSizeKey()
        Total file size in bytes (Read-only, value type CFNumber)

      • kCFURLTotalFileSizeKey

        public static CFStringRef kCFURLTotalFileSizeKey()
        Total size allocated on disk for the file in bytes (number of blocks times block size) (Read-only, value type CFNumber)

      • kCFURLTotalFileAllocatedSizeKey

        public static CFStringRef kCFURLTotalFileAllocatedSizeKey()
        Total displayable size of the file in bytes (this may include space used by metadata), or NULL if not available. (Read-only, value type CFNumber)

      • kCFURLIsAliasFileKey

        public static CFStringRef kCFURLIsAliasFileKey()
        Total allocated size of the file in bytes (this may include space used by metadata), or NULL if not available. This can be less than the value returned by kCFURLTotalFileSizeKey if the resource is compressed. (Read-only, value type CFNumber)

      • kCFURLFileProtectionKey

        public static CFStringRef kCFURLFileProtectionKey()
        true if the resource is a Finder alias file or a symlink, false otherwise ( Read-only, value type CFBooleanRef)

      • kCFURLFileProtectionNone

        public static CFStringRef kCFURLFileProtectionNone()
        The file has no special protections associated with it. It can be read from or written to at any time.

      • kCFURLFileProtectionComplete

        public static CFStringRef kCFURLFileProtectionComplete()
        The file is stored in an encrypted format on disk and cannot be read from or written to while the device is locked or booting.

      • kCFURLFileProtectionCompleteUnlessOpen

        public static CFStringRef kCFURLFileProtectionCompleteUnlessOpen()
        The file is stored in an encrypted format on disk. Files can be created while the device is locked, but once closed, cannot be opened again until the device is unlocked. If the file is opened when unlocked, you may continue to access the file normally, even if the user locks the device. There is a small performance penalty when the file is created and opened, though not when being written to or read from. This can be mitigated by changing the file protection to kCFURLFileProtectionComplete when the device is unlocked.

      • kCFURLFileProtectionCompleteUntilFirstUserAuthentication

        public static CFStringRef kCFURLFileProtectionCompleteUntilFirstUserAuthentication()
        The file is stored in an encrypted format on disk and cannot be accessed until after the device has booted. After the user unlocks the device for the first time, your app can access the file and continue to access it even if the user subsequently locks the device.

      • kCFURLVolumeLocalizedFormatDescriptionKey

        public static CFStringRef kCFURLVolumeLocalizedFormatDescriptionKey()
        As a convenience, volume properties can be requested from any file system URL. The value returned will reflect the property value for the volume on which the resource is located.

      • kCFURLVolumeTotalCapacityKey

        public static CFStringRef kCFURLVolumeTotalCapacityKey()
        The user-visible volume format (Read-only, value type CFString)

      • kCFURLVolumeAvailableCapacityKey

        public static CFStringRef kCFURLVolumeAvailableCapacityKey()
        Total volume capacity in bytes (Read-only, value type CFNumber)

      • kCFURLVolumeResourceCountKey

        public static CFStringRef kCFURLVolumeResourceCountKey()
        Total available capacity in bytes for "Opportunistic" resources, including space expected to be cleared by purging non-essential and cached resources. "Opportunistic" means something that the user is likely to want but does not expect to be present on the local system, but is ultimately non-essential and replaceable. This would include items that will be created or downloaded without an explicit request from the user on the current device. Examples: A background download of a newly available episode of a TV series that a user has been recently watching, a piece of content explicitly requested on another device, or a new document saved to a network server by the current user from another device. (Read-only, value type CFNumber)

      • kCFURLVolumeSupportsPersistentIDsKey

        public static CFStringRef kCFURLVolumeSupportsPersistentIDsKey()
        Total number of resources on the volume (Read-only, value type CFNumber)

      • kCFURLVolumeSupportsSymbolicLinksKey

        public static CFStringRef kCFURLVolumeSupportsSymbolicLinksKey()
        true if the volume format supports persistent object identifiers and can look up file system objects by their IDs (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsHardLinksKey

        public static CFStringRef kCFURLVolumeSupportsHardLinksKey()
        true if the volume format supports symbolic links (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsJournalingKey

        public static CFStringRef kCFURLVolumeSupportsJournalingKey()
        true if the volume format supports hard links (Read-only, value type CFBoolean)

      • kCFURLVolumeIsJournalingKey

        public static CFStringRef kCFURLVolumeIsJournalingKey()
        true if the volume format supports a journal used to speed recovery in case of unplanned restart (such as a power outage or crash). This does not necessarily mean the volume is actively using a journal. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsSparseFilesKey

        public static CFStringRef kCFURLVolumeSupportsSparseFilesKey()
        true if the volume is currently using a journal for speedy recovery after an unplanned restart. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsZeroRunsKey

        public static CFStringRef kCFURLVolumeSupportsZeroRunsKey()
        true if the volume format supports sparse files, that is, files which can have 'holes' that have never been written to, and thus do not consume space on disk. A sparse file may have an allocated size on disk that is less than its logical length. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsCaseSensitiveNamesKey

        public static CFStringRef kCFURLVolumeSupportsCaseSensitiveNamesKey()
        For security reasons, parts of a file (runs) that have never been written to must appear to contain zeroes. true if the volume keeps track of allocated but unwritten runs of a file so that it can substitute zeroes without actually writing zeroes to the media. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsCasePreservedNamesKey

        public static CFStringRef kCFURLVolumeSupportsCasePreservedNamesKey()
        true if the volume format treats upper and lower case characters in file and directory names as different. Otherwise an upper case character is equivalent to a lower case character, and you can't have two names that differ solely in the case of the characters. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsRootDirectoryDatesKey

        public static CFStringRef kCFURLVolumeSupportsRootDirectoryDatesKey()
        true if the volume format preserves the case of file and directory names. Otherwise the volume may change the case of some characters (typically making them all upper or all lower case). (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsVolumeSizesKey

        public static CFStringRef kCFURLVolumeSupportsVolumeSizesKey()
        true if the volume supports reliable storage of times for the root directory. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsRenamingKey

        public static CFStringRef kCFURLVolumeSupportsRenamingKey()
        true if the volume supports returning volume size values (kCFURLVolumeTotalCapacityKey and kCFURLVolumeAvailableCapacityKey). (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsAdvisoryFileLockingKey

        public static CFStringRef kCFURLVolumeSupportsAdvisoryFileLockingKey()
        true if the volume can be renamed. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsExtendedSecurityKey

        public static CFStringRef kCFURLVolumeSupportsExtendedSecurityKey()
        true if the volume implements whole-file flock(2) style advisory locks, and the O_EXLOCK and O_SHLOCK flags of the open(2) call. (Read-only, value type CFBoolean)

      • kCFURLVolumeIsBrowsableKey

        public static CFStringRef kCFURLVolumeIsBrowsableKey()
        true if the volume implements extended security (ACLs). (Read-only, value type CFBoolean)

      • kCFURLVolumeMaximumFileSizeKey

        public static CFStringRef kCFURLVolumeMaximumFileSizeKey()
        true if the volume should be visible via the GUI (i.e., appear on the Desktop as a separate volume). (Read-only, value type CFBoolean)

      • kCFURLVolumeIsEjectableKey

        public static CFStringRef kCFURLVolumeIsEjectableKey()
        The largest file size (in bytes) supported by this file system, or NULL if this cannot be determined. (Read-only, value type CFNumber)

      • kCFURLVolumeIsRemovableKey

        public static CFStringRef kCFURLVolumeIsRemovableKey()
        true if the volume's media is ejectable from the drive mechanism under software control. (Read-only, value type CFBoolean)

      • kCFURLVolumeIsInternalKey

        public static CFStringRef kCFURLVolumeIsInternalKey()
        true if the volume's media is removable from the drive mechanism. (Read-only, value type CFBoolean)

      • kCFURLVolumeIsAutomountedKey

        public static CFStringRef kCFURLVolumeIsAutomountedKey()
        true if the volume's device is connected to an internal bus, false if connected to an external bus, or NULL if not available. (Read-only, value type CFBoolean)

      • kCFURLVolumeIsLocalKey

        public static CFStringRef kCFURLVolumeIsLocalKey()
        true if the volume is automounted. Note: do not mistake this with the functionality provided by kCFURLVolumeSupportsBrowsingKey. (Read-only, value type CFBoolean)

      • kCFURLVolumeIsReadOnlyKey

        public static CFStringRef kCFURLVolumeIsReadOnlyKey()
        true if the volume is stored on a local device. (Read-only, value type CFBoolean)

      • kCFURLVolumeCreationDateKey

        public static CFStringRef kCFURLVolumeCreationDateKey()
        true if the volume is read-only. (Read-only, value type CFBoolean)

      • kCFURLVolumeURLForRemountingKey

        public static CFStringRef kCFURLVolumeURLForRemountingKey()
        The volume's creation date, or NULL if this cannot be determined. (Read-only, value type CFDate)

      • kCFURLVolumeUUIDStringKey

        public static CFStringRef kCFURLVolumeUUIDStringKey()
        The CFURL needed to remount a network volume, or NULL if not available. (Read-only, value type CFURL)

      • kCFURLVolumeNameKey

        public static CFStringRef kCFURLVolumeNameKey()
        The volume's persistent UUID as a string, or NULL if a persistent UUID is not available for the volume. (Read-only, value type CFString)

      • kCFURLVolumeLocalizedNameKey

        public static CFStringRef kCFURLVolumeLocalizedNameKey()
        The name of the volume (Read-write, settable if kCFURLVolumeSupportsRenamingKey is true and permissions allow, value type CFString)

      • kCFURLVolumeIsEncryptedKey

        public static CFStringRef kCFURLVolumeIsEncryptedKey()
        The user-presentable name of the volume (Read-only, value type CFString)

      • kCFURLVolumeIsRootFileSystemKey

        public static CFStringRef kCFURLVolumeIsRootFileSystemKey()
        true if the volume is encrypted. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsCompressionKey

        public static CFStringRef kCFURLVolumeSupportsCompressionKey()
        true if the volume is the root filesystem. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsFileCloningKey

        public static CFStringRef kCFURLVolumeSupportsFileCloningKey()
        true if the volume supports transparent decompression of compressed files using decmpfs. (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsSwapRenamingKey

        public static CFStringRef kCFURLVolumeSupportsSwapRenamingKey()
        true if the volume supports clonefile(2) (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsExclusiveRenamingKey

        public static CFStringRef kCFURLVolumeSupportsExclusiveRenamingKey()
        true if the volume supports renamex_np(2)'s RENAME_SWAP option (Read-only, value type CFBoolean)

      • kCFURLIsUbiquitousItemKey

        public static CFStringRef kCFURLIsUbiquitousItemKey()
        UbiquitousItem Properties

      • kCFURLUbiquitousItemHasUnresolvedConflictsKey

        public static CFStringRef kCFURLUbiquitousItemHasUnresolvedConflictsKey()
        true if this item is synced to the cloud, false if it is only a local file. (Read-only, value type CFBoolean)

      • kCFURLUbiquitousItemIsDownloadedKey

        public static CFStringRef kCFURLUbiquitousItemIsDownloadedKey()
        true if this item has conflicts outstanding. (Read-only, value type CFBoolean)

      • kCFURLUbiquitousItemIsDownloadingKey

        public static CFStringRef kCFURLUbiquitousItemIsDownloadingKey()
        Equivalent to NSURLUbiquitousItemDownloadingStatusKey == NSURLUbiquitousItemDownloadingStatusCurrent. Has never behaved as documented in earlier releases, hence deprecated. (Read-only, value type CFBoolean)

      • kCFURLUbiquitousItemIsUploadedKey

        public static CFStringRef kCFURLUbiquitousItemIsUploadedKey()
        true if data is being downloaded for this item. (Read-only, value type CFBoolean)

      • kCFURLUbiquitousItemIsUploadingKey

        public static CFStringRef kCFURLUbiquitousItemIsUploadingKey()
        true if there is data present in the cloud for this item. (Read-only, value type CFBoolean)

      • kCFURLUbiquitousItemPercentDownloadedKey

        public static CFStringRef kCFURLUbiquitousItemPercentDownloadedKey()
        true if data is being uploaded for this item. (Read-only, value type CFBoolean)

      • kCFURLUbiquitousItemPercentUploadedKey

        public static CFStringRef kCFURLUbiquitousItemPercentUploadedKey()
        Use NSMetadataQuery and NSMetadataUbiquitousItemPercentDownloadedKey on NSMetadataItem instead

      • kCFURLUbiquitousItemDownloadingStatusKey

        public static CFStringRef kCFURLUbiquitousItemDownloadingStatusKey()
        Use NSMetadataQuery and NSMetadataUbiquitousItemPercentUploadedKey on NSMetadataItem instead

      • kCFURLUbiquitousItemDownloadingErrorKey

        public static CFStringRef kCFURLUbiquitousItemDownloadingErrorKey()
        Returns the download status of this item. (Read-only, value type CFString). Possible values below.

      • kCFURLUbiquitousItemUploadingErrorKey

        public static CFStringRef kCFURLUbiquitousItemUploadingErrorKey()
        returns the error when downloading the item from iCloud failed. See the NSUbiquitousFile section in FoundationErrors.h. (Read-only, value type CFError)

      • kCFURLUbiquitousItemDownloadingStatusNotDownloaded

        public static CFStringRef kCFURLUbiquitousItemDownloadingStatusNotDownloaded()
        The values returned for kCFURLUbiquitousItemDownloadingStatusKey

      • kCFURLUbiquitousItemDownloadingStatusDownloaded

        public static CFStringRef kCFURLUbiquitousItemDownloadingStatusDownloaded()
        this item has not been downloaded yet. Use NSFileManager's startDownloadingUbiquitousItemAtURL:error: to download it

      • kCFURLUbiquitousItemDownloadingStatusCurrent

        public static CFStringRef kCFURLUbiquitousItemDownloadingStatusCurrent()
        there is a local version of this item available. The most current version will get downloaded as soon as possible.

      • kCFAbsoluteTimeIntervalSince1970

        public static double kCFAbsoluteTimeIntervalSince1970()

      • kCFAbsoluteTimeIntervalSince1904

        public static double kCFAbsoluteTimeIntervalSince1904()

      • kCFTypeBagCallBacks

        public static CFBagCallBacks kCFTypeBagCallBacks()

      • kCFCopyStringBagCallBacks

        public static CFBagCallBacks kCFCopyStringBagCallBacks()

      • kCFStringBinaryHeapCallBacks

        public static CFBinaryHeapCallBacks kCFStringBinaryHeapCallBacks()
        [@constant] kCFStringBinaryHeapCallBacks Predefined CFBinaryHeapCallBacks structure containing a set of callbacks appropriate for use when the values in a CFBinaryHeap are all CFString types.

      • kCFTimeZoneSystemTimeZoneDidChangeNotification

        public static CFStringRef kCFTimeZoneSystemTimeZoneDidChangeNotification()

      • kCFDateFormatterIsLenient

        public static CFStringRef kCFDateFormatterIsLenient()
        CFBoolean

      • kCFDateFormatterTimeZone

        public static CFStringRef kCFDateFormatterTimeZone()
        CFTimeZone

      • kCFDateFormatterCalendarName

        public static CFStringRef kCFDateFormatterCalendarName()
        CFString

      • kCFDateFormatterDefaultFormat

        public static CFStringRef kCFDateFormatterDefaultFormat()
        CFString

      • kCFDateFormatterTwoDigitStartDate

        public static CFStringRef kCFDateFormatterTwoDigitStartDate()
        CFDate

      • kCFDateFormatterDefaultDate

        public static CFStringRef kCFDateFormatterDefaultDate()
        CFDate

      • kCFDateFormatterCalendar

        public static CFStringRef kCFDateFormatterCalendar()
        CFCalendar

      • kCFDateFormatterEraSymbols

        public static CFStringRef kCFDateFormatterEraSymbols()
        CFArray of CFString

      • kCFDateFormatterMonthSymbols

        public static CFStringRef kCFDateFormatterMonthSymbols()
        CFArray of CFString

      • kCFDateFormatterShortMonthSymbols

        public static CFStringRef kCFDateFormatterShortMonthSymbols()
        CFArray of CFString

      • kCFDateFormatterWeekdaySymbols

        public static CFStringRef kCFDateFormatterWeekdaySymbols()
        CFArray of CFString

      • kCFDateFormatterShortWeekdaySymbols

        public static CFStringRef kCFDateFormatterShortWeekdaySymbols()
        CFArray of CFString

      • kCFDateFormatterAMSymbol

        public static CFStringRef kCFDateFormatterAMSymbol()
        CFString

      • kCFDateFormatterPMSymbol

        public static CFStringRef kCFDateFormatterPMSymbol()
        CFString

      • kCFDateFormatterLongEraSymbols

        public static CFStringRef kCFDateFormatterLongEraSymbols()
        CFArray of CFString

      • kCFDateFormatterVeryShortMonthSymbols

        public static CFStringRef kCFDateFormatterVeryShortMonthSymbols()
        CFArray of CFString

      • kCFDateFormatterStandaloneMonthSymbols

        public static CFStringRef kCFDateFormatterStandaloneMonthSymbols()
        CFArray of CFString

      • kCFDateFormatterShortStandaloneMonthSymbols

        public static CFStringRef kCFDateFormatterShortStandaloneMonthSymbols()
        CFArray of CFString

      • kCFDateFormatterVeryShortStandaloneMonthSymbols

        public static CFStringRef kCFDateFormatterVeryShortStandaloneMonthSymbols()
        CFArray of CFString

      • kCFDateFormatterVeryShortWeekdaySymbols

        public static CFStringRef kCFDateFormatterVeryShortWeekdaySymbols()
        CFArray of CFString

      • kCFDateFormatterStandaloneWeekdaySymbols

        public static CFStringRef kCFDateFormatterStandaloneWeekdaySymbols()
        CFArray of CFString

      • kCFDateFormatterShortStandaloneWeekdaySymbols

        public static CFStringRef kCFDateFormatterShortStandaloneWeekdaySymbols()
        CFArray of CFString

      • kCFDateFormatterVeryShortStandaloneWeekdaySymbols

        public static CFStringRef kCFDateFormatterVeryShortStandaloneWeekdaySymbols()
        CFArray of CFString

      • kCFDateFormatterQuarterSymbols

        public static CFStringRef kCFDateFormatterQuarterSymbols()
        CFArray of CFString

      • kCFDateFormatterShortQuarterSymbols

        public static CFStringRef kCFDateFormatterShortQuarterSymbols()
        CFArray of CFString

      • kCFDateFormatterStandaloneQuarterSymbols

        public static CFStringRef kCFDateFormatterStandaloneQuarterSymbols()
        CFArray of CFString

      • kCFDateFormatterShortStandaloneQuarterSymbols

        public static CFStringRef kCFDateFormatterShortStandaloneQuarterSymbols()
        CFArray of CFString

      • kCFDateFormatterGregorianStartDate

        public static CFStringRef kCFDateFormatterGregorianStartDate()
        CFDate

      • kCFDateFormatterDoesRelativeDateFormattingKey

        public static CFStringRef kCFDateFormatterDoesRelativeDateFormattingKey()
        CFBoolean

      • kCFBooleanTrue

        public static CFBooleanRef kCFBooleanTrue()

      • kCFBooleanFalse

        public static CFBooleanRef kCFBooleanFalse()

      • kCFNumberPositiveInfinity

        public static CFNumberRef kCFNumberPositiveInfinity()

      • kCFNumberNegativeInfinity

        public static CFNumberRef kCFNumberNegativeInfinity()

      • kCFNumberNaN

        public static CFNumberRef kCFNumberNaN()

      • kCFNumberFormatterCurrencyCode

        public static CFStringRef kCFNumberFormatterCurrencyCode()
        CFString

      • kCFNumberFormatterDecimalSeparator

        public static CFStringRef kCFNumberFormatterDecimalSeparator()
        CFString

      • kCFNumberFormatterCurrencyDecimalSeparator

        public static CFStringRef kCFNumberFormatterCurrencyDecimalSeparator()
        CFString

      • kCFNumberFormatterAlwaysShowDecimalSeparator

        public static CFStringRef kCFNumberFormatterAlwaysShowDecimalSeparator()
        CFBoolean

      • kCFNumberFormatterGroupingSeparator

        public static CFStringRef kCFNumberFormatterGroupingSeparator()
        CFString

      • kCFNumberFormatterUseGroupingSeparator

        public static CFStringRef kCFNumberFormatterUseGroupingSeparator()
        CFBoolean

      • kCFNumberFormatterPercentSymbol

        public static CFStringRef kCFNumberFormatterPercentSymbol()
        CFString

      • kCFNumberFormatterZeroSymbol

        public static CFStringRef kCFNumberFormatterZeroSymbol()
        CFString

      • kCFNumberFormatterNaNSymbol

        public static CFStringRef kCFNumberFormatterNaNSymbol()
        CFString

      • kCFNumberFormatterInfinitySymbol

        public static CFStringRef kCFNumberFormatterInfinitySymbol()
        CFString

      • kCFNumberFormatterMinusSign

        public static CFStringRef kCFNumberFormatterMinusSign()
        CFString

      • kCFNumberFormatterPlusSign

        public static CFStringRef kCFNumberFormatterPlusSign()
        CFString

      • kCFNumberFormatterCurrencySymbol

        public static CFStringRef kCFNumberFormatterCurrencySymbol()
        CFString

      • kCFNumberFormatterExponentSymbol

        public static CFStringRef kCFNumberFormatterExponentSymbol()
        CFString

      • kCFNumberFormatterMinIntegerDigits

        public static CFStringRef kCFNumberFormatterMinIntegerDigits()
        CFNumber

      • kCFNumberFormatterMaxIntegerDigits

        public static CFStringRef kCFNumberFormatterMaxIntegerDigits()
        CFNumber

      • kCFNumberFormatterMinFractionDigits

        public static CFStringRef kCFNumberFormatterMinFractionDigits()
        CFNumber

      • kCFNumberFormatterMaxFractionDigits

        public static CFStringRef kCFNumberFormatterMaxFractionDigits()
        CFNumber

      • kCFNumberFormatterGroupingSize

        public static CFStringRef kCFNumberFormatterGroupingSize()
        CFNumber

      • kCFNumberFormatterSecondaryGroupingSize

        public static CFStringRef kCFNumberFormatterSecondaryGroupingSize()
        CFNumber

      • kCFNumberFormatterRoundingMode

        public static CFStringRef kCFNumberFormatterRoundingMode()
        CFNumber

      • kCFNumberFormatterRoundingIncrement

        public static CFStringRef kCFNumberFormatterRoundingIncrement()
        CFNumber

      • kCFNumberFormatterFormatWidth

        public static CFStringRef kCFNumberFormatterFormatWidth()
        CFNumber

      • kCFNumberFormatterPaddingPosition

        public static CFStringRef kCFNumberFormatterPaddingPosition()
        CFNumber

      • kCFNumberFormatterPaddingCharacter

        public static CFStringRef kCFNumberFormatterPaddingCharacter()
        CFString

      • kCFNumberFormatterDefaultFormat

        public static CFStringRef kCFNumberFormatterDefaultFormat()
        CFString

      • kCFNumberFormatterMultiplier

        public static CFStringRef kCFNumberFormatterMultiplier()
        CFNumber

      • kCFNumberFormatterPositivePrefix

        public static CFStringRef kCFNumberFormatterPositivePrefix()
        CFString

      • kCFNumberFormatterPositiveSuffix

        public static CFStringRef kCFNumberFormatterPositiveSuffix()
        CFString

      • kCFNumberFormatterNegativePrefix

        public static CFStringRef kCFNumberFormatterNegativePrefix()
        CFString

      • kCFNumberFormatterNegativeSuffix

        public static CFStringRef kCFNumberFormatterNegativeSuffix()
        CFString

      • kCFNumberFormatterPerMillSymbol

        public static CFStringRef kCFNumberFormatterPerMillSymbol()
        CFString

      • kCFNumberFormatterInternationalCurrencySymbol

        public static CFStringRef kCFNumberFormatterInternationalCurrencySymbol()
        CFString

      • kCFNumberFormatterCurrencyGroupingSeparator

        public static CFStringRef kCFNumberFormatterCurrencyGroupingSeparator()
        CFString

      • kCFNumberFormatterIsLenient

        public static CFStringRef kCFNumberFormatterIsLenient()
        CFBoolean

      • kCFNumberFormatterUseSignificantDigits

        public static CFStringRef kCFNumberFormatterUseSignificantDigits()
        CFBoolean

      • kCFNumberFormatterMinSignificantDigits

        public static CFStringRef kCFNumberFormatterMinSignificantDigits()
        CFNumber

      • kCFNumberFormatterMaxSignificantDigits

        public static CFStringRef kCFNumberFormatterMaxSignificantDigits()
        CFNumber

      • kCFPreferencesAnyApplication

        public static CFStringRef kCFPreferencesAnyApplication()

      • kCFPreferencesCurrentApplication

        public static CFStringRef kCFPreferencesCurrentApplication()

      • kCFPreferencesAnyHost

        public static CFStringRef kCFPreferencesAnyHost()

      • kCFPreferencesCurrentHost

        public static CFStringRef kCFPreferencesCurrentHost()

      • kCFPreferencesAnyUser

        public static CFStringRef kCFPreferencesAnyUser()

      • kCFPreferencesCurrentUser

        public static CFStringRef kCFPreferencesCurrentUser()

      • kCFRunLoopDefaultMode

        public static CFStringRef kCFRunLoopDefaultMode()

      • kCFRunLoopCommonModes

        public static CFStringRef kCFRunLoopCommonModes()

      • kCFSocketCommandKey

        public static CFStringRef kCFSocketCommandKey()
        Constants used in name registry server communications

      • kCFSocketNameKey

        public static CFStringRef kCFSocketNameKey()

      • kCFSocketValueKey

        public static CFStringRef kCFSocketValueKey()

      • kCFSocketResultKey

        public static CFStringRef kCFSocketResultKey()

      • kCFSocketErrorKey

        public static CFStringRef kCFSocketErrorKey()

      • kCFSocketRegisterCommand

        public static CFStringRef kCFSocketRegisterCommand()

      • kCFSocketRetrieveCommand

        public static CFStringRef kCFSocketRetrieveCommand()

      • kCFStreamPropertyDataWritten

        public static CFStringRef kCFStreamPropertyDataWritten()
        Value will be a CFData containing all bytes thusfar written; used to recover the data written to a memory write stream.

      • kCFStreamPropertyAppendToFile

        public static CFStringRef kCFStreamPropertyAppendToFile()
        Property for file write streams; value should be a CFBoolean. Set to TRUE to append to a file, rather than to replace its contents

      • kCFStreamPropertyFileCurrentOffset

        public static CFStringRef kCFStreamPropertyFileCurrentOffset()
        Value is a CFNumber

      • kCFStreamPropertySocketNativeHandle

        public static CFStringRef kCFStreamPropertySocketNativeHandle()
        Value will be a CFData containing the native handle

      • kCFStreamPropertySocketRemoteHostName

        public static CFStringRef kCFStreamPropertySocketRemoteHostName()
        Value will be a CFString, or NULL if unknown

      • kCFStreamPropertySocketRemotePortNumber

        public static CFStringRef kCFStreamPropertySocketRemotePortNumber()
        Value will be a CFNumber, or NULL if unknown

      • kCFTypeSetCallBacks

        public static CFSetCallBacks kCFTypeSetCallBacks()
        [@constant] kCFTypeSetCallBacks Predefined CFSetCallBacks structure containing a set of callbacks appropriate for use when the values in a CFSet are all CFTypes.

      • kCFCopyStringSetCallBacks

        public static CFSetCallBacks kCFCopyStringSetCallBacks()
        [@constant] kCFCopyStringSetCallBacks Predefined CFSetCallBacks structure containing a set of callbacks appropriate for use when the values in a CFSet should be copies of a CFString.

      • kCFURLFileExists

        public static CFStringRef kCFURLFileExists()
        Older property keys

      • kCFURLFileDirectoryContents

        public static CFStringRef kCFURLFileDirectoryContents()

      • kCFURLFileLength

        public static CFStringRef kCFURLFileLength()

      • kCFURLFileLastModificationTime

        public static CFStringRef kCFURLFileLastModificationTime()

      • kCFURLFilePOSIXMode

        public static CFStringRef kCFURLFilePOSIXMode()

      • kCFURLFileOwnerID

        public static CFStringRef kCFURLFileOwnerID()

      • kCFURLHTTPStatusCode

        public static CFStringRef kCFURLHTTPStatusCode()

      • kCFURLHTTPStatusLine

        public static CFStringRef kCFURLHTTPStatusLine()

      • kCFBundleInfoDictionaryVersionKey

        public static CFStringRef kCFBundleInfoDictionaryVersionKey()
        ===================== Standard Info.plist keys =====================

      • kCFBundleExecutableKey

        public static CFStringRef kCFBundleExecutableKey()
        The version of the Info.plist format

      • kCFBundleIdentifierKey

        public static CFStringRef kCFBundleIdentifierKey()
        The name of the executable in this bundle, if any

      • kCFBundleVersionKey

        public static CFStringRef kCFBundleVersionKey()
        The bundle identifier (for CFBundleGetBundleWithIdentifier())

      • kCFBundleDevelopmentRegionKey

        public static CFStringRef kCFBundleDevelopmentRegionKey()
        The version number of the bundle. For Mac OS 9 style version numbers (for example "2.5.3d5"), clients can use CFBundleGetVersionNumber() instead of accessing this key directly since that function will properly convert the version string into its compact integer representation.

      • kCFBundleNameKey

        public static CFStringRef kCFBundleNameKey()
        The name of the development language of the bundle.

      • kCFBundleLocalizationsKey

        public static CFStringRef kCFBundleLocalizationsKey()
        The human-readable name of the bundle. This key is often found in the InfoPlist.strings since it is usually localized.

      • kCFPlugInDynamicRegistrationKey

        public static CFStringRef kCFPlugInDynamicRegistrationKey()
        ================ Standard Info.plist keys for plugIns ================

      • kCFPlugInDynamicRegisterFunctionKey

        public static CFStringRef kCFPlugInDynamicRegisterFunctionKey()

      • kCFPlugInUnloadFunctionKey

        public static CFStringRef kCFPlugInUnloadFunctionKey()

      • kCFPlugInFactoriesKey

        public static CFStringRef kCFPlugInFactoriesKey()

      • kCFPlugInTypesKey

        public static CFStringRef kCFPlugInTypesKey()

      • kCFErrorLocalizedFailureKey

        public static CFStringRef kCFErrorLocalizedFailureKey()
        Key to identify the end user-presentable failing operation ("what failed") description in userInfo. Should be one or more complete sentence(s), for instance 'The file "To Do List" couldn't be saved.'

      • kCFURLVolumeAvailableCapacityForImportantUsageKey

        public static CFStringRef kCFURLVolumeAvailableCapacityForImportantUsageKey()
        Total free space in bytes (Read-only, value type CFNumber)

      • kCFURLVolumeAvailableCapacityForOpportunisticUsageKey

        public static CFStringRef kCFURLVolumeAvailableCapacityForOpportunisticUsageKey()
        Total available capacity in bytes for "Important" resources, including space expected to be cleared by purging non-essential and cached resources. "Important" means something that the user or application clearly expects to be present on the local system, but is ultimately replaceable. This would include items that the user has explicitly requested via the UI, and resources that an application requires in order to provide functionality. Examples: A video that the user has explicitly requested to watch but has not yet finished watching or an audio file that the user has requested to download. This value should not be used in determining if there is room for an irreplaceable resource. In the case of irreplaceable resources, always attempt to save the resource regardless of available capacity and handle failure as gracefully as possible. (Read-only, value type CFNumber)

      • kCFURLVolumeSupportsImmutableFilesKey

        public static CFStringRef kCFURLVolumeSupportsImmutableFilesKey()
        true if the volume supports renamex_np(2)'s RENAME_EXCL option (Read-only, value type CFBoolean)

      • kCFURLVolumeSupportsAccessPermissionsKey

        public static CFStringRef kCFURLVolumeSupportsAccessPermissionsKey()
        true if the volume supports making files immutable with the kCFURLIsUserImmutableKey or kCFURLIsSystemImmutableKey properties (Read-only, value type CFBoolean)

      • kCFStreamErrorDomainSOCKS

        public static int kCFStreamErrorDomainSOCKS()
        kCFStreamErrorDomainSOCKS Discussion: SOCKS proxy error domain. Errors formulated using inlines below.

      • kCFStreamPropertySOCKSProxy

        public static CFStringRef kCFStreamPropertySOCKSProxy()
        kCFStreamPropertySOCKSProxy Discussion: Stream property key, for both set and copy operations. To set a stream to use a SOCKS proxy, call CFReadStreamSetProperty or CFWriteStreamSetProperty with the property name set to kCFStreamPropertySOCKSProxy and the value being a dictionary with at least the following two keys: kCFStreamPropertySOCKSProxyHost and kCFStreamPropertySOCKSProxyPort. The dictionary returned by SystemConfiguration for SOCKS proxies will work without alteration.

      • kCFStreamPropertySOCKSProxyHost

        public static CFStringRef kCFStreamPropertySOCKSProxyHost()
        kCFStreamPropertySOCKSProxyHost Discussion: CFDictionary key for SOCKS proxy information. The key kCFStreamPropertySOCKSProxyHost should contain a CFStringRef value representing the SOCKS proxy host. Defined to match kSCPropNetProxiesSOCKSProxy

      • kCFStreamPropertySOCKSProxyPort

        public static CFStringRef kCFStreamPropertySOCKSProxyPort()
        kCFStreamPropertySOCKSProxyPort Discussion: CFDictionary key for SOCKS proxy information. The key kCFStreamPropertySOCKSProxyPort should contain a CFNumberRef which itself is of type kCFNumberSInt32Type. This value should represent the port on which the proxy is listening. Defined to match kSCPropNetProxiesSOCKSPort

      • kCFStreamPropertySOCKSVersion

        public static CFStringRef kCFStreamPropertySOCKSVersion()
        kCFStreamPropertySOCKSVersion Discussion: CFDictionary key for SOCKS proxy information. By default, SOCKS5 will be used unless there is a kCFStreamPropertySOCKSVersion key in the dictionary. Its value must be kCFStreamSocketSOCKSVersion4 or kCFStreamSocketSOCKSVersion5 to set SOCKS4 or SOCKS5, respectively.

      • kCFStreamSocketSOCKSVersion4

        public static CFStringRef kCFStreamSocketSOCKSVersion4()
        kCFStreamSocketSOCKSVersion4 Discussion: CFDictionary value for SOCKS proxy information. Indcates that SOCKS will or is using version 4 of the SOCKS protocol.

      • kCFStreamSocketSOCKSVersion5

        public static CFStringRef kCFStreamSocketSOCKSVersion5()
        kCFStreamSocketSOCKSVersion5 Discussion: CFDictionary value for SOCKS proxy information. Indcates that SOCKS will or is using version 5 of the SOCKS protocol.

      • kCFStreamPropertySOCKSUser

        public static CFStringRef kCFStreamPropertySOCKSUser()
        kCFStreamPropertySOCKSUser Discussion: CFDictionary key for SOCKS proxy information. To set a user name and/or password, if required, the dictionary must contain the key(s) kCFStreamPropertySOCKSUser and/or kCFStreamPropertySOCKSPassword with the value being the user's name as a CFStringRef and/or the user's password as a CFStringRef, respectively.

      • kCFStreamPropertySOCKSPassword

        public static CFStringRef kCFStreamPropertySOCKSPassword()
        kCFStreamPropertySOCKSPassword Discussion: CFDictionary key for SOCKS proxy information. To set a user name and/or password, if required, the dictionary must contain the key(s) kCFStreamPropertySOCKSUser and/or kCFStreamPropertySOCKSPassword with the value being the user's name as a CFStringRef and/or the user's password as a CFStringRef, respectively.

      • kCFStreamErrorDomainSSL

        public static int kCFStreamErrorDomainSSL()
        kCFStreamErrorDomainSSL Discussion: Errors located in Security/SecureTransport.h

      • kCFStreamPropertySocketSecurityLevel

        public static CFStringRef kCFStreamPropertySocketSecurityLevel()
        kCFStreamPropertySocketSecurityLevel Discussion: Stream property key, for both set and copy operations. To set a stream to be secure, call CFReadStreamSetProperty or CFWriteStreamSetPropertywith the property name set to kCFStreamPropertySocketSecurityLevel and the value being one of the following values. Streams may set a security level after open in order to allow on-the-fly securing of a stream.

      • kCFStreamSocketSecurityLevelNone

        public static CFStringRef kCFStreamSocketSecurityLevelNone()
        kCFStreamSocketSecurityLevelNone Discussion: Stream property value, for both set and copy operations. Indicates to use no security (default setting).

      • kCFStreamSocketSecurityLevelSSLv2

        public static CFStringRef kCFStreamSocketSecurityLevelSSLv2()
        kCFStreamSocketSecurityLevelSSLv2 Note: SSLv2 is DEPRECATED starting in OS X 10.12 and iOS 10.0. Discussion: Stream property value, for both set and copy operations. Indicates to use SSLv2 security.

      • kCFStreamSocketSecurityLevelSSLv3

        public static CFStringRef kCFStreamSocketSecurityLevelSSLv3()
        kCFStreamSocketSecurityLevelSSLv3 Note: SSLv3 is DEPRECATED starting in OS X 10.12 and iOS 10.0. Discussion: Stream property value, for both set and copy operations. Indicates to use SSLv3 security.

      • kCFStreamSocketSecurityLevelTLSv1

        public static CFStringRef kCFStreamSocketSecurityLevelTLSv1()
        kCFStreamSocketSecurityLevelTLSv1 Discussion: Stream property value, for both set and copy operations. Indicates to use TLSv1 security.

      • kCFStreamSocketSecurityLevelNegotiatedSSL

        public static CFStringRef kCFStreamSocketSecurityLevelNegotiatedSSL()
        kCFStreamSocketSecurityLevelNegotiatedSSL Discussion: Stream property value, for both set and copy operations. Indicates to use TLS or SSL with fallback to lower versions. This is what HTTPS does, for instance.

      • kCFStreamPropertyShouldCloseNativeSocket

        public static CFStringRef kCFStreamPropertyShouldCloseNativeSocket()
        kCFStreamPropertyShouldCloseNativeSocket Discussion: Set the value to kCFBooleanTrue if the stream should close and release the underlying native socket when the stream is released. Set the value to kCFBooleanFalse to keep the native socket from closing and releasing when the stream is released. If the stream was created with a native socket, the default property setting on the stream is kCFBooleanFalse. The kCFStreamPropertyShouldCloseNativeSocket can be set through CFReadStreamSetProperty or CFWriteStreamSetProperty. The property can be copied through CFReadStreamCopyProperty or CFWriteStreamCopyProperty.

      • kCFURLFileContentIdentifierKey

        public static CFStringRef kCFURLFileContentIdentifierKey()
        The time the resource's attributes were last modified (Read-only, value type CFDate)

      • kCFURLMayShareFileContentKey

        public static CFStringRef kCFURLMayShareFileContentKey()
        A 64-bit value assigned by APFS that identifies a file's content data stream. Only cloned files and their originals can have the same identifier. (CFNumber)

      • kCFURLMayHaveExtendedAttributesKey

        public static CFStringRef kCFURLMayHaveExtendedAttributesKey()
        True for cloned files and their originals that may share all, some, or no data blocks. (CFBoolean)

      • kCFURLIsPurgeableKey

        public static CFStringRef kCFURLIsPurgeableKey()
        True if the file has extended attributes. False guarantees there are none. (CFBoolean)

      • kCFURLIsSparseKey

        public static CFStringRef kCFURLIsSparseKey()
        True if the file can be deleted by the file system when asked to free space. (CFBoolean)

      • kCFURLVolumeSupportsFileProtectionKey

        public static CFStringRef kCFURLVolumeSupportsFileProtectionKey()
        true if the volume supports setting POSIX access permissions with the kCFURLFileSecurityKey property (Read-only, value type CFBoolean)