github.com/s7techlab/cckit@v0.10.5/extensions/crosscc/cclocator_setting.pb.cc.go

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

/*
Package crosscc 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 crosscc

import (
	context "context"
	_ "embed"

	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"
)

// SettingServiceChaincode method names
const (

	// SettingServiceChaincodeMethodPrefix allows to use multiple services with same method names in one chaincode
	SettingServiceChaincodeMethodPrefix = "SettingService."

	SettingServiceChaincode_ServiceLocatorSet = SettingServiceChaincodeMethodPrefix + "ServiceLocatorSet"

	SettingServiceChaincode_ServiceLocatorGet = SettingServiceChaincodeMethodPrefix + "ServiceLocatorGet"

	SettingServiceChaincode_ListServiceLocators = SettingServiceChaincodeMethodPrefix + "ListServiceLocators"

	SettingServiceChaincode_PingService = SettingServiceChaincodeMethodPrefix + "PingService"

	SettingServiceChaincode_PingServices = SettingServiceChaincodeMethodPrefix + "PingServices"
)

// SettingServiceChaincode chaincode methods interface
type SettingServiceChaincode interface {
	ServiceLocatorSet(cckit_router.Context, *ServiceLocatorSetRequest) (*ServiceLocator, error)

	ServiceLocatorGet(cckit_router.Context, *ServiceLocatorId) (*ServiceLocator, error)

	ListServiceLocators(cckit_router.Context, *emptypb.Empty) (*ServiceLocators, error)

	PingService(cckit_router.Context, *ServiceLocatorId) (*PingServiceResponse, error)

	PingServices(cckit_router.Context, *emptypb.Empty) (*PingServiceResponses, error)
}

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

	r.Invoke(SettingServiceChaincode_ServiceLocatorSet,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.ServiceLocatorSet(ctx, ctx.Param().(*ServiceLocatorSetRequest))
		},
		cckit_defparam.Proto(&ServiceLocatorSetRequest{}))

	r.Query(SettingServiceChaincode_ServiceLocatorGet,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.ServiceLocatorGet(ctx, ctx.Param().(*ServiceLocatorId))
		},
		cckit_defparam.Proto(&ServiceLocatorId{}))

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

	r.Query(SettingServiceChaincode_PingService,
		func(ctx cckit_router.Context) (interface{}, error) {
			return cc.PingService(ctx, ctx.Param().(*ServiceLocatorId))
		},
		cckit_defparam.Proto(&ServiceLocatorId{}))

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

	return nil
}

//go:embed cclocator_setting.swagger.json
var SettingServiceSwagger []byte

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

func NewSettingServiceGatewayFromInstance(chaincodeInstance cckit_gateway.ChaincodeInstance) *SettingServiceGateway {
	return &SettingServiceGateway{
		ChaincodeInstance: chaincodeInstance,
	}
}

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

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

// ServiceDef returns service definition
func (c *SettingServiceGateway) ServiceDef() cckit_gateway.ServiceDef {
	return cckit_gateway.NewServiceDef(
		_SettingService_serviceDesc.ServiceName,
		SettingServiceSwagger,
		&_SettingService_serviceDesc,
		c,
		RegisterSettingServiceHandlerFromEndpoint,
	)
}

func (c *SettingServiceGateway) ServiceLocatorSet(ctx context.Context, in *ServiceLocatorSetRequest) (*ServiceLocator, 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, SettingServiceChaincode_ServiceLocatorSet, []interface{}{in}, &ServiceLocator{}); err != nil {
		return nil, err
	} else {
		return res.(*ServiceLocator), nil
	}
}

func (c *SettingServiceGateway) ServiceLocatorGet(ctx context.Context, in *ServiceLocatorId) (*ServiceLocator, 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, SettingServiceChaincode_ServiceLocatorGet, []interface{}{in}, &ServiceLocator{}); err != nil {
		return nil, err
	} else {
		return res.(*ServiceLocator), nil
	}
}

func (c *SettingServiceGateway) ListServiceLocators(ctx context.Context, in *emptypb.Empty) (*ServiceLocators, 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, SettingServiceChaincode_ListServiceLocators, []interface{}{in}, &ServiceLocators{}); err != nil {
		return nil, err
	} else {
		return res.(*ServiceLocators), nil
	}
}

func (c *SettingServiceGateway) PingService(ctx context.Context, in *ServiceLocatorId) (*PingServiceResponse, 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, SettingServiceChaincode_PingService, []interface{}{in}, &PingServiceResponse{}); err != nil {
		return nil, err
	} else {
		return res.(*PingServiceResponse), nil
	}
}

func (c *SettingServiceGateway) PingServices(ctx context.Context, in *emptypb.Empty) (*PingServiceResponses, 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, SettingServiceChaincode_PingServices, []interface{}{in}, &PingServiceResponses{}); err != nil {
		return nil, err
	} else {
		return res.(*PingServiceResponses), nil
	}
}