AbstractTupleImpl (Punch Punch Language Runtime Library 6.4.4 API)

java.lang.Object
- org.thales.punch.libraries.punchlang.impl.AbstractTupleImpl

All Implemented Interfaces:

Comparable<Tuple>, Tuple

Direct Known Subclasses:

TupleImpl
```
public abstract class AbstractTupleImpl
extends Object
implements Tuple
```
This class provide the many useful api methods defined in the Tuple interface. The core implementation of the nested structure is defined in subclass TupleImpl.

Author:

dimi

Field Summary

Fields
Modifier and Type Field and Description

protected Ancestor ancestor

protected Object content
the map for holding regular subtuples, if any

Fields
Modifier and Type	Field and Description
`protected Ancestor`	`ancestor`
`protected Object`	`content` the map for holding regular subtuples, if any

Constructor Summary

Constructors
Constructor and Description

AbstractTupleImpl()

Constructors
Constructor and Description
`AbstractTupleImpl()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`asBoolean()` Return the leaf value as a boolean.
`byte[]`	`asBytes()` Return the leaf value as a byte array.
`Collection<Tuple>`	`asCollection()` Returns a collection of elements.
`double`	`asDouble()` Return the leaf value as a double.
`double[]`	`asDoubleArray()` Easily get an array of double.
`float`	`asFloat()` Return the leaf value as a float.
`int`	`asInt()` Return the leaf value as an integer.
`long`	`asLong()` Return the leaf value as a long.
`long[]`	`asLongArray()` Easily get an array of long.
`String`	`asString()` Return the leaf value as a String.
`String`	`asString(String fmt, Object... values)` Return the leaf value as a String.
`String[]`	`asStringArray()` Easily get an array of long.
`void`	`attach(String key, Object value)` Attach some opaque data to this tuple.
`int`	`compareTo(Tuple o)`
`String`	`concat(String str)` Concatenates the specified string to the end of this string.
`boolean`	`containsOneOf(String[] strs)` Check if this tuple contains a sub-string.
`boolean`	`containsOneOf(Tuple resource)` Check if this tuple contains one of several sub-string.
`Tuple`	`cutPrefix(String s)` Remove a matching prefix
`Tuple`	`cutSuffix(String s)` Remove a matching prefix
`boolean`	`endsWith(String s)` Return true if the String value of this tuple ends with a given suffix.
`long`	`get(String key, long defaultValue)` Retrieve a field from a tuple, and if not there return a default.
`String`	`get(String key, String defaultValue)` Retrieve a field from a tuple, and if not there return a default.
`Tuple`	`get(Tuple key)` Return a sub-tuple by key.
`Object`	`getAttachment(String key)` Retrieve an attachment by key.
`protected org.ahocorasick.trie.Trie`	`getCreateTrie(Tuple resourceTuple, String key)` Retrieve the Trie attached to a resource tuple, create one if not in there.
`Tuple`	`getDeep(String key)` Return a sub-tuple by key recursively.
`Tuple`	`getDeepEs(String key)` Return a sub-tuple by key recursively.
`List<String>`	`getKeys()` Returns the list of inner property keys.
`String`	`getType()` return a String representation of the type of the value contained in a tuple.
`boolean`	`hasKey(String key)`
`int`	`indexOf(char ch)` String operation only.
`int`	`indexOf(char ch, int fromIndex)` String operation only.
`int`	`indexOf(String str)` String operation only.
`int`	`indexOf(String str, int fromIndex)` String operation only.
`boolean`	`isArray()` Return true if this tuple contains an array value
`boolean`	`isBooleanLeaf()` Check if a tuple contains a long value.
`boolean`	`isBytesLeaf()` Check if a tuple contains a Byte array value.
`boolean`	`isDoubleLeaf()` Check if a tuple contains a double value.
`boolean`	`isEquals(Object o)` Check if a tuple contains a leaf value and if it is equal to a given value
`boolean`	`isLongLeaf()` Check if a tuple contains a long value.
`boolean`	`isRoot()` Return true if this tuple is a root one.
`boolean`	`isSet()` Check if this tuple holds a set
`boolean`	`isStringLeaf()` Check if a tuple contains a String value.
`boolean`	`isTuple()` Return true if this tuple contains a tuple value
`int`	`length()` String API, returns the length of a String leaf Tuple.
`boolean`	`matches(String regex)` String API : Tells whether or not this string matches the given regular expression.
`boolean`	`remove(Tuple element)` Set operation: remove an element from a set.
`String`	`replace(char oldChar, char newChar)` Returns a string resulting from replacing all occurrences of oldChar in this string with newChar.
`String`	`replaceAll(String regex, String replacement)` Replaces each substring occurence of this string that matches the given regular expression `regex` with the given `replacement`.
`Tuple`	`replaceAllValues(String regex, String replacement)` For each inner String value contained in this tuple, replaces each substring occurence that matches the given regular expression with the given replacement.
`String`	`replaceFirst(String regex, String replacement)` Replaces the first substring of this string that matches the given regular expression with the given replacement.
`String[]`	`split(String s)` Splits this string around matches of the given regular expression.
`boolean`	`startsWith(String s)` Split a string tuple.
`String`	`substring(int beginIndex)`
`String`	`substring(int beginIndex, int endIndex)`
`protected static <T> T[]`	`toArray(T... items)`
`Tuple`	`toLowerCase()`
`Tuple`	`toUpperCase()`
`String`	`trim()` Methods inherited from plain Strings.
`Boolean`	`tryBoolean()` Try to parse the given value as Boolean.
`boolean`	`tryBoolean(boolean b)` Try to parse as Boolean or return a default value.
`byte[]`	`tryBytes()` Try to parse the given value as Byte array.
`byte[]`	`tryBytes(byte[] d)` Try to parse as Byte array or return a default value.
`Double`	`tryDouble()` Try to parse the given value as Double.
`double`	`tryDouble(double d)` Try to parse as Double or return a default value.
`String`	`tryIp()` Efficiently check for valid ip address.
`String`	`tryIp(String defaultValue)` Efficiently check for a valid ip address.
`String`	`tryIpv4()` Efficiently check for an dot decimal ipv4 ip address.
`String`	`tryIpv4(String defaultValue)` Efficiently check for an dot decimal ipv4 ip address.
`String`	`tryIpv6()` Efficiently check for an dot decimal ipv6 ip address.
`String`	`tryIpv6(String defaultValue)` Efficiently check for an dot decimal ipv6 ip address.
`Long`	`tryLong()` Try to parse the given value as Long.
`long`	`tryLong(long l)` Try to parse as Long or return default.

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

Methods inherited from interface org.thales.punch.libraries.punchlang.api.Tuple
add, append, asArray, asGeoShape, asSet, contains, decodeBase64, dump, duplicate, elements, empty, encodeBase64, equalsOneOf, exists, fromEscapedJson, get, getByKey, getElement, getElement, getEntries, getIterator, getSingleChild, getValues, isEmpty, isLeaf, leafAsString, merge, mergeWith, putAll, remove, remove, removeElement, replaceAllKeys, replaceAllKeyValues, select, set, set, size, skip, splitAsTupleArray, toAsciiJson, toEscapedJson, toFlat, toJson, toMap, toString

- Field Detail
  - content
```
protected Object content
```
    the map for holding regular subtuples, if any
  - ancestor
```
protected Ancestor ancestor
```
- Constructor Detail
  - AbstractTupleImpl
```
public AbstractTupleImpl()
```
- Method Detail
  - attach
```
public void attach(String key,
                   Object value)
