io.nosqlbench.engine.api.templating.ParsedOp

All Implemented Interfaces:: io.nosqlbench.nb.api.config.fieldreaders.DynamicFieldReader, io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader, LongFunction<Map<String,?>>

public class ParsedOp extends Object implements LongFunction<Map<String,?>>, io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader, io.nosqlbench.nb.api.config.fieldreaders.DynamicFieldReader

ParsedOp API

This is the primary developer-focused API for driver developers to use when up-converting op templates to operations. This ParsedOp is a wrapper around the op template structure. It provides many ways of constructing higher-order objects from a variety of sources.

Supporting Variety

For some drivers or protocols, the primary user interface is a statement format or grammar. For CQL or SQL, the most natural way of describing templates for operations is in that native format. For others, an operation template may look like a block of JSON or a HTTP request. All these forms are supported. In order to deal with the variety, there is a set of detailed rules for how the workload definitions are transformed into driver operations for a native driver. The high-level flow is:

Op Template Form
Normalized Data Structure
ParsedOp Form

The specifications govern how the raw op template form is transformed into the normalized data structure. This documentation focuses on the API provided by the last form, this class, although peripheral awareness of the first two forms will certainly help for any advanced scenarios. You can find detailed examples and specification tests under the workload_definition folder of the adapters-api module.

Op Template Parsing

Rule #1: All op templates are parsed into an internal normalized structure which contains:
1. A map of op fields, which can consist of:
  1. static field values
  2. dynamic field values, the actual value of which can only be known for a given cycle
2. Access to auxiliary configuration values like activity parameters. These can back-fill when values aren't present in the direct static or dynamic op fields.
3. Rule #2: When asking for a dynamic parameter, static parameters may be automatically promoted to functional form as a back-fill.
4. Rule #3: When asking for static parameters, config parameters may automatically be promoted as a back-fill.
The net effect of these rules is that the NoSQLBench driver developer may safely use functional forms to access data in the op template, or may decide that certain op fields must only be provided in a static way per operation.

Distinguishing Op Payload from Op Config

When a user specifies an op template, they may choose to provide only a single set of op fields without distinguishing between config or payload, or they may choose to directly configure each.
Example:
```
 ops:
 # both op and params explicitly named
   op1:
     op:
       opfield1: value1
     params:
       param2: value2
 # neither op field nor params named, so all assumed to be op fields
   op2:
     opfield1: value1
     param2: value2
     # in this case, if param2 is meant to be config level,
     # it is a likely config error that should be thrown to the user
 # only op field explicitly named, so remainder automatically pushed into params
   op3:
     op:
       opfield1: value1
     param2: value2
 # only params explicitly named, so remainder pushed into op payload
   op4:
     params:
       param2: value2
     opfield1: value1
 
```
All of these are considered valid constructions, and all of them may actually achieve the same result. This looks like an undesirable problem, but it serves to simplify things for users in one specific way: It allows them to be a vague, within guidelines, and still have a valid workload definition. The NoSQLBench runtime does a non-trivial amount of processing on the op template to ensure that it can conform to an unambiguous normalized internal structure on your behalf. This is needed because of how awful YAML is as a user configuration language in spite of its ubiquity in practice. The basic design guideline for these forms is that the op template must mean what a reasonable user would assume without looking at any documentation.

Design Invariants

The above rules imply invariants, which are made explicit here. ParsedOp.
- You may not use an op field name or parameter name for more than one purpose.
  - Treat all parameters supported by a driver adapter and it's op fields as a globally shared namespace, even if it is not. This avoids creating any confusion about what a parameter can be used for and how to use it for the right thing in the right place. For example, you may not use the parameter name `socket` in an op template to mean one thing and then use it at the driver adapter level to mean something different. However, if the meaning is congruent, a driver developer may choose to support some cross-cutting parameters at the activity level. These allowances are explicit, however, as each driver dictates what it will allow as activity parameters.
- Users may specify op payload fields within op params or activity params as fallback config sources in that order.
  - IF a name is valid as an op field, it must also be valid as such when specified in op params.
  - If a name is valid as an op field, it must also be valid as such when specified in activity params, within the scope of ParsedOp
  - When an op field is found via op params or activity params, it may NOT be dynamic. If dynamic values are intended to be provided at a common layer in the workload, then bindings support this already.
- You must access non-payload params via Config-oriented methods.
  - Op Templates contain op payload data and op configs (params, activity params).
  - You must use only ParsedOp getters with "...Config..." names, such as getConfigOr(String, Object, long) when accessing non-payload fields.
  - When a dynamic value is found via one of these calls, an error should be thrown, as configuration level data is not expected to be variant per-operation or cycle.
