mapper

Documentation

Index

• Constants
• func ConvertMappingValue(mappingType string, mappingValue interface{}) (interface{}, error)
• func GetObjectMapping(value interface{}) (interface{}, bool)
• func IsLiteral(value interface{}) bool
• func NewObjectMapper(mappings interface{}, exprF expression.Factory) (expr expression.Expr, err error)
• func NewObjectMapperFactory(exprFactory expression.Factory) expression.Factory
• func ToObjectMap(value interface{}) (map[string]interface{}, error)
• type ExprMapper
  • func (m *ExprMapper) Apply(inputScope data.Scope) (map[string]interface{}, error)
• type ExprMapperFactory
  • func (mf *ExprMapperFactory) NewMapper(mappings map[string]interface{}) (Mapper, error)
• type Factory
  • func NewFactory(resolver resolve.CompositeResolver) Factory
• type Mapper
• type ObjectMapper
  • func (obj *ObjectMapper) Eval(scope data.Scope) (value interface{}, err error)
• type ObjectMapperFactory
  • func (am *ObjectMapperFactory) NewExpr(value string) (expression.Expr, error)
  • func (am *ObjectMapperFactory) NewObjectMapper(value interface{}) (expression.Expr, error)
• type ObjectMapping

Constants

const (
	//To do an array mapping from upstreaming, use @foreach.
	/*
			"input": {

		    "val" : {
		        "a" : "=$activity[blah].out",
		        "addresses": {
		            "@foreach($activity[blah].out2, i)":
		            {
		              "street"  : "=$.street",
		              "zipcode" : "9999",
		              "state"   : "=$activity[test].state",
		              "addresses2": {
		                  "@foreach($.addresses2)":{
		                        "street2"  : "=$loop[i].street2",
		                        "zipcode2" : "=$.zipcode",
		                        "state2"   : "=$activity[test].state"
		                	  }
		               	}
		            	}
		        	}
		    	}
			}

	*/
	FOREACH = "@foreach"
)

Functions

func ConvertMappingValue

func ConvertMappingValue(mappingType string, mappingValue interface{}) (interface{}, error)

Deprecated

func GetObjectMapping

func GetObjectMapping(value interface{}) (interface{}, bool)

func IsLiteral

func IsLiteral(value interface{}) bool

func NewObjectMapper

func NewObjectMapper(mappings interface{}, exprF expression.Factory) (expr expression.Expr, err error)

func NewObjectMapperFactory

func NewObjectMapperFactory(exprFactory expression.Factory) expression.Factory

func ToObjectMap

func ToObjectMap(value interface{}) (map[string]interface{}, error)

Types

type ExprMapper

type ExprMapper struct {
	// contains filtered or unexported fields
}

func (*ExprMapper) Apply

func (m *ExprMapper) Apply(inputScope data.Scope) (map[string]interface{}, error)

type ExprMapperFactory

type ExprMapperFactory struct {
	// contains filtered or unexported fields
}

func (*ExprMapperFactory) NewMapper

func (mf *ExprMapperFactory) NewMapper(mappings map[string]interface{}) (Mapper, error)

type Factory

type Factory interface {
	NewMapper(mappings map[string]interface{}) (Mapper, error)
}

func NewFactory

func NewFactory(resolver resolve.CompositeResolver) Factory

type Mapper

type Mapper interface {
	Apply(scope data.Scope) (map[string]interface{}, error)
}

Mapper is a constructs that maps values to a map

type ObjectMapper

type ObjectMapper struct {
	// contains filtered or unexported fields
}

func (*ObjectMapper) Eval

func (obj *ObjectMapper) Eval(scope data.Scope) (value interface{}, err error)

type ObjectMapperFactory

type ObjectMapperFactory struct {
	// contains filtered or unexported fields
}

func (*ObjectMapperFactory) NewExpr

func (am *ObjectMapperFactory) NewExpr(value string) (expression.Expr, error)

func (*ObjectMapperFactory) NewObjectMapper

func (am *ObjectMapperFactory) NewObjectMapper(value interface{}) (expression.Expr, error)

type ObjectMapping

type ObjectMapping struct {
	Mapping interface{} `json:"mapping"`
}