mapping

package

Go to main page

Versions in this module

v0

v0.4.3

Mar 18, 2019

Changes in this version

+ const KeyRefNamespace

+ var ErrFieldTypeNotSupportedForKeyExtraction = errors.New(`field type not supported for key extraction`)

+ var ErrMappingUniqKeyExists = errors.New(`mapping uniq key exists`)

+ var KeyRefIdKeyer = attrsPKeyer([]string{ ... })

+ var KeyRefIdMapper = &StateMapping

+ var KeyRefMapper = &StateMapping

+ func NewKeyRef(target interface{}, idx string, refKey, pKey state.Key) *schema.KeyRef

+ func NewKeyRefId(target interface{}, idx string, refKey state.Key) *schema.KeyRefId

+ type EventMapped interface

type MappedState

+ GetByUniqKey func(schema interface{}, idx string, idxVal []string) (result interface{}, err error)

+ type ProtoEventMapped struct

+ func NewProtoEventMapped(instance interface{}, eventMapper EventMapper) (*ProtoEventMapped, error)

+ func (em *ProtoEventMapped) Name() (string, error)

+ func (em *ProtoEventMapped) ToBytes() ([]byte, error)

+ type ProtoStateMapped struct

+ func NewKeyRefIdMapped(target interface{}, idx string, refKey state.Key) *ProtoStateMapped

+ func NewKeyRefMapped(target interface{}, idx string, refKey, pKey state.Key) *ProtoStateMapped

+ func NewProtoStateMapped(instance interface{}, stateMapper StateMapper) *ProtoStateMapped

+ func (pm *ProtoStateMapped) Key() (state.Key, error)

+ func (pm *ProtoStateMapped) Keys() ([]state.KeyValue, error)

+ func (pm *ProtoStateMapped) Mapper() StateMapper

+ func (pm *ProtoStateMapped) ToBytes() ([]byte, error)

type StateImpl

+ func (s *StateImpl) GetByUniqKey(entry interface{}, idx string, idxVal []string) (result interface{}, err error)

+ type StateKeyDefinition struct

+ Attrs []string

+ Name string

+ type StateMapped interface

+ Keys func() ([]state.KeyValue, error)

+ Mapper func() StateMapper

type StateMapper

+ Keys func(instance interface{}) (key []state.KeyValue, err error)

type StateMappers

+ PrimaryKey func(schema interface{}) (key state.Key, err error)

type StateMapping

+ func (sm *StateMapping) Keys(entity interface{}) (kv []state.KeyValue, err error)

type StateMappingOpt

+ func UniqKey(name string, attrs ...[]string) StateMappingOpt

type StateMappings

+ func (smm StateMappings) PrimaryKey(entry interface{}) (pkey state.Key, err error)

v0.4.2

Mar 12, 2019

Changes in this version

type StateMapper

+ List func() interface{}

type StateMapping

+ func (sm *StateMapping) List() interface{}

type StateMappingOpt

+ func List(list proto.Message) StateMappingOpt

+ func PKeyComplexId(pkeySchema interface{}) StateMappingOpt

v0.4.1

Feb 27, 2019

Changes in this version

+ var ErrEntryTypeNotSupported = errors.New(`entry type not supported for mapping`)

+ var ErrEventMappingNotFound = errors.New(`event mapping not found`)

+ var ErrFieldNotExists = errors.New(`field is not exists`)

+ var ErrPrimaryKeyerNotDefined = errors.New(`primary keyer is not defined`)

+ var ErrStateMappingNotFound = errors.New(`state mapping not found`)

+ func MapEvents(eventMappings EventMappings) router.MiddlewareFunc

+ func MapStates(stateMappings StateMappings) router.MiddlewareFunc

+ type EventImpl struct

+ func NewEvent(stub shim.ChaincodeStubInterface, mappings EventMappings) *EventImpl

+ func (e *EventImpl) Set(entry interface{}, value ...interface{}) error

+ func (e *EventImpl) UseNameTransformer(nt state.StringTransformer) state.Event

+ func (e *EventImpl) UseSetTransformer(tb state.ToBytesTransformer) state.Event

+ type EventMapper interface

+ Name func(instance interface{}) (string, error)

+ Schema func() interface{}

+ type EventMappers interface

+ Exists func(schema interface{}) (exists bool)

+ Get func(schema interface{}) (eventMapper EventMapper, err error)

+ Map func(schema interface{}) (keyValue state.KeyValue, err error)

