github.com/s7techlab/cckit@v0.10.5/examples/fabcar/fabcar.pb.cc.go

// Code generated by protoc-gen-cc-gateway. DO NOT EDIT.
// source: fabcar/fabcar.proto

/*
Package fabcar contains
  *   chaincode methods names {service_name}Chaincode_{method_name}
  *   chaincode interface definition {service_name}Chaincode
  *   chaincode gateway definition {service_name}}Gateway
  *   chaincode service to cckit router registration func
*/
package fabcar

import (
	context "context"
	_ "embed"
	errors "errors"

	cckit_gateway "github.com/s7techlab/cckit/gateway"
	cckit_router "github.com/s7techlab/cckit/router"
	cckit_defparam "github.com/s7techlab/cckit/router/param/defparam"
	cckit_sdk "github.com/s7techlab/cckit/sdk"
	"google.golang.org/protobuf/types/known/emptypb"
)

// FabCarServiceChaincode method names
const (

	// FabCarServiceChaincodeMethodPrefix allows to use multiple services with same method names in one chaincode
	FabCarServiceChaincodeMethodPrefix = ""

	FabCarServiceChaincode_CreateMaker = FabCarServiceChaincodeMethodPrefix + "CreateMaker"

	FabCarServiceChaincode_DeleteMaker = FabCarServiceChaincodeMethodPrefix + "DeleteMaker"

	FabCarServiceChaincode_GetMaker = FabCarServiceChaincodeMethodPrefix + "GetMaker"

	FabCarServiceChaincode_ListMakers = FabCarServiceChaincodeMethodPrefix + "ListMakers"

	FabCarServiceChaincode_CreateCar = FabCarServiceChaincodeMethodPrefix + "CreateCar"

	FabCarServiceChaincode_UpdateCar = FabCarServiceChaincodeMethodPrefix + "UpdateCar"

	FabCarServiceChaincode_DeleteCar = FabCarServiceChaincodeMethodPrefix + "DeleteCar"

	FabCarServiceChaincode_GetCar = FabCarServiceChaincodeMethodPrefix + "GetCar"

	FabCarServiceChaincode_GetCarView = FabCarServiceChaincodeMethodPrefix + "GetCarView"

	FabCarServiceChaincode_ListCars = FabCarServiceChaincodeMethodPrefix + "ListCars"

	FabCarServiceChaincode_UpdateCarOwners = FabCarServiceChaincodeMethodPrefix + "UpdateCarOwners"

	FabCarServiceChaincode_DeleteCarOwner = FabCarServiceChaincodeMethodPrefix + "DeleteCarOwner"

	FabCarServiceChaincode_GetCarOwner = FabCarServiceChaincodeMethodPrefix + "GetCarOwner"

	FabCarServiceChaincode_ListCarOwners = FabCarServiceChaincodeMethodPrefix + "ListCarOwners"

	FabCarServiceChaincode_UpdateCarDetails = FabCarServiceChaincodeMethodPrefix + "UpdateCarDetails"

	FabCarServiceChaincode_DeleteCarDetail = FabCarServiceChaincodeMethodPrefix + "DeleteCarDetail"

	FabCarServiceChaincode_GetCarDetail = FabCarServiceChaincodeMethodPrefix + "GetCarDetail"

	FabCarServiceChaincode_ListCarDetails = FabCarServiceChaincodeMethodPrefix + "ListCarDetails"
)

// FabCarServiceChaincode chaincode methods interface
type FabCarServiceChaincode interface {
	CreateMaker(cckit_router.Context, *CreateMakerRequest) (*Maker, error)

	DeleteMaker(cckit_router.Context, *MakerName) (*Maker, error)

	GetMaker(cckit_router.Context, *MakerName) (*Maker, error)

	ListMakers(cckit_router.Context, *emptypb.Empty) (*Makers, error)

	CreateCar(cckit_router.Context, *CreateCarRequest) (*CarView, error)

	UpdateCar(cckit_router.Context, *UpdateCarRequest) (*CarView, error)

	DeleteCar(cckit_router.Context, *CarId) (*CarView, error)

	GetCar(cckit_router.Context, *CarId) (*Car, error)

	GetCarView(cckit_router.Context, *CarId) (*CarView, error)

	ListCars(cckit_router.Context, *emptypb.Empty) (*Cars, error)

	UpdateCarOwners(cckit_router.Context, *UpdateCarOwnersRequest) (*CarOwners, error)

	DeleteCarOwner(cckit_router.Context, *CarOwnerId) (*CarOwner, error)

	GetCarOwner(cckit_router.Context, *CarOwnerId) (*CarOwner, error)

	ListCarOwners(cckit_router.Context, *CarId) (*CarOwners, error)

	UpdateCarDetails(cckit_router.Context, *UpdateCarDetailsRequest) (*CarDetails, error)

	DeleteCarDetail(cckit_router.Context, *CarDetailId) (*CarDetail, error)

	GetCarDetail(cckit_router.Context, *CarDetailId) (*CarDetail, error)

	ListCarDetails(cckit_router.Context, *CarId) (*CarDetails, error)
}

