mapping

package
v0.4.3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 18, 2019 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source
const KeyRefNamespace = `_idx`

Variables

View Source
var (
	// ErrEntryTypeNotSupported entry type has no appropriate mapper type
	ErrEntryTypeNotSupported = errors.New(`entry type not supported for mapping`)

	// ErrEntryTypeNotDefined
	ErrStateMappingNotFound = errors.New(`state mapping not found`)

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

	// ErrFieldTypeNotSupportedForKeyExtraction key cannot extracted from field
	ErrFieldTypeNotSupportedForKeyExtraction = errors.New(`field type not supported for key extraction`)

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

	ErrFieldNotExists         = errors.New(`field is not exists`)
	ErrPrimaryKeyerNotDefined = errors.New(`primary keyer is not defined`)
)
View Source
var KeyRefIdKeyer = attrsPKeyer([]string{`Schema`, `Idx`, `RefKey`})
View Source
var KeyRefIdMapper = &StateMapping{
	schema:       &schema.KeyRefId{},
	namespace:    state.Key{KeyRefNamespace},
	primaryKeyer: KeyRefIdKeyer,
}
View Source
var KeyRefMapper = &StateMapping{
	schema:       &schema.KeyRef{},
	namespace:    state.Key{KeyRefNamespace},
	primaryKeyer: KeyRefIdKeyer,
}

Functions

func MapEvents

func MapEvents(eventMappings EventMappings) router.MiddlewareFunc

func MapStates

func MapStates(stateMappings StateMappings) router.MiddlewareFunc

func NewKeyRef

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

func NewKeyRefId

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

Types

type EventImpl

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

func NewEvent

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

func (*EventImpl) Set

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

func (*EventImpl) UseNameTransformer

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

func (*EventImpl) UseSetTransformer

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

type EventMapped

type EventMapped interface {
	state.NameValue
}

type EventMapper

type EventMapper interface {
	Schema() interface{}
	Name(instance interface{}) (string, error)
}

type EventMappers

type EventMappers interface {
	Exists(schema interface{}) (exists bool)
	Map(schema interface{}) (keyValue state.KeyValue, err error)
	Get(schema interface{}) (eventMapper EventMapper, err error)
}

type EventMapping

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

func (EventMapping) Name

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

func (EventMapping) Schema

func (em EventMapping) Schema() interface{}

type EventMappingOpt

type EventMappingOpt func(*EventMapping)

type EventMappings

type EventMappings map[string]*EventMapping

func (EventMappings) Add

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

func (EventMappings) Exists

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

func (EventMappings) Get

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

func (EventMappings) Map

func (emm EventMappings) Map(entry interface{}) (mapped EventMapped, err error)

type InstanceKeyer

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

type MappedState

type MappedState interface {
	state.State

	// ListWith allows to refine search criteria by adding to namespace key parts
	ListWith(schema interface{}, key state.Key) (result interface{}, err error)

	// GetByUniqKey return one entry
	GetByUniqKey(schema interface{}, idx string, idxVal []string) (result interface{}, err error)
}

type Namer

type Namer func(entity interface{}) string

type ProtoEventMapped

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

func NewProtoEventMapped

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

func (*ProtoEventMapped) Name

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

func (*ProtoEventMapped) ToBytes

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

type ProtoStateMapped

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

func NewKeyRefIdMapped

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

func NewKeyRefMapped

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

func NewProtoStateMapped

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

func (*ProtoStateMapped) Key

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

func (*ProtoStateMapped) Keys

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

func (*ProtoStateMapped) Mapper

func (pm *ProtoStateMapped) Mapper() StateMapper

func (*ProtoStateMapped) ToBytes

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

type StateImpl

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

func WrapState

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

func (*StateImpl) Delete

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

func (*StateImpl) Exists

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

func (*StateImpl) Get

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

func (*StateImpl) GetByUniqKey

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

func (*StateImpl) GetHistory

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

func (*StateImpl) GetInt

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

func (*StateImpl) Insert

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

func (*StateImpl) List

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

func (*StateImpl) ListWith

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

func (*StateImpl) Logger

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

func (*StateImpl) MappingNamespace

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

func (*StateImpl) Put

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

func (*StateImpl) UseKeyTransformer

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

func (*StateImpl) UseStateGetTransformer

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

func (*StateImpl) UseStatePutTransformer

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

type StateKeyDefinition

type StateKeyDefinition struct {
	Name  string
	Attrs []string
}

type StateMapped

type StateMapped interface {
	state.KeyValue // entry key and value
	Mapper() StateMapper
	Keys() ([]state.KeyValue, error)
}

type StateMapper

type StateMapper interface {
	Schema() interface{}
	List() interface{}
	Namespace() state.Key
	PrimaryKey(instance interface{}) (key state.Key, err error)
	Keys(instance interface{}) (key []state.KeyValue, err error)
}

StateMapper

type StateMappers

type StateMappers interface {
	Exists(schema interface{}) (exists bool)
	Map(schema interface{}) (keyValue state.KeyValue, err error)
	Get(schema interface{}) (stateMapper StateMapper, err error)
	PrimaryKey(schema interface{}) (key state.Key, err error)
}

StateMappers interface for mappers collection

type StateMapping

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

StateMapping defines metadata for mapping from schema to state keys/values

func (*StateMapping) Keys

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

func (*StateMapping) List

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

func (*StateMapping) Namespace

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

func (*StateMapping) PrimaryKey

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

func (*StateMapping) Schema

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

type StateMappingOpt

type StateMappingOpt func(*StateMapping, StateMappings)

func List

func List(list proto.Message) StateMappingOpt

List defined list container, it must have `Items` attr

func PKeyAttr

func PKeyAttr(attrs ...string) StateMappingOpt

func PKeyComplexId

func PKeyComplexId(pkeySchema interface{}) StateMappingOpt

func PKeyId

func PKeyId() StateMappingOpt

func PKeySchema

func PKeySchema(pkeySchema interface{}) StateMappingOpt

PKeySchema registers all fields from pkeySchema as part of primary key also register keyer for pkeySchema with with namespace from current schema

func PKeyer

func PKeyer(pkeyer InstanceKeyer) StateMappingOpt

func StateNamespace

func StateNamespace(namespace state.Key) StateMappingOpt

StateNamespace sets namespace for mapping

func UniqKey

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

type StateMappingOptions

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

type StateMappings

type StateMappings map[string]*StateMapping

func (StateMappings) Add

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

func (StateMappings) Exists

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

func (StateMappings) Get

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

func (StateMappings) Map

func (smm StateMappings) Map(entry interface{}) (mapped StateMapped, err error)

func (StateMappings) PrimaryKey

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

Jump to

Keyboard shortcuts

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