- The user must be warned when a required or optional config value is missing from op params (or activity params), but a value of the same name is found in op payload fields.
  - If rule #1 is followed, and names are unambiguous across the driver, then it is almost certainly a configuration error.
- When both an op payload field and a param field of the same name are defined through cascading configuration of param fields, the local op payload field takes precedence.
  - This is an extension of the param override rules which say that the closest (most local) value to an operation is the one that takes precedence.
  - In practice, there will be no conflicts between direct static and dynamic fields, but there will be possibly between static or dynamic fields and parameters and activity params. If a user wants to promote an activity param as an override to existing op fields, template variables allow for this to happen gracefully. Otherwise, the order of precedence is 1) op fields 2) op params 3) activity params.
Op Payload Forms
Field values can come from multiple sources. These forms and any of their combinations are supported.
Static Op Fields

Example:
```
 op:
   field1: value1
   field2:
     map3:
       key4: value4
     map5:
       key6: value6
   field7: false
   field8: 8.8
 
```
As shown, any literal value of any valid YAML type, including structured values like lists or maps are accepted as static op template values. A static value is any value which contains zero bind points at any level.
Dynamic Op Fields with Binding References

Example:
```
 op:
   field1: "{binding1}"
   field2: "value is: {binding1}"
 
 
```
In this form, {binding1} is known as a binding reference, since the binding function is defined elsewhere under the given name. The first field "field1" is specified with no leading nor trailing literals, and is thus taken as a raw binding reference, meaning that it will not be converted to a String. The second, named "field2", is what is known as a string template, and is syntactical sugar for a more complex binding which concatenates static and dynamic parts together. In this form, object types produced by binding functions are converted to string form before concatenation.

Note that a raw {binding1} value (without quotes) would be NOT be a binding reference, since YAML is a superset of JSON. this means that {binding1} would be converted to a map or JSON object type with invalid contents. This is warned about when detected as a null valued map key, although it also makes null values invalid for ANY op template value.

Dynamic Op Fields with Binding Definitions

Example:
```
 op:
   field1: "{{NumberNameToString()}}"
   field2: "value is: {{NumberNameToString()}}"
 
 
```
This form has exactly the same effect as the previous example as long as your bindings definitions included:
```
 bindings:
   binding1: NumberNameToString();
 
```
Dynamic Op Fields with Structure

Example:
```
   field1:
     k1: "{binding1}
     k2: "literal value"
   field2:
     - "value3"
     - "{binding4}"
     - "a value: {binding5}"
     - "{{NumberNameToString}}"
     - "a value: {{NumberNameToString()}}"
 
```
This example combines the previous ones with structure and dynamic values. Both field1 and field2 are dynamic, since each contains some dynamic value or template within. When field1 is accessed within a cycle, that cycle's value will be used as the seed to generate equivalent structures with all the literal and dynamic elements inserted as the template implies. As before, direct binding references like {binding4} will be inserted into the structure with whatever type the binding definition produces, so if you want strings in them, ensure that you configure your binding definitions thusly.

Op Template Params

Example:
```
 params:
  prepared: true
 ops:
  op1:
   field1: value1
   params:
    prepared: false
 
```
The params section are the first layer of external configuration values that an op template can use to distinguish op configuration parameters from op payload content. Op Template Params are referenced when any of the getConfigOr(String, Object, long) or other ...Config... getters are used (bypassing non-param fields). They are also accessed as a fallback when no static nor dynamic value is found for a reference op template field. Unlike op fields, op params cascade from within the workload YAML from the document level, down to each block and then down to each statement.
Activity Params

Example:
```
 ./nb run driver=... workload=... cl=LOCAL_QUORUM
 
```
When explicitly allowed by a driver adapter's configuration model, values like cl above can be seen as another fallback source for configuration parameters. The ParsedOp implementation will automatically look in the activity parameters if needed to find a missing configuration parameter, but this will only work if the specific named parameter is allowed at the activity level.

Constructor Summary

Constructors

Constructor

Description

ParsedOp(OpTemplate ot, io.nosqlbench.nb.api.config.standard.NBConfiguration activityCfg)

Create a parsed command from an Op template.

ParsedOp(OpTemplate opTemplate, io.nosqlbench.nb.api.config.standard.NBConfiguration activityCfg, List<Function<Map<String,Object>,Map<String,Object>>> preprocessors)