// RegisterFabCarServiceChaincode registers service methods as chaincode router handlers
func RegisterFabCarServiceChaincode(r *cckit_router.Group, cc FabCarServiceChaincode) error {

	r.Invoke(FabCarServiceChaincode_CreateMaker,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.CreateMaker(ctx, ctx.Param().(*CreateMakerRequest))
		},
		cckit_defparam.Proto(&CreateMakerRequest{}))

	r.Invoke(FabCarServiceChaincode_DeleteMaker,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.DeleteMaker(ctx, ctx.Param().(*MakerName))
		},
		cckit_defparam.Proto(&MakerName{}))

	r.Query(FabCarServiceChaincode_GetMaker,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.GetMaker(ctx, ctx.Param().(*MakerName))
		},
		cckit_defparam.Proto(&MakerName{}))

	r.Query(FabCarServiceChaincode_ListMakers,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.ListMakers(ctx, ctx.Param().(*emptypb.Empty))
		},
		cckit_defparam.Proto(&emptypb.Empty{}))

	r.Invoke(FabCarServiceChaincode_CreateCar,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.CreateCar(ctx, ctx.Param().(*CreateCarRequest))
		},
		cckit_defparam.Proto(&CreateCarRequest{}))

	r.Invoke(FabCarServiceChaincode_UpdateCar,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.UpdateCar(ctx, ctx.Param().(*UpdateCarRequest))
		},
		cckit_defparam.Proto(&UpdateCarRequest{}))

	r.Invoke(FabCarServiceChaincode_DeleteCar,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.DeleteCar(ctx, ctx.Param().(*CarId))
		},
		cckit_defparam.Proto(&CarId{}))

	r.Query(FabCarServiceChaincode_GetCar,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.GetCar(ctx, ctx.Param().(*CarId))
		},
		cckit_defparam.Proto(&CarId{}))

	r.Query(FabCarServiceChaincode_GetCarView,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.GetCarView(ctx, ctx.Param().(*CarId))
		},
		cckit_defparam.Proto(&CarId{}))

	r.Query(FabCarServiceChaincode_ListCars,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.ListCars(ctx, ctx.Param().(*emptypb.Empty))
		},
		cckit_defparam.Proto(&emptypb.Empty{}))

	r.Invoke(FabCarServiceChaincode_UpdateCarOwners,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.UpdateCarOwners(ctx, ctx.Param().(*UpdateCarOwnersRequest))
		},
		cckit_defparam.Proto(&UpdateCarOwnersRequest{}))

	r.Invoke(FabCarServiceChaincode_DeleteCarOwner,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.DeleteCarOwner(ctx, ctx.Param().(*CarOwnerId))
		},
		cckit_defparam.Proto(&CarOwnerId{}))

	r.Query(FabCarServiceChaincode_GetCarOwner,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.GetCarOwner(ctx, ctx.Param().(*CarOwnerId))
		},
		cckit_defparam.Proto(&CarOwnerId{}))

	r.Query(FabCarServiceChaincode_ListCarOwners,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.ListCarOwners(ctx, ctx.Param().(*CarId))
		},
		cckit_defparam.Proto(&CarId{}))

	r.Invoke(FabCarServiceChaincode_UpdateCarDetails,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.UpdateCarDetails(ctx, ctx.Param().(*UpdateCarDetailsRequest))
		},
		cckit_defparam.Proto(&UpdateCarDetailsRequest{}))

	r.Invoke(FabCarServiceChaincode_DeleteCarDetail,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.DeleteCarDetail(ctx, ctx.Param().(*CarDetailId))
		},
		cckit_defparam.Proto(&CarDetailId{}))

	r.Query(FabCarServiceChaincode_GetCarDetail,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.GetCarDetail(ctx, ctx.Param().(*CarDetailId))
		},
		cckit_defparam.Proto(&CarDetailId{}))

	r.Query(FabCarServiceChaincode_ListCarDetails,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.ListCarDetails(ctx, ctx.Param().(*CarId))
		},
		cckit_defparam.Proto(&CarId{}))

	return nil
}

