EventWriterUnsync

java.lang.Object
- org.jlab.coda.jevio.EventWriterUnsync

```
public class EventWriterUnsync
extends java.lang.Object
```
An EventWriter object is used for writing events to a file or to a byte buffer. This class does NOT write versions 1-3 data, only version 4! This class is not thread-safe.

Author:

heddle, timmer

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class EventWriterUnsync.IOStatus
This enum denotes the status of a read.

Nested Classes
Modifier and Type	Class and Description
`static class`	`EventWriterUnsync.IOStatus` This `enum` denotes the status of a read.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static int`	`BIT_INFO_OFFSET` Offset to where the bit information is written in the byte buffer, which always has a physical record header at the top.
`(package private) static int`	`BLOCK_LENGTH_OFFSET` Offset to where the block length is written in the byte buffer, which always has a physical record header at the top.
`(package private) static int`	`BLOCK_NUMBER_OFFSET` Offset to where the block number is written in the byte buffer, which always has a physical record header at the top.
`(package private) static boolean`	`debug` Turn on or off the debug printout.
`(package private) static int`	`DEFAULT_BLOCK_COUNT` The default maximum event count for a single block used for writing.
`(package private) static int`	`DEFAULT_BLOCK_SIZE` The default maximum size for a single block used for writing in ints or words.
`(package private) static int`	`EVENT_COUNT_OFFSET` Offset to where the event count is written in the byte buffer, which always has a physical record header at the top.
`(package private) static int`	`HEADER_LENGTH_OFFSET` Offset to where the header length is written in the byte buffer, which always has a physical record header at the top.
`(package private) static int`	`headerBytes` Size of block header in bytes.
`(package private) static int`	`headerWords` Size of block header in bytes.
`(package private) static int`	`MAGIC_OFFSET` Offset to where the magic number is written in the byte buffer, which always has a physical record header at the top.
`(package private) static int`	`MAX_BLOCK_COUNT` The upper limit of maximum event count for a single block used for writing.
`(package private) static int`	`MAX_BLOCK_SIZE` The upper limit of maximum size for a single block used for writing is 2^25 ints or words.
`(package private) static int`	`MIN_BLOCK_COUNT` The lower limit of maximum event count for a single block used for writing.
`(package private) static int`	`MIN_BLOCK_SIZE` The lower limit of maximum size for a single block used for writing, in ints (words).
`(package private) static int`	`RESERVED1_COUNT_OFFSET` Offset to where the first reserved word is written in the byte buffer, which always has a physical record header at the top.
`(package private) static int`	`VERSION_MASK` Mask to get version number from 6th int in block.

Constructor Summary

Constructors
Constructor and Description
`EventWriterUnsync(java.nio.ByteBuffer buf)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.nio.ByteBuffer buf, boolean append)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.nio.ByteBuffer buf, int blockSizeMax, int blockCountMax, java.lang.String xmlDictionary, java.util.BitSet bitInfo)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.nio.ByteBuffer buf, int blockSizeMax, int blockCountMax, java.lang.String xmlDictionary, java.util.BitSet bitInfo, boolean append)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.nio.ByteBuffer buf, int blockSizeMax, int blockCountMax, java.lang.String xmlDictionary, java.util.BitSet bitInfo, int reserved1, boolean append)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.nio.ByteBuffer buf, int blockSizeMax, int blockCountMax, java.lang.String xmlDictionary, java.util.BitSet bitInfo, int reserved1, int blockNumber)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.nio.ByteBuffer buf, int blockSizeMax, int blockCountMax, java.lang.String xmlDictionary, java.util.BitSet bitInfo, int reserved1, int blockNumber, boolean append, EvioBank firstEvent)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.nio.ByteBuffer buf, java.lang.String xmlDictionary, boolean append)` Create an `EventWriterUnsync` for writing events to a ByteBuffer.
`EventWriterUnsync(java.io.File file)` Creates an `EventWriterUnsync` for writing to a file in native byte order.
`EventWriterUnsync(java.io.File file, boolean append)` Creates an `EventWriterUnsync` for writing to a file in native byte order.
`EventWriterUnsync(java.io.File file, int blockSizeMax, int blockCountMax, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, java.util.BitSet bitInfo)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.io.File file, int blockSizeMax, int blockCountMax, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, java.util.BitSet bitInfo, boolean overWriteOK)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.io.File file, int blockSizeMax, int blockCountMax, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, java.util.BitSet bitInfo, boolean overWriteOK, boolean append)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.io.File file, java.lang.String dictionary, boolean append)` Creates an `EventWriterUnsync` for writing to a file in native byte order.
`EventWriterUnsync(java.lang.String filename)` Creates an `EventWriterUnsync` for writing to a file in native byte order.
`EventWriterUnsync(java.lang.String filename, boolean append)` Creates an `EventWriterUnsync` for writing to a file in native byte order.
`EventWriterUnsync(java.lang.String filename, boolean append, java.nio.ByteOrder byteOrder)` Creates an `EventWriterUnsync` for writing to a file in the specified byte order.
`EventWriterUnsync(java.lang.String baseName, java.lang.String directory, java.lang.String runType, int runNumber, long split, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.lang.String baseName, java.lang.String directory, java.lang.String runType, int runNumber, long split, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, boolean overWriteOK)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.lang.String baseName, java.lang.String directory, java.lang.String runType, int runNumber, long split, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, int streamId)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.lang.String baseName, java.lang.String directory, java.lang.String runType, int runNumber, long split, int blockSizeMax, int blockCountMax, int bufferSize, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, java.util.BitSet bitInfo, boolean overWriteOK, boolean append)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.lang.String baseName, java.lang.String directory, java.lang.String runType, int runNumber, long split, int blockSizeMax, int blockCountMax, int bufferSize, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, java.util.BitSet bitInfo, boolean overWriteOK, boolean append, EvioBank firstEvent)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.lang.String baseName, java.lang.String directory, java.lang.String runType, int runNumber, long split, int blockSizeMax, int blockCountMax, int bufferSize, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, java.util.BitSet bitInfo, boolean overWriteOK, boolean append, EvioBank firstEvent, int streamId)` Create an `EventWriterUnsync` for writing events to a file.
`EventWriterUnsync(java.lang.String baseName, java.lang.String directory, java.lang.String runType, int runNumber, long split, int blockSizeMax, int blockCountMax, int bufferSize, java.nio.ByteOrder byteOrder, java.lang.String xmlDictionary, java.util.BitSet bitInfo, boolean overWriteOK, boolean append, EvioBank firstEvent, int streamId, int splitNumber, int splitIncrement, int streamCount)` Create an `EventWriterUnsync` for writing events to a file.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`close()` This method flushes any remaining data to file and disables this object.
`protected EventWriterUnsync.IOStatus`	`examineFirstBlockHeader()` Reads part of the first block (physical record) header in order to determine the evio version # and endianness of the file or buffer in question.
`void`	`flush()` This method flushes any remaining internally buffered data to file.
`int`	`getBlockNumber()` Get the current block number.
`java.nio.ByteBuffer`	`getByteBuffer()` If writing to a file, return null.
`java.nio.ByteOrder`	`getByteOrder()` Get the byte order of the buffer/file being written into.
`long`	`getBytesWrittenToBuffer()` If writing to a buffer, get the number of bytes written to it including the ending header.
`java.lang.String`	`getCurrentFilename()` Get the name of the current file being written to.
`java.lang.String`	`getCurrentFilePath()` Get the full name or path of the current file being written to.
`int`	`getEventsWritten()` Get the number of events written to a file/buffer.
`int`	`getSplitCount()` Get the number of split files produced by this writer.
`int`	`getSplitNumber()` Get the current split count which is the number of files created by this object.
`boolean`	`hasRoom(int bytes)` Is there room to write this many bytes to an output buffer as a single event? Will always return true when writing to a file.
`boolean`	`isClosed()` Has `close()` been called (without reopening by calling `setBuffer(ByteBuffer)`) ?
`boolean`	`isDiskFull()` If writing file, is the partition it resides on full? Not full, in this context, means there's enough space to write a full split file + a full record + an extra 10MB as a safety factor.
`void`	`setBuffer(java.nio.ByteBuffer buf)` Set the buffer being written into (initially set in constructor).
`void`	`setBuffer(java.nio.ByteBuffer buf, java.util.BitSet bitInfo, int blockNumber)` Set the buffer being written into (initially set in constructor).
`void`	`setFirstEvent(java.nio.ByteBuffer buffer)` Set an event which will be written to the file/buffer as well as to all split files.
`void`	`setFirstEvent(EvioBank bank)` Set an event which will be written to the file/buffer as well as to all split files.
`void`	`setFirstEvent(EvioNode node)` Set an event which will be written to the file/buffer as well as to all split files.
`void`	`setStartingBlockNumber(int startingBlockNumber)` Set the number with which to start block numbers.
`boolean`	`toFile()` Is this object writing to file?
`void`	`writeEvent(java.nio.ByteBuffer eventBuffer)` Write an event (bank) to the buffer in evio version 4 format.
`void`	`writeEvent(java.nio.ByteBuffer bankBuffer, boolean force)` Write an event (bank) to the buffer in evio version 4 format.
`void`	`writeEvent(EvioBank bank)` Write an event (bank) to a buffer containing evio version 4 format blocks.
`void`	`writeEvent(EvioBank bank, boolean force)` Write an event (bank) to a buffer containing evio version 4 format blocks.
`void`	`writeEvent(EvioNode node, boolean force)` Write an event (bank) to the buffer in evio version 4 format.
`void`	`writeEvent(EvioNode node, boolean force, boolean duplicate)` Write an event (bank) to the buffer in evio version 4 format.
`boolean`	`writeEventToFile(EvioBank bank, java.nio.ByteBuffer bankBuffer, boolean force)` Write an event (bank) into a block and eventually to a file in evio version 4 format.
`boolean`	`writeEventToFile(EvioNode node, boolean force, boolean duplicate)` Write an event (bank) into a record and eventually to a file in evio version 4 format.

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

- Field Detail
  - BLOCK_LENGTH_OFFSET
```
static final int BLOCK_LENGTH_OFFSET
```
    Offset to where the block length is written in the byte buffer, which always has a physical record header at the top.
    
    See Also:
    
    Constant Field Values
  - BLOCK_NUMBER_OFFSET
```
static final int BLOCK_NUMBER_OFFSET
```
    Offset to where the block number is written in the byte buffer, which always has a physical record header at the top.
    
    See Also:
    
    Constant Field Values
  - HEADER_LENGTH_OFFSET
```
static final int HEADER_LENGTH_OFFSET
```
    Offset to where the header length is written in the byte buffer, which always has a physical record header at the top.
    
    See Also:
    
    Constant Field Values
  - EVENT_COUNT_OFFSET
```
static final int EVENT_COUNT_OFFSET
```
    Offset to where the event count is written in the byte buffer, which always has a physical record header at the top.
    
    See Also:
    
    Constant Field Values
  - RESERVED1_COUNT_OFFSET
```
static final int RESERVED1_COUNT_OFFSET
```
    Offset to where the first reserved word is written in the byte buffer, which always has a physical record header at the top.
    
    See Also:
    
    Constant Field Values
  - BIT_INFO_OFFSET
```
static final int BIT_INFO_OFFSET
```
    Offset to where the bit information is written in the byte buffer, which always has a physical record header at the top.
    
    See Also:
    
    Constant Field Values
  - MAGIC_OFFSET
```
static final int MAGIC_OFFSET
```
    Offset to where the magic number is written in the byte buffer, which always has a physical record header at the top.
    
    See Also:
    
    Constant Field Values
  - VERSION_MASK
```
static final int VERSION_MASK
```
    Mask to get version number from 6th int in block.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_BLOCK_SIZE
```
static final int DEFAULT_BLOCK_SIZE
```
    The default maximum size for a single block used for writing in ints or words. This gives block sizes of 2^22 ints or 16MB. It is a soft limit since a single event larger than this limit may need to be written.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_BLOCK_COUNT
```
static final int DEFAULT_BLOCK_COUNT
```
    The default maximum event count for a single block used for writing.
    
    See Also:
    
    Constant Field Values
  - MAX_BLOCK_SIZE
```
static final int MAX_BLOCK_SIZE
```
    The upper limit of maximum size for a single block used for writing is 2^25 ints or words. This gives block sizes of about 134MB. It is a soft limit since a single event larger than this limit may need to be written.
    
    See Also:
    
    Constant Field Values
  - MAX_BLOCK_COUNT
```
static final int MAX_BLOCK_COUNT
```
    The upper limit of maximum event count for a single block used for writing.
    
    See Also:
    
    Constant Field Values
  - MIN_BLOCK_SIZE
```
static final int MIN_BLOCK_SIZE
```
    The lower limit of maximum size for a single block used for writing, in ints (words). This gives block sizes of about 32k bytes.
    
    See Also:
    
    Constant Field Values
  - MIN_BLOCK_COUNT
```
static final int MIN_BLOCK_COUNT
```
    The lower limit of maximum event count for a single block used for writing.
    
    See Also:
    
    Constant Field Values
  - headerBytes
```
static final int headerBytes
```
    Size of block header in bytes.
    
    See Also:
    
    Constant Field Values
  - headerWords
```
static final int headerWords
```
    Size of block header in bytes.
    
    See Also:
    
    Constant Field Values
  - debug
```
static final boolean debug
```
    Turn on or off the debug printout.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - EventWriterUnsync
```
public EventWriterUnsync(java.io.File file)
                  throws EvioException