```
    Description copied from interface: Tuple
    
    Attach some opaque data to this tuple. You can then retrieve it using Tuple.getAttachment(String). Attachments are transient data, they survive as long as the holding tuple survives. Besides, they will not appear in the Tuple.toString() String representation of this tuple.
    
    Specified by:
    
    attach in interface Tuple
    
    Parameters:
    
    key - the key for retrieving the attachment later
    
    value - the attachment value
  - getAttachment
```
public Object getAttachment(String key)
```
    Description copied from interface: Tuple
    
    Retrieve an attachment by key.
    
    Specified by:
    
    getAttachment in interface Tuple
    
    Parameters:
    
    key - the attachment key
    
    Returns:
    
    the attachment or null if no attachement is defined for that key.
  - asBoolean
```
public boolean asBoolean()
```
    Description copied from interface: Tuple
    
    Return the leaf value as a boolean.
    
    Specified by:
    
    asBoolean in interface Tuple
    
    Returns:
    
    the contained value as a boolean
  - tryBoolean
```
public Boolean tryBoolean()
```
    Description copied from interface: Tuple
    
    Try to parse the given value as Boolean. Return the leaf as Boolean if it succeed, return null otherwise.
    
    Specified by:
    
    tryBoolean in interface Tuple
    
    Returns:
    
    the boolean value or null
  - tryBoolean
```
public boolean tryBoolean(boolean b)
```
    Description copied from interface: Tuple
    
    Try to parse as Boolean or return a default value.
    
    Specified by:
    
    tryBoolean in interface Tuple
    
    Parameters:
    
    b - the default value
    
    Returns:
    
    the contained boolean or default
  - toArray
```
@SafeVarargs
protected static <T> T[] toArray(T... items)
```
  - asDoubleArray
```
public double[] asDoubleArray()
```
    Description copied from interface: Tuple
    
    Easily get an array of double. It works as long as the inner value(s) can be transformed into double.
    Longs are converted to doubles, String also as long as they represent a valid double number.
    If your tuple contains a single value an array of size 1 will be returned.
    
    Specified by:
    
    asDoubleArray in interface Tuple
    
    Returns:
    
    an array of double
  - asLongArray
```
public long[] asLongArray()
```
    Description copied from interface: Tuple
    
    Easily get an array of long. It works as long as the inner value(s) can be transformed into double.
    Longs are converted to doubles, String also as long as they represent a valid double number.
    If your tuple contains a single value an array of size 1 will be returned.
    
    Specified by:
    
    asLongArray in interface Tuple
    
    Returns:
    
    an array of double
  - asStringArray
```
public String[] asStringArray()
```
    Description copied from interface: Tuple
    
    Easily get an array of long. It works as long as the inner value(s) can be transformed into double.
    Longs are converted to doubles, String also as long as they represent a valid double number.
    If your tuple contains a single value an array of size 1 will be returned.
    
    Specified by:
    
    asStringArray in interface Tuple
    
    Returns:
    
    an array of double
  - asDouble
```
public double asDouble()
```
    Description copied from interface: Tuple
    
    Return the leaf value as a double.
    
    Specified by:
    
    asDouble in interface Tuple
    
    Returns:
    
    the contained value as a double
  - tryDouble
```
public Double tryDouble()
```
    Description copied from interface: Tuple
    
    Try to parse the given value as Double. Return the leaf as Double if it succeed, return null otherwise.
    
    Specified by:
    
    tryDouble in interface Tuple
    
    Returns:
    
    the contained value as Double
  - tryDouble
```
public double tryDouble(double d)
```
    Description copied from interface: Tuple
    
    Try to parse as Double or return a default value.
    
    Specified by:
    
    tryDouble in interface Tuple
    
    Parameters:
    
    d - a default v alue
    
    Returns:
    
    the contained value as double or default
  - asFloat
```
public float asFloat()
```
    Description copied from interface: Tuple
    
    Return the leaf value as a float. This is DANGEROUS, use double instead. Only use it if for some reason you must deal with floats.
    
    Specified by:
    
    asFloat in interface Tuple
    
    Returns:
    
    the contained value as a float
  - asInt
```
public int asInt()
```
    Description copied from interface: Tuple
    
    Return the leaf value as an integer. This is DANGEROUS, use long instead. Only use it if for some reason you must deal with floats.
    
    Specified by:
    
    asInt in interface Tuple
    
    Returns:
    
    the contained value as an integer
  - asLong
```
public long asLong()
```
    Description copied from interface: Tuple
    
    Return the leaf value as a long.
    
    Specified by:
    
    asLong in interface Tuple
    
    Returns:
    
    the contained value as a long
  - tryLong
```
public Long tryLong()
```
    Description copied from interface: Tuple
    
    Try to parse the given value as Long. If it succeed, return the leaf as Long, otherwise return null.
    
    Specified by:
    
    tryLong in interface Tuple
    
    Returns:
    
    the contained value as Long
  - tryLong
```
public long tryLong(long l)
```
    Description copied from interface: Tuple
    
    Try to parse as Long or return default.
    
    Specified by:
    
    tryLong in interface Tuple
    
    Parameters:
    
    l - the default value
    
    Returns:
    
    the contained value as Long or default
  - tryIpv4
```
public String tryIpv4()
```
    Description copied from interface: Tuple
    Efficiently check for an dot decimal ipv4 ip address.
    This method will return a dotted numeric representation of convertible ip addresses.
```
 // this statement has no effect if there is no ipv4 value in
 // [message][callerIpAddress]
 [logs][log][client][ip] = [message][callerIpAddress].tryIpv4();
 
