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

• private static final org.apache.logging.log4j.Logger LOG

• public static final java.lang.String RULE_EXEC_INFO

• private final java.util.Map<java.lang.String, Advice> advices

• private ApplicationID appId

• private final java.util.Map<java.lang.String, Axis> axisList

• protected final java.util.Map<LongHashSet, T> cells

• private T defaultCellValue

• private static final java.lang.ThreadLocal<java.util.Deque<StackEntry>> executionStack

• private final gnu.trove.map.hash.TLongObjectHashMap<Axis> idToAxis

• private java.util.Map metaProps

• private java.lang.String name

• private java.lang.String sha1

• 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

• protected void addAdvice(Advice advice, java.lang.String method)

  Add advice to this n-cube that will be called before / after any Controller Method or URL-based Expression, for the given method

• void addAxis(Axis axis)

  Add an Axis to this NCube. All cells will be cleared when axis is added.

  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

  Returns:

  Column the added Column.

  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.

• 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.

  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.

  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.

• private java.util.Map<java.lang.String, java.util.List<Column>> bindCoordinateToAxisColumns(java.util.Map input)

  Bind the input coordinate to each axis. The reason the column is a List of columns that the coordinate binds to on the axis, is to support RULE axes. On a regular axis, the coordinate binds to a column (with a binary search or hashMap lookup), however, on a RULE axis, the act of binding to an axis results in a List.

  Parameters:

  input - The passed in input coordinate to bind (or multi-bind) to each axis.

• 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.

• protected void clearAdvices()

  For testing, advices need to be removed after test completes.

• void clearCells()

  Clear all cell values. All axes and columns remain.

• void clearMetaProperties()

  Remove all meta properties associated to this n-cube.

• void clearSha1()

• private java.lang.String columnIdsToString(java.util.Set<java.lang.Long> columns)

• 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.

  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).

  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).

• 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).

• static NCube<T> createCubeFromBytes(byte[] bytes)

  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.

• 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.

• NCube createStubCube()

• private static void deepSha1(java.security.MessageDigest md, java.lang.Object value, byte sep)

• boolean deleteAxis(java.lang.String axisName)

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

  Returns:

  boolean true if removed, false otherwise

  Parameters:

  axisName - String name of axis to remove

• 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.

  Returns:

  boolean true if deleted, false otherwise

  Parameters:

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

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

• NCube duplicate(java.lang.String newName)

  Create an equivalent n-cube as 'this'.

• private void ensureAllRuleAxesBound(java.util.Map coordinate, java.util.Map<java.lang.String, java.lang.Integer> conditionsFiredCountPerAxis)

  Verify that at least one rule on each rule axis fired. If not, then you have a CoordinateNotFoundException.

  Parameters:

  coordinate - Input (Map) coordinate for getCell()

  conditionsFiredCountPerAxis - Map that tracks AxisName to number of fired-columns bound to axis