```
    Creates an EventWriterUnsync for writing to a file in native byte order. If the file already exists, its contents will be overwritten. If it doesn't exist, it will be created.
    
    Parameters:
    
    file - the file object to write to.
    
    Throws:
    
    EvioException - file cannot be created
  - EventWriterUnsync
```
public EventWriterUnsync(java.io.File file,
                         boolean append)
                  throws EvioException
```
    Creates an EventWriterUnsync for writing to a file in native byte order. If the file already exists, its contents will be overwritten unless it is being appended to. If it doesn't exist, it will be created.
    
    Parameters:
    
    file - the file object to write to.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    Throws:
    
    EvioException - file cannot be created
  - EventWriterUnsync
```
public EventWriterUnsync(java.io.File file,
                         java.lang.String dictionary,
                         boolean append)
                  throws EvioException
```
    Creates an EventWriterUnsync for writing to a file in native byte order. If the file already exists, its contents will be overwritten unless it is being appended to. If it doesn't exist, it will be created.
    
    Parameters:
    
    file - the file object to write to.
    
    dictionary - dictionary in xml format or null if none.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    Throws:
    
    EvioException - file cannot be created
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String filename)
                  throws EvioException
```
    Creates an EventWriterUnsync for writing to a file in native byte order. If the file already exists, its contents will be overwritten. If it doesn't exist, it will be created.
    
    Parameters:
    
    filename - name of the file to write to.
    
    Throws:
    
    EvioException - file cannot be created
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String filename,
                         boolean append)
                  throws EvioException