Create a parsed command from an Op template.
Method Summary

Modifier and Type

Method

Description

Map<String,Object>

apply(long value)

<FA, FE> LongFunction<FA>

enhanceDefaultFunc(LongFunction<FA> func, String field, Class<FE> type, FE defaultFe, BiFunction<FA,FE,FA> combiner)

Enhance a Function with another required named field or function combiner OR a default value.

<FA, FE extends Enum<FE>> LongFunction<FA>

enhanceEnum(LongFunction<FA> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)

Enhance a Function with an optional enum function IFF it is defined.

<FA, FE> LongFunction<FA>

enhanceFunc(LongFunction<FA> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)

Enhance a Function with a named required function, or throw an error.

<FA, FE> LongFunction<FA>

enhanceFuncOptionally(LongFunction<FA> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)

Enhance a Function with a named optional function IFF it exists.

<FA, FE> Optional<LongFunction<FA>>

enhanceOptionalDefaultFunc(Optional<LongFunction<FA>> func, String field, Class<FE> type, FE defaultFe, BiFunction<FA,FE,FA> combiner)

Enhance an Optional Function with a named field or function combiner OR a default value, IFF the base function is present.

<FA, FE> Optional<LongFunction<FA>>

enhanceOptionalFuncOptionally(Optional<LongFunction<FA>> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)

Enhance an Optional Function with an optional named field or value combiner, IFF both functions are defined.

<T> T

get(String field, long input)

Get the named field value for a given long input.

<V> LongFunction<V>

getAsCachedFunctionOr(String fieldname, String defaultValue, Function<String,V> init)

Get a LongFunction that first creates a LongFunction of String as in getAsRequiredFunction(String, Class), but then applies the result and caches it for subsequent access.

<V> LongFunction<V>

getAsFunctionOr(String name, V defaultValue)

Get a LongFunction which returns either the static value, the dynamic value, or the default value, in that order, depending on where it is found first.

<V extends Enum<V>> Optional<LongFunction<V>>

getAsOptionalEnumFunction(String name, Class<V> type)

<V> Optional<LongFunction<String>>

getAsOptionalFunction(String name)

<V> Optional<LongFunction<V>>

getAsOptionalFunction(String name, Class<V> type)

Get the op field as a LongFunction

LongFunction<? extends String>

getAsRequiredFunction(String name)

Get the op field as a LongFunction of String.

<V> LongFunction<V>

getAsRequiredFunction(String name, Class<? extends V> type)

Optional<io.nosqlbench.virtdata.core.templates.ParsedStringTemplate>

getAsTemplate(String fieldname)

<T> T

getConfigOr(String name, T defaultValue, long input)

Works exactly like getStaticConfigOr(String, Object), except that dynamic values at the op field level will be generated on a per-input basis.

Set<String>

getDefinedNames()

<E extends Enum<E>> E

getEnumFromFieldOr(Class<E> enumClass, E defaultEnum, String fieldName)

LongFunction<?>

getMapper(String field)

Get the LongFunction which is used to resolve a dynamic field value.

String

getName()

<E extends Enum<E>> Optional<E>

getOptionalEnumFromField(Class<E> enumclass, String fieldName)

<T> Optional<T>

getOptionalStaticConfig(String name, Class<T> type)

<T> Optional<T>

getOptionalStaticValue(String field, Class<T> classOfT)

Return an optional value for the named field.

<E extends Enum<E>, V> Optional<io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>>

getOptionalTypeAndTargetEnum(Class<E> enumclass, Class<V> valueClass)

<E extends Enum<E>, V> Optional<io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>>

getOptionalTypeAndTargetEnum(Class<E> enumclass, Class<V> valueClass, String alternateTypeField, String alternateValueField)

int

getSize()

String

getStaticConfig(String name, Class<String> clazz)

<T> T

getStaticConfigOr(String name, T defaultValue)

Get the specified parameter by the user using the defined field which is closest to the op template.

<T> T

getStaticValue(String field)

Get the static value for the provided name, cast to the required type, where the type is inferred from the calling context.

<T> T

getStaticValue(String field, Class<T> classOfT)

Get the static value for the provided name, cast to the required type.

<T> T

getStaticValueOr(String name, T defaultValue)

Get the named static field value, or return the provided default, but throw an exception if the named field is dynamic.

io.nosqlbench.engine.api.templating.ParsedTemplateMap

getTemplateMap()

<E extends Enum<E>, V> io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>

getTypeAndTarget(Class<E> enumclass, Class<V> valueClass)