//go:embed fabcar.swagger.json
var FabCarServiceSwagger []byte

// NewFabCarServiceGateway creates gateway to access chaincode method via chaincode service
func NewFabCarServiceGateway(sdk cckit_sdk.SDK, channel, chaincode string, opts ...cckit_gateway.Opt) *FabCarServiceGateway {
	return NewFabCarServiceGatewayFromInstance(
		cckit_gateway.NewChaincodeInstanceService(
			sdk,
			&cckit_gateway.ChaincodeLocator{Channel: channel, Chaincode: chaincode},
			opts...,
		))
}

func NewFabCarServiceGatewayFromInstance(chaincodeInstance cckit_gateway.ChaincodeInstance) *FabCarServiceGateway {
	return &FabCarServiceGateway{
		ChaincodeInstance: chaincodeInstance,
	}
}

// gateway implementation
// gateway can be used as kind of SDK, GRPC or REST server ( via grpc-gateway or clay )
type FabCarServiceGateway struct {
	ChaincodeInstance cckit_gateway.ChaincodeInstance
}

func (c *FabCarServiceGateway) Invoker() cckit_gateway.ChaincodeInstanceInvoker {
	return cckit_gateway.NewChaincodeInstanceServiceInvoker(c.ChaincodeInstance)
}

// ServiceDef returns service definition
func (c *FabCarServiceGateway) ServiceDef() cckit_gateway.ServiceDef {
	return cckit_gateway.NewServiceDef(
		_FabCarService_serviceDesc.ServiceName,
		FabCarServiceSwagger,
		&_FabCarService_serviceDesc,
		c,
		RegisterFabCarServiceHandlerFromEndpoint,
	)
}

func (c *FabCarServiceGateway) CreateMaker(ctx context.Context, in *CreateMakerRequest) (*Maker, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_CreateMaker, []interface{}{in}, &Maker{}); err != nil {
		return nil, err
	} else {
		return res.(*Maker), nil
	}
}

func (c *FabCarServiceGateway) DeleteMaker(ctx context.Context, in *MakerName) (*Maker, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_DeleteMaker, []interface{}{in}, &Maker{}); err != nil {
		return nil, err
	} else {
		return res.(*Maker), nil
	}
}

func (c *FabCarServiceGateway) GetMaker(ctx context.Context, in *MakerName) (*Maker, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_GetMaker, []interface{}{in}, &Maker{}); err != nil {
		return nil, err
	} else {
		return res.(*Maker), nil
	}
}

func (c *FabCarServiceGateway) ListMakers(ctx context.Context, in *emptypb.Empty) (*Makers, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_ListMakers, []interface{}{in}, &Makers{}); err != nil {
		return nil, err
	} else {
		return res.(*Makers), nil
	}
}

func (c *FabCarServiceGateway) CreateCar(ctx context.Context, in *CreateCarRequest) (*CarView, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_CreateCar, []interface{}{in}, &CarView{}); err != nil {
		return nil, err
	} else {
		return res.(*CarView), nil
	}
}

func (c *FabCarServiceGateway) UpdateCar(ctx context.Context, in *UpdateCarRequest) (*CarView, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_UpdateCar, []interface{}{in}, &CarView{}); err != nil {
		return nil, err
	} else {
		return res.(*CarView), nil
	}
}

func (c *FabCarServiceGateway) DeleteCar(ctx context.Context, in *CarId) (*CarView, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_DeleteCar, []interface{}{in}, &CarView{}); err != nil {
		return nil, err
	} else {
		return res.(*CarView), nil
	}
}

func (c *FabCarServiceGateway) GetCar(ctx context.Context, in *CarId) (*Car, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_GetCar, []interface{}{in}, &Car{}); err != nil {
		return nil, err
	} else {
		return res.(*Car), nil
	}
}