```
    Creates an EventWriterUnsync for writing to a file in native byte order. If the file already exists, its contents will be overwritten unless it is being appended to. If it doesn't exist, it will be created.
    
    Parameters:
    
    filename - name of the file to write to.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    Throws:
    
    EvioException - file cannot be created
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String filename,
                         boolean append,
                         java.nio.ByteOrder byteOrder)
                  throws EvioException
```
    Creates an EventWriterUnsync for writing to a file in the specified byte order. If the file already exists, its contents will be overwritten unless it is being appended to. If it doesn't exist, it will be created.
    
    Parameters:
    
    filename - name of the file to write to.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    byteOrder - the byte order in which to write the file.
    
    Throws:
    
    EvioException - file cannot be created
  - EventWriterUnsync
```
public EventWriterUnsync(java.io.File file,
                         int blockSizeMax,
                         int blockCountMax,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. If the file already exists, its contents will be overwritten. If it doesn't exist, it will be created.
    
    Parameters:
    
    file - the file object to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    byteOrder - the byte order in which to write the file.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; file cannot be created
  - EventWriterUnsync
```
public EventWriterUnsync(java.io.File file,
                         int blockSizeMax,
                         int blockCountMax,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         boolean overWriteOK)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. If the file already exists, its contents will be overwritten unless the "overWriteOK" argument is false in which case an exception will be thrown. If it doesn't exist, it will be created.
    
    Parameters:
    
    file - the file to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    byteOrder - the byte order in which to write the file.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    overWriteOK - if false and the file already exists, an exception is thrown rather than overwriting it.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; file exists and cannot be deleted; file exists and user requested no deletion.
  - EventWriterUnsync
