Field Detail

• public static final java.lang.String DEFAULT_CELL_VALUE

• public static final java.lang.String DEFAULT_CELL_VALUE_CACHE

• public static final java.lang.String DEFAULT_CELL_VALUE_TYPE

• public static final java.lang.String DEFAULT_CELL_VALUE_URL

• public static final java.lang.String METAPROPERTY_TEST_DATA

• public static final java.lang.String METAPROPERTY_TEST_UPDATED

• public static final java.lang.String RULE_EXEC_INFO

• public static final java.lang.String validCubeNameChars

Constructor Detail

• NCube(java.lang.String name)

  Creata a new NCube instance with the passed in name

  Parameters:

  name - String name to use for the NCube.

Method Detail

• void addAxis(Axis axis)

  Add an Axis to this NCube. If the axis has a default column, all cells will be added to the default column. Otherwise, all cells will be cleared.

  Parameters:

  axis - Axis to add

• Column addColumn(java.lang.String axisName, java.lang.Comparable value, java.lang.String colName = null, java.lang.Long suggestedId = null)

  Add a column to the n-cube

  Parameters:

  axisName - String name of the Axis to which the column will be added.

  value - Comparable that will be the value for the given column. Cannot be null.

  colName - The optional name of the column, useful for RULE axis columns. Optional.

  suggestedId - Long id. If id is not valid for the column (unique id, and axis portion matches axis on which it is added), then the ID will be generated. Optional.

  Returns:

  Column the added Column.

• void addMetaProperties(java.util.Map<java.lang.String, java.lang.Object> allAtOnce)

  Add a Map of meta properties all at once.

  Parameters:

  allAtOnce - Map of meta properties to add