<E extends Enum<E>, V> io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>

getTypeAndTarget(Class<E> enumclass, Class<V> valueclass, String tname, String vname)

<E extends Enum<E>, V> Optional<io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>>

getTypeAndTargetFromEnum(Class<E> enumclass, Class<V> valueClass)

Given an enum of any type, return the enum value which is found in any of the field names of the op template, ignoring case and any non-word characters.

Class<?>

getValueType(String fieldname)

boolean

isDefined(String field)

boolean

isDefined(String... fields)

boolean

isDefined(String field, Class<?> type)

boolean

isDefinedAll(String... fields)

convenience method for conjugating isDefined(String) with AND

boolean

isDynamic(String field)

boolean

isStatic(String field)

boolean

isStatic(String field, Class<?> type)

boolean

isUndefined(String field)

Inverse of isDefined(String), provided for clarify in some situations

LongFunction<Object[]>

newArrayBinder(String... fields)

LongFunction<Object[]>

newArrayBinder(List<String> fields)

LongFunction<Object[]>

newArrayBinderFromBindPoints(List<io.nosqlbench.virtdata.core.templates.BindPoint> bindPoints)

LongFunction<List<Object>>

newListBinder(String... fields)

LongFunction<List<Object>>

newListBinder(List<String> fields)

LongFunction<Map<String,Object>>

newOrderedMapBinder(String... fields)

Map<String,Object>

parseStaticCmdMap(String key, String mainField)

<T> Optional<T>

takeOptionalStaticValue(String field, Class<T> classOfT)

<T> T

takeStaticConfigOr(String name, T defaultValue)

Get the parameter value from a static op template field OR any of the provided optional sources of op template values, including the activity parameters

String

toString()

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

Constructor Details
- ParsedOp
  
  public ParsedOp(OpTemplate ot, io.nosqlbench.nb.api.config.standard.NBConfiguration activityCfg)
  
  Create a parsed command from an Op template.
  
  Parameters:
  
  ot - An OpTemplate representing an operation to be performed in a native driver.
  
  activityCfg - The activity configuration, used for reading config parameters
- ParsedOp
  
  public ParsedOp(OpTemplate opTemplate, io.nosqlbench.nb.api.config.standard.NBConfiguration activityCfg, List<Function<Map<String,Object>,Map<String,Object>>> preprocessors)
  
  Create a parsed command from an Op template. This version is exactly like (OpTemplate,NBConfiguration) except that it allows preprocessors. Preprocessors are all applied to the the op template before it is applied to the parsed command fields, allowing you to combine or destructure fields from more tha one representation into a single canonical representation for processing.
  
  Parameters:
  
  opTemplate - The OpTemplate as provided by a user via YAML, JSON, or API (data structure)
  
  activityCfg - The activity configuration, used to resolve nested config parameters
  
  preprocessors - Map->Map transformers.
Method Details
- getName
  
  public String getName()
- getTemplateMap
  
  public io.nosqlbench.engine.api.templating.ParsedTemplateMap getTemplateMap()
- apply
  
  public Map<String,Object> apply(long value)
  
  Specified by:
  
  apply in interface LongFunction<Map<String,?>>
- isDynamic
  
  public boolean isDynamic(String field)
  
  Specified by:
  
  isDynamic in interface io.nosqlbench.nb.api.config.fieldreaders.DynamicFieldReader
- isStatic
  
  public boolean isStatic(String field)
  
  Parameters:
  
  field - The field name to look for in the static field map.
  
  Returns:
  
  true if and only if the named field is present in the static field map.
- isStatic
  
  public boolean isStatic(String field, Class<?> type)
- isDefined
  
  public boolean isDefined(String... fields)
  
  Specified by:
  
  isDefined in interface io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader
  
  Parameters:
  
  fields - Names of fields to look for in the static field map.
  
  Returns:
  
  true if and only if all provided field names are present in the static field map.
- getStaticValue
  
  public <T> T getStaticValue(String field, Class<T> classOfT)
  
  Get the static value for the provided name, cast to the required type.
  
  Specified by:
  
  getStaticValue in interface io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader
  
  Type Parameters:
  
  T - The parameter type of the return type, used at compile time only to qualify asserted return type
  
  Parameters:
  
  field - Name of the field to get
  
  classOfT - The type of the field to return. If actual type is not compatible to a cast to this type, then a casting error will be thrown.
  
  Returns:
  
  A value of type T, or null