```
public EventWriterUnsync(java.io.File file,
                         int blockSizeMax,
                         int blockCountMax,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         boolean overWriteOK,
                         boolean append)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. If the file already exists, its contents will be overwritten unless the "overWriteOK" argument is false in which case an exception will be thrown. Unless ..., the option to append these events to an existing file is true, in which case everything is fine. If the file doesn't exist, it will be created. Byte order defaults to big endian if arg is null.
    
    Parameters:
    
    file - the file to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    byteOrder - the byte order in which to write the file. This is ignored if appending to existing file.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    overWriteOK - if false and the file already exists, an exception is thrown rather than overwriting it.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if defined dictionary while appending; if file arg is null; if file could not be opened or positioned; if file exists but user requested no over-writing or appending.
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String baseName,
                         java.lang.String directory,
                         java.lang.String runType,
                         int runNumber,
                         long split,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. This constructor is useful when splitting and automatically naming the split files. If any of the generated files already exist, it will NOT be overwritten. Byte order defaults to big endian.
    
    Parameters:
    
    baseName - base file name used to generate complete file name (may not be null)
    
    directory - directory in which file is to be placed
    
    runType - name of run type configuration to be used in naming files
    
    runNumber - number of the CODA run, used in naming files
    
    split - if < 1, do not split file, write to only one file of unlimited size. Else this is max size in bytes to make a file before closing it and starting writing another.
    
    byteOrder - the byte order in which to write the file. Defaults to big endian if null.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    Throws:
    
    EvioException - if baseName arg is null; if file could not be opened, positioned, or written to; if file exists.
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String baseName,
                         java.lang.String directory,
                         java.lang.String runType,
                         int runNumber,
                         long split,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         int streamId)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. This constructor is useful when splitting and automatically naming the split files. If any of the generated files already exist, it will NOT be overwritten. Byte order defaults to big endian.
    
    Parameters:
    
    baseName - base file name used to generate complete file name (may not be null)
    
    directory - directory in which file is to be placed
    
    runType - name of run type configuration to be used in naming files
    
    runNumber - number of the CODA run, used in naming files
    
    split - if < 1, do not split file, write to only one file of unlimited size. Else this is max size in bytes to make a file before closing it and starting writing another.
    
    byteOrder - the byte order in which to write the file. Defaults to big endian if null.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    streamId - streamId number (100 > id > -1) for file name
    
    Throws:
    
    EvioException - if baseName arg is null; if file could not be opened, positioned, or written to; if file exists.
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String baseName,
                         java.lang.String directory,
                         java.lang.String runType,
                         int runNumber,
                         long split,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         boolean overWriteOK)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. This constructor is useful when splitting and automatically naming the split files. Byte order defaults to big endian.
    
    Parameters:
    
    baseName - base file name used to generate complete file name (may not be null)
    
    directory - directory in which file is to be placed
    
    runType - name of run type configuration to be used in naming files
    
    runNumber - number of the CODA run, used in naming files
    
    split - if < 1, do not split file, write to only one file of unlimited size. Else this is max size in bytes to make a file before closing it and starting writing another.
    
    byteOrder - the byte order in which to write the file. Defaults to big endian if null.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    overWriteOK - if false and the file already exists, an exception is thrown rather than overwriting it.
    
    Throws:
    
    EvioException - if baseName arg is null; if file could not be opened, positioned, or written to; if file exists.
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String baseName,
                         java.lang.String directory,
                         java.lang.String runType,
                         int runNumber,
                         long split,
                         int blockSizeMax,
                         int blockCountMax,
                         int bufferSize,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         boolean overWriteOK,
                         boolean append)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. If the file already exists, its contents will be overwritten unless the "overWriteOK" argument is false in which case an exception will be thrown. Unless ..., the option to append these events to an existing file is true, in which case everything is fine. If the file doesn't exist, it will be created. Byte order defaults to big endian if arg is null. File can be split while writing.
    The base file name may contain up to 2, C-style integer format specifiers using "d" and "x" (such as %03d, or %x). If more than 2 are found, an exception will be thrown. If no "0" precedes any integer between the "%" and the "d" or "x" of the format specifier, it will be added automatically in order to avoid spaces in the file name. The first specifier will be substituted with the given runNumber value. If the file is being split, the second will be substituted with the split number which starts at 0. If 2 specifiers exist and the file is not being split, no substitutions are made. If no specifier for the splitNumber exists, it is tacked onto the end of the file name after a dot (.).
    The base file name may contain characters of the form $(ENV_VAR) which will be substituted with the value of the associated environmental variable or a blank string if none is found.
    The base file name may also contain occurrences of the string "%s" which will be substituted with the value of the runType arg or nothing if the runType is null.
    
    Parameters:
    
    baseName - base file name used to generate complete file name (may not be null)
    
    directory - directory in which file is to be placed
    
    runType - name of run type configuration to be used in naming files
    
    runNumber - number of the CODA run, used in naming files
    
    split - if < 1, do not split file, write to only one file of unlimited size. Else this is max size in bytes to make a file before closing it and starting writing another.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    bufferSize - number of bytes to make the internal buffer which will be storing events before writing them to a file. Must be at least 4*blockSizeMax + 32. If not, it is set to that.
    
    byteOrder - the byte order in which to write the file. This is ignored if appending to existing file.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    overWriteOK - if false and the file already exists, an exception is thrown rather than overwriting it.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if defined dictionary while appending; if splitting file while appending; if file name arg is null; if file could not be opened, positioned, or written to; if file exists but user requested no over-writing or appending.
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String baseName,
                         java.lang.String directory,
                         java.lang.String runType,
                         int runNumber,
                         long split,
                         int blockSizeMax,
                         int blockCountMax,
                         int bufferSize,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         boolean overWriteOK,
                         boolean append,
                         EvioBank firstEvent)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. If the file already exists, its contents will be overwritten unless the "overWriteOK" argument is false in which case an exception will be thrown. Unless ..., the option to append these events to an existing file is true, in which case everything is fine. If the file doesn't exist, it will be created. Byte order defaults to big endian if arg is null. File can be split while writing.
    The base file name may contain up to 2, C-style integer format specifiers using "d" and "x" (such as %03d, or %x). If more than 2 are found, an exception will be thrown. If no "0" precedes any integer between the "%" and the "d" or "x" of the format specifier, it will be added automatically in order to avoid spaces in the file name. The first specifier will be substituted with the given runNumber value. If the file is being split, the second will be substituted with the split number which starts at 0. If 2 specifiers exist and the file is not being split, no substitutions are made. If no specifier for the splitNumber exists, it is tacked onto the end of the file name after a dot (.).
    The base file name may contain characters of the form $(ENV_VAR) which will be substituted with the value of the associated environmental variable or a blank string if none is found.
    The base file name may also contain occurrences of the string "%s" which will be substituted with the value of the runType arg or nothing if the runType is null.
    
    Parameters:
    
    baseName - base file name used to generate complete file name (may not be null)
    
    directory - directory in which file is to be placed
    
    runType - name of run type configuration to be used in naming files
    
    runNumber - number of the CODA run, used in naming files
    
    split - if < 1, do not split file, write to only one file of unlimited size. Else this is max size in bytes to make a file before closing it and starting writing another.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    bufferSize - number of bytes to make the internal buffer which will be storing events before writing them to a file. Must be at least 4*blockSizeMax + 32. If not, it is set to that.
    
    byteOrder - the byte order in which to write the file. This is ignored if appending to existing file.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    overWriteOK - if false and the file already exists, an exception is thrown rather than overwriting it.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    firstEvent - the first event written into each file (after any dictionary) including all split files; may be null. Useful for adding common, static info into each split file.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if defined dictionary while appending; if splitting file while appending; if file name arg is null; if file could not be opened, positioned, or written to; if file exists but user requested no over-writing or appending.
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String baseName,
                         java.lang.String directory,
                         java.lang.String runType,
                         int runNumber,
                         long split,
                         int blockSizeMax,
                         int blockCountMax,
                         int bufferSize,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         boolean overWriteOK,
                         boolean append,
                         EvioBank firstEvent,
                         int streamId)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. If the file already exists, its contents will be overwritten unless the "overWriteOK" argument is false in which case an exception will be thrown. Unless ..., the option to append these events to an existing file is true, in which case everything is fine. If the file doesn't exist, it will be created. Byte order defaults to big endian if arg is null. File can be split while writing.
    The base file name may contain up to 2, C-style integer format specifiers using "d" and "x" (such as %03d, or %x). If more than 2 are found, an exception will be thrown. If no "0" precedes any integer between the "%" and the "d" or "x" of the format specifier, it will be added automatically in order to avoid spaces in the file name. The first specifier will be substituted with the given runNumber value. If the file is being split, the second will be substituted with the split number which starts at 0. If 2 specifiers exist and the file is not being split, no substitutions are made. If no specifier for the splitNumber exists, it is tacked onto the end of the file name after a dot (.).
    The base file name may contain characters of the form $(ENV_VAR) which will be substituted with the value of the associated environmental variable or a blank string if none is found.
    The base file name may also contain occurrences of the string "%s" which will be substituted with the value of the runType arg or nothing if the runType is null.
    If multiple streams of data, each writing a file, end up with the same file name, they can be differentiated by a stream id number. If the id is > 0, the string, ".strm" is appended to the very end of the file followed by the id number (e.g. filename.strm1). This is done after the run type, run number, split numbers, and env vars have been inserted into the file name.
    
    Parameters:
    
    baseName - base file name used to generate complete file name (may not be null)
    
    directory - directory in which file is to be placed
    
    runType - name of run type configuration to be used in naming files
    
    runNumber - number of the CODA run, used in naming files
    
    split - if < 1, do not split file, write to only one file of unlimited size. Else this is max size in bytes to make a file before closing it and starting writing another.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    bufferSize - number of bytes to make the internal buffer which will be storing events before writing them to a file. Must be at least 4*blockSizeMax + 32. If not, it is set to that.
    
    byteOrder - the byte order in which to write the file. This is ignored if appending to existing file.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    overWriteOK - if false and the file already exists, an exception is thrown rather than overwriting it.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    firstEvent - the first event written into each file (after any dictionary) including all split files; may be null. Useful for adding common, static info into each split file.
    
    streamId - streamId number (100 > id > -1) for file name
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if defined dictionary or first event while appending; if splitting file while appending; if file name arg is null; if file could not be opened, positioned, or written to; if file exists but user requested no over-writing or appending.
  - EventWriterUnsync
```
public EventWriterUnsync(java.lang.String baseName,
                         java.lang.String directory,
                         java.lang.String runType,
                         int runNumber,
                         long split,
                         int blockSizeMax,
                         int blockCountMax,
                         int bufferSize,
                         java.nio.ByteOrder byteOrder,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         boolean overWriteOK,
                         boolean append,
                         EvioBank firstEvent,
                         int streamId,
                         int splitNumber,
                         int splitIncrement,
                         int streamCount)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a file. If the file already exists, its contents will be overwritten unless the "overWriteOK" argument is false in which case an exception will be thrown. Unless ..., the option to append these events to an existing file is true, in which case everything is fine. If the file doesn't exist, it will be created. Byte order defaults to big endian if arg is null. File can be split while writing.
    The base file name may contain up to 2, C-style integer format specifiers using "d" and "x" (such as %03d, or %x). If more than 2 are found, an exception will be thrown. If no "0" precedes any integer between the "%" and the "d" or "x" of the format specifier, it will be added automatically in order to avoid spaces in the file name. The first specifier will be substituted with the given runNumber value. If the file is being split, the second will be substituted with the split number which starts at 0. If 2 specifiers exist and the file is not being split, no substitutions are made. If no specifier for the splitNumber exists, it is tacked onto the end of the file name after a dot (.). If streamCount > 1, the split number is calculated starting with streamId and incremented by streamCount each time. In this manner, all split files will have unique, sequential names even though there are multiple parallel ERs.
    The base file name may contain characters of the form $(ENV_VAR) which will be substituted with the value of the associated environmental variable or a blank string if none is found.
    The base file name may also contain occurrences of the string "%s" which will be substituted with the value of the runType arg or nothing if the runType is null.
    If multiple streams of data, each writing a file, end up with the same file name, they can be differentiated by a stream id, starting split # and split increment.
    
    Parameters:
    
    baseName - base file name used to generate complete file name (may not be null)
    
    directory - directory in which file is to be placed
    
    runType - name of run type configuration to be used in naming files
    
    runNumber - number of the CODA run, used in naming files
    
    split - if < 1, do not split file, write to only one file of unlimited size. Else this is max size in bytes to make a file before closing it and starting writing another.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    bufferSize - number of bytes to make the internal buffer which will be storing events before writing them to a file. Must be at least 4*blockSizeMax + 32. If not, it is set to that.
    
    byteOrder - the byte order in which to write the file. This is ignored if appending to existing file.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    overWriteOK - if false and the file already exists, an exception is thrown rather than overwriting it.
    
    append - if true and the file already exists, all events to be written will be appended to the end of the file.
    
    firstEvent - the first event written into each file (after any dictionary) including all split files; may be null. Useful for adding common, static info into each split file.
    
    streamId - streamId number (100 > id > -1) for file name
    
    splitNumber - number at which to start the split numbers
    
    splitIncrement - amount to increment split number each time another file is created.
    
    streamCount - total number of streams in DAQ.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if defined dictionary or first event while appending; if splitting file while appending; if file name arg is null; if file could not be opened, positioned, or written to; if file exists but user requested no over-writing or appending; if streamId < 0, splitNumber < 0, or splitIncrement < 1.
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer. Uses the default number and size of blocks in buffer. Will overwrite any existing data in buffer!
    
    Parameters:
    
    buf - the buffer to write to.
    
    Throws:
    
    EvioException - if buf arg is null
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf,
                         boolean append)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer. Uses the default number and size of blocks in buffer.
    
    Parameters:
    
    buf - the buffer to write to.
    
    append - if true, all events to be written will be appended to the end of the buffer.
    
    Throws:
    
    EvioException - if buf arg is null
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf,
                         java.lang.String xmlDictionary,
                         boolean append)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer. Uses the default number and size of blocks in buffer.
    
    Parameters:
    
    buf - the buffer to write to.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    append - if true, all events to be written will be appended to the end of the buffer.
    
    Throws:
    
    EvioException - if buf arg is null
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf,
                         int blockSizeMax,
                         int blockCountMax,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer. Will overwrite any existing data in buffer!
    
    Parameters:
    
    buf - the buffer to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if buf arg is null
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf,
                         int blockSizeMax,
                         int blockCountMax,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         boolean append)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer. Block number starts at 0.
    
    Parameters:
    
    buf - the buffer to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    append - if true, all events to be written will be appended to the end of the buffer.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if buf arg is null; if defined dictionary while appending;
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf,
                         int blockSizeMax,
                         int blockCountMax,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         int reserved1,
                         int blockNumber)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer. Will overwrite any existing data in buffer!
    
    Parameters:
    
    buf - the buffer to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    reserved1 - set the value of the first "reserved" int in first block header. NOTE: only CODA (i.e. EMU) software should use this.
    
    blockNumber - number at which to start block number counting.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if buf arg is null
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf,
                         int blockSizeMax,
                         int blockCountMax,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         int reserved1,
                         boolean append)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer. Block number starts at 0.
    
    Parameters:
    
    buf - the buffer to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    reserved1 - set the value of the first "reserved" int in first block header. NOTE: only CODA (i.e. EMU) software should use this.
    
    append - if true, all events to be written will be appended to the end of the buffer.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if buf arg is null; if defined dictionary while appending;
  - EventWriterUnsync
