java.lang.Object
- org.qdl_lang.variables.QDLStem

All Implemented Interfaces:

Serializable, Map<String,Object>

Direct Known Subclasses:

StemVariable
```
public class QDLStem
extends Object
implements Map<String,Object>, Serializable
```
Created by Jeff Gaynor
on 6/27/22 at 6:33 AM

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`QDLStem.ARGetkeys`
`static class`	`QDLStem.KeyRankMap`	A map that is keyed by an integer and has lists of indices as values.
`protected static class`	`QDLStem.OrderedIndexEntry`
`static class`	`QDLStem.SizeOf`
`class`	`QDLStem.ValueIterator`

Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K extends Object,V extends Object>

Field Summary

Fields
Modifier and Type Field Description

static String STEM_ENTRY_CONNECTOR

static String STEM_INDEX_MARKER

Constructor Summary

Constructors
Constructor	Description
`QDLStem()`
`QDLStem(Long count, Object[] fillList)`	Initialize a QDL stem with count elements form the fillList.
`QDLStem(QDLList list)`	Initialize a QDL stem with a list

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addAll(QDLStem qdlStem)`
`void`	`addList(List list)`	Adds a list of objects to this stem, giving them indices appropriate indices This is mostly a convenience for people writing in java to create lists programatically.
`protected QDLStem.KeyRankMap`	`allKeys2()`
`QDLStem`	`almostUnique()`	This almost returns all the unique elements.
`void`	`clear()`
`Object`	`clone()`	Make a shallow copy of this stem variable.
`QDLStem`	`commonKeys(QDLStem arg2)`
`boolean`	`containsKey(Long key)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsKey(String key)`
`boolean`	`containsValue(Object value)`
`protected QDLStem`	`convertKeyByRank(List<List> list)`	Gets a list of lists, e.g.
`QDLStem`	`dim()`
`Set<Map.Entry<String,Object>>`	`entrySet()`
`QDLStem`	`excludeKeys(QDLStem keyList)`
`QDLStem`	`fromJSON(net.sf.json.JSON json)`
`QDLStem`	`fromJSON(net.sf.json.JSONArray array, boolean convert, int type)`
`QDLStem`	`fromJSON(net.sf.json.JSONObject jsonObject)`
`QDLStem`	`fromJSON(net.sf.json.JSONObject jsonObject, boolean convertVars, int type)`	Populate this from a JSON object.
`Object`	`get(Long key)`
`Object`	`get(Object key)`
`Object`	`get(String key)`
`IndexList`	`get(IndexList indexList, boolean strictMatching)`
`Object`	`get(StemMultiIndex w)`	Note that the
`Object`	`get(StemPath<StemPathEntry> stemPath)`
`Boolean`	`getBoolean(Long key)`
`Boolean`	`getBoolean(String key)`
`Object`	`getByMultiIndex(String index)`	This will take a stem with embedded .
`BigDecimal`	`getDecimal(Long key)`
`Object`	`getDefaultValue()`	If this is set, then any get with no key will return this value.
`Long`	`getLong(Long key)`
`Long`	`getLong(String key)`
`QDLList`	`getQDLList()`
`QDLMap`	`getQDLMap()`
`Long`	`getRank()`
`QDLStem`	`getStem(Long key)`
`QDLStem`	`getStem(String key)`
`String`	`getString(Long key)`
`String`	`getString(String key)`
`boolean`	`hasDefaultValue()`
`QDLStem`	`hasKey(QDLStem keyList)`	Modern successor to the deprecated `hasKeys(QDLStem)`.
`QDLStem`	`hasKeys(QDLStem keyList)`	Takes a stem and returns a boolean list conformable to the argument.
`boolean`	`hasValue(Object x)`
`QDLStem`	`includeKeys(QDLStem keyList)`
`QDLStem`	`indicesByRank()`	Returns a flat list of all indices at a given rank.
`QDLStem`	`indicesByRank(Long rank)`	Return the indices of a given rank for this stem.
`protected void`	`indicesByRank(QDLStem v, List list, QDLStem.KeyRankMap keyRankMap)`
`String`	`inputForm()`
`String`	`inputForm(int indentFactor)`
`String`	`inputForm(int indentFactor, String currentIndent)`
`boolean`	`isEmpty()`
`protected boolean`	`isIntVar(String var)`
`boolean`	`isList()`
`boolean`	`isLongIndex(String key)`	Does a regex on the index to see if it is really a long.
`protected boolean`	`isVar(String var)`
`QDLStem`	`keysByAxis(Long axis)`	Get by axis.
`StemKeys`	`keySet()`	return an enumeration (set) of ALL keys in order, starting with the list indices then the keys.
`void`	`listAdd(Object value)`	Add the single object to the list in this stem.
`void`	`listAppend(QDLStem stem)`	Append the list elements of the stem to this list.
`void`	`listCopy(long startIndex, long length, QDLStem target, long insertIndex)`	Copies the elements from this list to the target list.
`void`	`listInsertAt(long startIndex, long length, QDLStem target, long insertIndex)`	Insert the current
`QDLStem`	`listSubset(long startIndex)`	Insert the whole argument in to the current stem, re-adjusting indices.
`QDLStem`	`listSubset(long startIndex, long length)`
`QDLStem`	`mask(QDLStem stem2)`
`protected void`	`myPut(Object index, Object value)`
`IndexList`	`newGet(IndexList indexList, boolean strictMatching)`	Strict matching is used at the last resolution of the stem.
`QDLStem`	`newInstance()`
`QDLStem`	`newInstance(Long count, Object[] fillList)`
`Object`	`put(int index, Object value)`
`Object`	`put(Long index, Object value)`
`Object`	`put(String key, Object value)`
`void`	`putAll(Map<? extends String,?> m)`	This does not add the list elements because that causes issues with the contract for maps.
`void`	`putLongOrString(Object key, Object value)`
`Object`	`remove(Long key)`
`Object`	`remove(Object key)`
`Object`	`remove(String key)`
`boolean`	`remove(IndexList indexList)`
`void`	`remove(StemMultiIndex w)`
`boolean`	`removeAllByValue(Object c, boolean reorderLists)`
`boolean`	`removeAllByValue(Object c, boolean reorderLists, boolean listProcessed)`
`boolean`	`removeAllByValues(Collection c, boolean reorderLists)`	Removes every value in the collection from everywhere in the stem.
`void`	`renameKeys(QDLStem newKeys, boolean overWriteKeys)`
`void`	`set(IndexList indexList, Object value)`
`void`	`set(StemMultiIndex w, Object value)`
`void`	`setDefaultValue(Object defaultValue)`
`void`	`setQDLList(QDLList qdlList)`
`void`	`setQDLMap(QDLMap qdlMap)`
`int`	`size()`	As per usual Java `Map.size()` contract, return axis 0 count
`long`	`size(int axis)`	Return count down to a given axis.
`net.sf.json.JSON`	`toJSON()`	Converts this to a JSON object.
`net.sf.json.JSON`	`toJSON(boolean escapeNames, int type)`
`String`	`toString()`
`String`	`toString(int indentFactor)`
`String`	`toString(int indentFactor, String currentIndent)`
`QDLStem`	`union(QDLStem... stemVariables)`	This will return a new stem consisting of this stem and the union of all the stem arguments.
`Collection<Object>`	`values()`	Be aware that this creates an actual set so it reads every item.
`QDLSet`	`valueSet()`
`Iterator`	`valuesIterator()`	A specific iterator for the values of this stem.

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

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

- Field Detail
  - STEM_INDEX_MARKER
```
public static final String STEM_INDEX_MARKER
```
    See Also:
    
    Constant Field Values
  - STEM_ENTRY_CONNECTOR
```
public static String STEM_ENTRY_CONNECTOR
```
- Constructor Detail
  - QDLStem
```
public QDLStem()
```
  - QDLStem
```
public QDLStem(QDLList list)
```
    Initialize a QDL stem with a list
    
    Parameters:
    
    list -
  - QDLStem
```
public QDLStem(Long count,
               Object[] fillList)