- getStaticValue
  
  public <T> T getStaticValue(String field)
  
  Get the static value for the provided name, cast to the required type, where the type is inferred from the calling context.
  
  Specified by:
  
  getStaticValue in interface io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader
  
  Type Parameters:
  
  T - The parameter type of the return type. used at compile time only to quality return type.
  
  Parameters:
  
  field - Name of the field to get
  
  Returns:
  
  A value of type T, or null
- getAsTemplate
  
  public Optional<io.nosqlbench.virtdata.core.templates.ParsedStringTemplate> getAsTemplate(String fieldname)
- getStaticValueOr
  
  public <T> T getStaticValueOr(String name, T defaultValue)
  
  Get the named static field value, or return the provided default, but throw an exception if the named field is dynamic.
  
  Specified by:
  
  getStaticValueOr in interface io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader
  
  Type Parameters:
  
  T - The type of the field to return.
  
  Parameters:
  
  name - The name of the field value to return.
  
  defaultValue - A value to return if the named value is not present in static nor dynamic fields.
  
  Returns:
  
  The value
  
  Throws:
  
  RuntimeException - if the field name is only present in the dynamic fields.
- getStaticConfigOr
  
  public <T> T getStaticConfigOr(String name, T defaultValue)
  
  Get the specified parameter by the user using the defined field which is closest to the op template. This is the standard way of getting parameter values which can be specified at the op template, op param, or activity level.
  
  Type Parameters:
  
  T - The type of the value to return
  
  Parameters:
  
  name - The name of the configuration param
  
  defaultValue - the default value to return if the value is not defined anywhere in (op fields, op params, activity params)
  
  Returns:
  
  A configuration value
  
  Throws:
  
  io.nosqlbench.nb.api.config.standard.NBConfigError - if the named field is defined dynamically, as in this case, it is presumed that the parameter is not supported unless it is defined statically.
- takeStaticConfigOr
  
  public <T> T takeStaticConfigOr(String name, T defaultValue)
  
  Get the parameter value from a static op template field OR any of the provided optional sources of op template values, including the activity parameters
  
  Type Parameters:
  
  T - The type of the field
  
  Parameters:
  
  name - The config field name
  
  defaultValue - The default value, if the field is not defined in the op template nor the activity params
  
  Returns:
  
  The config value.
- getStaticConfig
  
  public String getStaticConfig(String name, Class<String> clazz)
- getOptionalStaticConfig
  
  public <T> Optional<T> getOptionalStaticConfig(String name, Class<T> type)
- getConfigOr
  
  public <T> T getConfigOr(String name, T defaultValue, long input)
  
  Works exactly like getStaticConfigOr(String, Object), except that dynamic values at the op field level will be generated on a per-input basis. This is a shortcut method for allowing configuration values to be accessed dynamically where it makes sense.
- getOptionalStaticValue
  
  public <T> Optional<T> getOptionalStaticValue(String field, Class<T> classOfT)
  
  Return an optional value for the named field. This is an Optional form of getStaticValue(java.lang.String, java.lang.Class<T>).
  
  Specified by:
  
  getOptionalStaticValue in interface io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader
  
  Type Parameters:
  
  T - The parameter type of the return
  
  Parameters:
  
  field - Name of the field to get
  
  classOfT - The type of field to return. If the actual type is not compatible to a cast to this type, then a casting error will be thrown.
  
  Returns:
  
  An optional value, empty unless the named value is defined in the static field map.
- takeOptionalStaticValue
  
  public <T> Optional<T> takeOptionalStaticValue(String field, Class<T> classOfT)
- get
  
  public <T> T get(String field, long input)
  
  Get the named field value for a given long input. This uses parameter type inference -- The casting to the return type will be based on the type of any assignment or casting on the caller's side. Thus, if the actual type is not compatable to a cast to the needed return type, a casting error will be thrown.
  
  Specified by:
  
  get in interface io.nosqlbench.nb.api.config.fieldreaders.DynamicFieldReader
  
  Type Parameters:
  
  T - The parameter type of the returned value. Inferred from usage context.
  
  Parameters:
  
  field - The name of the field to get.
  
  input - The seed value, or cycle value for which to generate the value.
  
  Returns:
  
  The value.
- getDefinedNames
  
  public Set<String> getDefinedNames()
  
  Returns:
  
  a set of names which are defined, whether in static fields or dynamic fields
- getAsRequiredFunction
  
  public LongFunction<? extends String> getAsRequiredFunction(String name)
  
  Get the op field as a LongFunction of String. This is a convenience form for getAsRequiredFunction(String, Class)
  
  Parameters:
  
  name - The field name which must be defined as static or dynamic
  
  Returns:
  
  A function which can provide the named field value