```
    Specified by:
    
    tryIpv4 in interface Tuple
    
    Returns:
    
    the ip address or null is none match
  - tryIp
```
public String tryIp(String defaultValue)
```
    Description copied from interface: Tuple
    Efficiently check for a valid ip address.
    This method will return a dotted numeric representation of convertible ip addresses.
```
 // this statement has no effect if there is no ipv4 value in
 // [message][callerIpAddress]
 [logs][log][client][ip] = [message][callerIpAddress].tryIp("0.0.0.0");
 
```
    Specified by:
    
    tryIp in interface Tuple
    
    Parameters:
    
    defaultValue - the default value to return
    
    Returns:
    
    the ip address or the default is none match
  - tryIp
```
public String tryIp()
```
    Description copied from interface: Tuple
    Efficiently check for valid ip address.
    This method will return a dotted numeric representation of convertible ip addresses.
```
 // this statement has no effect if there is no ipv4 value in
 // [message][callerIpAddress]
 [logs][log][client][ip] = [message][callerIpAddress].tryIp();
 
```
    Specified by:
    
    tryIp in interface Tuple
    
    Returns:
    
    the ip address or null is none match
  - tryIpv4
```
public String tryIpv4(String defaultValue)
```
    Description copied from interface: Tuple
    Efficiently check for an dot decimal ipv4 ip address.
    This method will return a dotted numeric representation of convertible ip addresses.
```
 // this statement has no effect if there is no ipv4 value in
 // [message][callerIpAddress]
 [logs][log][client][ip] = [message][callerIpAddress].tryIpv4("0.0.0.0");
 
