Dynamic (com.github.alexheretic:dynamics 4.0 API)

All Superinterfaces:

Weak<Dynamic>

All Known Implementing Classes:

AbstractDynamic, XmlDynamic
```
public interface Dynamic
extends Weak<Dynamic>
```
Wrapper allowing weakly-typed nested structure selection that's null-safe As an example consider a Map with the following structure called 'message'
```
    {
      "product": {
        "investment": {
          "info": {
            "current": {
              "name": "some name"
            }
          }
        }
      }
    }
 
```
We can select the nested 'name' field with Dynamic.from(message).dget("product.investment.info.current.name").asString()
Author:

Alex Butler

Field Summary

Fields
Modifier and Type Field and Description

static String ROOT_KEY
Default key value for top-level Dynamic instances

Fields
Modifier and Type	Field and Description
`static String`	`ROOT_KEY` Default key value for top-level Dynamic instances

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default Stream<Dynamic>`	`allChildren()`
`default Stream<Dynamic>`	`allChildrenBreadthFirst()` Returns a stream of all children in a breadth first order, for example a structure
`default Stream<Dynamic>`	`allChildrenDepthFirst()` Returns a stream of all children in a depth first order, for example a structure
`default <T> T`	`as(Class<T> type)` As `Weak.asObject()` casting to input type, and providing a better message in the exceptional case
`Stream<Dynamic>`	`children()`
`default Dynamic`	`dget(String dotSeparatedPath)` Shortcut for `dynamic.get("some.path.to.somewhere", ".")` avoiding the need for the second argument ie `dynamic.dget("some.path.to.somewhere")`
`static Dynamic`	`from(Object val)` Wraps a value in a dynamic representation, properly handled nested types are Maps & Collections all other types become dynamic end-points.
`Dynamic`	`get(Object key)` Returns a dynamic wrapping the immediate child of this instance with the input key, or a dynamic representing the lack of such a child.
`default Dynamic`	`get(String keyPath, String separator)` Performs multiple String gets as described by an input key path so `dynamic.get("one.two.three", ".")` is equivalent to `dynamic.get("one").get("two").get("three")`
`Weak<?>`	`key()` Returns Weak instance wrapping the key for this node.

Methods inherited from interface alexh.weak.Weak
asList, asMap, asObject, asOptional, asString, convert, is, isList, isMap, isPresent, isString, maybe

- Field Detail
  - ROOT_KEY
```
static final String ROOT_KEY
```
    Default key value for top-level Dynamic instances
    
    See Also:
    
    Constant Field Values
- Method Detail
  - from
```
static Dynamic from(Object val)
```
    Wraps a value in a dynamic representation, properly handled nested types are Maps & Collections all other types become dynamic end-points. In the general case you simply have to convert to one of these to be handled as a nested dynamic object See Converter to perform simple conversions to these types where applicable See XmlDynamic for an XML handling dynamic representation
    
    Parameters:
    
    val - some value
    
    Returns:
    
    Dynamic representation of the input value
  - get
```
Dynamic get(Object key)
```
    Returns a dynamic wrapping the immediate child of this instance with the input key, or a dynamic representing the lack of such a child. This is never null.
    
    Parameters:
    
    key - child key
    
    Returns:
    
    dynamic representing the child matching the input key, or a dynamic representing the key's absence
  - children
```
Stream<Dynamic> children()
```
    Returns:
    
    stream of all immediate children of this instance
  - get
```
default Dynamic get(String keyPath,
                    String separator)
```
    Performs multiple String gets as described by an input key path so dynamic.get("one.two.three", ".") is equivalent to dynamic.get("one").get("two").get("three")
    
    Parameters:
    
    keyPath - successive child keys separated by separator string
    
    separator - a string separator to split the input key input multiple keys
    
    Returns:
    
    dynamic representing the nested child
  - dget
```
default Dynamic dget(String dotSeparatedPath)
```
    Shortcut for dynamic.get("some.path.to.somewhere", ".") avoiding the need for the second argument ie dynamic.dget("some.path.to.somewhere")
    
    Parameters:
    
    dotSeparatedPath - successive child keys separated by "." character
    
    Returns:
    
    dynamic representing the nested child
  - key
```
Weak<?> key()
```
    Returns Weak instance wrapping the key for this node. To get the inner key call Weak.asObject() Top-level Dynamic objects have the key value ROOT_KEY
    
    Returns:
    
    key instance wrapper
  - allChildren
```
default Stream<Dynamic> allChildren()
```
    Returns:
    
    stream of all children of this instance at any depth
    
    See Also:
    
    allChildrenDepthFirst()
  - allChildrenDepthFirst
```
default Stream<Dynamic> allChildrenDepthFirst()
```
    Returns a stream of all children in a depth first order, for example a structure
```
 services:
   service1:
     name: service one
   service2:
     name: service two
 
```
    services.allChildrenDepthFirst() would produce a stream ordered [service1, service1.name, service2, service2.name] As such depth first searching can be implemented, for example
```
 services.allChildrenDepthFirst()
     .filter(child -> child.isString() && child.asString().equals("service one"))
     .findAny(); // Optional[Dynamic: service1.name]
 
```
    Returns:
    
    stream of all children of this instance at any depth
  - allChildrenBreadthFirst
```
default Stream<Dynamic> allChildrenBreadthFirst()
```
    Returns a stream of all children in a breadth first order, for example a structure
```
 services:
   service1:
     name: service one
   service2:
     name: service two
 
```
    services.allChildrenDepthFirst() would produce a stream ordered [service1, service2, service1.name, service2.name] As such breadth first searching can be implemented, for example
```
 services.allChildrenBreadthFirst()
     .anyMatch(child -> child.key().asString().equals("service2")); // true
 
```
    Returns:
    
    stream of all children of this instance at any depth
  - as
```
default <T> T as(Class<T> type)
```
    As Weak.asObject() casting to input type, and providing a better message in the exceptional case
    
    Specified by:
    
    as in interface Weak<Dynamic>
    
    Type Parameters:
    
    T - cast type
    
    Parameters:
    
    type - cast type
    
    Returns:
    
    unwrapped inner value cast to input type
    
    Throws:
    
    ClassCastException - when the wrapped instance that cannot be cast to the input
    
    NoSuchElementException - when this dynamic is not present, ie wraps no, or null, value

Interface Dynamic

Field Summary

Method Summary

Methods inherited from interface alexh.weak.Weak

Field Detail

ROOT_KEY

Method Detail

from

get

children

get

dget

key

allChildren

allChildrenDepthFirst

allChildrenBreadthFirst

as