- getAsOptionalFunction
  
  public <V> Optional<LongFunction<V>> getAsOptionalFunction(String name, Class<V> type)
  
  Get the op field as a LongFunction
  
  Parameters:
  
  name - The field name which must be defined as static or dynamic
  
  type - The value type which the field must be assignable to
  
  Returns:
  
  A function which can provide a value for the given name and type
- getAsOptionalEnumFunction
  
  public <V extends Enum<V>> Optional<LongFunction<V>> getAsOptionalEnumFunction(String name, Class<V> type)
- getAsOptionalFunction
  
  public <V> Optional<LongFunction<String>> getAsOptionalFunction(String name)
- getAsRequiredFunction
  
  public <V> LongFunction<V> getAsRequiredFunction(String name, Class<? extends V> type)
- getAsFunctionOr
  
  public <V> LongFunction<V> getAsFunctionOr(String name, V defaultValue)
  
  Get a LongFunction which returns either the static value, the dynamic value, or the default value, in that order, depending on where it is found first.
  
  Specified by:
  
  getAsFunctionOr in interface io.nosqlbench.nb.api.config.fieldreaders.DynamicFieldReader
  
  Type Parameters:
  
  V - The type of value to return
  
  Parameters:
  
  name - The param name for the value
  
  defaultValue - The default value to provide the value is not defined for static nor dynamic
  
  Returns:
  
  A LongFunction of type V
- getAsCachedFunctionOr
  
  public <V> LongFunction<V> getAsCachedFunctionOr(String fieldname, String defaultValue, Function<String,V> init)
  
  Get a LongFunction that first creates a LongFunction of String as in getAsRequiredFunction(String, Class), but then applies the result and caches it for subsequent access. This relies on ObjectCache internally.
  
  Type Parameters:
  
  V - The type of object to return
  
  Parameters:
  
  fieldname - The name of the field which could contain a static or dynamic value
  
  defaultValue - The default value to use in the init function if the fieldname is not defined as static nor dynamic
  
  init - A function to apply to the value to produce the product type
  
  Returns:
  
  A caching function which chains to the init function, with caching
- isDefined
  
  public boolean isDefined(String field)
  
  Specified by:
  
  isDefined in interface io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader
  
  Parameters:
  
  field - The requested field name
  
  Returns:
  
  true if the named field is defined as static or dynamic
- isUndefined
  
  public boolean isUndefined(String field)
  
  Inverse of isDefined(String), provided for clarify in some situations
  
  Parameters:
  
  field - The field name
  
  Returns:
  
  true if the named field is defined neither as static nor as dynamic
- isDefined
  
  public boolean isDefined(String field, Class<?> type)
  
  Specified by:
  
  isDefined in interface io.nosqlbench.nb.api.config.fieldreaders.StaticFieldReader
  
  Parameters:
  
  field - The requested field name
  
  type - The required type of the field value
  
  Returns:
  
  true if the named field is defined as static or dynamic and the value produced can be assigned to the specified type
- isDefinedAll
  
  public boolean isDefinedAll(String... fields)
  
  convenience method for conjugating isDefined(String) with AND
  
  Parameters:
  
  fields - The fields which should be defined as either static or dynamic
  
  Returns:
  
  true if all specified fields are defined as static or dynamic
- newListBinder
  
  public LongFunction<List<Object>> newListBinder(String... fields)
  
  Parameters:
  
  fields - The ordered field names for which the ListBinder will be created
  
  Returns:
  
  a new ListBinder which can produce a List of Objects from a long input.
- newListBinder
  
  public LongFunction<List<Object>> newListBinder(List<String> fields)
  
  Parameters:
  
  fields - The ordered field names for which the ListBinder will be created
  
  Returns:
  
  a new ListBinder which can produce a List of Objects from a long input.
- newOrderedMapBinder
  
  public LongFunction<Map<String,Object>> newOrderedMapBinder(String... fields)
  
  Parameters:
  
  fields - The ordered field names for which the OrderedMapBinder will be created
  
  Returns:
  
  a new OrderedMapBinder which can produce a Map of String to Objects from a long input.
- newArrayBinder
  
  public LongFunction<Object[]> newArrayBinder(String... fields)
  
  Parameters:
  
  fields - The ordered field names for which the ArrayBinder will be created
  
  Returns:
  
  a new ArrayBinder which can produce a Object array from a long input.
