LEOFile (OpenXLS Java Spreadsheet SDK 11.0.4 API)

java.lang.Object
- io.starter.formats.LEO.LEOFile

All Implemented Interfaces:

Serializable
```
public class LEOFile
extends Object
implements Serializable
```
LEOFile is an archive format compatible with other popular archive formats such as OLE. It contains multiple files or "Storages" which can subsequently contain data in popular desktop application formats.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static int actualOutput

static boolean DEBUG

int DEBUGLEVEL

static int IDXBLOCKSIZE

static int MAXDIFATLEN

Fields
Modifier and Type	Field and Description
`static int`	`actualOutput`
`static boolean`	`DEBUG`
`int`	`DEBUGLEVEL`
`static int`	`IDXBLOCKSIZE`
`static int`	`MAXDIFATLEN`

Constructor Summary

Constructors
Constructor and Description
`LEOFile()`
`LEOFile(ByteBuffer bytebuff)` a new LEO file containing LEO archive entries
`LEOFile(File fx)`
`LEOFile(File fpath, boolean usetempfile)` a new LEO file containing LEO archive entries
`LEOFile(File fpath, boolean usetempfile, boolean encryptedXLSX)` Instantiate a Leo file from an encrypted document.
`LEOFile(File fpath, int DEBUGLEVEL)` a new LEO file containing LEO archive entries
`LEOFile(InputStream stream)` Create a LEOFile from an input stream.
`LEOFile(String fname)` a new LEO file containing LEO archive entries

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`checkIsLEO(byte[] data, int count)` Checks whether the given byte array starts with the LEO magic number.
`void`	`clearAfterInit()`
`void`	`close()` Close the underlying IO streams for this LEOFile.
`void`	`closefb()` just closes the filebuffer withut clearing out buffers and storage tables
`Storage[]`	`getAllDirectories()` get all Directories in this LEO file
`static byte[]`	`getBytes(Block[] outblocks)`
`static void`	`getBytes(Block[] outblocks, OutputStream out)` Call this method for each storage, root storage first...
`static byte[]`	`getBytes(List bbvect)` return the bytes for the blocks in a vector
`static void`	`getBytes(List outblocks, OutputStream out)` Call this method for each storage, root storage first...
`static OutputStream`	`getByteStream(Block[] outblocks)`
`static OutputStream`	`getByteStream(List bbvect)` return the bytes for the blocks in a vector
`StorageTable`	`getDirectoryArray()` return the Directory Array for this LEOFile holds all directories (storages and streams) in correct order Directories in turn can reference streams of data
`BlockByteReader`	`getDocBlockBytes()` get the bytes of the DOC file.
`byte[]`	`getEncryptionStorageOverage()`
`String`	`getFileName()`
`LEOHeader`	`getHeader()`
`int`	`getMinBlocks()` Get the minimum blocks that this file can encompass
`static int`	`getSizeInBlocks(int sz, int blocksize)` get the number of Block records that this Storage needs to store its byte array
`Storage`	`getStorageByName(String s)` get a handle to a Storage within this LEO file
`BlockByteReader`	`getXLSBlockBytes()` get the bytes of the XLS file.
`boolean`	`hasDoc()` return whether the LEOFile contains a valid doc
`boolean`	`hasPivotCache()` return whether the LEOFile contains the _SX_DB_CUR Pivot Table Cache storage (required for Pivot Table)
`boolean`	`hasWorkBook()` return whether the LEOFile contains a valid workbook
`int[]`	`init(ByteBuffer bbuf)` read LEO file information from header.
`void`	`initWrapper(ByteBuffer bytebuff)` This is just removing some duplicate code from our constructors We should add some exception handling in here!
`void`	`readEncryptedFile(File encryptedFile)` Reads in an encrypted LEO stream.
`static int[]`	`readFAT(List vect)` returns the table of int locations in the file for the BIGBLOCK linked list.
`static FileBuffer`	`readFile(File fpath)` create a FileBuffer from a file, use system property to determine whether to use a temp file.
`static FileBuffer`	`readFile(File fpath, boolean usetempfile)` create a FileBuffer from a file, use boolean parameter to determine whether to use a temp file.
`static FileBuffer`	`readFile(String fpath)` read in a WorkBook ByteBuffer from a file path.
`void`	`shutdown()`
`List`	`writeBytes(OutputStream out, int workbook_byte_size)` Creates all the necessary headers and associated storages/structures that, along with the actual workbook data, makes up the document Basic Structure 1st sector or block= Header + 1st 109 sector chains (==FAT===array of sector numbers) Location of FAT==DIFAT Header denotes sector of "Root Directory" which in turn denotes sectors of all other directories (Workbook is but one of several directories) Each directory denotes the start block of any associated data into the FAT (sector chain index) (if directory is >0 an <4096 in size, it's associated data is stored in miniStorage Ok, so this is a little odd, it looks as if it collects all of the storages, and handles all of the preprocessing necessary to create FAT etc.

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

- Field Detail
  - MAXDIFATLEN
```
public static final int MAXDIFATLEN
```
    See Also:
    
    Constant Field Values
  - IDXBLOCKSIZE
```
public static final int IDXBLOCKSIZE
```
    See Also:
    
    Constant Field Values
  - DEBUG
```
public static final boolean DEBUG
```
    See Also:
    
    Constant Field Values
  - DEBUGLEVEL
```
public int DEBUGLEVEL
```
  - actualOutput
```
public static int actualOutput
```
- Constructor Detail
  - LEOFile
```
public LEOFile(String fname)
```
    a new LEO file containing LEO archive entries
    
    Parameters:
    
    String - a file path containing a valid LEOfile
  - LEOFile
```
public LEOFile(File fpath,
               boolean usetempfile,
               boolean encryptedXLSX)
```
    Instantiate a Leo file from an encrypted document. We currently have a hack in place for encrypted documents due to their having truncated bigblocks that our interface does not correctly handle.
    
    Parameters:
    
    a - file containing a valid LEOfile (XLS BIFF8)
    
    whether - to use a temp file
    
    if - the file is encrypted xlsx format
  - LEOFile
```
public LEOFile(File fpath,
               boolean usetempfile)
```
    a new LEO file containing LEO archive entries
    
    Parameters:
    
    a - file containing a valid LEOfile (XLS BIFF8)
    
    whether - to use a temp file
  - LEOFile
```
public LEOFile(File fpath,
               int DEBUGLEVEL)
```
    a new LEO file containing LEO archive entries
    
    Parameters:
    
    a - file containing a valid LEOfile (XLS BIFF8)
  - LEOFile
```
public LEOFile(ByteBuffer bytebuff)
```
    a new LEO file containing LEO archive entries
    
    Parameters:
    
    byte[] - a byte array containing a valid LEOfile
  - LEOFile
```
public LEOFile()
```
  - LEOFile
```
public LEOFile(InputStream stream)
        throws IOException
```
    Create a LEOFile from an input stream. Unfortunately because of our byte backer we need to write to a temporary file in order to do this
    
    Parameters:
    
    stream -
    
    Throws:
    
    IOException
  - LEOFile
```
public LEOFile(File fx)
```
- Method Detail
  - getHeader
```
public LEOHeader getHeader()
```
  - close
```
public void close()
           throws IOException
```
    Close the underlying IO streams for this LEOFile. Also deletes the temp file.
    
    Throws:
    
    Exception
    
    IOException
  - closefb
```
public void closefb()
             throws IOException
```
    just closes the filebuffer withut clearing out buffers and storage tables
    
    Throws:
    
    IOException
  - shutdown
```
public void shutdown()
```
  - checkIsLEO
```
public static boolean checkIsLEO(byte[] data,
                                 int count)
```
    Checks whether the given byte array starts with the LEO magic number.
  - initWrapper
```
public void initWrapper(ByteBuffer bytebuff)
```
    This is just removing some duplicate code from our constructors We should add some exception handling in here!
  - clearAfterInit
```
public void clearAfterInit()
```
  - readEncryptedFile
```
public void readEncryptedFile(File encryptedFile)
```
    Reads in an encrypted LEO stream. May be able to remove this and use the standard constructor, we shall see.
    
    Parameters:
    
    encryptedFile -
  - getFileName
```
public String getFileName()
```
  - hasWorkBook
```
public boolean hasWorkBook()
```
    return whether the LEOFile contains a valid workbook
  - hasDoc
```
public boolean hasDoc()
```
    return whether the LEOFile contains a valid doc
  - hasPivotCache
```
public boolean hasPivotCache()
```
    return whether the LEOFile contains the _SX_DB_CUR Pivot Table Cache storage (required for Pivot Table)
    
    Returns:
  - writeBytes
```
public List writeBytes(OutputStream out,
                       int workbook_byte_size)
```
    Creates all the necessary headers and associated storages/structures that, along with the actual workbook data, makes up the document Basic Structure 1st sector or block= Header + 1st 109 sector chains (==FAT===array of sector numbers) Location of FAT==DIFAT Header denotes sector of "Root Directory" which in turn denotes sectors of all other directories (Workbook is but one of several directories) Each directory denotes the start block of any associated data into the FAT (sector chain index) (if directory is >0 an <4096 in size, it's associated data is stored in miniStorage Ok, so this is a little odd, it looks as if it collects all of the storages, and handles all of the preprocessing necessary to create FAT etc. returns a list of all the storages, presumably to be handled by ByteStreamer. A little more information: A list of storages is generated. These storages do not include a) the workbook storage(!) which is meant to be the first record written after receiving the byte array b) individual miniFAT storages, these are all combined into one container storage that is not represented in the header c) the LeoHeader, which is written to the output stream already It seems as if this method needs several things 1) better header comments on its functions 2) break out logic to private methods to keep overall functions understandable. 3) Handle file formats other than XLS (ie doc, encrypted xls, ppt, etc) 4) be clear about its usage to outputStream. Why only the 1 storage written, maybe none would be better? 5) probably throw an exception 6) WHAT IS WITH THE STORAGES THAT ARE NOT STORAGES? -- these are non-directory storages used to write out the bytes contained within in the correct order for the document. These non-directory storages include the FAT and the minFAT blocks and miniStream
    
    Parameters:
    
    outputstream - to write out
    
    book - to write
    
    book - bytes size
    
    Returns:
    
    storages to write out in streamer
  - getStorageByName
```
public Storage getStorageByName(String s)
                         throws StorageNotFoundException
```
    get a handle to a Storage within this LEO file
    
    Throws:
    
    StorageNotFoundException
  - getAllDirectories
```
public Storage[] getAllDirectories()
```
    get all Directories in this LEO file
  - getDirectoryArray
```
public StorageTable getDirectoryArray()
```
    return the Directory Array for this LEOFile
    holds all directories (storages and streams) in correct order
    Directories in turn can reference streams of data
    
    Returns:
  - getDocBlockBytes
```
public BlockByteReader getDocBlockBytes()
```
    get the bytes of the DOC file.
  - getXLSBlockBytes
```
public BlockByteReader getXLSBlockBytes()
```
    get the bytes of the XLS file.
  - init
```
public int[] init(ByteBuffer bbuf)
```
    read LEO file information from header.
  - readFile
```
public static final FileBuffer readFile(File fpath)
```
    create a FileBuffer from a file, use system property to determine whether to use a temp file.
    
    Parameters:
    
    file - containing XLS bytes
    
    fpath -
    
    Returns:
  - readFile
```
public static final FileBuffer readFile(File fpath,
                                        boolean usetempfile)
```
    create a FileBuffer from a file, use boolean parameter to determine whether to use a temp file.
    
    Parameters:
    
    file - containing XLS bytes
    
    whether - to use a tempfile
    
    Returns:
  - readFile
```
public static final FileBuffer readFile(String fpath)
```
    read in a WorkBook ByteBuffer from a file path. from here on out, we're reading pointers to the bytes on disk access data directly on disk through the ByteBuffer.
    By default, OpenXLS will lock open WorkBook files, to close the file after parsing and work with a temporary file instead, use the following setting:
    
    System.getProperties().put("io.starter.formats.LEO.usetempfile", "true");
    
    IMPORTANT NOTE: You will need to clean up temp files occasionally in your user directory (temp filenames will begin with "ExtenXLS_".)
  - readFAT
```
public static final int[] readFAT(List vect)
```
    returns the table of int locations in the file for the BIGBLOCK linked list.
  - getBytes
```
public static final byte[] getBytes(Block[] outblocks)
```
  - getByteStream
```
public static final OutputStream getByteStream(Block[] outblocks)
```
  - getBytes
```
public static final void getBytes(Block[] outblocks,
                                  OutputStream out)
```
    Call this method for each storage, root storage first...
    
    Parameters:
    
    outblocks -
    
    out -
  - getBytes
```
public static final void getBytes(List outblocks,
                                  OutputStream out)
```
    Call this method for each storage, root storage first...
    
    Parameters:
    
    outblocks -
    
    out -
  - getBytes
```
public static final byte[] getBytes(List bbvect)
```
    return the bytes for the blocks in a vector
  - getByteStream
```
public static final OutputStream getByteStream(List bbvect)
```
    return the bytes for the blocks in a vector
  - getSizeInBlocks
```
public static final int getSizeInBlocks(int sz,
                                        int blocksize)
```
    get the number of Block records that this Storage needs to store its byte array
  - getMinBlocks
```
public int getMinBlocks()
```
    Get the minimum blocks that this file can encompass
    
    Returns:
  - getEncryptionStorageOverage
```
public byte[] getEncryptionStorageOverage()
```
    Returns:
    
    Returns the encryptionStorageOverage.

Class LEOFile

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAXDIFATLEN

IDXBLOCKSIZE

DEBUG

DEBUGLEVEL

actualOutput

Constructor Detail

LEOFile

LEOFile

LEOFile

LEOFile

LEOFile

LEOFile

LEOFile

LEOFile

Method Detail

getHeader

close

closefb

shutdown

checkIsLEO

initWrapper

clearAfterInit

readEncryptedFile

getFileName

hasWorkBook

hasDoc

hasPivotCache

writeBytes

getStorageByName

getAllDirectories

getDirectoryArray

getDocBlockBytes

getXLSBlockBytes

init

readFile

readFile

readFile

readFAT

getBytes

getByteStream

getBytes

getBytes

getBytes

getByteStream

getSizeInBlocks

getMinBlocks

getEncryptionStorageOverage