func (c *FabCarServiceGateway) GetCarView(ctx context.Context, in *CarId) (*CarView, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_GetCarView, []interface{}{in}, &CarView{}); err != nil {
		return nil, err
	} else {
		return res.(*CarView), nil
	}
}

func (c *FabCarServiceGateway) ListCars(ctx context.Context, in *emptypb.Empty) (*Cars, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_ListCars, []interface{}{in}, &Cars{}); err != nil {
		return nil, err
	} else {
		return res.(*Cars), nil
	}
}

func (c *FabCarServiceGateway) UpdateCarOwners(ctx context.Context, in *UpdateCarOwnersRequest) (*CarOwners, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_UpdateCarOwners, []interface{}{in}, &CarOwners{}); err != nil {
		return nil, err
	} else {
		return res.(*CarOwners), nil
	}
}

func (c *FabCarServiceGateway) DeleteCarOwner(ctx context.Context, in *CarOwnerId) (*CarOwner, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_DeleteCarOwner, []interface{}{in}, &CarOwner{}); err != nil {
		return nil, err
	} else {
		return res.(*CarOwner), nil
	}
}

func (c *FabCarServiceGateway) GetCarOwner(ctx context.Context, in *CarOwnerId) (*CarOwner, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_GetCarOwner, []interface{}{in}, &CarOwner{}); err != nil {
		return nil, err
	} else {
		return res.(*CarOwner), nil
	}
}

func (c *FabCarServiceGateway) ListCarOwners(ctx context.Context, in *CarId) (*CarOwners, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_ListCarOwners, []interface{}{in}, &CarOwners{}); err != nil {
		return nil, err
	} else {
		return res.(*CarOwners), nil
	}
}

func (c *FabCarServiceGateway) UpdateCarDetails(ctx context.Context, in *UpdateCarDetailsRequest) (*CarDetails, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_UpdateCarDetails, []interface{}{in}, &CarDetails{}); err != nil {
		return nil, err
	} else {
		return res.(*CarDetails), nil
	}
}

func (c *FabCarServiceGateway) DeleteCarDetail(ctx context.Context, in *CarDetailId) (*CarDetail, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Invoke(ctx, FabCarServiceChaincode_DeleteCarDetail, []interface{}{in}, &CarDetail{}); err != nil {
		return nil, err
	} else {
		return res.(*CarDetail), nil
	}
}

func (c *FabCarServiceGateway) GetCarDetail(ctx context.Context, in *CarDetailId) (*CarDetail, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_GetCarDetail, []interface{}{in}, &CarDetail{}); err != nil {
		return nil, err
	} else {
		return res.(*CarDetail), nil
	}
}

func (c *FabCarServiceGateway) ListCarDetails(ctx context.Context, in *CarId) (*CarDetails, error) {
	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker().Query(ctx, FabCarServiceChaincode_ListCarDetails, []interface{}{in}, &CarDetails{}); err != nil {
		return nil, err
	} else {
		return res.(*CarDetails), nil
	}
}

// FabCarServiceChaincodeResolver interface for service resolver
type (
	FabCarServiceChaincodeResolver interface {
		Resolve(ctx cckit_router.Context) (FabCarServiceChaincode, error)
	}

	FabCarServiceChaincodeLocalResolver struct {
		service FabCarServiceChaincode
	}

	FabCarServiceChaincodeLocatorResolver struct {
		locatorResolver cckit_gateway.ChaincodeLocatorResolver
		service         FabCarServiceChaincode
	}
)

func NewFabCarServiceChaincodeLocalResolver(service FabCarServiceChaincode) *FabCarServiceChaincodeLocalResolver {
	return &FabCarServiceChaincodeLocalResolver{
		service: service,
	}
}

func (r *FabCarServiceChaincodeLocalResolver) Resolve(ctx cckit_router.Context) (FabCarServiceChaincode, error) {
	if r.service == nil {
		return nil, errors.New("service not set for local chaincode resolver")
	}

	return r.service, nil
}

func NewFabCarServiceChaincodeResolver(locatorResolver cckit_gateway.ChaincodeLocatorResolver) *FabCarServiceChaincodeLocatorResolver {
	return &FabCarServiceChaincodeLocatorResolver{
		locatorResolver: locatorResolver,
	}
}