• protected LongHashSet ensureFullCoordinate(java.util.Collection<java.lang.Long> coordinate)

  Make sure the returned Set contains a column ID for each axis, even if the input set does not have a coordinate for an axis, but the axis has a default column (the default column's ID will be added to the returned Set).

  Returns:

  Set that contains only the necessary coordinates from the passed in Collection. If it cannot bind, null is returned.

• boolean equals(java.lang.Object other)

• private T executeAssociatedStatement(java.util.Map input, java.util.Map output, RuleInfo ruleInfo, Binding binding)

• private java.lang.Object executeExpression(java.util.Map ctx, CommandCell cmd)

• 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.

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

  Use this API to create NCubes from a 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.

  Parameters:

  json - Simple JSON format

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

  Use this API to create NCubes from a 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.

  Parameters:

  stream - Simple JSON format

• Axis get(java.lang.String axisName)

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

  Returns:

  Axis if found, null otherwise.

  Parameters:

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

• 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.

  Returns:

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

  Parameters:

  axisName - String name of Axis to fetch.

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

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

  Returns:

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

  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.

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

  Returns:

  Set containing all axis names on this n-cube.

• protected static java.lang.Boolean getBoolean(java.util.Map obj, java.lang.String key)

• 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. 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.

  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.

  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.

• protected T getCellById(java.util.Set<java.lang.Long> colIds, java.util.Map coordinate, java.util.Map output, java.lang.Object defaultValue = null)

  The lowest level cell fetch. This method uses the Set to fetch an exact cell, while maintaining the original input coordinate that the location was derived from (required because a given input coordinate could map to more than one cell). Once the cell is located, it is executed and the value from the executed cell is returned. In the case of Command Cells, it is the return value of the execution, otherwise the return is the value stored in the cell, and if there is no cell, then a default value from NCube is returned, if one is set. Default value ordering - first, a column level default is used if one exists (under Column's meta-key: 'DEFAULT_CELL'). If no column-level default is specified (no non-null value provided), then the NCube level default is chosen (if it exists). If no NCube level default is specified, then the defaultValue passed in is used, if it is non-null. REQUIRED: The coordinate passed to this method must have already been run through validateCoordinate(), which duplicates the coordinate and ensures the coordinate has at least an entry for each axis (entry not needed for axes with default column or rule axes).

• 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<LongHashSet, 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.

  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.

  Parameters:

  idCoord - Set ids that describe a binding to a cell

• LongHashSet getCoordinateKey(java.util.Map coordinate)

  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.

  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.

• private static java.util.Map<java.lang.String, java.lang.Integer> getCountersPerAxis(java.lang.String[] axisNames)

• byte[] getCubeAsGzipJsonBytes()

  Returns:

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

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

  Get the declared required scope keys for this n-cube. These keys are required to 'talk' to this cube and any of it's subordinate cubes. Note that the keys can be a list of Strings of an expression (which could join another n-cube).

  Returns:

  Set required scope keys.

  Parameters:

  input - Map containing input

  output - Map for writing output.

• 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, T> 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.

  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.

  Parameters:

  idCoord - Set column IDs.

• protected static java.lang.Long getLong(java.util.Map obj, java.lang.String key)

• 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.

  Returns:

  a Map containing Axis names and values to bind to those axes. One of the axes must have a Set bound to 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.

• 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.Set<java.lang.String> getReferencedCubeNames()

  Returns:

  Set names of all referenced cubes within this specific NCube. It is not recursive.

• protected java.util.Set<java.lang.String> getRequiredAxes()

  Returns:

  Set Axis names that do not have default columns. Note, a RULE axis name will never be included as a required Axis, even if it does not have a default column. This is because you typically do not bind a value to a rule axis name, but instead the columns on the rule axis execute in order.

• 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.

• protected static java.lang.String getString(java.util.Map obj, java.lang.String key)

• java.lang.String getVersion()

  Returns:

  String version of this n-cube. The version is set when the n-cube is loaded by the NCubeManager.

• private Axis getWildcardAxis(java.util.Map<java.lang.String, java.lang.Object> coordinate)

  Returns:

  Axis the axis that has a Set specified for it rather than a non-Set value. The Set associated to the input coordinate field indicates that the caller is matching more than one value against this axis.

  Parameters:

  coordinate - passed in coordinate for accessing this n-cube

• private java.util.List<Column> getWildcardColumns(Axis wildcardAxis, java.util.Map coordinate)

  Returns:

  a List of all columns that match the values in the Set, or in the case of an empty Set, all columns on the axis.

  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. The input coordinate must contain one Set as a value for one of the axes of the NCube. If empty, then the Set is treated as '*' (star). If it has 1 or more elements in it, then for each entry in the Set, a column position value is returned.

• boolean hasRuleAxis()

  Returns:

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

• int hashCode()

• private static NCube<T> hydrateCube(java.util.Map jsonNCube)

• private static boolean incrementVariableRadixCount(java.util.Map<java.lang.String, java.lang.Integer> counters, java.util.Map<java.lang.String, java.util.List<Column>> bindings, java.lang.String[] axisNames)

  Increment the variable radix number passed in. The number is represented by a Map, where the keys are the digit names (axis names), and the values are the associated values for the number.

  Returns:

  false if more incrementing can be done, otherwise true.

• 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.

  Returns:

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

  Parameters:

  other - NCube to compare to this ncube.

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

  Follow the exact same treatment of TRUTH as Groovy

• private static boolean isZero(java.lang.Integer count)

• private static void loadMetaProperties(java.util.Map props)

• 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().

  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.

  Parameters:

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

• protected java.util.Map prepareExecutionContext(java.util.Map coord, java.util.Map output)

  Prepare the execution context by providing it with references to important items like the input coordinate, output map, stack, and this (ncube).

• 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.

  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.

  Parameters:

  coordinate - Map coordinate of Cell to remove.

• 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.

  Returns:

  the prior cells value.

  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.

• 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.

  Returns:

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

  Parameters:

  key - String key name of meta property

  value - Object value to associate to key

• void setName(java.lang.String name)

  Set the name of this n-cube

  Parameters:

  name - String name

• protected void setSha1(java.lang.String sha1)

  This should only be called from NCubeManager when loading the cube from a database It is mainly to prevent an unnecessary sha1 calculation after being loaded from a db that already knows the sha1.

  Parameters:

  sha1 - String SHA-1 value to set into this n-cube. Should only be called internally from code constructing this n-cube from a persistent store.

• 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.

• private static java.lang.String stackToString()

• 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.

  Returns:

  String containing 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.

• protected static java.lang.String toJson(java.lang.Object o)

• java.lang.String toString()

• private static void trackInputKeysUsed(java.util.Map input, java.util.Map output)

• void updateColumn(long id, java.lang.Comparable value)

  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

• 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.

  Returns:

  Set column ids, indicating which columns were deleted.

  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.

• private java.util.Map validateCoordinate(java.util.Map coordinate, java.util.Map output)

  Ensure that the Map coordinate dimensionality satisfies this nCube. This method verifies that all axes are listed by name in the input coordinate.

  Parameters:

  coordinate - Map input coordinate

• 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.