```
    Specified by:
    
    tryIpv4 in interface Tuple
    
    Parameters:
    
    defaultValue - the default value to return
    
    Returns:
    
    the ip address or the default is none match
  - tryIpv6
```
public String tryIpv6()
```
    Description copied from interface: Tuple
    Efficiently check for an dot decimal ipv6 ip address.
    This method will return a dotted numeric representation of convertible ip addresses.
```
 // this statement has no effect if there is no ipv4 value in
 // [message][callerIpAddress]
 [logs][log][client][ipv6] = [message][callerIpAddress].tryIpv6();
 
```
    Specified by:
    
    tryIpv6 in interface Tuple
    
    Returns:
    
    the ip address or null is none match
  - tryIpv6
```
public String tryIpv6(String defaultValue)
```
    Description copied from interface: Tuple
    Efficiently check for an dot decimal ipv6 ip address.
    This method will return a dotted numeric representation of convertible ip addresses.
```
 // this statement has no effect if there is no ipv4 value in
 // [message][callerIpAddress]
 [logs][log][client][ipv6] = [message][callerIpAddress].tryIpv6("::0");
 
```
    Specified by:
    
    tryIpv6 in interface Tuple
    
    Parameters:
    
    defaultValue - the default value to return
    
    Returns:
    
    the ip address or the default is none match
  - asString
```
public String asString()
```
    Description copied from interface: Tuple
    
    Return the leaf value as a String. Note that this method does not attempt to transform other type into String representation. It only work on String leaf values.
    
    Specified by:
    
    asString in interface Tuple
    
    Returns:
    
    the contained value as a String
  - asString
```
public String asString(String fmt,
                       Object... values)
