repository

Documentation

Overview

Code generated by argen. DO NOT EDIT. This code was generated from a template.

Manual changes to this file may cause unexpected behavior in your application. Manual changes to this file will be overwritten if the code is regenerated.

Generate info: argen@v1.11.0-b (Commit: 6934fae2)

Index

• Variables
• type FieldMeta
• type IndexMeta
• type NSPackage
  • func (n NSPackage) GetCallDebugInfo(ns string, args [][]byte, fixture ...octopus.CallMockFixture) string
  • func (n NSPackage) GetDeleteDebugInfo(ns uint32, primaryKey [][]byte, fixture ...octopus.DeleteMockFixture) string
  • func (n NSPackage) GetInsertDebugInfo(ns uint32, needRetVal bool, insertMode octopus.InsertMode, ...) string
  • func (n NSPackage) GetSelectDebugInfo(ns uint32, indexnum uint32, offset uint32, limit uint32, keys [][][]byte, ...) string
  • func (n NSPackage) GetUpdateDebugInfo(ns uint32, primaryKey [][]byte, updateOps []octopus.Ops, ...) string
• type SpaceMeta

Variables

var NamespacePackages = NSPackage{
	"24": {
		PackageName: "reward",
		Unpacker: func(ctx context.Context, tuple octopus.TupleData) (any, error) {
			obj, err := reward.TupleToStruct(ctx, tuple)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			return reward.MarshalFixtures([]*reward.Reward{obj})
		},
		FixtureUnpacker: func(ctx context.Context, source []byte) (res []any, err error) {
			fxts, err := reward.UnmarshalFixturesFromJSON(source)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			for _, v := range fxts {
				res = append(res, v)
			}

			return
		},
		Fields: []FieldMeta{

			{
				Name: "Code",
				Unpacker: func(packedField []byte) (any, error) {

					return reward.UnpackCode(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Services",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := reward.UnpackServices(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return reward.MarshalServices(field)
				},
			},

			{
				Name: "Partner",
				Unpacker: func(packedField []byte) (any, error) {

					return reward.UnpackPartner(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Extra",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := reward.UnpackExtra(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return reward.MarshalExtra(field)
				},
			},

			{
				Name: "Flags",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := reward.UnpackFlags(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return reward.MarshalFlags(field)
				},
			},

			{
				Name: "Unlocked",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := reward.UnpackUnlocked(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return reward.MarshalUnlocked(field)
				},
			},

			{
				Name: "Description",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := reward.UnpackDescription(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return reward.MarshalDescription(field)
				},
			},
		},
		Indexes: map[string]IndexMeta{

			"0.1": {
				Name:     "Code",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return reward.UnpackKeyIndexCode(packedKeys) },
			},
			"1.1": {
				Name:     "Partner",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return reward.UnpackKeyIndexPartner(packedKeys) },
			},
		},
		PK: IndexMeta{

			Name:     "Code",
			Unpacker: func(packedKeys [][][]byte) (any, error) { return reward.UnpackKeyIndexCode(packedKeys) },
		},
	},
	"5": {
		PackageName: "arobj",
		Unpacker: func(ctx context.Context, tuple octopus.TupleData) (any, error) {
			obj, err := arobj.TupleToStruct(ctx, tuple)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			return arobj.MarshalFixtures([]*arobj.ArObj{obj})
		},
		FixtureUnpacker: func(ctx context.Context, source []byte) (res []any, err error) {
			fxts, err := arobj.UnmarshalFixturesFromJSON(source)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			for _, v := range fxts {
				res = append(res, v)
			}

			return
		},
		Fields: []FieldMeta{

			{
				Name: "ID",
				Unpacker: func(packedField []byte) (any, error) {

					return arobj.UnpackID(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Name",
				Unpacker: func(packedField []byte) (any, error) {

					return arobj.UnpackName(bytes.NewReader(packedField))
				},
			},

			{
				Name: "AnotherID",
				Unpacker: func(packedField []byte) (any, error) {

					return arobj.UnpackAnotherID(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Type",
				Unpacker: func(packedField []byte) (any, error) {

					return arobj.UnpackType(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Flags",
				Unpacker: func(packedField []byte) (any, error) {

					return arobj.UnpackFlags(bytes.NewReader(packedField))
				},
			},
		},
		Indexes: map[string]IndexMeta{

			"0.1": {
				Name:     "ID",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return arobj.UnpackKeyIndexID(packedKeys) },
			},
			"1.1": {
				Name:     "Type",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return arobj.UnpackKeyIndexType(packedKeys) },
			},
			"2.2": {
				Name:     "TypeID",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return arobj.UnpackKeyIndexTypeID(packedKeys) },
			},
			"2.1": {
				Name:     "TypePart",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return arobj.UnpackKeyIndexTypePart(packedKeys) },
			},
		},
		PK: IndexMeta{

			Name:     "ID",
			Unpacker: func(packedKeys [][][]byte) (any, error) { return arobj.UnpackKeyIndexID(packedKeys) },
		},
	},
	"25": {
		PackageName: "boolindexed",
		Unpacker: func(ctx context.Context, tuple octopus.TupleData) (any, error) {
			obj, err := boolindexed.TupleToStruct(ctx, tuple)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			return boolindexed.MarshalFixtures([]*boolindexed.Boolindexed{obj})
		},
		FixtureUnpacker: func(ctx context.Context, source []byte) (res []any, err error) {
			fxts, err := boolindexed.UnmarshalFixturesFromJSON(source)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			for _, v := range fxts {
				res = append(res, v)
			}

			return
		},
		Fields: []FieldMeta{

			{
				Name: "Code",
				Unpacker: func(packedField []byte) (any, error) {

					return boolindexed.UnpackCode(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Invisible",
				Unpacker: func(packedField []byte) (any, error) {

					return boolindexed.UnpackInvisible(bytes.NewReader(packedField))
				},
			},
		},
		Indexes: map[string]IndexMeta{

			"0.1": {
				Name:     "Code",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return boolindexed.UnpackKeyIndexCode(packedKeys) },
			},
			"1.1": {
				Name:     "Invisible",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return boolindexed.UnpackKeyIndexInvisible(packedKeys) },
			},
		},
		PK: IndexMeta{

			Name:     "Code",
			Unpacker: func(packedKeys [][][]byte) (any, error) { return boolindexed.UnpackKeyIndexCode(packedKeys) },
		},
	},
	"quantityOfCategories": {
		PackageName: "category",
		Unpacker: func(ctx context.Context, tuple octopus.TupleData) (any, error) {
			obj, err := category.TupleToStruct(ctx, tuple)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			return category.MarshalFixtures([]*category.Category{obj})
		},
		FixtureUnpacker: func(ctx context.Context, source []byte) (res []any, err error) {
			fxts, err := category.UnmarshalFixturesFromJSON(source)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			for _, v := range fxts {
				res = append(res, v)
			}

			return
		},
		Fields:  []FieldMeta{},
		Indexes: map[string]IndexMeta{},
		PK:      IndexMeta{},
	},
	"foo": {
		PackageName: "foo",
		Unpacker: func(ctx context.Context, tuple octopus.TupleData) (any, error) {
			obj, err := foo.TupleToStruct(ctx, tuple)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			return foo.MarshalFixtures([]*foo.Foo{obj})
		},
		FixtureUnpacker: func(ctx context.Context, source []byte) (res []any, err error) {
			fxts, err := foo.UnmarshalFixturesFromJSON(source)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			for _, v := range fxts {
				res = append(res, v)
			}

			return
		},
		Fields:  []FieldMeta{},
		Indexes: map[string]IndexMeta{},
		PK:      IndexMeta{},
	},
	"6": {
		PackageName: "promoperiods",
		Unpacker: func(ctx context.Context, tuple octopus.TupleData) (any, error) {
			obj, err := promoperiods.TupleToStruct(ctx, tuple)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			return promoperiods.MarshalFixtures([]*promoperiods.Promoperiods{obj})
		},
		FixtureUnpacker: func(ctx context.Context, source []byte) (res []any, err error) {
			fxts, err := promoperiods.UnmarshalFixturesFromJSON(source)
			if err != nil {
				return nil, fmt.Errorf("can't decode tuple: %s", err)
			}

			for _, v := range fxts {
				res = append(res, v)
			}

			return
		},
		Fields: []FieldMeta{

			{
				Name: "ID",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackID(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Code",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackCode(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Email",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackEmail(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Start",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackStart(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Finish",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := promoperiods.UnpackFinish(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return promoperiods.MarshalFinish(field)
				},
			},

			{
				Name: "Action",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackAction(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Platform",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := promoperiods.UnpackPlatform(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return promoperiods.MarshalPlatform(field)
				},
			},

			{
				Name: "Promobunch",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackPromobunch(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Platforms",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackPlatforms(bytes.NewReader(packedField))
				},
			},

			{
				Name: "PlanID",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackPlanID(bytes.NewReader(packedField))
				},
			},

			{
				Name: "PlanType",
				Unpacker: func(packedField []byte) (any, error) {

					return promoperiods.UnpackPlanType(bytes.NewReader(packedField))
				},
			},

			{
				Name: "Price",
				Unpacker: func(packedField []byte) (any, error) {
					field, err := promoperiods.UnpackPrice(bytes.NewReader(packedField))
					if err != nil {
						return nil, err
					}

					return promoperiods.MarshalPrice(field)
				},
			},
		},
		Indexes: map[string]IndexMeta{

			"0.1": {
				Name:     "ID",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexID(packedKeys) },
			},
			"1.1": {
				Name:     "Code",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexCode(packedKeys) },
			},
			"2.1": {
				Name:     "Email",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexEmail(packedKeys) },
			},
			"3.2": {
				Name:     "PlanTypePrice",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexPlanTypePrice(packedKeys) },
			},
			"4.2": {
				Name:     "EmailCode",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexEmailCode(packedKeys) },
			},
			"5.2": {
				Name:     "EmailAction",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexEmailAction(packedKeys) },
			},
			"4.1": {
				Name:     "EmailPart",
				Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexEmailPart(packedKeys) },
			},
		},
		PK: IndexMeta{

			Name:     "ID",
			Unpacker: func(packedKeys [][][]byte) (any, error) { return promoperiods.UnpackKeyIndexID(packedKeys) },
		},
	},
}