```
    Initialize a QDL stem with count elements form the fillList. This returns a simple list. See QDLList(long, Object[]) for the contract.
    
    Parameters:
    
    count -
    
    fillList -
- Method Detail
  - newInstance
```
public QDLStem newInstance()
```
  - newInstance
```
public QDLStem newInstance(Long count,
                           Object[] fillList)
```
  - getQDLMap
```
public QDLMap getQDLMap()
```
  - setQDLMap
```
public void setQDLMap(QDLMap qdlMap)
```
  - getLong
```
public Long getLong(String key)
```
  - getStem
```
public QDLStem getStem(String key)
```
  - getStem
```
public QDLStem getStem(Long key)
```
  - getLong
```
public Long getLong(Long key)
```
  - remove
```
public Object remove(String key)
```
  - containsKey
```
public boolean containsKey(String key)
```
  - getString
```
public String getString(String key)
```
  - getBoolean
```
public Boolean getBoolean(String key)
```
  - get
```
public Object get(String key)
```
  - getQDLList
```
public QDLList getQDLList()
```
  - setQDLList
```
public void setQDLList(QDLList qdlList)
```
  - getBoolean
```
public Boolean getBoolean(Long key)
```
  - get
```
public Object get(Long key)
```
  - getDecimal
```
public BigDecimal getDecimal(Long key)
```
  - getString
```
public String getString(Long key)
```
  - put
```
public Object put(Long index,
                  Object value)