```
public EventWriterUnsync(java.nio.ByteBuffer buf,
                         int blockSizeMax,
                         int blockCountMax,
                         java.lang.String xmlDictionary,
                         java.util.BitSet bitInfo,
                         int reserved1,
                         int blockNumber,
                         boolean append,
                         EvioBank firstEvent)
                  throws EvioException
```
    Create an EventWriterUnsync for writing events to a ByteBuffer.
    
    Parameters:
    
    buf - the buffer to write to.
    
    blockSizeMax - the max blocksize to use which must be >= MIN_BLOCK_SIZE and <= MAX_BLOCK_SIZE ints. The size of the block will not be larger than this size unless a single event itself is larger.
    
    blockCountMax - the max number of events (including dictionary) in a single block which must be >= MIN_BLOCK_COUNT and <= MAX_BLOCK_COUNT.
    
    xmlDictionary - dictionary in xml format or null if none.
    
    bitInfo - set of bits to include in first block header.
    
    reserved1 - set the value of the first "reserved" int in first block header. NOTE: only CODA (i.e. EMU) software should use this.
    
    blockNumber - number at which to start block number counting.
    
    append - if true, all events to be written will be appended to the end of the buffer.
    
    firstEvent - the first event written into the buffer (after any dictionary). May be null. Not useful when writing to a buffer as this event may be written using normal means.
    
    Throws:
    
    EvioException - if blockSizeMax or blockCountMax exceed limits; if buf arg is null; if defined dictionary while appending;