func (r *FabCarServiceChaincodeLocatorResolver) Resolve(ctx cckit_router.Context) (FabCarServiceChaincode, error) {
	if r.service != nil {
		return r.service, nil
	}

	locator, err := r.locatorResolver(ctx, _FabCarService_serviceDesc.ServiceName)
	if err != nil {
		return nil, err
	}

	r.service = NewFabCarServiceChaincodeStubInvoker(locator)
	return r.service, nil
}

type FabCarServiceChaincodeStubInvoker struct {
	Invoker cckit_gateway.ChaincodeStubInvoker
}

func NewFabCarServiceChaincodeStubInvoker(locator *cckit_gateway.ChaincodeLocator) *FabCarServiceChaincodeStubInvoker {
	return &FabCarServiceChaincodeStubInvoker{
		Invoker: &cckit_gateway.LocatorChaincodeStubInvoker{Locator: locator},
	}
}

func (c *FabCarServiceChaincodeStubInvoker) CreateMaker(ctx cckit_router.Context, in *CreateMakerRequest) (*Maker, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) DeleteMaker(ctx cckit_router.Context, in *MakerName) (*Maker, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) GetMaker(ctx cckit_router.Context, in *MakerName) (*Maker, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_GetMaker, []interface{}{in}, &Maker{}); err != nil {
		return nil, err
	} else {
		return res.(*Maker), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) ListMakers(ctx cckit_router.Context, in *emptypb.Empty) (*Makers, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_ListMakers, []interface{}{in}, &Makers{}); err != nil {
		return nil, err
	} else {
		return res.(*Makers), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) CreateCar(ctx cckit_router.Context, in *CreateCarRequest) (*CarView, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) UpdateCar(ctx cckit_router.Context, in *UpdateCarRequest) (*CarView, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) DeleteCar(ctx cckit_router.Context, in *CarId) (*CarView, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) GetCar(ctx cckit_router.Context, in *CarId) (*Car, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_GetCar, []interface{}{in}, &Car{}); err != nil {
		return nil, err
	} else {
		return res.(*Car), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) GetCarView(ctx cckit_router.Context, in *CarId) (*CarView, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_GetCarView, []interface{}{in}, &CarView{}); err != nil {
		return nil, err
	} else {
		return res.(*CarView), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) ListCars(ctx cckit_router.Context, in *emptypb.Empty) (*Cars, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_ListCars, []interface{}{in}, &Cars{}); err != nil {
		return nil, err
	} else {
		return res.(*Cars), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) UpdateCarOwners(ctx cckit_router.Context, in *UpdateCarOwnersRequest) (*CarOwners, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) DeleteCarOwner(ctx cckit_router.Context, in *CarOwnerId) (*CarOwner, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) GetCarOwner(ctx cckit_router.Context, in *CarOwnerId) (*CarOwner, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_GetCarOwner, []interface{}{in}, &CarOwner{}); err != nil {
		return nil, err
	} else {
		return res.(*CarOwner), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) ListCarOwners(ctx cckit_router.Context, in *CarId) (*CarOwners, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_ListCarOwners, []interface{}{in}, &CarOwners{}); err != nil {
		return nil, err
	} else {
		return res.(*CarOwners), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) UpdateCarDetails(ctx cckit_router.Context, in *UpdateCarDetailsRequest) (*CarDetails, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) DeleteCarDetail(ctx cckit_router.Context, in *CarDetailId) (*CarDetail, error) {

	return nil, cckit_gateway.ErrInvokeMethodNotAllowed

}

func (c *FabCarServiceChaincodeStubInvoker) GetCarDetail(ctx cckit_router.Context, in *CarDetailId) (*CarDetail, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_GetCarDetail, []interface{}{in}, &CarDetail{}); err != nil {
		return nil, err
	} else {
		return res.(*CarDetail), nil
	}

}

func (c *FabCarServiceChaincodeStubInvoker) ListCarDetails(ctx cckit_router.Context, in *CarId) (*CarDetails, error) {

	var inMsg interface{} = in
	if v, ok := inMsg.(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return nil, err
		}
	}

	if res, err := c.Invoker.Query(ctx.Stub(), FabCarServiceChaincode_ListCarDetails, []interface{}{in}, &CarDetails{}); err != nil {
		return nil, err
	} else {
		return res.(*CarDetails), nil
	}

}