Package org.knime.core.data.container

Implementation of a DataContainer.

See:
          Description

Interface Summary
CellFactory Factory for a ColumnRearranger to provide new columns which are, e.g.
KNIMEStreamConstants Defines some constants commonly used when writing Buffer files.
RowAppender This is a very simple interface that allows adding DataRows to a DataTable, DataContainer, or anything else.
 

Class Summary
AbstractCellFactory Default implementation of a CellFactory, which creates more than a single new column.
BlobDataCell Abstract Binary large object cell used to handle potentially large cells.
BlobDataCell.BlobAddress Utility class that holds information where the blob is located.
BlobSupportDataRow Special row implementation that supports to access the wrapper cells of BlobDataCell.
BlobWrapperDataCell Wrapper for BlobDataCell.
BlockableInputStream Input Stream that wraps a given input stream and searches for terminated end blocks.
BlockableOutputStream Output stream that allows to set block marks.
Buffer A buffer writes the rows from a DataContainer to a file.
Buffer.FromFileIterator Super class of all file iterators.
BufferFromFileIteratorVersion1x (Obsolete) File iterator to read files written by a Buffer.
BufferFromFileIteratorVersion20 File iterator to read stream written by a Buffer.
BufferFromFileIteratorVersion20.DataCellStreamReader Utility class that separates the logic of reading DataCells from the stream.
CellClassInfo Pair of cell class and possibly a DataType that represents the collection element type (only if cell class is a collection).
CloseableRowIterator A row iterator that can be closed in order to save resources.
ColumnRearranger Meta object to describe in which way a table shall be modified (column-based) to create a new table.
ColumnRearranger.SpecAndFactoryObject Utility class that helps us with internal data structures.
ConcatenateTable  
ContainerTable Class implementing the DataTable interface and using a buffer from a DataContainer as data source.
CopyOnAccessTask Opens (on demand) a zip file from the workspace location and copies the binary data content to temp for further reading.
DataContainer Buffer that collects DataRow objects and creates a DataTable on request.
DataContainer.BufferCreator Helper class to create a Buffer instance given a binary file and the data table spec.
DCObjectInputStream Obsolete input stream to read Files written with Buffer objects in KNIME 1.x (and 2.0TechPreview).
DCObjectInputVersion2 Class interpreting the file format as written by the Buffer class.
DCObjectOutputVersion2 Object writing the binary stream of a Buffer.
JoinedTable Class that realizes a join table of two BufferedDataTable arguments.
JoinTableIterator Internal iterator class that concatenates two rows.
LongUTFDataInputStream Input Stream that's used to read from stream written by LongUTFDataOuputStream.
LongUTFDataOutputStream Wrapper class of a DataOutputStream that also allows to write UTF strings longer than 65535.
NoKeyBuffer Buffer implementation that does not write the row keys.
PriorityGlobalObjectInputStream Object input stream, which can be used to load classes using a given preferred ClassLoader.
RearrangeColumnsTable Table implementation that is created based on a ColumnRearranger.
SingleCellFactory Convenience implementation of a cell factory with one new column.
TableSpecReplacerTable Table that only replaces the data table spec of an underlying table.
WrappedTable Special table implementation that simply wraps a given BufferedDataTable.
 

Exception Summary
DataContainerException Exception that may be thrown by a DataContainer if the data is invalid.
 

Package org.knime.core.data.container Description

Implementation of a DataContainer.

A DataContainer is a buffer that you can use to fill a data table. Use this class when you create much (and also just little) data and you don't want to bother about a data structure that keeps the calculated data. A DataContainer will take care of it, it will memorize the rows that you've added and also buffer it to the disk when the data gets large so that memory gets a bottleneck. Typically, you write code like this:

  DataContainer container = new DataContainer();
  container.open(aDataTableSpec);
  for (...) {
    DataRow newRow = calculateRow();
    container.add(newRow)
  }
  container.close();
  DataTable result = container.getTable();
        

This package contains also implementations for easy storage of datatables whose columns have changed. For further details on how to use them, refer to the description of NodeModel and its execute method.



Copyright, 2003 - 2010. All rights reserved.
University of Konstanz, Germany.
Chair for Bioinformatics and Information Mining, Prof. Dr. Michael R. Berthold.
You may not modify, publish, transmit, transfer or sell, reproduce, create derivative works from, distribute, perform, display, or in any way exploit any of the content, in whole or in part, except as otherwise expressly permitted in writing by the copyright owner or as specified in the license file distributed with this product.