@swiftbrowser/wasm-sdk-foundation 0.0.0-stage → 0.9.1

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFSocket.h

@@ -0,0 +1,220 @@
+/*	CFSocket.h
+	Copyright (c) 1999-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#if !defined(__COREFOUNDATION_CFSOCKET__)
+#define __COREFOUNDATION_CFSOCKET__ 1
+
+#include "CFRunLoop.h"
+#include "CFData.h"
+
+CF_IMPLICIT_BRIDGING_ENABLED
+CF_EXTERN_C_BEGIN
+
+typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFSocket * CFSocketRef;
+
+/* A CFSocket contains a native socket within a structure that can 
+be used to read from the socket in the background and make the data
+thus read available using a runloop source.  The callback used for
+this may be of three types, as specified by the callBackTypes
+argument when creating the CFSocket.
+
+If kCFSocketReadCallBack is used, then data will not be
+automatically read, but the callback will be called when data
+is available to be read, or a new child socket is waiting to be
+accepted.
+    
+If kCFSocketAcceptCallBack is used, then new child sockets will be
+accepted and passed to the callback, with the data argument being
+a pointer to a CFSocketNativeHandle.  This is usable only with
+connection rendezvous sockets.
+
+If kCFSocketDataCallBack is used, then data will be read in chunks
+in the background and passed to the callback, with the data argument
+being a CFDataRef.
+
+These three types are mutually exclusive, but any one of them may
+have kCFSocketConnectCallBack added to it, if the socket will be
+used to connect in the background.  Connect in the background occurs
+if CFSocketConnectToAddress is called with a negative timeout
+value, in which case the call returns immediately, and a
+kCFSocketConnectCallBack is generated when the connect finishes.
+In this case the data argument is either NULL, or a pointer to
+an SInt32 error code if the connect failed.  kCFSocketConnectCallBack
+will never be sent more than once for a given socket.
+
+The callback types may also have kCFSocketWriteCallBack added to
+them, if large amounts of data are to be sent rapidly over the 
+socket and notification is desired when there is space in the
+kernel buffers so that the socket is writable again.  
+
+With a connection-oriented socket, if the connection is broken from the
+other end, then one final kCFSocketReadCallBack or kCFSocketDataCallBack 
+will occur.  In the case of kCFSocketReadCallBack, the underlying socket 
+will have 0 bytes available to read.  In the case of kCFSocketDataCallBack,
+the data argument will be a CFDataRef of length 0.
+
+There are socket flags that may be set to control whether callbacks of 
+a given type are automatically reenabled after they are triggered, and 
+whether the underlying native socket will be closed when the CFSocket
+is invalidated.  By default read, accept, and data callbacks are 
+automatically reenabled; write callbacks are not, and connect callbacks
+may not be, since they are sent once only.  Be careful about automatically
+reenabling read and write callbacks, since this implies that the 
+callbacks will be sent repeatedly if the socket remains readable or
+writable respectively.  Be sure to set these flags only for callbacks
+that your CFSocket actually possesses; the result of setting them for
+other callback types is undefined.
+
+Individual callbacks may also be enabled and disabled manually, whether 
+they are automatically reenabled or not.  If they are not automatically 
+reenabled, then they will need to be manually reenabled when the callback 
+is ready to be received again (and not sooner).  Even if they are 
+automatically reenabled, there may be occasions when it will be useful
+to be able to manually disable them temporarily and then reenable them.
+Be sure to enable and disable only callbacks that your CFSocket actually
+possesses; the result of enabling and disabling other callback types is
+undefined.
+
+By default the underlying native socket will be closed when the CFSocket 
+is invalidated, but it will not be if kCFSocketCloseOnInvalidate is 
+turned off.  This can be useful in order to destroy a CFSocket but 
+continue to use the underlying native socket.  The CFSocket must 
+still be invalidated when it will no longer be used.  Do not in 
+either case close the underlying native socket without invalidating 
+the CFSocket.
+
+Addresses are stored as CFDatas containing a struct sockaddr
+appropriate for the protocol family; make sure that all fields are
+filled in properly when passing in an address.  
+
+*/
+
+/* Values for CFSocketError */
+typedef CF_ENUM(CFIndex, CFSocketError) {
+    kCFSocketSuccess = 0,
+    kCFSocketError = -1L,
+    kCFSocketTimeout = -2L
+};
+
+typedef struct {
+    SInt32	protocolFamily;
+    SInt32	socketType;
+    SInt32	protocol;
+    CFDataRef	address;
+} CFSocketSignature;
+
+/* Values for CFSocketCallBackType */
+typedef CF_OPTIONS(CFOptionFlags, CFSocketCallBackType) {
+    kCFSocketNoCallBack = 0,
+    kCFSocketReadCallBack = 1,
+    kCFSocketAcceptCallBack = 2,
+    kCFSocketDataCallBack = 3,
+    kCFSocketConnectCallBack = 4,
+    kCFSocketWriteCallBack = 8
+};
+
+/* Socket flags */
+CF_ENUM(CFOptionFlags) {
+    kCFSocketAutomaticallyReenableReadCallBack = 1,
+    kCFSocketAutomaticallyReenableAcceptCallBack = 2,
+    kCFSocketAutomaticallyReenableDataCallBack = 3,
+    kCFSocketAutomaticallyReenableWriteCallBack = 8,
+    kCFSocketLeaveErrors API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0)) = 64,
+    kCFSocketCloseOnInvalidate = 128
+};
+
+typedef void (*CFSocketCallBack)(CFSocketRef s, CFSocketCallBackType type, CFDataRef address, const void *data, void *info);
+/* If the callback wishes to keep hold of address or data after the point that it returns, then it must copy them. */
+
+typedef struct {
+    CFIndex	version;
+    void *	info;
+    const void *(*retain)(const void *info);
+    void	(*release)(const void *info);
+    CFStringRef	(*copyDescription)(const void *info);
+} CFSocketContext;
+
+#if TARGET_OS_WIN32
+typedef uintptr_t CFSocketNativeHandle;
+#else
+typedef int CFSocketNativeHandle;
+#endif
+
+CF_EXPORT CFTypeID	CFSocketGetTypeID(void);
+
+CF_EXPORT CFSocketRef	CFSocketCreate(CFAllocatorRef allocator, SInt32 protocolFamily, SInt32 socketType, SInt32 protocol, CFOptionFlags callBackTypes, CFSocketCallBack callout, const CFSocketContext *context);
+CF_EXPORT CFSocketRef	CFSocketCreateWithNative(CFAllocatorRef allocator, CFSocketNativeHandle sock, CFOptionFlags callBackTypes, CFSocketCallBack callout, const CFSocketContext *context);
+CF_EXPORT CFSocketRef	CFSocketCreateWithSocketSignature(CFAllocatorRef allocator, const CFSocketSignature *signature, CFOptionFlags callBackTypes, CFSocketCallBack callout, const CFSocketContext *context);
+/* CFSocketCreateWithSocketSignature() creates a socket of the requested type and binds its address (using CFSocketSetAddress()) to the requested address.  If this fails, it returns NULL. */
+CF_EXPORT CFSocketRef	CFSocketCreateConnectedToSocketSignature(CFAllocatorRef allocator, const CFSocketSignature *signature, CFOptionFlags callBackTypes, CFSocketCallBack callout, const CFSocketContext *context, CFTimeInterval timeout);
+/* CFSocketCreateConnectedToSocketSignature() creates a socket suitable for connecting to the requested type and address, and connects it (using CFSocketConnectToAddress()).  If this fails, it returns NULL. */
+
+CF_EXPORT CFSocketError	CFSocketSetAddress(CFSocketRef s, CFDataRef address);
+CF_EXPORT CFSocketError	CFSocketConnectToAddress(CFSocketRef s, CFDataRef address, CFTimeInterval timeout);
+CF_EXPORT void		CFSocketInvalidate(CFSocketRef s);
+
+CF_EXPORT Boolean	CFSocketIsValid(CFSocketRef s);
+CF_EXPORT CFDataRef	CFSocketCopyAddress(CFSocketRef s);
+CF_EXPORT CFDataRef	CFSocketCopyPeerAddress(CFSocketRef s);
+CF_EXPORT void		CFSocketGetContext(CFSocketRef s, CFSocketContext *context);
+CF_EXPORT CFSocketNativeHandle	CFSocketGetNative(CFSocketRef s);
+
+CF_EXPORT CFRunLoopSourceRef	CFSocketCreateRunLoopSource(CFAllocatorRef allocator, CFSocketRef s, CFIndex order);
+
+CF_EXPORT CFOptionFlags	CFSocketGetSocketFlags(CFSocketRef s);
+CF_EXPORT void		CFSocketSetSocketFlags(CFSocketRef s, CFOptionFlags flags);
+CF_EXPORT void		CFSocketDisableCallBacks(CFSocketRef s, CFOptionFlags callBackTypes);
+CF_EXPORT void		CFSocketEnableCallBacks(CFSocketRef s, CFOptionFlags callBackTypes);
+
+
+/* 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. */
+CF_EXPORT CFSocketError	CFSocketSendData(CFSocketRef s, CFDataRef address, CFDataRef data, CFTimeInterval timeout);
+
+/* 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.
+*/
+
+CF_EXPORT CFSocketError	CFSocketRegisterValue(const CFSocketSignature *nameServerSignature, CFTimeInterval timeout, CFStringRef name, CFPropertyListRef value);
+CF_EXPORT CFSocketError	CFSocketCopyRegisteredValue(const CFSocketSignature *nameServerSignature, CFTimeInterval timeout, CFStringRef name, CFPropertyListRef *value, CFDataRef *nameServerAddress);
+
+CF_EXPORT CFSocketError	CFSocketRegisterSocketSignature(const CFSocketSignature *nameServerSignature, CFTimeInterval timeout, CFStringRef name, const CFSocketSignature *signature);
+CF_EXPORT CFSocketError	CFSocketCopyRegisteredSocketSignature(const CFSocketSignature *nameServerSignature, CFTimeInterval timeout, CFStringRef name, CFSocketSignature *signature, CFDataRef *nameServerAddress);
+
+CF_EXPORT CFSocketError	CFSocketUnregister(const CFSocketSignature *nameServerSignature, CFTimeInterval timeout, CFStringRef name);
+
+CF_EXPORT void		CFSocketSetDefaultNameRegistryPortNumber(UInt16 port);
+CF_EXPORT UInt16	CFSocketGetDefaultNameRegistryPortNumber(void);
+
+/* Constants used in name registry server communications */
+CF_EXPORT const CFStringRef kCFSocketCommandKey;
+CF_EXPORT const CFStringRef kCFSocketNameKey;
+CF_EXPORT const CFStringRef kCFSocketValueKey;
+CF_EXPORT const CFStringRef kCFSocketResultKey;
+CF_EXPORT const CFStringRef kCFSocketErrorKey;
+CF_EXPORT const CFStringRef kCFSocketRegisterCommand;
+CF_EXPORT const CFStringRef kCFSocketRetrieveCommand;
+
+CF_EXTERN_C_END
+CF_IMPLICIT_BRIDGING_DISABLED
+
+#endif /* ! __COREFOUNDATION_CFSOCKET__ */
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFStorage.h