```
    Description copied from interface: Tuple
    
    Return the leaf value as a String. Note that this method does not attempt to transform other type into String representation. It only work on String leaf values.
    The additional argument will be used to format an error message in case an exception is raised. This is handy to write log parsers that report clear errors.
    
    Specified by:
    
    asString in interface Tuple
    
    Returns:
  - concat
```
public String concat(String str)
```
    Description copied from interface: Tuple
    
    Concatenates the specified string to the end of this string.
    If the length of the argument string is 0, then this String object is returned. Otherwise, a String object is returned that represents a character sequence that is the concatenation of the character sequence represented by this String object and the character sequence represented by the argument string.
    
    Specified by:
    
    concat in interface Tuple
    
    Parameters:
    
    str - the string to concatenate
    
    Returns:
    
    the concatenated string
  - getDeep
```
public Tuple getDeep(String key)
```
    Description copied from interface: Tuple
    
    Return a sub-tuple by key recursively. If the key value is punch-style format, then it executes Tuple.get() functions recursively.
    
    Specified by:
    
    getDeep in interface Tuple
    
    Parameters:
    
    key - the key of the sub-tuple. It can be plain String format "name" or punch-style format "[user][name]"
    
    Returns:
    
    the sub-tuple or null if it does not exists
  - getDeepEs
```
public Tuple getDeepEs(String key)
```
    Description copied from interface: Tuple
    
    Return a sub-tuple by key recursively.
    This variant accepts both the punch "[user][name]" format as well as the standard elasticsearch "user.name" format.
    For the rest it behaves exactly as Tuple.getDeep(String)
    
    Specified by:
    
    getDeepEs in interface Tuple
    
    Parameters:
    
    key - the key of the sub tuple. Accepted forms are "name", "[user][name]" or "user.name"
    
    Returns:
    
    the sub-tuple or null if it does not exists
  - get
```
public Tuple get(Tuple key)
```
    Description copied from interface: Tuple
    
    Return a sub-tuple by key. If it does not exists, create it.
    This variant expect the string key to be contained in a tuple. It will convert the leaf value to a string, and fail if it is not a leaf value.
    
    Specified by:
    
    get in interface Tuple
    
    Parameters:
    
    key - the sub-tuple key
    
    Returns:
    
    the sub-tuple
  - getKeys
```
public List<String> getKeys()
```
    Description copied from interface: Tuple
    
    Returns the list of inner property keys. This assumes the tuple is a map tuple.
    
    Specified by:
    
    getKeys in interface Tuple
    
    Returns:
    
    the list of keys
  - hasKey
```
public boolean hasKey(String key)
```
    Specified by:
    
    hasKey in interface Tuple
    
    Parameters:
    
    key - the key to look for
    
    Returns:
    
    true if this tuple has some (direct) subtuple for the given key.
  - indexOf
```
public int indexOf(char ch)
```
    Description copied from interface: Tuple
    
    String operation only. Returns the index within this string of the first occurrence of the specified character.
    
    Specified by:
    
    indexOf in interface Tuple
    
    Parameters:
    
    ch - the character
    
    Returns:
    
    the index
  - indexOf
```
public int indexOf(char ch,
                   int fromIndex)
```
    Description copied from interface: Tuple
    
    String operation only. Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.
    
    Specified by:
    
    indexOf in interface Tuple
    
    Parameters:
    
    ch - the character
    
    fromIndex - the start index
    
    Returns:
    
    the index
  - indexOf
```
public int indexOf(String str)
```
    Description copied from interface: Tuple
    
    String operation only. Returns the index within this string of the first occurrence of the specified substring.
    
    Specified by:
    
    indexOf in interface Tuple
    
    Parameters:
    
    str - the substring to search for.
    
    Returns:
    
    the index
  - indexOf
```
public int indexOf(String str,
                   int fromIndex)