```
  - containsKey
```
public boolean containsKey(Long key)
```
  - remove
```
public Object remove(Long key)
```
  - addList
```
public void addList(List list)
```
    Adds a list of objects to this stem, giving them indices appropriate indices This is mostly a convenience for people writing in java to create lists programatically. Note there is no parameter for this list since that will blow up if there are mixed entries.
    
    Parameters:
    
    list -
  - listAppend
```
public void listAppend(QDLStem stem)
```
    Append the list elements of the stem to this list. This integrates the lists but does not affect the maps.
    
    Parameters:
    
    stem -
  - listAdd
```
public void listAdd(Object value)
```
    Add the single object to the list in this stem. This allows you to add a stem as a list value, unlike listAppend(QDLStem) which appends the elements of the argument's list to the current object's list.
    
    Parameters:
    
    value -
  - listCopy
```
public void listCopy(long startIndex,
                     long length,
                     QDLStem target,
                     long insertIndex)
```
    Copies the elements from this list to the target list. Note that this will over-write any elements already in the target. If you need to insert elements, use the listInsertAt(long, long, QDLStem, long) method.
    
    Parameters:
    
    startIndex - first index in the source
    
    length - how many elements to take from the source
    
    target - that target to get the copy
    
    insertIndex - where in the target to start copying.
  - listInsertAt
```
public void listInsertAt(long startIndex,
                         long length,
                         QDLStem target,
                         long insertIndex)
```
    Insert the current
    
    Parameters:
    
    startIndex -
    
    length -
    
    target -
    
    insertIndex -
  - listSubset
```
public QDLStem listSubset(long startIndex)
```
    Insert the whole argument in to the current stem, re-adjusting indices.
    
    Parameters:
    
    startIndex -
  - listSubset
```
public QDLStem listSubset(long startIndex,
                          long length)
```
  - isList
```
public boolean isList()
```
  - put
```
public Object put(int index,
                  Object value)
```
  - getDefaultValue
```
public Object getDefaultValue()
```
    If this is set, then any get with no key will return this value. Since the basic unit of QDL is the stem, this gives us a way of basically turning a scalar in to a stem without having to do complicated size and key matching.
    
    Note that containsKey(Object) still works as usual, so you can ask if a key exists.
    
    Returns:
  - setDefaultValue
```
public void setDefaultValue(Object defaultValue)
```
  - hasDefaultValue
```
public boolean hasDefaultValue()
```
  - size
```
public int size()
```
    As per usual Java Map.size() contract, return axis 0 count
    
    Specified by:
    
    size in interface Map<String,Object>
    
    Returns:
  - size
```
public long size(int axis)
```
    Return count down to a given axis. This accepts ProcessStemAxisRestriction.ALL_AXES as well, which gives the count of every entry, i.e., the cardinality of the stem.
    
    Parameters:
    
    axis -
    
    Returns:
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<String,Object>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<String,Object>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<String,Object>
  - clone
```
public Object clone()
```
    Make a shallow copy of this stem variable.
    
    Overrides:
    
    clone in class Object
    
    Returns:
  - putLongOrString
```
public void putLongOrString(Object key,
                            Object value)
```
  - get
```
public Object get(Object key)
```
    Specified by:
    
    get in interface Map<String,Object>
  - put
```
public Object put(String key,
                  Object value)