@@ -0,0 +1,296 @@
+/*	CFStorage.h
+	Copyright (c) 1999-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+/*!
+        @header CFStorage
+CFStorage stores an array of arbitrary-sized values. There are no callbacks;
+all that is provided about the values is the size, and the appropriate number
+of bytes are copied in and out of the CFStorage.
+
+CFStorage uses a balanced tree to store the values, and is most appropriate
+for situations where potentially a large number values (more than a hundred
+bytes' worth) will be stored and there will be a lot of editing (insertions and deletions).
+
+Getting to an item is O(log n), although caching the last result often reduces this
+to a constant time.
+
+The overhead of CFStorage is 48 bytes. There is no per item overhead; the 
+non-leaf nodes in the tree cost 20 bytes each, and the worst case extra
+capacity (unused space in the leaves) is 12%, typically much less.
+
+Because CFStorage does not necessarily use a single block of memory to store the values,
+when you ask for a value, you get back the pointer to the value and optionally
+the range of other values that are consecutive and thus reachable as if the
+storage was a single block.
+*/
+
+#if !defined(__COREFOUNDATION_CFSTORAGE__)
+#define __COREFOUNDATION_CFSTORAGE__ 1
+
+#include "CFBase.h"
+
+typedef CF_OPTIONS(CFOptionFlags, CFStorageEnumerationOptionFlags) {
+        kCFStorageEnumerationConcurrent = (1UL << 0) /* Allow enumeration to proceed concurrently */
+};
+
+CF_EXTERN_C_BEGIN
+
+/*!
+        @typedef CFStorageRef
+	This is the type of a reference to a CFStorage instance.
+*/
+typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFStorage *CFStorageRef;
+
+/*!
+	@typedef CFStorageApplierFunction
+	Type of the callback function used by the apply functions of
+		CFStorage.
+	@param val The current value from the storage.
+	@param context The user-defined context parameter given to the apply
+		function.
+*/
+typedef void (*CFStorageApplierFunction)(const void *val, void *context);
+
+/*!
+	@typedef CFStorageRangeApplierBlock
+	Type of the callback block used by the apply functions of
+	    CFStorage
+	@param val  A pointer to a range of values, numbering range.length
+	@param range The range of values.  This will always be a subrange of the range
+	    passed to the apply function.  Do not try to modify the contents of the vals pointer, because
+	    there is no guarantee it points into the contents of the CFStorage object.
+	 @param stop An "out" parameter that, if set to true from within the block, indicates that the enumeration may stop.
+ 
+*/
+#if __BLOCKS__
+typedef void (^CFStorageApplierBlock)(const void *vals, CFRange range, bool *stop);
+#endif
+
+/*!
+        @function CFStorageGetTypeID
+        Returns the type identifier of all CFStorage instances.
+*/
+CF_EXPORT CFTypeID CFStorageGetTypeID(void);
+
+/*!
+        @function CFStorageCreate
+        Creates a new mutable storage with elements of the given size.
+	@param alloc 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.
+	@param valueSizeInBytes The size in bytes of each of the elements 
+		to be stored in the storage.  If this value is zero or
+		negative, the result is undefined.
+	@result A reference to the new CFStorage instance.
+*/
+CF_EXPORT CFStorageRef CFStorageCreate(CFAllocatorRef alloc, CFIndex valueSizeInBytes);
+
+/*!
+	@function CFStorageInsertValues
+	Allocates space for range.length values at location range.location.  Use
+	 CFStorageReplaceValues() to set those values.
+	@param storage The storage to which the values are to be inserted.
+		If this parameter is not a valid CFStorage, the behavior is undefined.
+	@param range The range of values within the storage to insert. The
+ 		range location must be at least zero and not exceed the count of the storage.
+ 		Values at indexes equal to or greater than the range location have their indexes
+  		increased by the length of the range.  Thus this creates a gap in the storage
+  		 equal to the length of the given range.  If the range length is negative, the
+   		behavior is undefined. The range may be empty (length 0),
+  		 in which case there is no effect.
+   		
+*/
+CF_EXPORT void CFStorageInsertValues(CFStorageRef storage, CFRange range);
+
+/*!
+	@function CFStorageDeleteValues
+	Deletes the values of the storage in the specified range.
+	@param storage The storage from which the values are to be deleted.
+		If this parameter is not a valid CFStorage, the behavior is undefined.
+	@param range The range of values within the storage to delete. If the
+		range location or end point (defined by the location plus
+		length minus 1) are outside the index space of the storage (0
+		to N inclusive, where N is the count of the storage), 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 deleted.
+*/
+CF_EXPORT void CFStorageDeleteValues(CFStorageRef storage, CFRange range);
+
+/*!
+	@function CFStorageGetCount
+	Returns the number of values currently in the storage.
+	@param storage The storage to be queried. If this parameter is not a valid
+		CFStorage, the behavior is undefined.
+	@result The number of values in the storage.
+*/
+CF_EXPORT CFIndex CFStorageGetCount(CFStorageRef storage);
+
+/*!
+	@function CFStorageGetValueAtIndex
+		Returns a pointer to the specified value.  The pointer is mutable and may be used to
+		get or set the value.  This is considered to be a mutating function, and so calling this
+		while accessing the CFStorage from another thread is undefined behavior,
+ 		even if you do not set a value.  To access the CFStorage in a non-mutating
+  		manner, use the more efficient CFStorageGetConstValueAtIndex().
+	@param storage The storage to be queried. If this parameter is not a
+		valid CFStorage, the behavior is undefined.
+	@param idx The index of the value to retrieve. If the index is
+		outside the index space of the storage (0 to N-1 inclusive,
+		where N is the count of the storage), the behavior is
+		undefined.
+	@param validConsecutiveValueRange This parameter is a C pointer to a CFRange.
+		If NULL is specified, this argument is ignored; otherwise, the range
+		is set to the range of values that may be accessed via an offset from the result pointer.
+		The range location is set to the index of the lowest consecutive
+		value and the range length is set to the count of consecutive values.
+	@result The value with the given index in the storage.
+*/
+CF_EXPORT void *CFStorageGetValueAtIndex(CFStorageRef storage, CFIndex idx, CFRange *validConsecutiveValueRange);
+
+/*!
+	@function CFStorageGetConstValueAtIndex
+		Returns a pointer to the specified value.  The pointer is immutable and may
+		only be used to get the value.  This is not considered to be a mutating function,
+		so it is safe to call this concurrently with other non-mutating functions.  Furthermore,
+ 		this is often more efficient than CFStorageGetValueAtIndex(), so it should be used
+  		in preference to that function when possible.
+	@param storage The storage to be queried. If this parameter is not a
+		valid CFStorage, the behavior is undefined.
+	@param idx The index of the value to retrieve. If the index is
+		outside the index space of the storage (0 to N-1 inclusive,
+		where N is the count of the storage), the behavior is
+		undefined.
+	@param validConsecutiveValueRange This parameter is a C pointer to a CFRange.
+		If NULL is specified, this argument is ignored; otherwise, the range
+		is set to the range of values that may be accessed via an offset from the result pointer.
+		The range location is set to the index of the lowest consecutive
+		value and the range length is set to the count of consecutive values.
+	@result The value with the given index in the storage.
+*/
+CF_EXPORT const void *CFStorageGetConstValueAtIndex(CFStorageRef storage, CFIndex idx, CFRange *validConsecutiveValueRange);
+
+/*!
+        @function CFStorageGetValues
+	Fills the buffer with values from the storage.
+	@param storage The storage to be queried. If this parameter is not a
+		valid CFStorage, the behavior is undefined.
+	@param range The range of values within the storage to retrieve. If
+		the range location or end point (defined by the location
+		plus length minus 1) are outside the index space of the
+		storage (0 to N-1 inclusive, where N is the count of the
+		storage), 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.
+	@param values A C array of to be filled with values from the storage. 
+                The values in the C array are ordered
+		in the same order in which they appear in the storage. If this
+		parameter is not a valid pointer to a C array of at least
+		range.length pointers, the behavior is undefined.
+*/
+CF_EXPORT void CFStorageGetValues(CFStorageRef storage, CFRange range, void *values);
+
+/*!
+	@function CFStorageApplyFunction
+	Calls a function once for each value in the set.
+	@param storage The storage to be operated upon. If this parameter is not
+		a valid CFStorage, the behavior is undefined.
+	@param range The range of values within the storage to operate on. If the
+		range location or end point (defined by the location plus
+		length minus 1) are outside the index space of the storage (0
+		to N inclusive, where N is the count of the storage), 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 no values are operated on.
+	@param applier The callback function to call once for each value in
+		the given storage. If this parameter is not a
+		pointer to a function of the correct prototype, the behavior
+		is undefined. If there are values in the storage which the
+		applier function does not expect or cannot properly apply
+		to, the behavior is undefined. 
+	@param 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.
+*/
+CF_EXPORT void CFStorageApplyFunction(CFStorageRef storage, CFRange range, CFStorageApplierFunction CF_NOESCAPE applier, void *context);
+
+/*!
+	@function CFStorageApplyBlock
+	Enumerates ranges of stored objects with a block.
+ 	@param storage The storage to be operated upon. If this parameter is not
+		a valid CFStorage, the behavior is undefined.
+	 @param range The range of values within the storage to operate on. If the
+		 sum of the range location and length is larger than the
+		 count of the storage, the behavior is undefined.  If the
+		 range location or length is negative, the behavior is undefined.
+  	@param options Options controlling how the enumeration may proceed.
+  	@param applier The callback block.  The block is passed a pointer to
+		a buffer of contiguous objects in the storage, and the range of stored 
+		values represented by the buffer.  If the block modifies the 
+ 		contents of the buffer, the behavior is undefined.  If the block modifies
+  		the contents of the CFStorage, the behavior is undefined.
+ 
+ */
+#if __BLOCKS__
+CF_EXPORT void CFStorageApplyBlock(CFStorageRef storage, CFRange range, CFStorageEnumerationOptionFlags options, CFStorageApplierBlock CF_NOESCAPE applier);
+#endif
+
+
+/*!
+	@function CFStorageCreateWithSubrange
+	Returns a new CFStorage that contains a portion of an existing CFStorage.
+ 	@param storage The storage to be operated upon. If this parameter is not
+		a valid CFStorage, the behavior is undefined.
+	 @param range The range of values within the storage to operate on. If the
+		 sum of the range location and length is larger than the
+		 count of the storage, the behavior is undefined.  If the
+		 range location or length is negative, the behavior is undefined.
+ 	 @result A reference to a new CFStorage containing a byte-for-byte copy of
+		 the objects in the range.  This may use copy-on-write techniques
+ 		 to allow efficient implementation.
+ */
+CF_EXPORT CFStorageRef CFStorageCreateWithSubrange(CFStorageRef storage, CFRange range);
+
+/*!
+        @function CFStorageReplaceValues
+	Replaces a range of values in the storage.
+	@param storage The storage from which the specified values are to be
+		removed. If this parameter is not a valid CFStorage,
+		the behavior is undefined.
+	@param range The range of values within the storage to replace. If the
+		range location or end point (defined by the location plus
+		length minus 1) are outside the index space of the storage (0
+		to N inclusive, where N is the count of the storage), 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.
+	@param values A C array of the values to be copied into the storage. 
+		The new values in the storage are ordered in the same order 
+		in which they appear in this C array. This parameter may be NULL 
+		if the range length 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
+		range length pointers, the behavior is undefined.
+*/
+CF_EXPORT void CFStorageReplaceValues(CFStorageRef storage, CFRange range, const void *values);
+
+/* Private stuff...
+*/
+CF_EXPORT CFIndex __CFStorageGetCapacity(CFStorageRef storage);
+CF_EXPORT CFIndex __CFStorageGetValueSize(CFStorageRef storage);
+CF_EXPORT void __CFStorageSetAlwaysFrozen(CFStorageRef storage, bool alwaysFrozen);
+
+
+CF_EXTERN_C_END
+
+#endif /* ! __COREFOUNDATION_CFSTORAGE__ */
+