- Method Detail
  - isDiskFull
```
public boolean isDiskFull()
```
    If writing file, is the partition it resides on full? Not full, in this context, means there's enough space to write a full split file + a full record + an extra 10MB as a safety factor.
    
    Returns:
    
    true if the partition the file resides on is full, else false.
  - getBytesWrittenToBuffer
```
public long getBytesWrittenToBuffer()
```
    If writing to a buffer, get the number of bytes written to it including the ending header.
    
    Returns:
    
    number of bytes written to buffer
  - setBuffer
```
public void setBuffer(java.nio.ByteBuffer buf,
                      java.util.BitSet bitInfo,
                      int blockNumber)
               throws EvioException
```
    Set the buffer being written into (initially set in constructor). This method allows the user to avoid having to create a new EventWriterUnsync each time a bank needs to be written to a different buffer. This does nothing if writing to a file. Not for use if appending.
    Do not use this method unless you know what you are doing.
    
    Parameters:
    
    buf - the buffer to write to.
    
    bitInfo - set of bits to include in first block header.
    
    blockNumber - number at which to start block number counting.
    
    Throws:
    
    EvioException - if this object was not closed prior to resetting the buffer, buffer arg is null, or in appending mode.
  - setBuffer
```
public void setBuffer(java.nio.ByteBuffer buf)
               throws EvioException
```
    Set the buffer being written into (initially set in constructor). This method allows the user to avoid having to create a new EventWriterUnsync each time a bank needs to be written to a different buffer. This does nothing if writing to a file. Not for use if appending.
    Do not use this method unless you know what you are doing.
    
    Parameters:
    
    buf - the buffer to write to.
    
    Throws:
    
    EvioException - if this object was not closed prior to resetting the buffer, buffer arg is null, or in appending mode.
  - getByteBuffer
```
public java.nio.ByteBuffer getByteBuffer()
```
    If writing to a file, return null. If writing to a buffer, get a duplicate of the user-given buffer being written into. The buffer's position will be 0 and its limit will be the size of the valid data. Basically, it's ready to be read from. The returned buffer shares data with the original buffer but has separate limit, position, and mark. Useful if trying to send buffer over the network. Do not call this while simultaneously calling close, flush, setFirstEvent, or writeEvent.
    
    Returns:
    
    buffer being written into, made ready for reading; null if writing to file
  - toFile
```
public boolean toFile()
```
    Is this object writing to file?
    
    Returns:
    
    true if writing to file, else false.
  - isClosed
```
public boolean isClosed()
```
    Has close() been called (without reopening by calling setBuffer(ByteBuffer)) ?
    
    Returns:
    
    true if this object closed, else false.
  - getCurrentFilename
```
public java.lang.String getCurrentFilename()
```
    Get the name of the current file being written to. Returns null if no file.
    
    Returns:
    
    the name of the current file being written to.
  - getCurrentFilePath
```
public java.lang.String getCurrentFilePath()
```
    Get the full name or path of the current file being written to. Returns null if no file.
    
    Returns:
    
    the full name or path of the current file being written to.
  - getSplitNumber
```
public int getSplitNumber()
```
    Get the current split count which is the number of files created by this object. Warning, this value may be changing.
    
    Returns:
    
    the current split count which is the number of files created by this object.
  - getSplitCount
```
public int getSplitCount()
```
    Get the number of split files produced by this writer.
    
    Returns:
    
    number of split files produced by this writer.
  - getBlockNumber
```
public int getBlockNumber()
```
    Get the current block number. Warning, this value may be changing.
    
    Returns:
    
    the current block number.
  - getEventsWritten
```
public int getEventsWritten()
```
    Get the number of events written to a file/buffer. Remember that a particular event may not yet be flushed to the file/buffer. If the file being written to is split, the returned value refers to all split files taken together.
    
    Returns:
    
    number of events written to a file/buffer.
  - getByteOrder
```
public java.nio.ByteOrder getByteOrder()
```
    Get the byte order of the buffer/file being written into.
    
    Returns:
    
    byte order of the buffer/file being written into.
  - setStartingBlockNumber
