This is IXStore.h in view mode; [Download] [Up]
/*
IXStore.h
Copyright 1991, NeXT Computer, Inc.
*/
#import "protocols.h"
#import <mach/mach.h>
#import <objc/hashtable.h>
#import <objc/Object.h>
@class NXData;
/* This pasteboard type is used to copy store images created by */
/* getContents:andLength: between processes via the pasteboard server.*/
extern NXAtom IXStorePboardType;
@interface IXStore: Object
{
@public
unsigned changeCount;
@private
unsigned nestingLevel;
struct StoreBlockServer *blockServer;
struct StoreBroker *storeBroker;
struct StoreTransRecord *queueForward;
struct StoreTransRecord *queueReverse;
struct {
unsigned exceptions:1;
unsigned freeOnWrite:1;
unsigned RESERVED1:30;
} _storeStatus;
}
/* These two methods set and report the interface error reporting policy. For */
/* compatibility with 3.0 FCS, most of the methods implemented by this class */
/* raise an exception when passed an invalid argument, such as an invalid block */
/* handle. This can be quite cumbersome to use. When exceptions are disabled, */
/* the method return values indicate success or failure.*/
- enableExceptions:(BOOL)aBoolean;
- (BOOL)areExceptionsEnabled;
/* Copying a store creates an independent concurrent context. The number of */
/* contexts is limited only by resource consumption. Changes made by one */
/* context do not affect another context until they are committed.*/
- copy;
/* The underlying objects shared by all contexts are reference counted. When */
/* the last context is freed, the underlying objects are also freed. Freeing */
/* the underlying objects destroys the contents of the store.*/
- free;
- init; /* Creates a memory based store.*/
/* These two methods are used when archiving stores. If freeOnWrite is sent, */
/* the receiver will free itsself after archiving. willFreeOnWrite returns */
/* true if the receiver will free itsself after archiving.*/
- freeOnWrite;
- (BOOL)willFreeOnWrite;
/* The effects of methods that create and free blocks are delayed until */
/* transaction commit, even if transactions are not enabled.*/
/* Opening or resizing a block locks it against access by other contexts. */
/* Closing a block unlocks it, unless transactions are enabled and the block */
/* has been modified; in that case, the close is deferred until transaction */
/* commit. Blocks are closed automatically when the opening transaction ends.*/
/* Attempting to open or resize a locked block will result in an IX_LockedError */
/* exception. This permits the implementation of a two phase locking strategy. */
/* Creates a new block of the requested size. A block size of zero is valid.*/
/* The contents of the block are initialized to zero. Returns the block handle*/
/* by reference.*/
- createBlock:(unsigned *)handle ofSize:(unsigned)size;
/* Frees an existing block. Once freed, the block may not be operated upon */
/* except by closeBlock: or abortBlock:, unless the transaction is aborted. */
/* Returns self, or nil if the supplied handle is invalid.*/
- freeBlock:(unsigned)handle;
- (BOOL)blockExists:(unsigned)blockHandle; /* tests existence of the block*/
- abortBlock:(unsigned)handle; /* aborts all changes to the block*/
- closeBlock:(unsigned)handle; /* commits all changes and closes the block*/
/* Copies the designated block, returning the handle of the copy, or zero if */
/* the supplied handle is not valid.*/
- (unsigned)copyBlock:(unsigned)handle
atOffset:(unsigned)offset forLength:(unsigned)length;
/* These two methods return a pointer to the contents of the designated block, */
/* or NULL if the supplied handle is invalid. openBlock:atOffset:forLength: */
/* copies the block first, if transactions are enabled, and returns a pointer */
/* to the copy. readBlock:atOffset:forLength: does not copy the block.*/
- (void *)openBlock:(unsigned)handle
atOffset:(unsigned)offset forLength:(unsigned)length;
- (void *)readBlock:(unsigned)handle
atOffset:(unsigned)offset forLength:(unsigned)length;
/* This method copies data into a block in the store in the most efficient */
/* manner possible. Data should never by copied into a block with vm_copy, */
/* unless the store is known to be a member of the class IXStore, since the*/
/* subclasses of IXStore may use file paging that does not support vm_copy.*/
- copyData:(void *)data toBlock:(unsigned)handle
atOffset:(unsigned)offset forLength:(unsigned)length;
/* These two methods are designed to permit a store to be used over the wire. */
/* exportBlock:atOffset:forLength: returns an NXData containing the contents */
/* of the block. importBlock:atOffset:forLength: takes an NXData containing */
/* the new contents of the block, and opens the block for writing, then copies */
/* from the NXData to the contents of the block.*/
- (NXData *)exportBlock:(unsigned)handle
atOffset:(unsigned)offset forLength:(unsigned)length;
- importBlock:(unsigned)handle
atOffset:(unsigned)offset fromData:(NXData *)data;
/* These two methods report and modify the size of a block, respectively. A */
/* size of zero is valid; there are no contents associated with a block of zero */
/* size. Resizing a block locks the block, and may cause the block's in memory */
/* location to change. If the block must be accessed after resizing, it should */
/* be reopened to obtain a pointer to the new in memory location. The contents */
/* of the newly created portion of a block that grows are zeroed.*/
- (unsigned)sizeOfBlock:(unsigned)handle;
- resizeBlock:(unsigned)handle toSize:(unsigned)size;
/* By default, transactions are disabled. Starting the first transaction */
/* permanently enables them. There is a performance penalty for enabling */
/* transactions, since blocks must be copied before they can be modified when */
/* transactions are enabled. With transactions disabled, aborting a block or */
/* transaction is equivalent to committing the block or transaction.*/
/* When transactions are enabled, calls to startTransaction are optional, */
/* since a new transaction is automatically started by the first operation that */
/* modifies the contents of the store. Calling startTransaction more than once */
/* before a call to commitTransaction or abortTransaction causes nesting. The */
/* nesting level is returned by startTransaction. Within a nested transaction, */
/* the effects of createBlock:ofSize: and freeBlock: are reversible relative to */
/* the enclosing transaction, as are all changes made to blocks opened by the */
/* nested transaction. When a nested transaction is committed, its results are */
/* carried into the enclosing transaction as modifications.*/
- (unsigned)startTransaction;
- abortTransaction;
- commitTransaction;
- (unsigned)nestingLevel; /* returns the transaction nesting level*/
- (BOOL)areTransactionsEnabled; /* true if transactions are already enabled*/
- (int)changeCount; /* increases by one for each commit or abort transaction*/
/* Returns the number of blocks in the store, taking into account changes */
/* pending in the receiving context.*/
- (unsigned)count;
/* Returns the largest valid block handle; this provides an upper bound on */
/* valid block handles, useful for iterating over all blocks in the store.*/
- (unsigned)capacity;
/* Frees all blocks in the store. This method starts and commits a private */
/* transaction, if transactions are enabled. The private transaction will be */
/* nested within any outstanding transactions.*/
- empty;
/* These methods remove free space by relocating blocks toward the origin of */
/* the virtual address space defined by the store. A timeout of zero allows */
/* the compaction to run to completion.*/
- compact;
- compactWithTimeout:(int)msecs;
/* The resident size limit restricts the amount of backing store that may */
/* remain mapped between transactions. Note that it does not affect the amount */
/* of backing store that may be mapped during the course of a transaction. A */
/* size of zero indicates that the resident size is unlimited.*/
- setSizeLimit:(vm_size_t)limit;
- (vm_size_t)sizeLimit;
- (vm_size_t)apparentSize; /* size of the backing store's virtual address space*/
- (vm_size_t)residentSize; /* the amount of backing store that is mapped*/
/* These two methods create and install virtual memory images of stores; this */
/* is the most efficient way to copy stores. The images are virtual memory */
/* snap shots; if a store is modified after an image is created, the image will */
/* diverge from the store via copy- on- write.*/
- getContents:(vm_address_t *)data andLength:(vm_size_t *)length;
- setContents:(vm_address_t)data andLength:(vm_size_t)length;
/* This is a cover for the two preceding methods for copying one store to another.*/
- copyFromStore:(IXStore *)aStore;
@end
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.