```
    Description copied from interface: Tuple
    
    String operation only. Returns the index within this string of the first occurrence of the specified substring, starting at some index.
    
    Specified by:
    
    indexOf in interface Tuple
    
    Parameters:
    
    str - the substring to search for, starting the search at the specified index.
    
    fromIndex - the starting index to start searching from
    
    Returns:
    
    the requested index
  - isArray
```
public boolean isArray()
```
    Description copied from interface: Tuple
    
    Return true if this tuple contains an array value
    
    Specified by:
    
    isArray in interface Tuple
    
    Returns:
    
    true or false
  - isBooleanLeaf
```
public boolean isBooleanLeaf()
```
    Description copied from interface: Tuple
    
    Check if a tuple contains a long value.
    
    Specified by:
    
    isBooleanLeaf in interface Tuple
    
    Returns:
    
    true or false
  - isDoubleLeaf
```
public boolean isDoubleLeaf()
```
    Description copied from interface: Tuple
    
    Check if a tuple contains a double value.
    
    Specified by:
    
    isDoubleLeaf in interface Tuple
    
    Returns:
    
    true or false
  - isEquals
```
public boolean isEquals(Object o)
```
    Description copied from interface: Tuple
    
    Check if a tuple contains a leaf value and if it is equal to a given value
    
    Specified by:
    
    isEquals in interface Tuple
    
    Parameters:
    
    o - a java object value
    
    Returns:
    
    true or false
  - isLongLeaf
```
public boolean isLongLeaf()
```
    Description copied from interface: Tuple
    
    Check if a tuple contains a long value.
    
    Specified by:
    
    isLongLeaf in interface Tuple
    
    Returns:
    
    true or false
  - isRoot
```
public boolean isRoot()
```
    Description copied from interface: Tuple
    
    Return true if this tuple is a root one. A candidate tuple is non root.
    
    Specified by:
    
    isRoot in interface Tuple
    
    Returns:
    
    true or false
  - isSet
```
public boolean isSet()
```
    Description copied from interface: Tuple
    
    Check if this tuple holds a set
    
    Specified by:
    
    isSet in interface Tuple
    
    Returns:
    
    true or false
  - isStringLeaf
```
public boolean isStringLeaf()
```
    Description copied from interface: Tuple
    
    Check if a tuple contains a String value.
    
    Specified by:
    
    isStringLeaf in interface Tuple
    
    Returns:
    
    true or false
  - isBytesLeaf
```
public boolean isBytesLeaf()
```
    Description copied from interface: Tuple
    
    Check if a tuple contains a Byte array value.
    
    Specified by:
    
    isBytesLeaf in interface Tuple
    
    Returns:
    
    true or false
  - isTuple
```
public boolean isTuple()
```
    Description copied from interface: Tuple
    
    Return true if this tuple contains a tuple value
    
    Specified by:
    
    isTuple in interface Tuple
    
    Returns:
    
    true or false
  - length
```
public int length()
```
    Description copied from interface: Tuple
    
    String API, returns the length of a String leaf Tuple. This is a shortcut for asString().length. Watch Out : this only works for String leaf tuple.
    
    Specified by:
    
    length in interface Tuple
    
    Returns:
    
    the string leaf length.
  - matches
```
public boolean matches(String regex)
```
    Description copied from interface: Tuple
    
    String API : Tells whether or not this string matches the given regular expression.
    
    Specified by:
    
    matches in interface Tuple
    
    Parameters:
    
    regex - the regular expression to which this string is to be matched
    
    Returns:
    
    true if it matches
  - remove
```
public boolean remove(Tuple element)
```
    Description copied from interface: Tuple
    
    Set operation: remove an element from a set.
    
    Specified by:
    
    remove in interface Tuple
    
    Parameters:
    
    element - the contained tuple to remove
    
    Returns:
    
    true if the element was removed. false if it was not there.
  - replace
```
public String replace(char oldChar,
                      char newChar)
```
    Description copied from interface: Tuple
    Returns a string resulting from replacing all occurrences of oldChar in this string with newChar.
    If the character oldChar does not occur in the character sequence represented by this String object, then a reference to this String object is returned. Otherwise, a String object is returned that represents a character sequence identical to the character sequence represented by this String object, except that every occurrence of oldChar is replaced by an occurrence of newChar. Examples:
```
        "mesquite in your cellar".replace('e', 'o')
        returns "mosquito in your collar"
  "the war of baronets".replace('r', 'y')
        returns "the way of bayonets"
  "sparring with a purple porpoise".replace('p', 't')
        returns "starring with a turtle tortoise"
  "JonL".replace('q', 'x') returns "JonL" (no change)
 
```
    Specified by:
    
    replace in interface Tuple
    
    Parameters:
    
    oldChar - the old char
    
    newChar - the new char
    
    Returns:
    
    the update String
  - replaceAll
```
public String replaceAll(String regex,
                         String replacement)
```
    Description copied from interface: Tuple
    
    Replaces each substring occurence of this string that matches the given regular expression regex with the given replacement. This methods only acts on the Tuple String value. It has no effect if the Tuple contains somethng else than a String.
    Check the Tuple.replaceAllValues(java.lang.String, java.lang.String), Tuple.replaceAllKeys(java.lang.String, java.lang.String) or Tuple.replaceAllKeyValues(java.lang.String, java.lang.String) for recursive versions that do the job on all keys and?or values contained in a nested Tuple.
    
    Specified by:
    
    replaceAll in interface Tuple
    
    Parameters:
    
    regex - the regular expression
    
    replacement - the replacement String
    
    Returns:
    
    the updated String
  - replaceAllValues
```
public Tuple replaceAllValues(String regex,
                              String replacement)
```
    Description copied from interface: Tuple
    
    For each inner String value contained in this tuple, replaces each substring occurence that matches the given regular expression with the given replacement.
    
    Specified by:
    
    replaceAllValues in interface Tuple
    
    Parameters:
    
    regex - the regular expression
    
    replacement - the replacement String
    
    Returns:
    
    the updated String
  - replaceFirst
```
public String replaceFirst(String regex,
                           String replacement)