```
    Specified by:
    
    put in interface Map<String,Object>
  - remove
```
public Object remove(Object key)
```
    Specified by:
    
    remove in interface Map<String,Object>
  - addAll
```
public void addAll(QDLStem qdlStem)
```
  - putAll
```
public void putAll(Map<? extends String,?> m)
```
    This does not add the list elements because that causes issues with the contract for maps. If you are adding all the values of a stem to this one, use addAll(QDLStem).
    
    Specified by:
    
    putAll in interface Map<String,Object>
    
    Parameters:
    
    m -
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<String,Object>
  - keySet
```
public StemKeys keySet()
```
    return an enumeration (set) of ALL keys in order, starting with the list indices then the keys.
    
    Specified by:
    
    keySet in interface Map<String,Object>
    
    Returns:
  - values
```
public Collection<Object> values()
```
    Be aware that this creates an actual set so it reads every item. If you need to iterate over the elements (so single pass, not potentially multiple passes) consider using valuesIterator() while gets the iterators and manages them.
    
    Specified by:
    
    values in interface Map<String,Object>
    
    Returns:
  - entrySet
```
public Set<Map.Entry<String,Object>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<String,Object>
  - isLongIndex
```
public boolean isLongIndex(String key)
```
    Does a regex on the index to see if it is really a long. Note that this still is needed since a user can set a.'2' := 3 and this should turn it into a list entry otherwise we get both string and list entries with "the same" key.
    
    Parameters:
    
    key -
    
    Returns:
  - isVar
```
protected boolean isVar(String var)
```
  - isIntVar
```
protected boolean isIntVar(String var)
```
  - valueSet
```
public QDLSet valueSet()
```
  - almostUnique
```
public QDLStem almostUnique()
```
    This almost returns all the unique elements. The issue is that if there are deeply nested stems, then do not entirely get made unique before getting added to the result, hence the simplest fix is that in that case is to call this twice. Someday this can be fixed with a careful rewrite of the recursion in stem lists.
    
    Returns:
  - dim
```
public QDLStem dim()
```
  - getRank
```
public Long getRank()
```
  - get
```
public Object get(StemPath<StemPathEntry> stemPath)
```
  - union
```
public QDLStem union(QDLStem... stemVariables)
```
    This will return a new stem consisting of this stem and the union of all the stem arguments. The effect is to overwrite the current stem values with the argument values. so e.g.
    {'a':1}~{'a':2,'b':3}~{'b':4,'c':5} {a:2, b:4, c:5}
    Parameters:
    
    stemVariables -
    
    Returns:
  - valuesIterator
```
public Iterator valuesIterator()
```
    A specific iterator for the values of this stem. This should be used when traversing all values, such as in WhileLoops.
    
    Returns:
  - hasValue
```
public boolean hasValue(Object x)
```
  - mask
```
public QDLStem mask(QDLStem stem2)
```
  - commonKeys
```
public QDLStem commonKeys(QDLStem arg2)
```
  - renameKeys
```
public void renameKeys(QDLStem newKeys,
                       boolean overWriteKeys)
```
  - excludeKeys
```
public QDLStem excludeKeys(QDLStem keyList)
```
  - includeKeys
```
public QDLStem includeKeys(QDLStem keyList)
```
  - hasKeys
```
public QDLStem hasKeys(QDLStem keyList)
```
    Takes a stem and returns a boolean list conformable to the argument.
    
    Parameters:
    
    keyList -
    
    Returns:
  - hasKey
```
public QDLStem hasKey(QDLStem keyList)
```
    Modern successor to the deprecated hasKeys(QDLStem). This returns a left conformable stem as it should.
    
    Parameters:
    
    keyList -
    
    Returns:
  - get
```
public IndexList get(IndexList indexList,
                     boolean strictMatching)
```
  - newGet
```
public IndexList newGet(IndexList indexList,
                        boolean strictMatching)
```
    Strict matching is used at the last resolution of the stem. It means that left over scalars are flagged as errors since there is no stem waiting to resolve them.
    
    Parameters:
    
    indexList -
    
    strictMatching -
    
    Returns:
  - set
```
public void set(IndexList indexList,
                Object value)
```
  - remove
```
public boolean remove(IndexList indexList)
```
  - myPut
```
protected void myPut(Object index,
                     Object value)
```
  - get
```
public Object get(StemMultiIndex w)
```
    Note that the
    
    Parameters:
    
    w -
    
    Returns:
  - set
```
public void set(StemMultiIndex w,
                Object value)
```
  - remove
```
public void remove(StemMultiIndex w)
```
  - allKeys2
```
protected QDLStem.KeyRankMap allKeys2()
```
  - keysByAxis
```
public QDLStem keysByAxis(Long axis)
```
    Get by axis. So if axis is 0, top level keys only, axis == 1 yields rank 2 keys
    
    Parameters:
    
    axis -
    
    Returns:
  - indicesByRank