• T at(java.util.Map coordinate, java.util.Map output = [:], java.lang.Object defaultValue = null)

  Fetch the contents of the cell at the location specified by the coordinate argument. Be aware that if you have any rule cubes in the execution path, they can execute more than one cell. The cell value returned is the value of the last cell executed. Typically, in a rule cube, you are writing to specific keys within the rule cube, and the calling code then accesses the 'output' Map to fetch the values at these specific keys.

  Parameters:

  coordinate - Map of String keys to values meant to bind to each axis of the n-cube.

  output - Map that can be written to by the code within the the n-cubes (for example, GroovyExpressions.

  defaultValue - Object placed here will be returned if there is no cell at the location pinpointed by the input coordinate. Normally, the defaulValue of the n-cube is returned, but if this parameter is passed a non-null value, then it will be returned.

  Returns:

  Cell pinpointed by the input coordinate. If there is nothing stored at this location, then if there is an axis containing a column with a default value (set as meta-property Column.DEFAULT_VALUE [key: 'default_value']), then that will be returned. If there is no column with a default value, then the n-cube's default value will be returned. If defaultValue is null, then then n-cube defaultValue argument will be returned.

• void breakAxisReference(java.lang.String axisName)

  Convert a reference axis to a non-reference axis. 'Break the Reference.'

  Parameters:

  axisName - String name of reference axis to convert.

• void clearCells()

  Clear all cell values. All axes and columns remain.

• void clearMetaProperties()

  Remove all meta properties associated to this n-cube.

• void clearSha1()

• CompileInfo compile()

  Pre-compile command cells, meta-properties, and rule conditions that are expressions

• boolean containsCell(java.util.Map coordinate, boolean useDefault = false)

  Test to see if a value is mapped at the given coordinate. The 2nd argument allows you to take into account the n-cube level Default Cell value or not. Set to true to have the default value considered, false otherwise.

  Parameters:

  coordinate - Map (coordinate) of a cell

  useDefault - (optional, defaults to false. Set to true, then if a non-default value for the n-cube is set, this method will return true).

  Returns:

  1. boolean true if a defaultValue is set (non-null) and useDefault is true 2. boolean true if a cell is located at the specified coordinate in the sparse cell map. For RULE axes, the name of the Rule Axis must be bound to a rule name (e.g. the 'name' attribute on the Column expression).

• boolean containsCellById(java.util.Collection<java.lang.Long> coordinate)

  Returns:

  true if and only if there is a cell stored at the location specified by the Set coordinate. If the IDs don't locate a coordinate, no exception is thrown - simply false is returned. If no coordinate is supplied for an axis (or axes) that has a default column, then the default column will be bound to for that axis (or axes).

• boolean containsMetaProperty(java.lang.String key)

  Test for existence of a given meta-property key.

  Parameters:

  key - String name of key

  Returns:

  boolean true if the passed in meta-property key exists, false otherwise.

• <T> static NCube<T> createCubeFromBytes(byte[] bytes, int pos = 0, int length = bytes.length)

  Create a cube from a byte[] of JSON bytes, or a gzip byte[] of JSON bytes, both are JSON content representing an n-cube. Calling ncube.toFormattedJson() is the source of the JSON format used.

• <T> static NCube<T> createCubeFromStream(java.io.InputStream stream)

  Create an n-cube from a stream of bytes. The stream can be either a JSON stream of an n-cube or a g-zip JSON stream.

• boolean deleteAxis(java.lang.String axisName)

  Remove an axis from an NCube. All cells will be cleared when an axis is deleted.

  Parameters:

  axisName - String name of axis to remove

  Returns:

  boolean true if removed, false otherwise

• boolean deleteColumn(java.lang.String axisName, java.lang.Comparable value)

  Delete a column from the named axis. All cells that reference this column will be deleted.

  Parameters:

  axisName - String name of Axis contains column to be removed.

  value - Comparable value used to identify column (Long if identifying a RULE column)

  Returns:

  boolean true if deleted, false otherwise

• NCube duplicate(java.lang.String newName = name)

  Create an equivalent n-cube as 'this'.

• boolean equals(java.lang.Object other)

• java.lang.Object extractMetaPropertyValue(java.lang.Object value, java.util.Map input = [:], java.util.Map output = [:])

  If a meta property value is fetched from an Axis or a Column, the value should be extracted using this API, so as to allow executable values to be retrieved.

  Parameters:

  value - Object value to be extracted.

• Column findColumn(java.lang.String axisName, java.lang.Comparable value)

  Convenience method to locate column when you have the axis name as a String and the value to find. If the named axis is a rule axis, then it is expected that value is either a String name of the rule or the long ID of the rule column.

  Parameters:

  axisName - String name of axis. Case does not matter when locating by name.

  value - Comparable value used to find the column.

  Returns:

  Column instance if located, otherwise null.

• <T> static NCube<T> fromSimpleJson(java.lang.String json)

  Use this API to create NCubes from a simple JSON format.

  Parameters:

  json - Simple JSON format

  Returns:

  NCube instance created from the passed in JSON. It is not added to the static list of NCubes. If you want that, call addCube() after creating the NCube with this API.

• <T> static NCube<T> fromSimpleJson(java.io.InputStream stream)

  Use this API to create NCubes from a simple JSON format.

  Parameters:

  stream - Simple JSON format

  Returns:

  NCube instance created from the passed in JSON. It is not added to the static list of NCubes. If you want that, call addCube() after creating the NCube with this API.

• Axis get(java.lang.String axisName)

  This API allows Groovy code to do this: ncube.axisName or ncube['axisName'] to fetch an axis.

  Parameters:

  axisName - String name of axis to get (case ignored)

  Returns:

  Axis if found, null otherwise.

• java.util.List<Advice> getAdvices(java.lang.String method)

  Returns:

  List advices added to this n-cube.

• ApplicationID getApplicationID()

  Returns:

  ApplicationID for this n-cube. This contains the app name, version, etc. that this n-cube is part of.

• java.util.List<Axis> getAxes()

  Returns:

  List a List of all axis within this n-cube.

• Axis getAxis(java.lang.String axisName)

  Retrieve an axis (by name) from this NCube.

  Parameters:

  axisName - String name of Axis to fetch.

  Returns:

  Axis instance requested by name, or null if it does not exist.

• Axis getAxisFromColumnId(long id, boolean columnMustExist = true)

  Given the passed in Column ID, return the axis that contains the column.

  Parameters:

  id - Long id of a Column on one of the Axes within this n-cube.

  columnMustExist - boolean, defaults to true. The axis will only be returned if the column id passed in is that of a column on the axis. For example, a deleted column ID, while it may contain the correct axis id, it is no longer on the axis. If this is false, then the axis will still be returned even if the column id represents a column no longer on the axis. If true, both the axis and column must exist.

  Returns:

  Axis containing the column id, or null if the id does not match any columns.

• java.util.Set<java.lang.String> getAxisNames()

  Returns:

  Set containing all axis names on this n-cube.

• T getCell(java.util.Map coordinate, java.util.Map output = [:], java.lang.Object defaultValue = null)

  Fetch the contents of the cell at the location specified by the coordinate argument.
  
   Note that if you have any rule axes, they can execute more than one time.  The value
   returned by this method is the value of the last cell executed. Typically, in a rule cube,
   you are writing to specific keys within the output Map, and the calling code then accesses
   the 'output' Map to fetch the values at these specific keys.
  
   A rule axis name can have a String, Collection, Map, or nothing associated to it.
     - If the value is a String, then it is the name of the rule to begin execution
       (skips past rules ahead of it).
     - If the value associated to a rule axis name is a Collection, then it is considered a
       Collection of rule names to run (orchestration).  In that case, only the named rules
       will be executed (their conditions evaluated, and if true, the associated statements).
     - If the associated value is a Map, then the keys will be the names of meta-property keys
       associated to the rule condition column meta-property keys, and the values must match
       the value associated to the meta-property. The special value NCUBE.DONT_CARE can be
       associated to the key, in which case only the key name of the meta-property must match
       the key name in the passed in map in order for the rule to be selected.  If there
       is more than one entry in the passed in Map, then the rules must match on all entries.
       This is a conjunction (or AND) - the rules match all keys are selected.
     - If nothing is associated to the rule axis name (or null), then all rules are selected.
  
   Once the rules are selected, all rule conditions are executed.  If the condition is true,
   then the associated statement is executed.
  
   Note: More than one rule axis can be added to an n-cube.  In this case, each rule axis
   name can have its own orchestration (rule list) to select the rules on the given axis.
   

  Parameters:

  coordinate - Map of String keys to values meant to bind to each axis of the n-cube.

  output - Map that can be written to by the code within the the n-cubes (for example, GroovyExpressions.

  defaultValue - Object placed here will be returned if there is no cell at the location pinpointed by the input coordinate. Normally, the defaulValue of the n-cube is returned, but if this parameter is passed a non-null value, then it will be returned.

  Returns:

  Cell pinpointed by the input coordinate. If there is nothing stored at this location, then if there is an axis containing a column with a default value (set as meta-property Column.DEFAULT_VALUE [key: 'default_value']), then that will be returned. If there is no column with a default value, then the n-cube's default value will be returned. If defaultValue is null, then then n-cube defaultValue argument will be returned.

• java.lang.Object getCellByIdNoExecute(java.util.Set<java.lang.Long> coordinate)

  Mainly useful for displaying an ncube within an editor. This will get the actual stored cell, not execute it. The caller will get CommandCell instances for example, as opposed to the return value of the executed CommandCell.

• java.util.Map<java.util.Set<java.lang.Long>, T> getCellMap()

  Returns:

  read-only copy of the n-cube cells.

• java.lang.Object getCellNoExecute(java.util.Map coordinate)

  Fetch the actual 'formula' at the given cell. In the case of primitives, the primitive will be returned. However, in the case of an Expression, the Expression will be returned, not executed.

  throws:

  CoordinateNotFoundException if the coordinate does not represent a coordinate with the space of this n-cube.

  Returns:

  value stored at the given location. Since this method will return null when there is no value in an empty (unset) cell, use containsCell() if you need to distinguish between not present and null.

• java.lang.Object getColumnDefault(java.util.Set<java.lang.Long> colIds)

  Given the passed in column IDs, return the column level default value if one exists or null otherwise. In the case of intersection, then null is returned, meaning that the n-cube level default cell value will be returned at intersections.

• java.util.Map getCoordinateFromIds(java.util.Set<java.lang.Long> idCoord)

  Turn a Set of column IDs into a 'normal' coordinate that has values that will bind to axes the 'normal' way. For RULE axes, the key will be the rule axis name and the value will be the rule name. If there is no rule name, then the value will be the long ID of the column on the rule axis.

  Parameters:

  idCoord - Set ids that describe a binding to a cell

  Returns:

  Map standard coordinate. Note that this coordinate has an entry for a rule axis, which typically would NOT be used for a call to getCell(), as normally rule axes have no binding (so all conditions on the rule axis execute). The returned coordinate, however, is useful for setCell(), removeCell(), containsCell(), and getCellNoExecute() APIs. To use with getCell(), remove the entry or entries that have rule axis names.

• java.util.Set<java.lang.Long> getCoordinateKey(java.util.Map coordinate, java.util.Map output = new CaseInsensitiveMap()

  Parameters:

  coordinate - Map containing Axis names as keys, and Comparable's as values. The coordinate key matches an axis name, and then the column on the axis is found that best matches the input coordinate value. Use this when the input is expected to only match one value on an axis. For example, for a RULE axis, the key name is the RULE axis name, and the value is the rule name to match.

  Returns:

  a Set key in the form of Column1,Column2,...Column-n where the Columns are the Column IDs along the axis that match the value associated to the key (axis name) of the passed in input coordinate. The ordering is the order the axes are stored within in NCube. The returned Set is the 'key' of NCube's cells Map, which maps a coordinate (Set of column IDs) to the cell value.

• byte[] getCubeAsGzipJsonBytes()

  Returns:

  byte[] containing the bytes of this N-Cube when converted to JSON format and then gzipped.

• T getDefaultCellValue()

  Returns:

  T the default value that will be returned when a coordinate specifies a cell that has no entry associated to it. This is a space-saving technique, as the most common cell value can be set as the defaultCellValue, and then the cells that would have had this value can be left empty.

• java.util.Map<java.lang.String, java.lang.Object> getDisplayCoordinateFromIds(java.util.Set<java.lang.Long> idCoord)

  Fetch a 'display' coordinate from the passed in Set of IDs. The returned coordinate will have the String 'default column' for column ids that represent default columns. If any of the columns have a name (like columns on a rule axis), the name will be included in the String associated to the axis name entry.

  Parameters:

  idCoord - Set column IDs.

  Returns:

  Map where the keys of the Map are axis names, and the values are the associated values that would bind to the axes, except for default column and rule axes. This API is typically used for display purposes.

• java.util.Map<java.lang.Object, T> getMap(java.util.Map coordinate, java.util.Map output = [:], java.lang.Object defaultValue = null)

  Get a Map of column values and corresponding cell values where all axes but one are held to a fixed (single) column, and one axis allows more than one value to match against it.

  Parameters:

  coordinate - Map - A coordinate where the keys are axis names, and the values are intended to match a column on each axis, with one exception. One of the axis values in the coordinate input map must be an instanceof a Set. If the set is empty, all columns and cell values for the given axis will be returned in a Map. If the Set has values in it, then only the columns on the 'wildcard' axis that match the values in the set will be returned (along with the corresponding cell values).

  output - Map that can be written to by the code within the the n-cubes (for example, GroovyExpressions. Optional.

  defaultValue - Object placed here will be returned if there is no cell at the location pinpointed by the input coordinate. Normally, the defaulValue of the n-cube is returned, but if this parameter is passed a non-null value, then it will be returned. Optional.

  Returns:

  a Map containing Axis names and values to bind to those axes. One of the axes must have a Set bound to it.

• long getMaxAxisId()

  Determine highest ID used by the axes. When adding an additional axis, it is recommended to use this value plus 1 for adding another axis.

  Returns:

  long the highest ID used by any axis.

• java.util.Map getMetaProperties()

  Fetch n-cube meta properties (SHA1, HEAD_SHA1, and CHANGE_TYPE are not meta-properties. Use their respective accessor functions to obtain those).

  Returns:

  Map (case insensitive keys) containing meta (additional) properties for the n-cube. Modifications to this Map do not modify the actual meta properties of n-cube. To do that, you need to use setMetaProperty(), addMetaProperty(), or remoteMetaProperty()

• java.lang.Object getMetaProperty(java.lang.String key)

  Fetch the value associated to the passed in Key from the MetaProperties (if any exist). If none exist, null is returned.

• java.lang.String getName()

  Returns:

  String name of the NCube

• int getNumCells()

  Returns:

  int total number of cells that are uniquely set (non default) within this NCube.

• int getNumDimensions()

  Returns:

  int the number of axis (dimensions) for this n-cube.

• long getNumPotentialCells()

  Returns:

  long number of potential cells this n-cube potentially has

• java.util.Set<java.lang.String> getOptionalScope(java.util.Map input, java.util.Map output)

  Get the optional scope keys. These are keys that if supplied, might change the returned value, but if not supplied a value is still returned. For example, an axis that has a Default column is an optional scope. If no value is supplied for that axis, the Default column is chosen. However, supplying a value for it *may* change the column selected. Similarly, a cube may reference another cube, and the 'sub-cube' may use different scope keys than the calling cube. These additional keys are located and added as optional scope.

  Returns:

  Set of String scope key names that are optional.

• java.util.List<java.util.Map<java.lang.String, T>> getPopulatedCellCoordinates()

  Returns:

  List> which is a List of coordinates, one for each populated cell within the n-cube. These coordinates can be used with setCell(), removeCell(), containsCell(), and getCellNoExecute() APIs. To use with getCell(), any rule axis bindings in the coordinate would need to be removed. This is because it is expected that getCell() will run all conditions on a rule axis.

• java.util.Map<java.util.Map, java.util.Set<java.lang.String>> getReferencedCubeNames()

  Returns:

  Map> A map keyed by cell coordinates within this specific NCube. Each map entry contains the cube names referenced by the cell coordinate in question. It is not recursive.

• java.util.Set<java.lang.String> getRequiredScope(java.util.Map input, java.util.Map output)

  Determine the required 'scope' needed to access all cells within this NCube. Effectively, you are determining how many axis names (keys in a Map coordinate) are required to be able to access any cell within this NCube. Keep in mind, that CommandCells allow this NCube to reference other NCubes and therefore the referenced NCubes must be checked as well. This code will not get stuck in an infinite loop if one cube has cells that reference another cube, and it has cells that reference back (it has cycle detection).

  Returns:

  Set names of axes that will need to be in an input coordinate in order to use all cells within this NCube.

• static RuleInfo getRuleInfo(java.util.Map output)

  Get / Create the RuleInfo Map stored at output[NCube.RULE_EXEC_INFO]

• java.lang.String getStatus()

  Returns:

  ReleaseStatus of this n-cube as it was loaded.

• java.util.List<NCubeTest> getTestData()

• java.lang.String getVersion()

  Returns:

  String version of this n-cube as it was loaded.

• boolean hasRuleAxis()

  Returns:

  boolean true if there is at least one rule axis, false if there are no rule axes.

• int hashCode()

• boolean isComparableCube(NCube<T> other)

  Test if another n-cube is 'comparable' with this n-cube. This means that they have the same number of dimensions (axes) and each axis has the same name. This test will allow many operations to be performed on two cubes once it is known they are 'compatible' such as union, intersection, even matrix operations like multiply, etc.

  Parameters:

  other - NCube to compare to this ncube.

  Returns:

  boolean true if the passed in cube has the same number of axes, the axes have the same names, otherwise false.

• static boolean isTrue(java.lang.Object ruleValue)

  Follow the exact same treatment of TRUTH as Groovy

• java.util.Map mapReduce(java.lang.String rowAxisName, java.lang.String colAxisName, groovy.lang.Closure where = { true }, java.util.Map input = [:], java.util.Map output = [:], java.util.Set columnsToSearch = null, java.util.Set columnsToReturn = null)

  Filter rows of an n-cube. Use this API to fetch a subset of an n-cube, similar to SQL SELECT.

  Parameters:

  rowAxisName - String name of axis acting as the ROW axis.

  colAxisName - String name of axis acting as the COLUMN axis.

  where - Closure groovy closure. Written as condition in terms of the columns on the colAxisName. Example: { Map input -> (input.state == 'TX' || input.state == 'OH') && (input.attribute == 'fuzzy')}. This will only return rows where this condition is true ('state' and 'attribute' are two column values from the colAxisName). The values for each row in the rowAxis is bound to the where expression for each row. If the row passes the 'where' condition, it is included in the output.

  output - Map the output Map use to write multiple return values to, just like getCell() or at().

  input - Map the input Map just like it is used for getCell() or at(). Only needed when there are three (3) or more dimensions. All values in the input map (excluding the axis specified by rowAxisName and colAxisName) are bound just as they are in getCell() or at().

  columnsToSearch - Set which allows reducing the number of columns bound for use in the where clause. If not specified, all columns on the colAxisName can be used. For example, if you had an axis named 'attribute', and it has 10 columns on it, you could list just two (2) of the columns here, and only those columns would be placed into values accessible to the where clause via input.xxx == 'someValue'. The mapReduce() API runs faster when fewer columns are included in the columnsToSearch.

  columnsToReturn - Set of values to indicate which columns to return. If not specified, the entire 'row' is returned. For example, if you had an axis named 'attribute', and it has 10 columns on it, you could list just two (2) of the columns here, in the returned Map of rows, only these two columns will be in the returned Map. The columnsToSearch and columnsToReturn can be completely different, overlap, or not be specified. This param is similar to the 'Select List' portion of the SQL SELECT statement. It essentially defaults to '*', but you can have it return less column/value pairs in the returned Map if you add only the columns you want returned here.

  Returns:

  Map of Maps - The outer Map is keyed by the column values of all row columns. If the row Axis is a discrete axis, then the keys of the map are all the values of the columns. If a non-discrete axis is used, then the keys are the name meta-key for each column. If a non-discrete axis is used and there are no name attributes on the columns, and exception will be thrown. The 'value' associated to the key (column value or column name) is a Map record, where the keys are the column values (or names) for axis named colAxisName. The associated values are the values for each cell in the same column, for when the 'where' condition holds true (groovy true).

• void mergeDeltas(java.util.List<Delta> deltas)

  Merge the passed in List of Delta's into this n-cube.

  Parameters:

  deltas - List of Delta instances.

• static java.util.Map objectToMap(java.lang.Object o)

  Convert an Object to a Map. This allows an object to then be passed into n-cube as a coordinate. Of course the returned map can have additional key/value pairs added to it after calling this method, but before calling getCell().

  Parameters:

  o - Object any Java object to bind to an NCube.

  Returns:

  Map where the fields of the object are the field names from the class, and the associated values are the values associated to the fields on the object.

• void removeAxisReferenceTransform(java.lang.String axisName)

  Remove transform from a reference axis.

  Parameters:

  axisName - String name of reference axis.

• T removeCell(java.util.Map coordinate)

  Clear (remove) the cell at the given coordinate. The cell is dropped from the internal sparse storage. After this call, containsCell(coord) for the same cell will return false.

  Parameters:

  coordinate - Map coordinate of Cell to remove.

  Returns:

  value of cell that was removed. For RULE axes, the name of the Rule Axis must be bound to a rule name (e.g. the 'name' attribute on the Column expression). If you need to distinguish between a null stored in a null, versus nothing being stored there, use containsCell() first.

• T removeCellById(java.util.Set<java.lang.Long> coordinate)

  Clear a cell directly from the cell sparse-matrix specified by the passed in Column IDs. After this call, containsCell(coord) for the same coordinate would return false.

• java.lang.Object removeMetaProperty(java.lang.String key)

  Remove a meta-property entry

• void renameAxis(java.lang.String oldName, java.lang.String newName)

  Rename an axis

  Parameters:

  oldName - String old name

  newName - String new name

• void setApplicationID(ApplicationID appId)

• T setCell(T value, java.util.Map coordinate)

  Store a value in the cell at the passed in coordinate.

  Parameters:

  value - A value to store in the NCube cell.

  coordinate - Map coordinate used to identify what cell to update. The Map contains keys that are axis names, and values that will locate to the nearest column on the axis.

  Returns:

  the prior cells value.

• T setCellById(T value, java.util.Set<java.lang.Long> coordinate)

  Set a cell directly into the cell sparse-matrix specified by the passed in Column IDs.

• void setDefaultCellValue(T defaultCellValue)

  Set the default cell value for this n-cube. This is a space-saving technique, as the most common cell value can be set as the defaultCellValue, and then the cells that would have had this value can be left empty.

  Parameters:

  defaultCellValue - T the default value that will be returned when a coordinate specifies a cell that has no entry associated to it.

• java.lang.Object setMetaProperty(java.lang.String key, java.lang.Object value)

  Set (add / overwrite) a Meta Property associated to this n-cube.

  Parameters:

  key - String key name of meta property

  value - Object value to associate to key

  Returns:

  prior value associated to key or null if none was associated prior

• void setName(java.lang.String name)

  Set the name of this n-cube

  Parameters:

  name - String name

• static void setStackEntryCoordinateValueMaxSize(int maxSize)

  Sets the max size for coordinate value strings in StackEntry.

  Parameters:

  maxSize - int

• void setTestData(java.lang.Object[] tests)

• java.lang.String sha1()

  Returns:

  SHA1 value for this n-cube. The value is durable in that Axis order and cell order do not affect the SHA1 value.

• java.lang.String toFormattedJson(java.util.Map options = null)

  Format this n-cube into JSON using the passed in 'options' Map to control the desired output. See the JsonFormatter's format() API for available options.

  Returns:

  String JSON representing this entire n-cube, in the format controlled by the passed in options Map.

• java.lang.String toHtml(java.lang.String... headers)

  Use this API to generate an HTML view of this NCube.

  Parameters:

  headers - String list of axis names to place at top. If more than one is listed, the first axis encountered that matches one of the passed in headers, will be the axis chosen to be displayed at the top.

  Returns:

  String containing an HTML view of this NCube.

• java.lang.String toString()

• void updateColumn(long id, java.lang.Comparable value, java.lang.String name = null, int order = -1i)

  Change the value of a Column along an axis.

  Parameters:

  id - long indicates the column to change

  value - Comparable new value to set into the column

  order - int (optional) new display order for column

• java.util.Set<java.lang.Long> updateColumns(java.lang.String axisName, java.util.Collection<Column> newCols, boolean allowPositiveColumnIds = false)

  Update all of the columns along an axis at once. Any cell referencing a column that is deleted, will also be deleted from the internal sparse matrix (Map) of cells.

  Parameters:

  axisName - String axis name to update

  newCols - List display ordered list of columns. An n-cube editor program, for example, would call this API with an axisName and set of new columns.

  Returns:

  Set column ids, indicating which columns were deleted.

• T use(java.util.Map altInput, java.util.Map input, java.util.Map output, java.lang.Object defaultCellValue)

  Grab the cell located at altInput, then run it in terms of the input.

• static void validateCubeName(java.lang.String cubeName)

  Ensure that the passed in name is a valid n-cube name,

  throws:

  IllegalArgumentException if the name is invalid, otherwise it is silent.

  Parameters:

  cubeName - String cube name to test.