```
    Description copied from interface: Tuple
    
    Replaces the first substring of this string that matches the given regular expression with the given replacement.
    
    Specified by:
    
    replaceFirst in interface Tuple
    
    Parameters:
    
    regex - the regular expression
    
    replacement - the replacement String
    
    Returns:
    
    the updated String
  - substring
```
public String substring(int beginIndex)
```
    Specified by:
    
    substring in interface Tuple
    
    Parameters:
    
    beginIndex - the substring start index
    
    Returns:
    
    the requested substring
  - substring
```
public String substring(int beginIndex,
                        int endIndex)
```
    Specified by:
    
    substring in interface Tuple
    
    Parameters:
    
    beginIndex - the substring start index
    
    endIndex - the substring end index
    
    Returns:
    
    the requested substring
  - toLowerCase
```
public Tuple toLowerCase()
```
    Specified by:
    
    toLowerCase in interface Tuple
    
    Returns:
    
    the upper case String
  - cutPrefix
```
public Tuple cutPrefix(String s)
```
    Description copied from interface: Tuple
    
    Remove a matching prefix
    
    Specified by:
    
    cutPrefix in interface Tuple
    
    Parameters:
    
    s - the string value
    
    Returns:
    
    a new leaf Tuple
  - cutSuffix
```
public Tuple cutSuffix(String s)
```
    Description copied from interface: Tuple
    
    Remove a matching prefix
    
    Specified by:
    
    cutSuffix in interface Tuple
    
    Parameters:
    
    s - the string value
    
    Returns:
    
    a new leaf Tuple
  - startsWith
```
public boolean startsWith(String s)
```
    Description copied from interface: Tuple
    
    Split a string tuple.
    
    Specified by:
    
    startsWith in interface Tuple
    
    Parameters:
    
    s - the string value
    
    Returns:
    
    a new leaf Tuple
  - split
```
public String[] split(String s)
```
    Description copied from interface: Tuple
    
    Splits this string around matches of the given regular expression.
    
    Specified by:
    
    split in interface Tuple
    
    Parameters:
    
    s - - the delimiting regular expression
    
    Returns:
    
    a new leaf Tuple
  - endsWith
```
public boolean endsWith(String s)
```
    Description copied from interface: Tuple
    
    Return true if the String value of this tuple ends with a given suffix.
    
    Specified by:
    
    endsWith in interface Tuple
    
    Parameters:
    
    s - the String to match a suffix
    
    Returns:
    
    true or false
  - toUpperCase
```
public Tuple toUpperCase()
```
    Specified by:
    
    toUpperCase in interface Tuple
    
    Returns:
    
    the upper case String
  - trim
```
public String trim()
```
    Description copied from interface: Tuple
    
    Methods inherited from plain Strings. This only works if the tuple is a String leaf tuple.
    See String.trim().
    
    Specified by:
    
    trim in interface Tuple
    
    Returns:
    
    the trimed String
  - get
```
public String get(String key,
                  String defaultValue)
```
    Description copied from interface: Tuple
    
    Retrieve a field from a tuple, and if not there return a default.
    
    Specified by:
    
    get in interface Tuple
    
    Parameters:
    
    key - the key to look for
    
    defaultValue - a default value to return if no value is associated to the key
    
    Returns:
    
    the requested value
  - get
```
public long get(String key,
                long defaultValue)
```
    Description copied from interface: Tuple
    
    Retrieve a field from a tuple, and if not there return a default.
    
    Specified by:
    
    get in interface Tuple
    
    Parameters:
    
    key - the key to look for
    
    defaultValue - a default value to return if no value is associated to the key
    
    Returns:
    
    the requested value
  - asCollection
```
public Collection<Tuple> asCollection()
```
    Description copied from interface: Tuple
    
    Returns a collection of elements. This assumes the tuple is an array or a set value. It is ordered only if it is an array.
    
    Specified by:
    
    asCollection in interface Tuple
    
    Returns:
    
    the list of array elements
  - getType
```
public String getType()
```
    Description copied from interface: Tuple
    
    return a String representation of the type of the value contained in a tuple. This methods returns one of "String", "bool", "array", "set", "long", "double", "bytes", "tuple" or "empty".
    
    Specified by:
    
    getType in interface Tuple
    
    Returns:
    
    a type description.
  - containsOneOf
```
public boolean containsOneOf(String[] strs)
```
    Description copied from interface: Tuple
    Check if this tuple contains a sub-string. You can pass one or several substring as argument. This method simply iterates to check if one of the substring you need is in there. If you have a large list, prefer the variant using a resource tuple which internally relies on a PatriciaTree.
    Here is a typical usage :
```
 
        if (tuple.containsOneOf("CNN", "FOX", "TF1")) {
                ...
    }
 
 
