mapping

Apr 4, 2022

Changes in this version

type EventMappings

+ func MergeEventMappings(one EventMappings, more ...EventMappings) EventMappings

type StateMappings

+ func MergeStateMappings(one StateMappings, more ...StateMappings) StateMappings

+ func (smm StateMappings) Resolve(objectType string, value []byte) (entry interface{}, err error)

Jan 20, 2022

Changes in this version

+ type EventResolver interface

+ Resolve func(eventName string, payload []byte) (event interface{}, err error)

Dec 16, 2021

Changes in this version

+ var DefaultSerializer = &state.ProtoSerializer

+ var ErrEventNameNotFound = errors.New(`event name not found`)

+ type EventInstance struct

+ func NewEventInstance(instance interface{}, eventMapper EventMapper, serializer state.Serializer) (*EventInstance, error)

+ func (ei EventInstance) Name() (string, error)

+ func (ei EventInstance) ToBytes() ([]byte, error)

type EventMappings

+ func (emm EventMappings) Resolve(eventName string, payload []byte) (event interface{}, err error)

+ type StateInstance struct

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

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

+ func NewStateInstance(instance interface{}, stateMapper StateMapper, serializer state.Serializer) *StateInstance

+ func (si *StateInstance) Key() (state.Key, error)

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

+ func (si *StateInstance) Mapper() StateMapper

+ func (si *StateInstance) ToBytes() ([]byte, error)

Nov 15, 2021

Changes in this version

+ var ErrEventPayloadEmpty = errors.New(`event payload empty`)

+ func EventNameForPayload(payload interface{}) string

+ type Command interface

+ Execute func(state.State) error

+ type CommandInsert struct

+ Entry interface{}

+ func (ci *CommandInsert) Execute(state state.State) error

+ func (ci *CommandInsert) String() string

+ type CommandPut struct

+ Entry interface{}

+ func (ci *CommandPut) Execute(state state.State) error

+ func (ci *CommandPut) String() string

+ type Commands []Command

+ func (cc *Commands) Insert(entry interface{}) *Commands

+ func (cc *Commands) Put(entry interface{}) *Commands

+ type EntryMapper struct

+ Commands Commands

+ Event *Event

+ func NewEntryMapper() *EntryMapper

+ func (em *EntryMapper) Apply(state state.State, event state.Event) error

+ type Event struct

+ Name string

+ Payload interface{}

+ func EventFromPayload(payload interface{}) *Event

+ type Query interface

+ Query func(state.State) error

Sep 20, 2021

Changes in this version

type StateMapping

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

type StateMappingOpt

+ func WithConstPKey(keys ...state.Key) StateMappingOpt

+ func WithNamespace(namespace state.Key) StateMappingOpt

type StateMappings

+ func (smm StateMappings) GetBySchema(schema interface{}) (StateMapper, error)

Aug 10, 2021

Changes in this version

type Impl

+ func (s *Impl) ListPaginated(entry interface{}, pageSize int32, bookmark string, target ...interface{}) (interface{}, *pb.QueryResponseMetadata, error)

+ func (s *Impl) ListPaginatedWith(schema interface{}, key state.Key, pageSize int32, bookmark string) (result interface{}, metadata *pb.QueryResponseMetadata, err error)

type MappedState

+ ListPaginatedWith func(schema interface{}, key state.Key, pageSize int32, bookmark string) (result interface{}, metadata *pb.QueryResponseMetadata, err error)

Feb 16, 2021

Changes in this version

+ const TimestampKeyLayout

Dec 9, 2019

Changes in this version

+ var ErrIndexAlreadyExists = errors.New(`index already exists`)

+ var ErrIndexReferenceNotFound = errors.New(`index reference not found`)

+ func KeyRefsDiff(prevKeys []state.KeyValue, newKeys []state.KeyValue) (deleted, inserted []state.KeyValue, err error)

type Impl

+ func (s *Impl) GetByKey(entry interface{}, idx string, idxVal []string, target ...interface{}) (result interface{}, err error)

+ type InstanceMultiKeyer func(instance interface{}) ([]state.Key, error)

type MappedState

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

+ type StateIndex struct

+ Keyer InstanceMultiKeyer

+ Name string

+ Required bool

+ Uniq bool

+ type StateIndexDef struct

+ Fields []string

+ Keyer InstanceMultiKeyer

+ Multi bool

+ Name string

+ Required bool

type StateMapper

+ Indexes func() []*StateIndex

type StateMapping

+ func (sm *StateMapping) AddIndex(idx *StateIndex) error

+ func (sm *StateMapping) Index(name string) *StateIndex

+ func (sm *StateMapping) Indexes() []*StateIndex

type StateMappingOpt

+ func WithIndex(idx *StateIndexDef) StateMappingOpt

Aug 29, 2019

Changes in this version

type StateMapper

+ KeyerFor func() interface{}

type StateMapping

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

type StateMappingOpt

+ func KeyerFor(schema interface{}) StateMappingOpt

Jun 26, 2019

Changes in this version

type StateMappingOpt

+ func PKeyConst(key state.Key) StateMappingOpt

Jun 6, 2019

Changes in this version

+ func SchemaNamespace(schema interface{}) state.Key

type StateMappings

+ func (smm *StateMappings) IdxKey(entity interface{}, idx string, idxVal state.Key) (state.Key, error)

May 29, 2019

Changes in this version

type EventImpl

+ func WrapEvent(event state.Event, mappings EventMappings) *EventImpl

May 15, 2019

Changes in this version

type Impl

+ func (s *Impl) DeletePrivate(collection string, entry interface{}) (err error)

+ func (s *Impl) ExistsPrivate(collection string, entry interface{}) (exists bool, err error)

+ func (s *Impl) GetPrivate(collection string, entry interface{}, target ...interface{}) (result interface{}, err error)

+ func (s *Impl) InsertPrivate(collection string, entry interface{}, value ...interface{}) (err error)

+ func (s *Impl) ListPrivate(collection string, usePrivateDataIterator bool, namespace interface{}, ...) (result interface{}, err error)

+ func (s *Impl) PutPrivate(collection string, entry interface{}, value ...interface{}) (err error)

Apr 23, 2019

Changes in this version

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

+ var KeyRefIDMapper = &StateMapping

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

+ type Impl struct

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

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

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

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

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

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

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

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

+ func (s *Impl) ListWith(entry interface{}, key state.Key) (result interface{}, err error)

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

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

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

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

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

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

type ProtoStateMapped

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

type StateMappingOpt

+ func IsKeyerSchema() StateMappingOpt

type StateMappings

+ func (smm StateMappings) GetByNamespace(namespace state.Key) (StateMapper, error)

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)

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

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)