```
public QDLStem indicesByRank(Long rank)
```
    Return the indices of a given rank for this stem.
    
    Parameters:
    
    rank -
    
    Returns:
  - convertKeyByRank
```
protected QDLStem convertKeyByRank(List<List> list)
```
    Gets a list of lists, e.g.
    [[foo, 0], [foo, 1], [foo, 2], [foo, tyu]]
    and returns a stem of these.
    Parameters:
    
    list -
    
    Returns:
  - indicesByRank
```
protected void indicesByRank(QDLStem v,
                             List list,
                             QDLStem.KeyRankMap keyRankMap)
```
  - indicesByRank
```
public QDLStem indicesByRank()
```
    Returns a flat list of all indices at a given rank. Each element is a stem. Special case is rank of 0 returns the same as rank == 1, except the elements are scalars, not stems with a single element.
    
    Returns:
  - toJSON
```
public net.sf.json.JSON toJSON()
```
    Converts this to a JSON object. Names of stem components are decoded. So if you have a stem, a., with component $23foo, then a.$23foo yields
    {"#foo":...}
    I.e. the $23 is treated as an escaped name and converted back. If you do not want stem names escaped when converting to JSON, then use toJSON(boolean, int) with the argument being false. In that case the outputted JSON would be
    {"$23foo":...}
    Returns:
  - toJSON
```
public net.sf.json.JSON toJSON(boolean escapeNames,
                               int type)
```
  - fromJSON
```
public QDLStem fromJSON(net.sf.json.JSON json)
```
  - fromJSON
```
public QDLStem fromJSON(net.sf.json.JSONObject jsonObject)
```
  - fromJSON
```
public QDLStem fromJSON(net.sf.json.JSONObject jsonObject,
                        boolean convertVars,
                        int type)
```
    Populate this from a JSON object. Note that JSON arrays are turned in to stem lists.
    
    Parameters:
    
    jsonObject - return this object, populated
  - fromJSON
```
public QDLStem fromJSON(net.sf.json.JSONArray array,
                        boolean convert,
                        int type)
```
  - toString
```
public String toString(int indentFactor,
                       String currentIndent)
```
  - toString
```
public String toString(int indentFactor)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - inputForm
```
public String inputForm()
```
  - inputForm
```
public String inputForm(int indentFactor)
```
  - inputForm
```
public String inputForm(int indentFactor,
                        String currentIndent)
```
  - removeAllByValues
```
public boolean removeAllByValues(Collection c,
                                 boolean reorderLists)
```
    Removes every value in the collection from everywhere in the stem. Optionally, lists will be reordered too. Since this a bit more
    
    Parameters:
    
    c -
    
    reorderLists -
    
    Returns:
  - removeAllByValue
```
public boolean removeAllByValue(Object c,
                                boolean reorderLists)
```
  - removeAllByValue
```
public boolean removeAllByValue(Object c,
                                boolean reorderLists,
                                boolean listProcessed)
```
  - getByMultiIndex
```
public Object getByMultiIndex(String index)
```
    This will take a stem with embedded . and return the object at that index.
    
    E.g.
    
    myStem.getByMultiIndex("a.b.c");
    
    would return myStem.a.b.c;
    
    This just calls get(StemMultiIndex).
    
    Note
    
    In this call, you pass in the exact index you want, unlike get(StemMultiIndex) which accepts the name of the stem as the first argument
    
    Parameters:
    
    index -
    
    Returns:

Modifier and Type	Field	Description
`static String`	`STEM_ENTRY_CONNECTOR`
`static String`	`STEM_INDEX_MARKER`

Class QDLStem

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Field Detail

STEM_INDEX_MARKER

STEM_ENTRY_CONNECTOR

Constructor Detail

QDLStem

QDLStem

QDLStem

Method Detail

newInstance

newInstance

getQDLMap

setQDLMap

getLong

getStem

getStem

getLong

remove

containsKey

getString

getBoolean

get

getQDLList

setQDLList

getBoolean

get

getDecimal

getString

put

containsKey

remove

addList

listAppend

listAdd

listCopy

listInsertAt

listSubset

listSubset

isList

put

getDefaultValue

setDefaultValue

hasDefaultValue

size

size

isEmpty

containsKey

containsValue

clone

putLongOrString

get

put

remove

addAll

putAll

clear

keySet

values

entrySet

isLongIndex

isVar

isIntVar

valueSet

almostUnique

dim

getRank

get

union

valuesIterator

hasValue

mask

commonKeys

renameKeys