Types

type FieldMeta

type FieldMeta struct {
	Name     string
	Unpacker func(packedField []byte) (any, error)
}

type IndexMeta

type IndexMeta struct {
	Name     string
	Unpacker func(packedKeys [][][]byte) (any, error)
}

type NSPackage

type NSPackage map[string]SpaceMeta

func (NSPackage) GetCallDebugInfo

func (n NSPackage) GetCallDebugInfo(ns string, args [][]byte, fixture ...octopus.CallMockFixture) string

func (NSPackage) GetDeleteDebugInfo

func (n NSPackage) GetDeleteDebugInfo(ns uint32, primaryKey [][]byte, fixture ...octopus.DeleteMockFixture) string

func (NSPackage) GetInsertDebugInfo

func (n NSPackage) GetInsertDebugInfo(ns uint32, needRetVal bool, insertMode octopus.InsertMode, tuple octopus.TupleData, fixture ...octopus.InsertMockFixture) string

func (NSPackage) GetSelectDebugInfo

func (n NSPackage) GetSelectDebugInfo(ns uint32, indexnum uint32, offset uint32, limit uint32, keys [][][]byte, fixture ...octopus.SelectMockFixture) string

func (NSPackage) GetUpdateDebugInfo

func (n NSPackage) GetUpdateDebugInfo(ns uint32, primaryKey [][]byte, updateOps []octopus.Ops, fixture ...octopus.UpdateMockFixture) string

type SpaceMeta

type SpaceMeta struct {
	PackageName     string
	Unpacker        func(ctx context.Context, tuple octopus.TupleData) (any, error)
	FixtureUnpacker func(ctx context.Context, source []byte) ([]any, error)
	Fields          []FieldMeta
	PK              IndexMeta
	Indexes         map[string]IndexMeta
}