```
    Should you need to ignore the case :
```
 
        if (tuple.toLowerCase().containsOneOf("cnn", "fox", "tf1")) {
                ...
    }
 
 
```
    Specified by:
    
    containsOneOf in interface Tuple
    
    Parameters:
    
    strs - the list of String to check for
    
    Returns:
    
    true if one of the string is in there
  - containsOneOf
```
public boolean containsOneOf(Tuple resource)
```
    Description copied from interface: Tuple
    Check if this tuple contains one of several sub-string. This variant takes in a resource tuple, and creates an aho-corasick index. It is created only the first time you call this method, subsequent calls will benefit from the ready to be used index.
    Please note that this tuple must be a Leaf tuple, more precisely of type String for this to work. Otherwise, you will get false.
    Use this variant only if your set of substrings does never change. It is the most efficient in particular if you have many sub-strings to check for.
    An example will best illustrate how it works. Say you have a domain name in a tuple field, [host][name] that contains for example "www.mydomain-prod.com". Suppose you want to know if that domain name contains one of the following substring
```
 
        [ "prod", "admin" ]
 
 
```
    Put your substring in a resource file (say) my-patterns.json. You can then simply write :
```
 
  Tuple tuple = [host][name]
    ...
        if (tuple.containsOneOf(getResourceTuple("my-patterns"))) {
                ...
    }
 
 
```
    Specified by:
    
    containsOneOf in interface Tuple
    
    Parameters:
    
    resource - your resource tuple, containing your string atoms
    
    Returns:
    
    true if your String leaf value contains one of the substring defined in the resource tuple.
  - compareTo
```
public int compareTo(Tuple o)
```
    Specified by:
    
    compareTo in interface Comparable<Tuple>
  - getCreateTrie
```
protected org.ahocorasick.trie.Trie getCreateTrie(Tuple resourceTuple,
                                                  String key)
```
    Retrieve the Trie attached to a resource tuple, create one if not in there.
    
    Parameters:
    
    resourceTuple - the resource Tuple, remember these are static and attached to a punchlet context
    
    key - the key for retrieving the trie
    
    Returns:
    
    the attached Trie
  - asBytes
```
public byte[] asBytes()
```
    Description copied from interface: Tuple
    
    Return the leaf value as a byte array.
    
    Specified by:
    
    asBytes in interface Tuple
    
    Returns:
    
    the contained value as an array of bytes
  - tryBytes
```
public byte[] tryBytes()
```
    Description copied from interface: Tuple
    
    Try to parse the given value as Byte array. Return the leaf as Byte array if it succeed, return null otherwise.
    
    Specified by:
    
    tryBytes in interface Tuple
    
    Returns:
    
    the Byte[] value or null
  - tryBytes
```
public byte[] tryBytes(byte[] d)
```
    Description copied from interface: Tuple
    
    Try to parse as Byte array or return a default value.
    
    Specified by:
    
    tryBytes in interface Tuple
    
    Parameters:
    
    d - the default value
    
    Returns:
    
    the contained Byte[] or default

Class AbstractTupleImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.thales.punch.libraries.punchlang.api.Tuple

Field Detail

content

ancestor

Constructor Detail

AbstractTupleImpl

Method Detail

attach

getAttachment

asBoolean

tryBoolean

tryBoolean

toArray

asDoubleArray

asLongArray

asStringArray

asDouble

tryDouble

tryDouble

asFloat

asInt

asLong

tryLong

tryLong

tryIpv4

tryIp

tryIp

tryIpv4

tryIpv6

tryIpv6

asString

asString

concat

getDeep

getDeepEs

get

getKeys

hasKey

indexOf

indexOf

indexOf

indexOf

isArray

isBooleanLeaf

isDoubleLeaf

isEquals

isLongLeaf

isRoot

isSet

isStringLeaf

isBytesLeaf

isTuple

length

matches

remove

replace

replaceAll

replaceAllValues

replaceFirst

substring

substring

toLowerCase

cutPrefix

cutSuffix

startsWith

split

endsWith

toUpperCase

trim

get

get

asCollection

getType

containsOneOf

containsOneOf