github.com/cloudwan/edgelq-sdk@v1.15.4/logging/client/v1/log/log_service.pb.descriptors.go

// Code generated by protoc-gen-goten-client
// API: LogService
// DO NOT EDIT!!!

package log_client

import (
	"google.golang.org/protobuf/proto"

	gotenclient "github.com/cloudwan/goten-sdk/runtime/client"
	gotenresource "github.com/cloudwan/goten-sdk/runtime/resource"
)

// proto imports
import (
	log "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = new(proto.Message)
	_ = new(gotenclient.MethodDescriptor)
	_ = gotenresource.WildcardId
)

// make sure we're using proto imports
var (
	_ = &log.Log{}
)

var (
	descriptorsInitialized        bool
	logServiceDescriptor          *LogServiceDescriptor
	listLogsDescriptor            *ListLogsDescriptor
	createLogsDescriptor          *CreateLogsDescriptor
	streamingCreateLogsDescriptor *StreamingCreateLogsDescriptor
)

type ListLogsDescriptor struct{}

type ListLogsDescriptorClientMsgHandle struct{}

type ListLogsDescriptorServerMsgHandle struct{}

func (d *ListLogsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListLogsRequest{}
}

func (d *ListLogsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListLogsResponse{}
}

func (d *ListLogsDescriptor) IsUnary() bool {
	return true
}

func (d *ListLogsDescriptor) IsClientStream() bool {
	return false
}

func (d *ListLogsDescriptor) IsServerStream() bool {
	return false
}

func (d *ListLogsDescriptor) IsCollection() bool {
	return true
}

func (d *ListLogsDescriptor) IsPlural() bool {
	return true
}

func (d *ListLogsDescriptor) HasResource() bool {
	return true
}

func (d *ListLogsDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *ListLogsDescriptor) GetVerb() string {
	return "query"
}

func (d *ListLogsDescriptor) GetMethodName() string {
	return "ListLogs"
}

func (d *ListLogsDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogService/ListLogs"
}

func (d *ListLogsDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *ListLogsDescriptor) GetApiName() string {
	return "LogService"
}

func (d *ListLogsDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

func (d *ListLogsDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *ListLogsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logServiceDescriptor
}

func (d *ListLogsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log.GetDescriptor()
}

func (d *ListLogsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListLogsDescriptorClientMsgHandle{}
}

func (d *ListLogsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListLogsDescriptorServerMsgHandle{}
}

func (h *ListLogsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ListLogsRequest) *log.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *ListLogsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListLogsRequest) []*log.Name
	})
	if ok {
		return log.LogNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListLogsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ListLogsRequest) *log.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *ListLogsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListLogsRequest) *log.Log
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListLogsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListLogsRequest) []*log.Log
	})
	if ok {
		return log.LogList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *ListLogsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ListLogsResponse) *log.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *ListLogsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListLogsResponse) []*log.Name
	})
	if ok {
		return log.LogNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListLogsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ListLogsResponse) *log.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *ListLogsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListLogsResponse) *log.Log
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListLogsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListLogsResponse) []*log.Log
	})
	if ok {
		return log.LogList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetListLogsDescriptor() *ListLogsDescriptor {
	return listLogsDescriptor
}

type CreateLogsDescriptor struct{}

type CreateLogsDescriptorClientMsgHandle struct{}

type CreateLogsDescriptorServerMsgHandle struct{}

func (d *CreateLogsDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateLogsRequest{}
}

func (d *CreateLogsDescriptor) NewEmptyServerMsg() proto.Message {
	return &CreateLogsResponse{}
}

func (d *CreateLogsDescriptor) IsUnary() bool {
	return true
}

func (d *CreateLogsDescriptor) IsClientStream() bool {
	return false
}

func (d *CreateLogsDescriptor) IsServerStream() bool {
	return false
}

func (d *CreateLogsDescriptor) IsCollection() bool {
	return true
}

func (d *CreateLogsDescriptor) IsPlural() bool {
	return true
}

func (d *CreateLogsDescriptor) HasResource() bool {
	return true
}

func (d *CreateLogsDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *CreateLogsDescriptor) GetVerb() string {
	return "batchCreate"
}

func (d *CreateLogsDescriptor) GetMethodName() string {
	return "CreateLogs"
}

func (d *CreateLogsDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogService/CreateLogs"
}

func (d *CreateLogsDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *CreateLogsDescriptor) GetApiName() string {
	return "LogService"
}

func (d *CreateLogsDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

func (d *CreateLogsDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *CreateLogsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logServiceDescriptor
}

func (d *CreateLogsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log.GetDescriptor()
}

func (d *CreateLogsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateLogsDescriptorClientMsgHandle{}
}

func (d *CreateLogsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateLogsDescriptorServerMsgHandle{}
}

func (h *CreateLogsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*CreateLogsRequest) *log.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *CreateLogsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateLogsRequest) []*log.Name
	})
	if ok {
		return log.LogNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateLogsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*CreateLogsRequest) *log.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*log.ParentName)(nil)
}

