MemStrategy (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- com.bigdata.rwstore.sector.MemStrategy

All Implemented Interfaces:

ICounterSetAccess, IBufferStrategy, IAddressManager, IAllocationManagerStore, IMRMW, IMROW, IRawStore, IStreamStore, IAllocationManager, IHistoryManager, IRWStrategy
```
public class MemStrategy
extends Object
implements IBufferStrategy, IRWStrategy, IAllocationManagerStore
```
A buffer implementation backed by an IMemoryManager.

Version:

$Id$

Author:

Martyn Cutcher

Field Summary
- Fields inherited from interface com.bigdata.rawstore.IAddressManager
  NULL

Constructor Summary

Constructors
Constructor and Description

MemStrategy(IMemoryManager mmgr)

Constructors
Constructor and Description
`MemStrategy(IMemoryManager mmgr)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abort()` A method that requires the implementation to discard its buffered write set (if any).
`void`	`abortContext(IAllocationContext context)` Indicates that the allocation context will no longer be used and that the allocations made within the context should be discarded.
`int`	`checkDeferredFrees(AbstractJournal abstractJournal)` This method is invoked during the commit protocol and gives the backing store an opportunity to check whether storage associated with deferred frees can now be released.
`void`	`close()` Close the store immediately.
`void`	`closeForWrites()` Seals the store against further writes and discards any write caches since they will no longer be used.
`void`	`commit()` A method that removes assumptions of how a specific strategy commits data.
`void`	`delete(long addr)` Delete the data (unisolated).
`void`	`delete(long addr, IAllocationContext context)` Delete the data associated with the address within the allocation context.
`void`	`deleteResources()` Deletes the backing file(s) (if any).
`void`	`destroy()` Closes the store immediately (if open) and deletes its persistent resources.
`void`	`detachContext(IAllocationContext context)` Indicates that the allocation context will no longer be used, but that the allocations made within the context should be preserved.
`void`	`force(boolean metadata)` Force the data to stable storage.
`IAddressManager`	`getAddressManager()`
`BufferMode`	`getBufferMode()` The buffer mode supported by the implementation
`int`	`getByteCount(long addr)` The length of the datum in bytes.
`Lock`	`getCommitLock()` Optionally return a `Lock` that must be used (when non- `null`) to make the `IBufferStrategy.commit()` / `IRWStrategy.postCommit()` strategy atomic.
`CounterSet`	`getCounters()` Return the performance counter hierarchy.
`long`	`getExtent()` The current size of the journal in bytes.
`File`	`getFile()` The backing file -or- `null` if there is no backing file for the store.
`int`	`getHeaderSize()` The size of the journal header, including MAGIC, version, and both root blocks.
`long`	`getInitialExtent()` The initial extent.
`InputStream`	`getInputStream(long addr)` Return an input stream from which a previously written stream may be read back.
`long`	`getLastReleaseTime()` If history is retained this returns the time for which data was most recently released.
`long`	`getMaximumExtent()` The maximum extent allowable before a buffer overflow operation will be rejected.
`int`	`getMaxRecordSize()`
`long`	`getMetaBitsAddr()` The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access.
`long`	`getMetaStartAddr()` The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access.
`long`	`getNextOffset()` The next offset at which a data item would be written on the store as an offset into the user extent.
`long`	`getOffset(long addr)` The offset on the store at which the datum is stored.
`int`	`getOffsetBits()`
`IPSOutputStream`	`getOutputStream()` Return an output stream which can be used to write on the backing store.
`IPSOutputStream`	`getOutputStream(IAllocationContext context)` Return an output stream which can be used to write on the backing store within the given allocation context.
`long`	`getPhysicalAddress(long addr)` Determine the unencoded physical address
`IResourceMetadata`	`getResourceMetadata()` A description of this store in support of the scale-out architecture.
`IMemoryManager`	`getStore()` Return the backing `IStore`.
`long`	`getUserExtent()` The size of the user data extent in bytes.
`UUID`	`getUUID()` Return the `UUID` which identifies this `IRawStore`.
`boolean`	`isCommitted(long addr)` Return `true` iff the allocation having that address is flagged as committed.
`boolean`	`isDirty()` Return `true` if the store has been modified since the last `IBufferStrategy.commit()` or `IBufferStrategy.abort()`.
`boolean`	`isFullyBuffered()` True iff the store is fully buffered (all reads are against memory).
`boolean`	`isOpen()` `true` iff the store is open.
`boolean`	`isReadOnly()` `true` iff the store does not allow writes.
`boolean`	`isStable()` True iff backed by stable storage.
`IAllocationContext`	`newAllocationContext(boolean isolated)` Creates a context to be used to isolate updates to within the context until it is released to the parent environment.
`IRawTx`	`newTx()` A hook used to support session protection by incrementing and decrementing a transaction counter within the `IStore`.
`void`	`postCommit()` Called post commit to dispose any transient commit state retained to support reset/rollback.
`ByteBuffer`	`read(long addr)` Read the data (unisolated).
`ByteBuffer`	`readRootBlock(boolean rootBlock0)` Read the specified root block from the backing file.
`void`	`registerExternalCache(ConcurrentWeakValueCache<Long,ICommitter> historicalIndexCache, int byteCount)` Call made from AbstractJournal to register the cache used.
`boolean`	`requiresCommit(IRootBlockView block)` A method that removes assumptions of how a specific strategy determines whether a transaction commit is required.
`long`	`saveDeferrals()` Saves the current list of delete blocks, returning the address allocated.
`long`	`size()` The #of application data bytes written on the store (does not count any headers or root blocks that may exist for the store).
`long`	`toAddr(int nbytes, long offset)` Converts a byte count and offset into a long integer.
`String`	`toString(long addr)` A human readable representation of the address.
`long`	`transferTo(RandomAccessFile out)` A block operation that transfers the serialized records (aka the written on portion of the user extent) en mass from the buffer onto an output file.
`void`	`truncate(long extent)` Either truncates or extends the journal.
`boolean`	`useChecksums()` Return `true` if the store uses per-record checksums.
`long`	`write(ByteBuffer data)` Write the data (unisolated).
`long`	`write(ByteBuffer data, IAllocationContext context)` FIXME There are two unit tests for the `MemStore` which are failing due to this method not being implemented.
`void`	`writeRootBlock(IRootBlockView rootBlock, ForceEnum forceOnCommitEnum)` Write the root block onto stable storage (ie, flush it through to disk).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - MemStrategy
```
public MemStrategy(IMemoryManager mmgr)
```
- Method Detail
  - getStore
```
public IMemoryManager getStore()
```
    Description copied from interface: IRWStrategy
    
    Return the backing IStore.
    
    Specified by:
    
    getStore in interface IRWStrategy
  - abort
```
public void abort()
```
    Description copied from interface: IBufferStrategy
    
    A method that requires the implementation to discard its buffered write set (if any). The caller is responsible for any necessary synchronization as part of the abort protocol.
    
    Specified by:
    
    abort in interface IBufferStrategy
  - closeForWrites
```
public void closeForWrites()
```
    Description copied from interface: IBufferStrategy
    
    Seals the store against further writes and discards any write caches since they will no longer be used. Buffered writes are NOT forced to the disk so the caller SHOULD be able to guarantee that concurrent writers are NOT running. The method should be implemented such that concurrent readers are NOT disturbed.
    
    Specified by:
    
    closeForWrites in interface IBufferStrategy
  - commit
```
public void commit()
```
    Description copied from interface: IBufferStrategy
    
    A method that removes assumptions of how a specific strategy commits data. For most strategies the action is void since the client WORM DISK strategy writes data as allocated. For the Read Write Strategy more data must be managed as part of the protocol outside of the RootBlock, and this is the method that triggers that management. The caller MUST provide appropriate synchronization.
    
    Specified by:
    
    commit in interface IBufferStrategy
  - getCommitLock
```
public Lock getCommitLock()
```
    Description copied from interface: IRWStrategy
    
    Optionally return a Lock that must be used (when non- null) to make the IBufferStrategy.commit() / IRWStrategy.postCommit() strategy atomic.
    
    Specified by:
    
    getCommitLock in interface IRWStrategy
  - postCommit
```
public void postCommit()
```
    Description copied from interface: IRWStrategy
    
    Called post commit to dispose any transient commit state retained to support reset/rollback.
    Note: It is the responsibility of the commit protocol layers to wind up calling IBufferStrategy.abort() if there is a failure during the commit protocol.
    
    Specified by:
    
    postCommit in interface IRWStrategy
  - getAddressManager
```
public IAddressManager getAddressManager()
```
    Specified by:
    
    getAddressManager in interface IBufferStrategy
  - getBufferMode
```
public BufferMode getBufferMode()
```
    Description copied from interface: IBufferStrategy
    
    The buffer mode supported by the implementation
    
    Specified by:
    
    getBufferMode in interface IBufferStrategy
    
    Returns:
    The implemented buffer mode.
  - getCounters
```
public CounterSet getCounters()
```
    Description copied from interface: IBufferStrategy
    
    Return the performance counter hierarchy.
    
    Specified by:
    
    getCounters in interface ICounterSetAccess
    
    Specified by:
    
    getCounters in interface IBufferStrategy
  - getExtent
```
public long getExtent()
```
    Description copied from interface: IBufferStrategy
    
    The current size of the journal in bytes. When the journal is backed by a disk file this is the actual size on disk of that file. The initial value for this property is set by Options.INITIAL_EXTENT.
    
    Specified by:
    
    getExtent in interface IBufferStrategy
  - getHeaderSize
```
public int getHeaderSize()
```
    Description copied from interface: IBufferStrategy
    
    The size of the journal header, including MAGIC, version, and both root blocks. This is used as an offset when computing the address of a record in an underlying file and is ignored by buffer modes that are not backed by a file (e.g., transient) or that are memory mapped (since the map is setup to skip over the header)
    
    Specified by:
    
    getHeaderSize in interface IBufferStrategy
  - getInitialExtent
```
public long getInitialExtent()
```
    Description copied from interface: IBufferStrategy
    
    The initial extent.
    
    Specified by:
    
    getInitialExtent in interface IBufferStrategy
  - getMaxRecordSize
```
public int getMaxRecordSize()
```
    Specified by:
    
    getMaxRecordSize in interface IBufferStrategy
    
    Returns:
    the maximum record size supported by this strategy
  - getMaximumExtent
```
public long getMaximumExtent()
```
    Description copied from interface: IBufferStrategy
    
    The maximum extent allowable before a buffer overflow operation will be rejected.
    Note: The semantics here differ from those defined by Options.MAXIMUM_EXTENT. The latter specifies the threshold at which a journal will overflow (onto another journal) while this specifies the maximum size to which a buffer is allowed to grow.
    Note: This is normally zero (0L), which basically means that the maximum extent is ignored by the IBufferStrategy but respected by the AbstractJournal, resulting in a soft limit on journal overflow.
    
    Specified by:
    
    getMaximumExtent in interface IBufferStrategy
    
    Returns:
    The maximum extent permitted for the buffer -or- 0L iff no limit is imposed.
  - getMetaBitsAddr
```
public long getMetaBitsAddr()
```
    Description copied from interface: IBufferStrategy
    
    The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access. The metaBitsAddr is the address in the file where the metaBits that control the allocation of the allocation blocks themselves is stored.
    
    Specified by:
    
    getMetaBitsAddr in interface IBufferStrategy
    
    Returns:
    the metaBitsAddr for the root block if any
  - getMetaStartAddr
```
public long getMetaStartAddr()
```
    Description copied from interface: IBufferStrategy
    
    The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access. The metaStartAddr is the address in the file where the allocation blocks are stored.
    
    Specified by:
    
    getMetaStartAddr in interface IBufferStrategy
    
    Returns:
    the metaStartAddr for the root block if any
  - getNextOffset
```
public long getNextOffset()
```
    Description copied from interface: IBufferStrategy
    
    The next offset at which a data item would be written on the store as an offset into the user extent.
    
    Specified by:
    
    getNextOffset in interface IBufferStrategy
  - getOffsetBits
```
public int getOffsetBits()
```
    Specified by:
    
    getOffsetBits in interface IBufferStrategy
    
    Returns:
    the number of bits available in the address to define offset
  - getUserExtent
```
public long getUserExtent()
```
    Description copied from interface: IBufferStrategy
    
    The size of the user data extent in bytes.
    Note: The size of the user extent is always generally smaller than the value reported by IBufferStrategy.getExtent() since the latter also reports the space allocated to the journal header and root blocks.
    
    Specified by:
    
    getUserExtent in interface IBufferStrategy
  - readRootBlock
```
public ByteBuffer readRootBlock(boolean rootBlock0)
```
    Description copied from interface: IBufferStrategy
    
    Read the specified root block from the backing file.
    
    Specified by:
    
    readRootBlock in interface IBufferStrategy
  - requiresCommit
```
public boolean requiresCommit(IRootBlockView block)
```
    Description copied from interface: IBufferStrategy
    
    A method that removes assumptions of how a specific strategy determines whether a transaction commit is required.
    
    Specified by:
    
    requiresCommit in interface IBufferStrategy
    
    Parameters:
    block - The root block held by the client, can be checked against the state of the Buffer Strategy
    
    Returns:
    whether any modification has occurred.
  - transferTo
```
public long transferTo(RandomAccessFile out)
                throws IOException
```
    Description copied from interface: IBufferStrategy
    
    A block operation that transfers the serialized records (aka the written on portion of the user extent) en mass from the buffer onto an output file. The buffered records are written "in order" starting at the current position on the output file. The file is grown if necessary. The file position is advanced to the last byte written on the file.
    Note: Implementations of this method MUST be synchronized so that the operation is atomic with respect to concurrent writers.
    
    Specified by:
    
    transferTo in interface IBufferStrategy
    
    Parameters:
    out - The file to which the buffer contents will be transferred.
    
    Returns:
    The #of bytes written.
    
    Throws:
    
    IOException
  - truncate
```
public void truncate(long extent)
```
    Description copied from interface: IBufferStrategy
    
    Either truncates or extends the journal.
    Note: Implementations of this method MUST be synchronized so that the operation is atomic with respect to concurrent writers.
    
    Specified by:
    
    truncate in interface IBufferStrategy
    
    Parameters:
    extent - The new extent of the journal. This value represent the total extent of the journal, including any root blocks together with the user extent.
  - useChecksums
```
public boolean useChecksums()
```
    Description copied from interface: IBufferStrategy
    
    Return true if the store uses per-record checksums. When true, an additional 4 bytes are written after the record on the disk. Those bytes contain the checksum of the record.
    
    Specified by:
    
    useChecksums in interface IBufferStrategy
  - writeRootBlock
```
public void writeRootBlock(IRootBlockView rootBlock,
                  ForceEnum forceOnCommitEnum)
```
    Description copied from interface: IBufferStrategy
    
    Write the root block onto stable storage (ie, flush it through to disk).
    
    Specified by:
    
    writeRootBlock in interface IBufferStrategy
    
    Parameters:
    rootBlock - The root block. Which root block is indicated by IRootBlockView.isRootBlock0().
  - close
```
public void close()
```
    Description copied from interface: IRawStore
    
    Close the store immediately.
    
    Specified by:
    
    close in interface IRawStore
  - delete
```
public void delete(long addr)
```
    Description copied from interface: IRawStore
    
    Delete the data (unisolated).
    After this operation subsequent reads on the address MAY fail and the caller MUST NOT depend on the ability to read at that address.
    
    Specified by:
    
    delete in interface IRawStore
    
    Parameters:
    addr - A long integer formed using Addr that encodes both the offset at which the data was written and the #of bytes that were written.
  - deleteResources
```
public void deleteResources()
```
    Description copied from interface: IRawStore
    
    Deletes the backing file(s) (if any).
    
    Specified by:
    
    deleteResources in interface IRawStore
  - destroy
```
public void destroy()
```
    Description copied from interface: IRawStore
    
    Closes the store immediately (if open) and deletes its persistent resources. Does NOT throw an IllegalStateException if the store is already closed, but still deletes the backing resources.
    
    Specified by:
    
    destroy in interface IRawStore
    
    See Also:
    IRawStore.deleteResources()
  - force
```
public void force(boolean metadata)
```
    Description copied from interface: IRawStore
    
    Force the data to stable storage. While this is NOT sufficient to guarantee an atomic commit, the data must be forced to disk as part of an atomic commit protocol.
    
    Specified by:
    
    force in interface IRawStore
    
    Parameters:
    metadata - If true, then force both the file contents and the file metadata to disk.
  - getFile
```
public File getFile()
```
    Description copied from interface: IRawStore
    
    The backing file -or- null if there is no backing file for the store.
    
    Specified by:
    
    getFile in interface IRawStore
  - getResourceMetadata
```
public IResourceMetadata getResourceMetadata()
```
    Description copied from interface: IRawStore
    
    A description of this store in support of the scale-out architecture.
    
    Specified by:
    
    getResourceMetadata in interface IRawStore
  - getUUID
```
public UUID getUUID()
```
    Description copied from interface: IRawStore
    
    Return the UUID which identifies this IRawStore. This supports IRawStore.getResourceMetadata().
    
    Specified by:
    
    getUUID in interface IRawStore
  - isFullyBuffered
```
public boolean isFullyBuffered()
```
    Description copied from interface: IRawStore
    
    True iff the store is fully buffered (all reads are against memory). Implementations MAY change the value returned by this method over the life cycle of the store, e.g., to conserve memory a store may drop or decrease its buffer if it is backed by disk.
    Note: This does not guarantee that the OS will not swap the buffer onto disk.
    
    Specified by:
    
    isFullyBuffered in interface IRawStore
  - isOpen
```
public boolean isOpen()
```
    Description copied from interface: IRawStore
    
    true iff the store is open.
    
    Specified by:
    
    isOpen in interface IRawStore
    
    Returns:
    true iff the store is open.
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: IRawStore
    
    true iff the store does not allow writes.
    
    Specified by:
    
    isReadOnly in interface IRawStore
  - isStable
```
public boolean isStable()
```
    Description copied from interface: IRawStore
    
    True iff backed by stable storage.
    
    Specified by:
    
    isStable in interface IRawStore
  - read
```
public ByteBuffer read(long addr)
```
    Description copied from interface: IRawStore
    
    Read the data (unisolated).
    
    Specified by:
    
    read in interface IRawStore
    
    Parameters:
    addr - A long integer that encodes both the offset from which the data will be read and the #of bytes to be read. See IAddressManager.toAddr(int, long).
    
    Returns:
    The data read. The buffer will be flipped to prepare for reading (the position will be zero and the limit will be the #of bytes read).
  - size
```
public long size()
```
    Description copied from interface: IRawStore
    
    The #of application data bytes written on the store (does not count any headers or root blocks that may exist for the store).
    
    Specified by:
    
    size in interface IRawStore
  - write
```
public long write(ByteBuffer data)
```
    Description copied from interface: IRawStore
    
    Write the data (unisolated).
    
    Specified by:
    
    write in interface IRawStore
    
    Parameters:
    data - The data. The bytes from the current Buffer.position() to the Buffer.limit() will be written and the Buffer.position() will be advanced to the Buffer.limit() . The caller may subsequently modify the contents of the buffer without changing the state of the store (i.e., the data are copied into the store).
    
    Returns:
    A long integer formed that encodes both the offset from which the data may be read and the #of bytes to be read. See IAddressManager.
  - getByteCount
```
public int getByteCount(long addr)
```
    Description copied from interface: IAddressManager
    
    The length of the datum in bytes. This must be the actual length of the record on the disk, not the length of the caller's byte[]. This is necessary in order to support transparent checksums and/or compression for records in the IRawStore.
    
    Specified by:
    
    getByteCount in interface IAddressManager
    
    Parameters:
    addr - The opaque identifier that is the within store locator for some datum.
    
    Returns:
    The offset of that datum.
  - getOffset
```
public long getOffset(long addr)
```
    Description copied from interface: IAddressManager
    
    The offset on the store at which the datum is stored. While this is often the offset of a byte into a file on disk, implementations MAY assign offsets using other strategies.
    
    Specified by:
    
    getOffset in interface IAddressManager
    
    Parameters:
    addr - The opaque identifier that is the within store locator for some datum.
    
    Returns:
    The offset of that datum.
  - getPhysicalAddress
```
public long getPhysicalAddress(long addr)
```
    Description copied from interface: IAddressManager
    
    Determine the unencoded physical address
    
    Specified by:
    
    getPhysicalAddress in interface IAddressManager
    
    Parameters:
    addr - The encoded address
    
    Returns:
    an unencoded address offset
  - toAddr
```
public long toAddr(int nbytes,
          long offset)
```
    Description copied from interface: IAddressManager
    
    Converts a byte count and offset into a long integer.
    
    Specified by:
    
    toAddr in interface IAddressManager
    
    Parameters:
    nbytes - The byte count.
    offset - The byte offset.
    
    Returns:
    The long integer.
  - toString
```
public String toString(long addr)
```
    Description copied from interface: IAddressManager
    
    A human readable representation of the address.
    
    Specified by:
    
    toString in interface IAddressManager
    
    Parameters:
    addr - The opaque identifier that is the within store locator for some datum.
    
    Returns:
    A human readable representation.
  - newTx
```
public IRawTx newTx()
```
    Description copied from interface: IHistoryManager
    
    A hook used to support session protection by incrementing and decrementing a transaction counter within the IStore. As long as a transaction is active we can not release data which is currently marked as freed but was committed at the point the session started.
    
    Specified by:
    
    newTx in interface IHistoryManager
  - abortContext
```
public void abortContext(IAllocationContext context)
```
    Description copied from interface: IAllocationManager
    
    Indicates that the allocation context will no longer be used and that the allocations made within the context should be discarded. The allocations associated with the context are discarded, as are any deletes made within the scope of that allocation context. The allocators associated with the allocation context are return to the global list of available allocators.
    
    Specified by:
    
    abortContext in interface IAllocationManager
    
    Parameters:
    context - The application object which serves as the allocation context.
  - detachContext
```
public void detachContext(IAllocationContext context)
```
    Description copied from interface: IAllocationManager
    
    Indicates that the allocation context will no longer be used, but that the allocations made within the context should be preserved. The allocations associated with the context are propagated to the parent allocation context. The IStore is the top-level parent of allocation contexts. The allocators associated with the allocation context are return to the global list of available allocators.
    
    Specified by:
    
    detachContext in interface IAllocationManager
    
    Parameters:
    context - The application object which serves as the allocation context.
  - checkDeferredFrees
```
public int checkDeferredFrees(AbstractJournal abstractJournal)
```
    Description copied from interface: IHistoryManager
    
    This method is invoked during the commit protocol and gives the backing store an opportunity to check whether storage associated with deferred frees can now be released. The backing store needs to reply the deferred free blocks for the commit points that will be released, mark those addresses as free, and free the logged delete blocks.
    
    Specified by:
    
    checkDeferredFrees in interface IHistoryManager
    
    Returns:
    number of addresses freed
    See Also:
    AbstractJournal#commitNow()
  - delete
```
public void delete(long addr,
          IAllocationContext context)
```
    Description copied from interface: IAllocationManagerStore
    
    Delete the data associated with the address within the allocation context. The delete is not visible outside of the allocation until the allocation context has been merged into the parent allocation context.
    
    Specified by:
    
    delete in interface IAllocationManagerStore
    
    Parameters:
    addr - The address whose allocation is to be deleted.
    context - The allocation context.
  - getLastReleaseTime
```
public long getLastReleaseTime()
```
    Description copied from interface: IHistoryManager
    
    If history is retained this returns the time for which data was most recently released. No request can be made for data earlier than this.
    
    Specified by:
    
    getLastReleaseTime in interface IHistoryManager
    
    Returns:
    latest data release time
  - registerExternalCache
```
public void registerExternalCache(ConcurrentWeakValueCache<Long,ICommitter> historicalIndexCache,
                         int byteCount)
```
    Description copied from interface: IHistoryManager
    
    Call made from AbstractJournal to register the cache used. This can then be accessed to clear entries when storage is made available for re-cycling.
    Note: It is not safe to clear at the point of the delete request since the data could still be loaded if the data is retained for a period due to a non-zero retention period or session protection.
    
    Specified by:
    
    registerExternalCache in interface IHistoryManager
  - saveDeferrals
```
public long saveDeferrals()
```
    Description copied from interface: IHistoryManager
    
    Saves the current list of delete blocks, returning the address allocated. This can be used later to retrieve the addresses of allocations to be freed.
    Writes the content of currentTxnFreeList to the store.
    These are the current buffered frees that have yet been saved into a block referenced from the deferredFreeList
    
    Specified by:
    
    saveDeferrals in interface IHistoryManager
    
    Returns:
    the address of the deferred addresses saved on the store, or zero if none.
    See Also:
    DeleteBlockCommitter
  - write
```
public long write(ByteBuffer data,
         IAllocationContext context)
```
    FIXME There are two unit tests for the MemStore which are failing due to this method not being implemented. Those methods are using an abstract task within an isolated action journal context.
    
    Specified by:
    
    write in interface IAllocationManagerStore
    
    Parameters:
    data - The data.
    context - The allocation context.
    
    Returns:
    The address at which the data was written.
  - isCommitted
```
public boolean isCommitted(long addr)
```
    Description copied from interface: IRWStrategy
    
    Return true iff the allocation having that address is flagged as committed. The caller must be holding the allocation lock in order for the result to remain valid outside of the method call.
    
    Specified by:
    
    isCommitted in interface IRWStrategy
    
    Parameters:
    addr - The address.
    
    Returns:
    true iff the address is currently committed.
  - getInputStream
```
public InputStream getInputStream(long addr)
```
    Description copied from interface: IStreamStore
    
    Return an input stream from which a previously written stream may be read back.
    
    Specified by:
    
    getInputStream in interface IStreamStore
    
    Parameters:
    addr - The address at which the stream was written.
    
    Returns:
    an input stream for the data for provided address
  - getOutputStream
```
public IPSOutputStream getOutputStream()
```
    Description copied from interface: IStreamStore
    
    Return an output stream which can be used to write on the backing store. You can recover the address used to read back the data from the IPSOutputStream.
    
    Specified by:
    
    getOutputStream in interface IStreamStore
    
    Returns:
    The output stream.
  - getOutputStream
```
public IPSOutputStream getOutputStream(IAllocationContext context)
```
    Description copied from interface: IAllocationManagerStore
    
    Return an output stream which can be used to write on the backing store within the given allocation context. You can recover the address used to read back the data from the IPSOutputStream.
    
    Specified by:
    
    getOutputStream in interface IAllocationManagerStore
    
    Parameters:
    context - The context within which any allocations are made by the returned IPSOutputStream.
    
    Returns:
    an output stream to stream data to and to retrieve an address to later stream the data back.
  - isDirty
```
public boolean isDirty()
```
    Description copied from interface: IBufferStrategy
    
    Return true if the store has been modified since the last IBufferStrategy.commit() or IBufferStrategy.abort().
    
    Specified by:
    
    isDirty in interface IBufferStrategy
    
    Returns:
    true if store has been modified since last IBufferStrategy.commit() or IBufferStrategy.abort().
  - newAllocationContext
```
public IAllocationContext newAllocationContext(boolean isolated)
```
    Description copied from interface: IAllocationManager
    
    Creates a context to be used to isolate updates to within the context until it is released to the parent environment.
    
    Specified by:
    
    newAllocationContext in interface IAllocationManager
    
    Returns:
    a new IAlocationContext

Class MemStrategy

Field Summary

Fields inherited from interface com.bigdata.rawstore.IAddressManager

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MemStrategy

Method Detail

getStore

abort

closeForWrites

commit

getCommitLock

postCommit

getAddressManager

getBufferMode

getCounters

getExtent

getHeaderSize

getInitialExtent

getMaxRecordSize

getMaximumExtent

getMetaBitsAddr

getMetaStartAddr

getNextOffset

getOffsetBits

getUserExtent

readRootBlock

requiresCommit

transferTo

truncate

useChecksums

writeRootBlock

close

delete

deleteResources

destroy

force

getFile

getResourceMetadata

getUUID

isFullyBuffered

isOpen

isReadOnly

isStable

read

size

write

getByteCount

getOffset

getPhysicalAddress

toAddr

toString

newTx

abortContext

detachContext

checkDeferredFrees

delete

getLastReleaseTime

registerExternalCache

saveDeferrals

write

isCommitted

getInputStream

getOutputStream

getOutputStream

isDirty

newAllocationContext