```
public void setStartingBlockNumber(int startingBlockNumber)
```
    Set the number with which to start block numbers. This method does nothing if events have already been written.
    
    Parameters:
    
    startingBlockNumber - the number with which to start block numbers.
  - setFirstEvent
```
public void setFirstEvent(EvioNode node)
                   throws EvioException,
                          java.io.IOException
```
    Set an event which will be written to the file/buffer as well as to all split files. It's called the "first event" as it will be the first event written to each split file (after the dictionary) if this method is called early enough or the first event was defined in the constructor.
    Since this method is always called after the constructor, the common block will have already been written with a dictionary and firstEvent if either was defined in the constructor. The event given here will be written immediately somewhere in the body of the file, with the forth-coming split files having that event in the first block along with any dictionary.
    This means that if the firstEvent is given in the constructor, then the caller may end up with 2 copies of it in a single file (if this method is called once). It's also possible to get 2 copies in a file if this method is called immediately prior to the file splitting.
    By its nature this method is not useful for writing to a buffer since it is never split and the event can be written to it as any other.
    Do not call this while simultaneously calling close, flush, writeEvent, or getByteBuffer.
    
    Parameters:
    
    node - node representing event to be placed first in each file written including all splits. If null, no more first events are written to any files.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if event is bad format; if close() already called; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - setFirstEvent
```
public void setFirstEvent(java.nio.ByteBuffer buffer)
                   throws EvioException,
                          java.io.IOException
```
    Set an event which will be written to the file/buffer as well as to all split files. It's called the "first event" as it will be the first event written to each split file (after the dictionary) if this method is called early enough or the first event was defined in the constructor.
    Since this method is always called after the constructor, the common block will have already been written with a dictionary and firstEvent if either was defined in the constructor. The event given here will be written immediately somewhere in the body of the file, with the forth-coming split files having that event in the first block along with any dictionary.
    This means that if the firstEvent is given in the constructor, then the caller may end up with 2 copies of it in a single file (if this method is called once). It's also possible to get 2 copies in a file if this method is called immediately prior to the file splitting.
    By its nature this method is not useful for writing to a buffer since it is never split and the event can be written to it as any other.
    The method writeEvent(org.jlab.coda.jevio.EvioNode, boolean) calls writeCommonBlock() which, in turn, only gets called when synchronized. So synchronizing this method will make sure firstEvent only gets set while nothing is being written.
    
    Parameters:
    
    buffer - buffer containing event to be placed first in each file written including all splits. If null, no more first events are written to any files.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if event is bad format; if close() already called; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - setFirstEvent
```
public void setFirstEvent(EvioBank bank)
                   throws EvioException,
                          java.io.IOException
```
    Set an event which will be written to the file/buffer as well as to all split files. It's called the "first event" as it will be the first event written to each split file (after the dictionary) if this method is called early enough or the first event was defined in the constructor.
    Since this method is always called after the constructor, the common block will have already been written with a dictionary and firstEvent if either was defined in the constructor. The event given here will be written immediately somewhere in the body of the file, with the forth-coming split files having that event in the first block along with any dictionary.
    This means that if the firstEvent is given in the constructor, then the caller may end up with 2 copies of it in a single file (if this method is called once). It's also possible to get 2 copies in a file if this method is called immediately prior to the file splitting.
    By its nature this method is not useful for writing to a buffer since it is never split and the event can be written to it as any other.
    Do not call this while simultaneously calling close, flush, writeEvent, or getByteBuffer.
    
    Parameters:
    
    bank - event to be placed first in each file written including all splits. If null, no more first events are written to any files.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if event is bad format; if close() already called; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - flush
```
public void flush()
```
    This method flushes any remaining internally buffered data to file. Calling close() automatically does this so it isn't necessary to call before closing. This method should only be used when writing events at such a low rate that it takes an inordinate amount of time for internally buffered data to be written to the file.
    Calling this can kill performance. May not call this when simultaneously calling writeEvent, close, setFirstEvent, or getByteBuffer.
  - close
```
public void close()
```
    This method flushes any remaining data to file and disables this object. May not call this when simultaneously calling writeEvent, flush, setFirstEvent, or getByteBuffer.
  - examineFirstBlockHeader
```
protected EventWriterUnsync.IOStatus examineFirstBlockHeader()
                                                      throws java.io.IOException,
                                                             EvioException
```
    Reads part of the first block (physical record) header in order to determine the evio version # and endianness of the file or buffer in question. These things do not need to be examined in subsequent block headers.
    
    Returns:
    
    status of read attempt
    
    Throws:
    
    java.io.IOException - if error reading file
    
    EvioException - if not in append mode; if file has bad format;
  - hasRoom
```
public boolean hasRoom(int bytes)
```
    Is there room to write this many bytes to an output buffer as a single event? Will always return true when writing to a file.
    
    Parameters:
    
    bytes - number of bytes to write
    
    Returns:
    
    true if there still room in the output buffer, else false.
  - writeEvent
```
public void writeEvent(EvioNode node,
                       boolean force)
                throws EvioException,
                       java.io.IOException
```
    Write an event (bank) to the buffer in evio version 4 format. If the internal buffer is full, it will be flushed to the file if writing to a file. Otherwise an exception will be thrown. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    
    Parameters:
    
    node - object representing the event to write in buffer form
    
    force - if writing to disk, force it to write event to the disk.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if close() already called; if bad eventBuffer format; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - writeEvent
```
public void writeEvent(EvioNode node,
                       boolean force,
                       boolean duplicate)
                throws EvioException,
                       java.io.IOException
```
    Write an event (bank) to the buffer in evio version 4 format. If the internal buffer is full, it will be flushed to the file if writing to a file. Otherwise an exception will be thrown. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    
    Parameters:
    
    node - object representing the event to write in buffer form
    
    force - if writing to disk, force it to write event to the disk.
    
    duplicate - if true, duplicate node's buffer so its position and limit can be changed without issue.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if close() already called; if bad eventBuffer format; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer; if null node arg;
  - writeEventToFile