func (h *CreateLogsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateLogsRequest) *log.Log
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *CreateLogsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateLogsRequest) []*log.Log
	})
	if ok {
		return log.LogList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *CreateLogsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*CreateLogsResponse) *log.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *CreateLogsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateLogsResponse) []*log.Name
	})
	if ok {
		return log.LogNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateLogsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*CreateLogsResponse) *log.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *CreateLogsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateLogsResponse) *log.Log
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *CreateLogsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateLogsResponse) []*log.Log
	})
	if ok {
		return log.LogList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateLogsDescriptor() *CreateLogsDescriptor {
	return createLogsDescriptor
}

type StreamingCreateLogsDescriptor struct{}

type StreamingCreateLogsDescriptorClientMsgHandle struct{}

type StreamingCreateLogsDescriptorServerMsgHandle struct{}

func (d *StreamingCreateLogsDescriptor) NewEmptyClientMsg() proto.Message {
	return &StreamingCreateLogsRequest{}
}

func (d *StreamingCreateLogsDescriptor) NewEmptyServerMsg() proto.Message {
	return &StreamingCreateLogsResponse{}
}

func (d *StreamingCreateLogsDescriptor) IsUnary() bool {
	return false
}

func (d *StreamingCreateLogsDescriptor) IsClientStream() bool {
	return true
}

func (d *StreamingCreateLogsDescriptor) IsServerStream() bool {
	return true
}

func (d *StreamingCreateLogsDescriptor) IsCollection() bool {
	return true
}

func (d *StreamingCreateLogsDescriptor) IsPlural() bool {
	return false
}

func (d *StreamingCreateLogsDescriptor) HasResource() bool {
	return true
}

func (d *StreamingCreateLogsDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *StreamingCreateLogsDescriptor) GetVerb() string {
	return "streamingCreate"
}

func (d *StreamingCreateLogsDescriptor) GetMethodName() string {
	return "StreamingCreateLogs"
}

func (d *StreamingCreateLogsDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogService/StreamingCreateLogs"
}

func (d *StreamingCreateLogsDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *StreamingCreateLogsDescriptor) GetApiName() string {
	return "LogService"
}

func (d *StreamingCreateLogsDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

func (d *StreamingCreateLogsDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *StreamingCreateLogsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logServiceDescriptor
}

func (d *StreamingCreateLogsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log.GetDescriptor()
}

func (d *StreamingCreateLogsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &StreamingCreateLogsDescriptorClientMsgHandle{}
}

func (d *StreamingCreateLogsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &StreamingCreateLogsDescriptorServerMsgHandle{}
}

func (h *StreamingCreateLogsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*StreamingCreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*StreamingCreateLogsRequest) *log.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*StreamingCreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*StreamingCreateLogsRequest) []*log.Name
	})
	if ok {
		return log.LogNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*StreamingCreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*StreamingCreateLogsRequest) *log.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*log.ParentName)(nil)
}

func (h *StreamingCreateLogsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*StreamingCreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*StreamingCreateLogsRequest) *log.Log
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*StreamingCreateLogsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*StreamingCreateLogsRequest) []*log.Log
	})
	if ok {
		return log.LogList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*StreamingCreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*StreamingCreateLogsResponse) *log.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*StreamingCreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*StreamingCreateLogsResponse) []*log.Name
	})
	if ok {
		return log.LogNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*StreamingCreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*StreamingCreateLogsResponse) *log.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*StreamingCreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*StreamingCreateLogsResponse) *log.Log
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *StreamingCreateLogsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*StreamingCreateLogsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*StreamingCreateLogsResponse) []*log.Log
	})
	if ok {
		return log.LogList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetStreamingCreateLogsDescriptor() *StreamingCreateLogsDescriptor {
	return streamingCreateLogsDescriptor
}

type LogServiceDescriptor struct{}

func (d *LogServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		listLogsDescriptor,
		createLogsDescriptor,
		streamingCreateLogsDescriptor,
	}
}

func (d *LogServiceDescriptor) GetFullAPIName() string {
	return "/ntt.logging.v1.LogService"
}

func (d *LogServiceDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *LogServiceDescriptor) GetApiName() string {
	return "LogService"
}

func (d *LogServiceDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

func (d *LogServiceDescriptor) GetServiceVersion() string {
	return "v1"
}

func GetLogServiceDescriptor() *LogServiceDescriptor {
	return logServiceDescriptor
}

func initDescriptors() {
	logServiceDescriptor = &LogServiceDescriptor{}
	listLogsDescriptor = &ListLogsDescriptor{}
	createLogsDescriptor = &CreateLogsDescriptor{}
	streamingCreateLogsDescriptor = &StreamingCreateLogsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(logServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listLogsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createLogsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(streamingCreateLogsDescriptor)
}

func init() {
	if !descriptorsInitialized {
		initDescriptors()
		descriptorsInitialized = true
	}
}