- newArrayBinder
  
  public LongFunction<Object[]> newArrayBinder(List<String> fields)
  
  Parameters:
  
  fields - The ordered field names for which the ArrayBinder will be created
  
  Returns:
  
  a new ArrayBinder which can produce a Object array from a long input.
- newArrayBinderFromBindPoints
  
  public LongFunction<Object[]> newArrayBinderFromBindPoints(List<io.nosqlbench.virtdata.core.templates.BindPoint> bindPoints)
  
  Parameters:
  
  bindPoints - The BindPoints for which the ArrayBinder will be created
  
  Returns:
  
  a new ArrayBinder which can produce a Object array from a long input.
- getMapper
  
  public LongFunction<?> getMapper(String field)
  
  Get the LongFunction which is used to resolve a dynamic field value.
  
  Parameters:
  
  field - The field name for a dynamic parameter
  
  Returns:
  
  The mapping function
- getSize
  
  public int getSize()
  
  Returns:
  
  the logical map size, including all static and dynamic fields
- getValueType
  
  public Class<?> getValueType(String fieldname)
- getTypeAndTargetFromEnum
  
  public <E extends Enum<E>, V> Optional<io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>> getTypeAndTargetFromEnum(Class<E> enumclass, Class<V> valueClass)
  
  Given an enum of any type, return the enum value which is found in any of the field names of the op template, ignoring case and any non-word characters. This is useful for matching op templates to op types where the presence of a field determines the type. Further, if there are multiple matching names, an OpConfigError is thrown to avoid possible ambiguity.
  
  Type Parameters:
  
  E - Generic type for the enum class
  
  Parameters:
  
  enumclass - The enum class for matching values
  
  Returns:
  
  Optionally, an enum value which matches, or Optional.empty()
  
  Throws:
  
  io.nosqlbench.nb.api.errors.OpConfigError - if more than one field matches
- getOptionalTypeAndTargetEnum
  
  public <E extends Enum<E>, V> Optional<io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>> getOptionalTypeAndTargetEnum(Class<E> enumclass, Class<V> valueClass)
- getOptionalTypeAndTargetEnum
  
  public <E extends Enum<E>, V> Optional<io.nosqlbench.engine.api.templating.TypeAndTarget<E,V>> getOptionalTypeAndTargetEnum(Class<E> enumclass, Class<V> valueClass, String alternateTypeField, String alternateValueField)
- getTypeAndTarget
  
  public <E extends Enum<E>, V> io.nosqlbench.engine.api.templating.TypeAndTarget<E,V> getTypeAndTarget(Class<E> enumclass, Class<V> valueClass)
- getTypeAndTarget
  
  public <E extends Enum<E>, V> io.nosqlbench.engine.api.templating.TypeAndTarget<E,V> getTypeAndTarget(Class<E> enumclass, Class<V> valueclass, String tname, String vname)
- getOptionalEnumFromField
  
  public <E extends Enum<E>> Optional<E> getOptionalEnumFromField(Class<E> enumclass, String fieldName)
- getEnumFromFieldOr
  
  public <E extends Enum<E>> E getEnumFromFieldOr(Class<E> enumClass, E defaultEnum, String fieldName)
- enhanceDefaultFunc
  
  public <FA, FE> LongFunction<FA> enhanceDefaultFunc(LongFunction<FA> func, String field, Class<FE> type, FE defaultFe, BiFunction<FA,FE,FA> combiner)
  
  Enhance a Function with another required named field or function combiner OR a default value.
  
  Type Parameters:
  
  FA - The base function result type
  
  FE - The enhancer function result type
  
  Parameters:
  
  func - The base function
  
  field - The field name to derive the named enhancer function from
  
  type - The type of the field value
  
  defaultFe - The default value of the field, if none is provided
  
  combiner - A BiFunction which applies the field or function combiner to the base function
  
  Returns:
  
  an enhanced function
- enhanceFunc
  
  public <FA, FE> LongFunction<FA> enhanceFunc(LongFunction<FA> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)
  
  Enhance a Function with a named required function, or throw an error.
  
  Type Parameters:
  
  FA - The base function result type
  
  FE - The enhancer function result type
  
  Parameters:
  
  func - The base function
  
  field - The field name to derive the named enhancer function from
  
  type - The type of the field value
  
  combiner - A BiFunction which applies the field or function combiner to the base function
  
  Returns:
  
  a version of the base function, optionally enhanced