+ type EventMapping struct

+ func (em EventMapping) Name(instance interface{}) (string, error)

+ func (em EventMapping) Schema() interface{}

+ type EventMappingOpt func(*EventMapping)

+ type EventMappings map[string]*EventMapping

+ func (emm EventMappings) Add(schema interface{}, opts ...EventMappingOpt) EventMappings

+ func (emm EventMappings) Exists(entry interface{}) bool

+ func (emm EventMappings) Get(entry interface{}) (EventMapper, error)

+ func (emm EventMappings) Map(entry interface{}) (mapped state.NameValue, err error)

+ type InstanceKeyer func(instance interface{}) (key state.Key, err error)

+ type MappedState interface

+ ListWith func(schema interface{}, key state.Key) (result []interface{}, err error)

+ MappingNamespace func(schema interface{}) (state.Key, error)

+ type Namer func(entity interface{}) string

+ type ProtoEventMapper struct

+ func NewProtoEventMapper(instance interface{}, eventMapper EventMapper) (*ProtoEventMapper, error)

+ func (em *ProtoEventMapper) Name() (string, error)

+ func (em *ProtoEventMapper) ToBytes() ([]byte, error)

+ type ProtoStateMapper struct

+ func NewProtoStateMapper(instance interface{}, stateMapper StateMapper) (*ProtoStateMapper, error)

+ func (pm *ProtoStateMapper) Key() (state.Key, error)

+ func (pm *ProtoStateMapper) ToBytes() ([]byte, error)

+ type StateImpl struct

+ func WrapState(s state.State, mappings StateMappings) *StateImpl

+ func (s *StateImpl) Delete(entry interface{}) (err error)

+ func (s *StateImpl) Exists(entry interface{}) (exists bool, err error)

+ func (s *StateImpl) Get(entry interface{}, target ...interface{}) (result interface{}, err error)

+ func (s *StateImpl) GetHistory(key interface{}, target interface{}) (result state.HistoryEntryList, err error)

+ func (s *StateImpl) GetInt(key interface{}, defaultValue int) (result int, err error)

+ func (s *StateImpl) Insert(entry interface{}, value ...interface{}) (err error)

+ func (s *StateImpl) List(namespace interface{}, target ...interface{}) (result []interface{}, err error)

+ func (s *StateImpl) ListWith(schema interface{}, key state.Key) (result []interface{}, err error)

+ func (s *StateImpl) Logger() *shim.ChaincodeLogger

+ func (s *StateImpl) MappingNamespace(schema interface{}) (state.Key, error)

+ func (s *StateImpl) Put(entry interface{}, value ...interface{}) (err error)

+ func (s *StateImpl) UseKeyTransformer(kt state.KeyTransformer) state.State

+ func (s *StateImpl) UseStateGetTransformer(fb state.FromBytesTransformer) state.State

+ func (s *StateImpl) UseStatePutTransformer(tb state.ToBytesTransformer) state.State

+ type StateMapper interface

+ Namespace func() state.Key

+ PrimaryKey func(instance interface{}) (key state.Key, err error)

+ Schema func() interface{}

+ type StateMappers interface

+ Exists func(schema interface{}) (exists bool)

+ Get func(schema interface{}) (stateMapper StateMapper, err error)

+ Map func(schema interface{}) (keyValue state.KeyValue, err error)

+ type StateMapping struct

+ func (sm *StateMapping) Namespace() state.Key

+ func (sm *StateMapping) PrimaryKey(entity interface{}) (state.Key, error)

+ func (sm *StateMapping) Schema() interface{}

+ type StateMappingOpt func(*StateMapping, StateMappings)

+ func PKeyAttr(attrs ...string) StateMappingOpt

+ func PKeyId() StateMappingOpt

+ func PKeySchema(pkeySchema interface{}) StateMappingOpt

+ func PKeyer(pkeyer InstanceKeyer) StateMappingOpt

+ func StateNamespace(namespace state.Key) StateMappingOpt

+ type StateMappingOptions struct

+ type StateMappings map[string]*StateMapping

+ func (smm StateMappings) Add(schema interface{}, opts ...StateMappingOpt) StateMappings

+ func (smm StateMappings) Exists(entry interface{}) bool

+ func (smm StateMappings) Get(entry interface{}) (StateMapper, error)

+ func (smm StateMappings) Map(entry interface{}) (mapped state.KeyValue, err error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL