com.pixelmed.dicom

## Class BinaryOutputStream

- java.lang.Object
- - java.io.OutputStream
  - - java.io.FilterOutputStream
    - - com.pixelmed.dicom.BinaryOutputStream

All Implemented Interfaces:
  java.io.Closeable, java.io.Flushable, java.lang.AutoCloseable

Direct Known Subclasses:
  DicomOutputStream

    public class BinaryOutputStream
    extends java.io.FilterOutputStream

A class that extends `FilterOutputStream` by adding the concept of little and big endian binary value encoding, and supplies functions for writing various sized integer and floating point words.

See Also:
  `BinaryInputStream`

### Field Summary

Fields
`protected long` `byteOffset`

### Fields inherited from class java.io.FilterOutputStream

`out`

### Constructor Summary

Constructors
Constructor and Description
`BinaryOutputStream(java.io.OutputStream o, boolean big)`

### Method Summary

Methods
`long` `getByteOffset()` Get the byte offset where the next byte will be written.
`boolean` `isBigEndian()` Is the stream byte order big endian ?
`boolean` `isLittleEndian()` Is the stream byte order little endian ?
`protected void` `localInit(boolean big)`
`static void` `main(java.lang.String[] arg)` For testing.
`void` `setBigEndian()` Set the stream byte order to big endian.
`void` `setEndian(boolean big)` Set the stream byte order to that specified.
`void` `setLittleEndian()` Set the stream byte order to little endian.
`void` `write(byte[] b)` Writes `b.length` bytes to this output stream.
`void` `write(byte[] b, int off, int len)` Writes `len` bytes from the specified byte array starting at offset `off` to this output stream.
`void` `write(int b)` Writes the specified `byte` to this output stream.
`void` `writeDouble(double value)` Write one floating point 64 bit value.
`void` `writeDouble(double[] f, int len)` Write an array of floating point 64 bit values.
`void` `writeFloat(float value)` Write one floating point 32 bit value.
`void` `writeFloat(float[] f, int len)` Write an array of floating point 32 bit values.
`void` `writeSigned16(int v)` Write one signed integer 16 bit value.
`void` `writeSigned32(long v)` Write one signed integer 32 bit value.
`void` `writeUnsigned16(int v)` Write one unsigned integer 16 bit value.
`void` `writeUnsigned16(short[] w, int len)` Write an array of unsigned integer 16 bit values.
`void` `writeUnsigned32(long v)` Write one unsigned integer 32 bit value.
`void` `writeUnsigned8(int v)` Write one unsigned integer 8 bit value.

### Methods inherited from class java.io.FilterOutputStream

`close, flush`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### byteOffset

    protected long byteOffset

### Constructor Detail

#### BinaryOutputStream

    public BinaryOutputStream(java.io.OutputStream o,
                      boolean big)

Parameters:
  `o` -
  `big` -

### Method Detail

#### getByteOffset

    public long getByteOffset()

Get the byte offset where the next byte will be written.

Will be zero at the start of the file.

Returns:
  the byte offset

#### localInit

    protected void localInit(boolean big)

Parameters:
  `big` -

#### write

    public void write(byte[] b,
             int off,
             int len)
               throws java.io.IOException

Writes `len` bytes from the specified byte array starting at offset `off` to this output stream.

The `write` method of `BinaryOutputStream` calls the corresponding multi-byte write method of one argument of the. `OutputStream` supplied in the constructor, and overrides the default use of multiple calls to the single-byte write method that is the behavior of `FilterOutputStream`.

The exceptions thrown are whatever is thrown by the `OutputStream` write method.

Overrides:
  `write` in class `java.io.FilterOutputStream`
Parameters:
  `b` - the data.
  `off` - the start offset in the data.
  `len` - the number of bytes to write.
Throws:
  `java.io.IOException` - if an I/O error occurs.

#### write

    public void write(int b)
               throws java.io.IOException

Writes the specified `byte` to this output stream.

Overrides:
  `write` in class `java.io.FilterOutputStream`
Parameters:
  `b` - the `byte`.
Throws:
  `java.io.IOException` - if an I/O error occurs.

#### write

    public void write(byte[] b)
               throws java.io.IOException

Writes `b.length` bytes to this output stream.

Overrides:
  `write` in class `java.io.FilterOutputStream`
Parameters:
  `b` - the data to be written.
Throws:
  `java.io.IOException` - if an I/O error occurs.

#### isBigEndian

    public boolean isBigEndian()

Is the stream byte order big endian ?

Returns:
  true if big endian, false if little endian

#### isLittleEndian

    public boolean isLittleEndian()

Is the stream byte order little endian ?

Returns:
  true if little endian, false if big endian

#### setBigEndian

    public void setBigEndian()

Set the stream byte order to big endian.

#### setLittleEndian

    public void setLittleEndian()

Set the stream byte order to little endian.

#### setEndian

    public void setEndian(boolean big)

Set the stream byte order to that specified.

Parameters:
  `big` - true if to set to big endian, false if little endian

#### writeUnsigned8

    public final void writeUnsigned8(int v)
                              throws java.io.IOException

Write one unsigned integer 8 bit value.

Parameters:
  `v` - an int containing an unsigned value
Throws:
  `java.io.IOException`

#### writeUnsigned16

    public final void writeUnsigned16(int v)
                               throws java.io.IOException

Write one unsigned integer 16 bit value.

Parameters:
  `v` - an int containing an unsigned value
Throws:
  `java.io.IOException`

#### writeSigned16

    public final void writeSigned16(int v)
                             throws java.io.IOException

Write one signed integer 16 bit value.

Parameters:
  `v` - an int containing an signed value
Throws:
  `java.io.IOException`

#### writeUnsigned32

    public final void writeUnsigned32(long v)
                               throws java.io.IOException

Write one unsigned integer 32 bit value.

Parameters:
  `v` - a long containing an unsigned value
Throws:
  `java.io.IOException`

#### writeSigned32

    public final void writeSigned32(long v)
                             throws java.io.IOException

Write one signed integer 32 bit value.

Parameters:
  `v` - a long containing an signed value
Throws:
  `java.io.IOException`

#### writeFloat

    public final void writeFloat(float value)
                          throws java.io.IOException

Write one floating point 32 bit value.

Parameters:
  `value` - a float value
Throws:
  `java.io.IOException`

#### writeDouble

    public final void writeDouble(double value)
                           throws java.io.IOException

Write one floating point 64 bit value.

Parameters:
  `value` - a double value
Throws:
  `java.io.IOException`

#### writeUnsigned16

    public final void writeUnsigned16(short[] w,
                       int len)
                               throws java.io.IOException

Write an array of unsigned integer 16 bit values.

Parameters:
  `w` - an array of integers to write
  `len` - the number of 16 bit values to write
Throws:
  `java.io.IOException`

#### writeFloat

    public final void writeFloat(float[] f,
                  int len)
                          throws java.io.IOException

Write an array of floating point 32 bit values.

Parameters:
  `f` - an array of floats to write
  `len` - the number of values to write
Throws:
  `java.io.IOException`

#### writeDouble

    public final void writeDouble(double[] f,
                   int len)
                           throws java.io.IOException

Write an array of floating point 64 bit values.

Parameters:
  `f` - an array of floats to write
  `len` - the number of values to write
Throws:
  `java.io.IOException`

#### main

    public static void main(java.lang.String[] arg)

For testing.

Parameters:
  `arg` -