- enhanceFuncOptionally
  
  public <FA, FE> LongFunction<FA> enhanceFuncOptionally(LongFunction<FA> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)
  
  Enhance a Function with a named optional function IFF it exists.
  
  Type Parameters:
  
  FA - The base function result type
  
  FE - The enhancer function result type
  
  Parameters:
  
  func - The base function
  
  field - The field name to derive the named enhancer function from
  
  type - The type of the field value
  
  combiner - A BiFunction which applies the field or function combiner to the base function
  
  Returns:
  
  a version of the base function, optionally enhanced
- enhanceOptionalFuncOptionally
  
  public <FA, FE> Optional<LongFunction<FA>> enhanceOptionalFuncOptionally(Optional<LongFunction<FA>> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)
  
  Enhance an Optional Function with an optional named field or value combiner, IFF both functions are defined.
  
  Type Parameters:
  
  FA - The base function result type
  
  FE - The enhancer function result type
  
  Parameters:
  
  func - The base function
  
  field - The field name to derive the named enhancer function from
  
  type - The type of the field value
  
  combiner - A BiFunction which applies the field or function combiner to the base function
  
  Returns:
  
  the enhanced optional function
- enhanceOptionalDefaultFunc
  
  public <FA, FE> Optional<LongFunction<FA>> enhanceOptionalDefaultFunc(Optional<LongFunction<FA>> func, String field, Class<FE> type, FE defaultFe, BiFunction<FA,FE,FA> combiner)
  
  Enhance an Optional Function with a named field or function combiner OR a default value, IFF the base function is present.
  
  Create a required function for the specified field and default value, IFF the main function is present. The base type of the function remains the same, and if present, will be extended with the required field value or function in the provided combiner.
  
  Type Parameters:
  
  FA - The base function result type
  
  FE - The enhancer function result type
  
  Parameters:
  
  func - The base function
  
  field - The field name to derive the named enhancer function from
  
  type - The type of the field value
  
  defaultFe - The default value of the field, if none is provided
  
  combiner - A BiFunction which applies the field or function combiner to the base function
  
  Returns:
  
  the enhanced optional base function
- enhanceEnum
  
  public <FA, FE extends Enum<FE>> LongFunction<FA> enhanceEnum(LongFunction<FA> func, String field, Class<FE> type, BiFunction<FA,FE,FA> combiner)
  
  Enhance a Function with an optional enum function IFF it is defined.
  
  Type Parameters:
  
  FA - The base function result type
  
  FE - The enhancer function result type
  
  Parameters:
  
  func - The base function
  
  field - The field name to derive the named enhancer function from
  
  type - The type of the field value
  
  combiner - A BiFunction which applies the field or function combiner to the base function
  
  Returns:
  
  an (optionally) enhanced base function
- parseStaticCmdMap
  
  public Map<String,Object> parseStaticCmdMap(String key, String mainField)
- toString
  
  public String toString()
  
  Overrides:
  
  toString in class Object

Class ParsedOp

ParsedOp API

Supporting Variety

Op Template Parsing

Distinguishing Op Payload from Op Config

Example:

Design Invariants

Op Payload Forms

Static Op Fields

Example:

Dynamic Op Fields with Binding References

Example:

Dynamic Op Fields with Binding Definitions

Example:

Dynamic Op Fields with Structure

Example:

Op Template Params

Example:

Activity Params

Example:

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Details

ParsedOp

ParsedOp

Method Details

getName

getTemplateMap

apply

isDynamic

isStatic

isStatic

isDefined

getStaticValue

getStaticValue

getAsTemplate

getStaticValueOr

getStaticConfigOr

takeStaticConfigOr

getStaticConfig

getOptionalStaticConfig

getConfigOr

getOptionalStaticValue

takeOptionalStaticValue

get

getDefinedNames

getAsRequiredFunction

getAsOptionalFunction

getAsOptionalEnumFunction

getAsOptionalFunction

getAsRequiredFunction

getAsFunctionOr

getAsCachedFunctionOr

isDefined

isUndefined

isDefined

isDefinedAll

newListBinder

newListBinder

newOrderedMapBinder

newArrayBinder

newArrayBinder

newArrayBinderFromBindPoints

getMapper

getSize

getValueType

getTypeAndTargetFromEnum

getOptionalTypeAndTargetEnum

getOptionalTypeAndTargetEnum

getTypeAndTarget

getTypeAndTarget

getOptionalEnumFromField

getEnumFromFieldOr

enhanceDefaultFunc

enhanceFunc

enhanceFuncOptionally

enhanceOptionalFuncOptionally

enhanceOptionalDefaultFunc

enhanceEnum