```
public boolean writeEventToFile(EvioNode node,
                                boolean force,
                                boolean duplicate)
                         throws EvioException,
                                java.io.IOException
```
    Write an event (bank) into a record and eventually to a file in evio version 4 format. If the internal buffer is full, it will be flushed to the file. Otherwise an exception will be thrown.
    If splitting files, this method returns false if disk partition is too full to write the complete, next split file. If force arg is true, write anyway. DO NOT mix calling this method with calling writeEvent(EvioNode, boolean, boolean) (or the methods which call it). Results are unpredictable as it messes up the logic used to quit writing to full disk. The buffer must contain only the event's data (event header and event data) and must not be in complete evio file format. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    Be warned that injudicious use of a true 2nd arg, the force flag, will kill performance when writing to a file. A true 3rd arg can be used when the backing buffer of the node is accessed by multiple threads simultaneously. This allows that buffer's limit and position to be changed without interfering with the other threads.
    
    Parameters:
    
    node - object representing the event to write in buffer form
    
    force - if writing to disk, force it to write event to the disk.
    
    duplicate - if true, duplicate node's buffer so its position and limit can be changed without issue.
    
    Returns:
    
    true if event was added to record. If splitting files, false if disk partition too full to write the complete, next split file. False if interrupted. If force arg is true, write anyway.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if close() already called; if bad eventBuffer format; if file could not be opened for writing; if file exists but user requested no over-writing; if null node arg;
  - writeEvent
```
public void writeEvent(java.nio.ByteBuffer eventBuffer)
                throws EvioException,
                       java.io.IOException
```
    Write an event (bank) to the buffer in evio version 4 format. The given event buffer must contain only the event's data (event header and event data) and must not be in complete evio file format. If the internal buffer is full, it will be flushed to the file if writing to a file. Otherwise an exception will be thrown. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    
    Parameters:
    
    eventBuffer - the event (bank) to write in buffer form
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if close() already called; if bad eventBuffer format; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - writeEvent
```
public void writeEvent(EvioBank bank)
                throws EvioException,
                       java.io.IOException
```
    Write an event (bank) to a buffer containing evio version 4 format blocks. Each block has an integral number of events. There are limits to the number of events in each block and the total size of each block. If writing to a file, each full buffer is written - one at a time - and may contain multiple blocks. Dictionary is never written with this method. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    
    Parameters:
    
    bank - the bank to write.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if close() already called; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - writeEvent
```
public void writeEvent(java.nio.ByteBuffer bankBuffer,
                       boolean force)
                throws EvioException,
                       java.io.IOException
```
    Write an event (bank) to the buffer in evio version 4 format. The given event buffer must contain only the event's data (event header and event data) and must not be in complete evio file format. If the internal buffer is full, it will be flushed to the file if writing to a file. Otherwise an exception will be thrown. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    Be warned that injudicious use of the 2nd arg, the force flag, will kill performance.
    
    Parameters:
    
    bankBuffer - the bank (as a ByteBuffer object) to write.
    
    force - if writing to disk, force it to write event to the disk.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if close() already called; if bad eventBuffer format; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - writeEvent
```
public void writeEvent(EvioBank bank,
                       boolean force)
                throws EvioException,
                       java.io.IOException
```
    Write an event (bank) to a buffer containing evio version 4 format blocks. Each block has an integral number of events. There are limits to the number of events in each block and the total size of each block. If writing to a file, each full buffer is written - one at a time - and may contain multiple blocks. Dictionary is never written with this method. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    Be warned that injudicious use of the 2nd arg, the force flag, will kill performance.
    
    Parameters:
    
    bank - the bank to write.
    
    force - if writing to disk, force it to write event to the disk.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if close() already called; if file could not be opened for writing; if file exists but user requested no over-writing; if no room when writing to user-given buffer;
  - writeEventToFile
```
public boolean writeEventToFile(EvioBank bank,
                                java.nio.ByteBuffer bankBuffer,
                                boolean force)
                         throws EvioException,
                                java.io.IOException
```
    Write an event (bank) into a block and eventually to a file in evio version 4 format. This method will not work with this object setup to write into a buffer. If splitting files, this method returns false if disk partition is too full to write the complete, next split file. If force arg is true, write anyway. DO NOT mix calling this method with calling writeEvent(EvioBank, ByteBuffer, boolean) (or the methods which call it). Results are unpredictable as it messes up the logic used to quit writing to full disk.
    The event to be written may be in one of two forms. The first is as an EvioBank object and the second is as a ByteBuffer containing only the event's data (event header and event data) and must not be in complete evio file format. The first non-null of the bank arguments will be written. Do not call this while simultaneously calling close, flush, setFirstEvent, or getByteBuffer.
    Be warned that injudicious use of a true 2nd arg, the force flag, will kill performance.
    This method is not used to write the dictionary or the first event (common block). That is only done with the method writeCommonBlock().
    
    Parameters:
    
    bank - the bank (as an EvioBank object) to write.
    
    bankBuffer - the bank (as a ByteBuffer object) to write.
    
    force - if writing to disk, force it to write event to the disk.
    
    Returns:
    
    true if event was added to block. If splitting files, false if disk partition too full to write the complete, next split file. False if interrupted. If force arg is true, write anyway.
    
    Throws:
    
    java.io.IOException - if error writing file
    
    EvioException - if event is opposite byte order of internal buffer; if bad bankBuffer format; if close() already called; if not writing to file; if file could not be opened for writing; if file exists but user requested no over-writing;

Class EventWriterUnsync

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BLOCK_LENGTH_OFFSET

BLOCK_NUMBER_OFFSET

HEADER_LENGTH_OFFSET

EVENT_COUNT_OFFSET

RESERVED1_COUNT_OFFSET

BIT_INFO_OFFSET

MAGIC_OFFSET

VERSION_MASK

DEFAULT_BLOCK_SIZE

DEFAULT_BLOCK_COUNT

MAX_BLOCK_SIZE

MAX_BLOCK_COUNT

MIN_BLOCK_SIZE

MIN_BLOCK_COUNT

headerBytes

headerWords

debug

Constructor Detail

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

EventWriterUnsync

Method Detail

isDiskFull

getBytesWrittenToBuffer

setBuffer

setBuffer

getByteBuffer

toFile

isClosed

getCurrentFilename

getCurrentFilePath

getSplitNumber

getSplitCount

getBlockNumber

getEventsWritten

getByteOrder

setStartingBlockNumber

setFirstEvent

setFirstEvent

setFirstEvent

flush

close

examineFirstBlockHeader

hasRoom

writeEvent

writeEvent

writeEventToFile

writeEvent

writeEvent

writeEvent

writeEvent

writeEventToFile