github.com/cloudwan/edgelq-sdk@v1.15.4/logging/client/v1alpha2/log_descriptor/log_descriptor_service.pb.descriptors.go (about)

     1  // Code generated by protoc-gen-goten-client
     2  // API: LogDescriptorService
     3  // DO NOT EDIT!!!
     4  
     5  package log_descriptor_client
     6  
     7  import (
     8  	"google.golang.org/protobuf/proto"
     9  
    10  	gotenclient "github.com/cloudwan/goten-sdk/runtime/client"
    11  	gotenresource "github.com/cloudwan/goten-sdk/runtime/resource"
    12  )
    13  
    14  // proto imports
    15  import (
    16  	log_descriptor "github.com/cloudwan/edgelq-sdk/logging/resources/v1alpha2/log_descriptor"
    17  	emptypb "google.golang.org/protobuf/types/known/emptypb"
    18  )
    19  
    20  // Reference imports to suppress errors if they are not otherwise used.
    21  var (
    22  	_ = new(proto.Message)
    23  	_ = new(gotenclient.MethodDescriptor)
    24  	_ = gotenresource.WildcardId
    25  )
    26  
    27  // make sure we're using proto imports
    28  var (
    29  	_ = &log_descriptor.LogDescriptor{}
    30  	_ = &emptypb.Empty{}
    31  )
    32  
    33  var (
    34  	descriptorsInitialized           bool
    35  	logDescriptorServiceDescriptor   *LogDescriptorServiceDescriptor
    36  	getLogDescriptorDescriptor       *GetLogDescriptorDescriptor
    37  	batchGetLogDescriptorsDescriptor *BatchGetLogDescriptorsDescriptor
    38  	listLogDescriptorsDescriptor     *ListLogDescriptorsDescriptor
    39  	watchLogDescriptorDescriptor     *WatchLogDescriptorDescriptor
    40  	watchLogDescriptorsDescriptor    *WatchLogDescriptorsDescriptor
    41  	createLogDescriptorDescriptor    *CreateLogDescriptorDescriptor
    42  	updateLogDescriptorDescriptor    *UpdateLogDescriptorDescriptor
    43  	deleteLogDescriptorDescriptor    *DeleteLogDescriptorDescriptor
    44  )
    45  
    46  type GetLogDescriptorDescriptor struct{}
    47  
    48  type GetLogDescriptorDescriptorClientMsgHandle struct{}
    49  
    50  type GetLogDescriptorDescriptorServerMsgHandle struct{}
    51  
    52  func (d *GetLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
    53  	return &GetLogDescriptorRequest{}
    54  }
    55  
    56  func (d *GetLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
    57  	return &log_descriptor.LogDescriptor{}
    58  }
    59  
    60  func (d *GetLogDescriptorDescriptor) IsUnary() bool {
    61  	return true
    62  }
    63  
    64  func (d *GetLogDescriptorDescriptor) IsClientStream() bool {
    65  	return false
    66  }
    67  
    68  func (d *GetLogDescriptorDescriptor) IsServerStream() bool {
    69  	return false
    70  }
    71  
    72  func (d *GetLogDescriptorDescriptor) IsCollection() bool {
    73  	return false
    74  }
    75  
    76  func (d *GetLogDescriptorDescriptor) IsPlural() bool {
    77  	return false
    78  }
    79  
    80  func (d *GetLogDescriptorDescriptor) HasResource() bool {
    81  	return true
    82  }
    83  
    84  func (d *GetLogDescriptorDescriptor) RequestHasResourceBody() bool {
    85  	return false
    86  }
    87  
    88  func (d *GetLogDescriptorDescriptor) GetVerb() string {
    89  	return "get"
    90  }
    91  
    92  func (d *GetLogDescriptorDescriptor) GetMethodName() string {
    93  	return "GetLogDescriptor"
    94  }
    95  
    96  func (d *GetLogDescriptorDescriptor) GetFullMethodName() string {
    97  	return "/ntt.logging.v1alpha2.LogDescriptorService/GetLogDescriptor"
    98  }
    99  
   100  func (d *GetLogDescriptorDescriptor) GetProtoPkgName() string {
   101  	return "ntt.logging.v1alpha2"
   102  }
   103  
   104  func (d *GetLogDescriptorDescriptor) GetApiName() string {
   105  	return "LogDescriptorService"
   106  }
   107  
   108  func (d *GetLogDescriptorDescriptor) GetServiceDomain() string {
   109  	return "logging.edgelq.com"
   110  }
   111  
   112  func (d *GetLogDescriptorDescriptor) GetServiceVersion() string {
   113  	return "v1alpha2"
   114  }
   115  
   116  func (d *GetLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   117  	return logDescriptorServiceDescriptor
   118  }
   119  
   120  func (d *GetLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   121  	return log_descriptor.GetDescriptor()
   122  }
   123  
   124  func (d *GetLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   125  	return &GetLogDescriptorDescriptorClientMsgHandle{}
   126  }
   127  
   128  func (d *GetLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   129  	return &GetLogDescriptorDescriptorServerMsgHandle{}
   130  }
   131  
   132  func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   133  	typedMsg := msg.(*GetLogDescriptorRequest)
   134  	var asInterface interface{} = h
   135  	override, ok := asInterface.(interface {
   136  		OverrideExtractResourceName(*GetLogDescriptorRequest) *log_descriptor.Name
   137  	})
   138  	if ok {
   139  		return override.OverrideExtractResourceName(typedMsg)
   140  	}
   141  	{
   142  		if name := typedMsg.GetName(); name != nil {
   143  			return name
   144  		}
   145  	}
   146  	return (*log_descriptor.Name)(nil)
   147  }
   148  
   149  func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   150  	typedMsg := msg.(*GetLogDescriptorRequest)
   151  	var asInterface interface{} = h
   152  	override, ok := asInterface.(interface {
   153  		OverrideExtractResourceNames(*GetLogDescriptorRequest) []*log_descriptor.Name
   154  	})
   155  	if ok {
   156  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   157  	}
   158  	return nil
   159  }
   160  
   161  func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   162  	typedMsg := msg.(*GetLogDescriptorRequest)
   163  	var asInterface interface{} = h
   164  	override, ok := asInterface.(interface {
   165  		OverrideExtractCollectionName(*GetLogDescriptorRequest) *log_descriptor.ParentName
   166  	})
   167  	if ok {
   168  		return override.OverrideExtractCollectionName(typedMsg)
   169  	}
   170  	return nil
   171  }
   172  
   173  func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   174  	typedMsg := msg.(*GetLogDescriptorRequest)
   175  	var asInterface interface{} = h
   176  	override, ok := asInterface.(interface {
   177  		OverrideExtractResourceBody(*GetLogDescriptorRequest) *log_descriptor.LogDescriptor
   178  	})
   179  	if ok {
   180  		return override.OverrideExtractResourceBody(typedMsg)
   181  	}
   182  	return nil
   183  }
   184  
   185  func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   186  	typedMsg := msg.(*GetLogDescriptorRequest)
   187  	var asInterface interface{} = h
   188  	override, ok := asInterface.(interface {
   189  		OverrideExtractResourceBodies(*GetLogDescriptorRequest) []*log_descriptor.LogDescriptor
   190  	})
   191  	if ok {
   192  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   193  	}
   194  	return nil
   195  }
   196  
   197  func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   198  	typedMsg := msg.(*log_descriptor.LogDescriptor)
   199  	var asInterface interface{} = h
   200  	override, ok := asInterface.(interface {
   201  		OverrideExtractResourceName(*log_descriptor.LogDescriptor) *log_descriptor.Name
   202  	})
   203  	if ok {
   204  		return override.OverrideExtractResourceName(typedMsg)
   205  	}
   206  	{
   207  		if name := typedMsg.GetName(); name != nil {
   208  			return name
   209  		}
   210  	}
   211  	return (*log_descriptor.Name)(nil)
   212  }
   213  
   214  func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   215  	typedMsg := msg.(*log_descriptor.LogDescriptor)
   216  	var asInterface interface{} = h
   217  	override, ok := asInterface.(interface {
   218  		OverrideExtractResourceNames(*log_descriptor.LogDescriptor) []*log_descriptor.Name
   219  	})
   220  	if ok {
   221  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   222  	}
   223  	return nil
   224  }
   225  
   226  func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   227  	typedMsg := msg.(*log_descriptor.LogDescriptor)
   228  	var asInterface interface{} = h
   229  	override, ok := asInterface.(interface {
   230  		OverrideExtractCollectionName(*log_descriptor.LogDescriptor) *log_descriptor.ParentName
   231  	})
   232  	if ok {
   233  		return override.OverrideExtractCollectionName(typedMsg)
   234  	}
   235  	return nil
   236  }
   237  
   238  func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   239  	return msg.(*log_descriptor.LogDescriptor)
   240  }
   241  
   242  func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   243  	typedMsg := msg.(*log_descriptor.LogDescriptor)
   244  	var asInterface interface{} = h
   245  	override, ok := asInterface.(interface {
   246  		OverrideExtractResourceBodies(*log_descriptor.LogDescriptor) []*log_descriptor.LogDescriptor
   247  	})
   248  	if ok {
   249  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   250  	}
   251  	return nil
   252  }
   253  
   254  func GetGetLogDescriptorDescriptor() *GetLogDescriptorDescriptor {
   255  	return getLogDescriptorDescriptor
   256  }
   257  
   258  type BatchGetLogDescriptorsDescriptor struct{}
   259  
   260  type BatchGetLogDescriptorsDescriptorClientMsgHandle struct{}
   261  
   262  type BatchGetLogDescriptorsDescriptorServerMsgHandle struct{}
   263  
   264  func (d *BatchGetLogDescriptorsDescriptor) NewEmptyClientMsg() proto.Message {
   265  	return &BatchGetLogDescriptorsRequest{}
   266  }
   267  
   268  func (d *BatchGetLogDescriptorsDescriptor) NewEmptyServerMsg() proto.Message {
   269  	return &BatchGetLogDescriptorsResponse{}
   270  }
   271  
   272  func (d *BatchGetLogDescriptorsDescriptor) IsUnary() bool {
   273  	return true
   274  }
   275  
   276  func (d *BatchGetLogDescriptorsDescriptor) IsClientStream() bool {
   277  	return false
   278  }
   279  
   280  func (d *BatchGetLogDescriptorsDescriptor) IsServerStream() bool {
   281  	return false
   282  }
   283  
   284  func (d *BatchGetLogDescriptorsDescriptor) IsCollection() bool {
   285  	return false
   286  }
   287  
   288  func (d *BatchGetLogDescriptorsDescriptor) IsPlural() bool {
   289  	return true
   290  }
   291  
   292  func (d *BatchGetLogDescriptorsDescriptor) HasResource() bool {
   293  	return true
   294  }
   295  
   296  func (d *BatchGetLogDescriptorsDescriptor) RequestHasResourceBody() bool {
   297  	return false
   298  }
   299  
   300  func (d *BatchGetLogDescriptorsDescriptor) GetVerb() string {
   301  	return "batchGet"
   302  }
   303  
   304  func (d *BatchGetLogDescriptorsDescriptor) GetMethodName() string {
   305  	return "BatchGetLogDescriptors"
   306  }
   307  
   308  func (d *BatchGetLogDescriptorsDescriptor) GetFullMethodName() string {
   309  	return "/ntt.logging.v1alpha2.LogDescriptorService/BatchGetLogDescriptors"
   310  }
   311  
   312  func (d *BatchGetLogDescriptorsDescriptor) GetProtoPkgName() string {
   313  	return "ntt.logging.v1alpha2"
   314  }
   315  
   316  func (d *BatchGetLogDescriptorsDescriptor) GetApiName() string {
   317  	return "LogDescriptorService"
   318  }
   319  
   320  func (d *BatchGetLogDescriptorsDescriptor) GetServiceDomain() string {
   321  	return "logging.edgelq.com"
   322  }
   323  
   324  func (d *BatchGetLogDescriptorsDescriptor) GetServiceVersion() string {
   325  	return "v1alpha2"
   326  }
   327  
   328  func (d *BatchGetLogDescriptorsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   329  	return logDescriptorServiceDescriptor
   330  }
   331  
   332  func (d *BatchGetLogDescriptorsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   333  	return log_descriptor.GetDescriptor()
   334  }
   335  
   336  func (d *BatchGetLogDescriptorsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   337  	return &BatchGetLogDescriptorsDescriptorClientMsgHandle{}
   338  }
   339  
   340  func (d *BatchGetLogDescriptorsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   341  	return &BatchGetLogDescriptorsDescriptorServerMsgHandle{}
   342  }
   343  
   344  func (h *BatchGetLogDescriptorsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   345  	typedMsg := msg.(*BatchGetLogDescriptorsRequest)
   346  	var asInterface interface{} = h
   347  	override, ok := asInterface.(interface {
   348  		OverrideExtractResourceName(*BatchGetLogDescriptorsRequest) *log_descriptor.Name
   349  	})
   350  	if ok {
   351  		return override.OverrideExtractResourceName(typedMsg)
   352  	}
   353  	return nil
   354  }
   355  
   356  func (h *BatchGetLogDescriptorsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   357  	typedMsg := msg.(*BatchGetLogDescriptorsRequest)
   358  	var asInterface interface{} = h
   359  	override, ok := asInterface.(interface {
   360  		OverrideExtractResourceNames(*BatchGetLogDescriptorsRequest) []*log_descriptor.Name
   361  	})
   362  	if ok {
   363  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   364  	}
   365  	{
   366  		if names := typedMsg.GetNames(); len(names) > 0 {
   367  			return log_descriptor.LogDescriptorNameList(names)
   368  		}
   369  	}
   370  	return (log_descriptor.LogDescriptorNameList)(nil)
   371  }
   372  
   373  func (h *BatchGetLogDescriptorsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   374  	typedMsg := msg.(*BatchGetLogDescriptorsRequest)
   375  	var asInterface interface{} = h
   376  	override, ok := asInterface.(interface {
   377  		OverrideExtractCollectionName(*BatchGetLogDescriptorsRequest) *log_descriptor.ParentName
   378  	})
   379  	if ok {
   380  		return override.OverrideExtractCollectionName(typedMsg)
   381  	}
   382  	return nil
   383  }
   384  
   385  func (h *BatchGetLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   386  	typedMsg := msg.(*BatchGetLogDescriptorsRequest)
   387  	var asInterface interface{} = h
   388  	override, ok := asInterface.(interface {
   389  		OverrideExtractResourceBody(*BatchGetLogDescriptorsRequest) *log_descriptor.LogDescriptor
   390  	})
   391  	if ok {
   392  		return override.OverrideExtractResourceBody(typedMsg)
   393  	}
   394  	return nil
   395  }
   396  
   397  func (h *BatchGetLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   398  	typedMsg := msg.(*BatchGetLogDescriptorsRequest)
   399  	var asInterface interface{} = h
   400  	override, ok := asInterface.(interface {
   401  		OverrideExtractResourceBodies(*BatchGetLogDescriptorsRequest) []*log_descriptor.LogDescriptor
   402  	})
   403  	if ok {
   404  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   405  	}
   406  	return nil
   407  }
   408  
   409  func (h *BatchGetLogDescriptorsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   410  	typedMsg := msg.(*BatchGetLogDescriptorsResponse)
   411  	var asInterface interface{} = h
   412  	override, ok := asInterface.(interface {
   413  		OverrideExtractResourceName(*BatchGetLogDescriptorsResponse) *log_descriptor.Name
   414  	})
   415  	if ok {
   416  		return override.OverrideExtractResourceName(typedMsg)
   417  	}
   418  	return nil
   419  }
   420  
   421  func (h *BatchGetLogDescriptorsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   422  	typedMsg := msg.(*BatchGetLogDescriptorsResponse)
   423  	var asInterface interface{} = h
   424  	override, ok := asInterface.(interface {
   425  		OverrideExtractResourceNames(*BatchGetLogDescriptorsResponse) []*log_descriptor.Name
   426  	})
   427  	if ok {
   428  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   429  	}
   430  	{
   431  		if resources := typedMsg.GetLogDescriptors(); len(resources) > 0 {
   432  			list := make(log_descriptor.LogDescriptorNameList, 0, len(resources))
   433  			for _, res := range resources {
   434  				list = append(list, res.GetName())
   435  			}
   436  			return list
   437  		}
   438  	}
   439  	return (log_descriptor.LogDescriptorNameList)(nil)
   440  }
   441  
   442  func (h *BatchGetLogDescriptorsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   443  	typedMsg := msg.(*BatchGetLogDescriptorsResponse)
   444  	var asInterface interface{} = h
   445  	override, ok := asInterface.(interface {
   446  		OverrideExtractCollectionName(*BatchGetLogDescriptorsResponse) *log_descriptor.ParentName
   447  	})
   448  	if ok {
   449  		return override.OverrideExtractCollectionName(typedMsg)
   450  	}
   451  	return nil
   452  }
   453  
   454  func (h *BatchGetLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   455  	typedMsg := msg.(*BatchGetLogDescriptorsResponse)
   456  	var asInterface interface{} = h
   457  	override, ok := asInterface.(interface {
   458  		OverrideExtractResourceBody(*BatchGetLogDescriptorsResponse) *log_descriptor.LogDescriptor
   459  	})
   460  	if ok {
   461  		return override.OverrideExtractResourceBody(typedMsg)
   462  	}
   463  	return nil
   464  }
   465  
   466  func (h *BatchGetLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   467  	typedMsg := msg.(*BatchGetLogDescriptorsResponse)
   468  	var asInterface interface{} = h
   469  	override, ok := asInterface.(interface {
   470  		OverrideExtractResourceBodies(*BatchGetLogDescriptorsResponse) []*log_descriptor.LogDescriptor
   471  	})
   472  	if ok {
   473  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   474  	}
   475  	{
   476  		if resources := typedMsg.GetLogDescriptors(); len(resources) > 0 {
   477  			return log_descriptor.LogDescriptorList(resources)
   478  		}
   479  	}
   480  	return (log_descriptor.LogDescriptorList)(nil)
   481  }
   482  
   483  func GetBatchGetLogDescriptorsDescriptor() *BatchGetLogDescriptorsDescriptor {
   484  	return batchGetLogDescriptorsDescriptor
   485  }
   486  
   487  type ListLogDescriptorsDescriptor struct{}
   488  
   489  type ListLogDescriptorsDescriptorClientMsgHandle struct{}
   490  
   491  type ListLogDescriptorsDescriptorServerMsgHandle struct{}
   492  
   493  func (d *ListLogDescriptorsDescriptor) NewEmptyClientMsg() proto.Message {
   494  	return &ListLogDescriptorsRequest{}
   495  }
   496  
   497  func (d *ListLogDescriptorsDescriptor) NewEmptyServerMsg() proto.Message {
   498  	return &ListLogDescriptorsResponse{}
   499  }
   500  
   501  func (d *ListLogDescriptorsDescriptor) IsUnary() bool {
   502  	return true
   503  }
   504  
   505  func (d *ListLogDescriptorsDescriptor) IsClientStream() bool {
   506  	return false
   507  }
   508  
   509  func (d *ListLogDescriptorsDescriptor) IsServerStream() bool {
   510  	return false
   511  }
   512  
   513  func (d *ListLogDescriptorsDescriptor) IsCollection() bool {
   514  	return true
   515  }
   516  
   517  func (d *ListLogDescriptorsDescriptor) IsPlural() bool {
   518  	return true
   519  }
   520  
   521  func (d *ListLogDescriptorsDescriptor) HasResource() bool {
   522  	return true
   523  }
   524  
   525  func (d *ListLogDescriptorsDescriptor) RequestHasResourceBody() bool {
   526  	return false
   527  }
   528  
   529  func (d *ListLogDescriptorsDescriptor) GetVerb() string {
   530  	return "list"
   531  }
   532  
   533  func (d *ListLogDescriptorsDescriptor) GetMethodName() string {
   534  	return "ListLogDescriptors"
   535  }
   536  
   537  func (d *ListLogDescriptorsDescriptor) GetFullMethodName() string {
   538  	return "/ntt.logging.v1alpha2.LogDescriptorService/ListLogDescriptors"
   539  }
   540  
   541  func (d *ListLogDescriptorsDescriptor) GetProtoPkgName() string {
   542  	return "ntt.logging.v1alpha2"
   543  }
   544  
   545  func (d *ListLogDescriptorsDescriptor) GetApiName() string {
   546  	return "LogDescriptorService"
   547  }
   548  
   549  func (d *ListLogDescriptorsDescriptor) GetServiceDomain() string {
   550  	return "logging.edgelq.com"
   551  }
   552  
   553  func (d *ListLogDescriptorsDescriptor) GetServiceVersion() string {
   554  	return "v1alpha2"
   555  }
   556  
   557  func (d *ListLogDescriptorsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   558  	return logDescriptorServiceDescriptor
   559  }
   560  
   561  func (d *ListLogDescriptorsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   562  	return log_descriptor.GetDescriptor()
   563  }
   564  
   565  func (d *ListLogDescriptorsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   566  	return &ListLogDescriptorsDescriptorClientMsgHandle{}
   567  }
   568  
   569  func (d *ListLogDescriptorsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   570  	return &ListLogDescriptorsDescriptorServerMsgHandle{}
   571  }
   572  
   573  func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   574  	typedMsg := msg.(*ListLogDescriptorsRequest)
   575  	var asInterface interface{} = h
   576  	override, ok := asInterface.(interface {
   577  		OverrideExtractResourceName(*ListLogDescriptorsRequest) *log_descriptor.Name
   578  	})
   579  	if ok {
   580  		return override.OverrideExtractResourceName(typedMsg)
   581  	}
   582  	return nil
   583  }
   584  
   585  func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   586  	typedMsg := msg.(*ListLogDescriptorsRequest)
   587  	var asInterface interface{} = h
   588  	override, ok := asInterface.(interface {
   589  		OverrideExtractResourceNames(*ListLogDescriptorsRequest) []*log_descriptor.Name
   590  	})
   591  	if ok {
   592  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   593  	}
   594  	return nil
   595  }
   596  
   597  func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   598  	typedMsg := msg.(*ListLogDescriptorsRequest)
   599  	var asInterface interface{} = h
   600  	override, ok := asInterface.(interface {
   601  		OverrideExtractCollectionName(*ListLogDescriptorsRequest) *log_descriptor.ParentName
   602  	})
   603  	if ok {
   604  		return override.OverrideExtractCollectionName(typedMsg)
   605  	}
   606  	{
   607  		if parentName := typedMsg.GetParent(); parentName != nil {
   608  			return parentName
   609  		}
   610  	}
   611  	return (*log_descriptor.ParentName)(nil)
   612  }
   613  
   614  func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   615  	typedMsg := msg.(*ListLogDescriptorsRequest)
   616  	var asInterface interface{} = h
   617  	override, ok := asInterface.(interface {
   618  		OverrideExtractResourceBody(*ListLogDescriptorsRequest) *log_descriptor.LogDescriptor
   619  	})
   620  	if ok {
   621  		return override.OverrideExtractResourceBody(typedMsg)
   622  	}
   623  	return nil
   624  }
   625  
   626  func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   627  	typedMsg := msg.(*ListLogDescriptorsRequest)
   628  	var asInterface interface{} = h
   629  	override, ok := asInterface.(interface {
   630  		OverrideExtractResourceBodies(*ListLogDescriptorsRequest) []*log_descriptor.LogDescriptor
   631  	})
   632  	if ok {
   633  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   634  	}
   635  	return nil
   636  }
   637  
   638  func (h *ListLogDescriptorsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   639  	typedMsg := msg.(*ListLogDescriptorsResponse)
   640  	var asInterface interface{} = h
   641  	override, ok := asInterface.(interface {
   642  		OverrideExtractResourceName(*ListLogDescriptorsResponse) *log_descriptor.Name
   643  	})
   644  	if ok {
   645  		return override.OverrideExtractResourceName(typedMsg)
   646  	}
   647  	return nil
   648  }
   649  
   650  func (h *ListLogDescriptorsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   651  	typedMsg := msg.(*ListLogDescriptorsResponse)
   652  	var asInterface interface{} = h
   653  	override, ok := asInterface.(interface {
   654  		OverrideExtractResourceNames(*ListLogDescriptorsResponse) []*log_descriptor.Name
   655  	})
   656  	if ok {
   657  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   658  	}
   659  	{
   660  		if resources := typedMsg.GetLogDescriptors(); len(resources) > 0 {
   661  			list := make(log_descriptor.LogDescriptorNameList, 0, len(resources))
   662  			for _, res := range resources {
   663  				list = append(list, res.GetName())
   664  			}
   665  			return list
   666  		}
   667  	}
   668  	return (log_descriptor.LogDescriptorNameList)(nil)
   669  }
   670  
   671  func (h *ListLogDescriptorsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   672  	typedMsg := msg.(*ListLogDescriptorsResponse)
   673  	var asInterface interface{} = h
   674  	override, ok := asInterface.(interface {
   675  		OverrideExtractCollectionName(*ListLogDescriptorsResponse) *log_descriptor.ParentName
   676  	})
   677  	if ok {
   678  		return override.OverrideExtractCollectionName(typedMsg)
   679  	}
   680  	return nil
   681  }
   682  
   683  func (h *ListLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   684  	typedMsg := msg.(*ListLogDescriptorsResponse)
   685  	var asInterface interface{} = h
   686  	override, ok := asInterface.(interface {
   687  		OverrideExtractResourceBody(*ListLogDescriptorsResponse) *log_descriptor.LogDescriptor
   688  	})
   689  	if ok {
   690  		return override.OverrideExtractResourceBody(typedMsg)
   691  	}
   692  	return nil
   693  }
   694  
   695  func (h *ListLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   696  	typedMsg := msg.(*ListLogDescriptorsResponse)
   697  	var asInterface interface{} = h
   698  	override, ok := asInterface.(interface {
   699  		OverrideExtractResourceBodies(*ListLogDescriptorsResponse) []*log_descriptor.LogDescriptor
   700  	})
   701  	if ok {
   702  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   703  	}
   704  	{
   705  		if resources := typedMsg.GetLogDescriptors(); len(resources) > 0 {
   706  			return log_descriptor.LogDescriptorList(resources)
   707  		}
   708  	}
   709  	return (log_descriptor.LogDescriptorList)(nil)
   710  }
   711  
   712  func GetListLogDescriptorsDescriptor() *ListLogDescriptorsDescriptor {
   713  	return listLogDescriptorsDescriptor
   714  }
   715  
   716  type WatchLogDescriptorDescriptor struct{}
   717  
   718  type WatchLogDescriptorDescriptorClientMsgHandle struct{}
   719  
   720  type WatchLogDescriptorDescriptorServerMsgHandle struct{}
   721  
   722  func (d *WatchLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
   723  	return &WatchLogDescriptorRequest{}
   724  }
   725  
   726  func (d *WatchLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
   727  	return &WatchLogDescriptorResponse{}
   728  }
   729  
   730  func (d *WatchLogDescriptorDescriptor) IsUnary() bool {
   731  	return false
   732  }
   733  
   734  func (d *WatchLogDescriptorDescriptor) IsClientStream() bool {
   735  	return false
   736  }
   737  
   738  func (d *WatchLogDescriptorDescriptor) IsServerStream() bool {
   739  	return true
   740  }
   741  
   742  func (d *WatchLogDescriptorDescriptor) IsCollection() bool {
   743  	return false
   744  }
   745  
   746  func (d *WatchLogDescriptorDescriptor) IsPlural() bool {
   747  	return false
   748  }
   749  
   750  func (d *WatchLogDescriptorDescriptor) HasResource() bool {
   751  	return true
   752  }
   753  
   754  func (d *WatchLogDescriptorDescriptor) RequestHasResourceBody() bool {
   755  	return false
   756  }
   757  
   758  func (d *WatchLogDescriptorDescriptor) GetVerb() string {
   759  	return "watch"
   760  }
   761  
   762  func (d *WatchLogDescriptorDescriptor) GetMethodName() string {
   763  	return "WatchLogDescriptor"
   764  }
   765  
   766  func (d *WatchLogDescriptorDescriptor) GetFullMethodName() string {
   767  	return "/ntt.logging.v1alpha2.LogDescriptorService/WatchLogDescriptor"
   768  }
   769  
   770  func (d *WatchLogDescriptorDescriptor) GetProtoPkgName() string {
   771  	return "ntt.logging.v1alpha2"
   772  }
   773  
   774  func (d *WatchLogDescriptorDescriptor) GetApiName() string {
   775  	return "LogDescriptorService"
   776  }
   777  
   778  func (d *WatchLogDescriptorDescriptor) GetServiceDomain() string {
   779  	return "logging.edgelq.com"
   780  }
   781  
   782  func (d *WatchLogDescriptorDescriptor) GetServiceVersion() string {
   783  	return "v1alpha2"
   784  }
   785  
   786  func (d *WatchLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   787  	return logDescriptorServiceDescriptor
   788  }
   789  
   790  func (d *WatchLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   791  	return log_descriptor.GetDescriptor()
   792  }
   793  
   794  func (d *WatchLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   795  	return &WatchLogDescriptorDescriptorClientMsgHandle{}
   796  }
   797  
   798  func (d *WatchLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   799  	return &WatchLogDescriptorDescriptorServerMsgHandle{}
   800  }
   801  
   802  func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   803  	typedMsg := msg.(*WatchLogDescriptorRequest)
   804  	var asInterface interface{} = h
   805  	override, ok := asInterface.(interface {
   806  		OverrideExtractResourceName(*WatchLogDescriptorRequest) *log_descriptor.Name
   807  	})
   808  	if ok {
   809  		return override.OverrideExtractResourceName(typedMsg)
   810  	}
   811  	{
   812  		if name := typedMsg.GetName(); name != nil {
   813  			return name
   814  		}
   815  	}
   816  	return (*log_descriptor.Name)(nil)
   817  }
   818  
   819  func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   820  	typedMsg := msg.(*WatchLogDescriptorRequest)
   821  	var asInterface interface{} = h
   822  	override, ok := asInterface.(interface {
   823  		OverrideExtractResourceNames(*WatchLogDescriptorRequest) []*log_descriptor.Name
   824  	})
   825  	if ok {
   826  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   827  	}
   828  	return nil
   829  }
   830  
   831  func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   832  	typedMsg := msg.(*WatchLogDescriptorRequest)
   833  	var asInterface interface{} = h
   834  	override, ok := asInterface.(interface {
   835  		OverrideExtractCollectionName(*WatchLogDescriptorRequest) *log_descriptor.ParentName
   836  	})
   837  	if ok {
   838  		return override.OverrideExtractCollectionName(typedMsg)
   839  	}
   840  	return nil
   841  }
   842  
   843  func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   844  	typedMsg := msg.(*WatchLogDescriptorRequest)
   845  	var asInterface interface{} = h
   846  	override, ok := asInterface.(interface {
   847  		OverrideExtractResourceBody(*WatchLogDescriptorRequest) *log_descriptor.LogDescriptor
   848  	})
   849  	if ok {
   850  		return override.OverrideExtractResourceBody(typedMsg)
   851  	}
   852  	return nil
   853  }
   854  
   855  func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   856  	typedMsg := msg.(*WatchLogDescriptorRequest)
   857  	var asInterface interface{} = h
   858  	override, ok := asInterface.(interface {
   859  		OverrideExtractResourceBodies(*WatchLogDescriptorRequest) []*log_descriptor.LogDescriptor
   860  	})
   861  	if ok {
   862  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   863  	}
   864  	return nil
   865  }
   866  
   867  func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   868  	typedMsg := msg.(*WatchLogDescriptorResponse)
   869  	var asInterface interface{} = h
   870  	override, ok := asInterface.(interface {
   871  		OverrideExtractResourceName(*WatchLogDescriptorResponse) *log_descriptor.Name
   872  	})
   873  	if ok {
   874  		return override.OverrideExtractResourceName(typedMsg)
   875  	}
   876  	{
   877  		if resChange := typedMsg.GetChange(); resChange != nil {
   878  			switch tResChange := resChange.ChangeType.(type) {
   879  			case *log_descriptor.LogDescriptorChange_Added_:
   880  				return tResChange.Added.GetLogDescriptor().GetName()
   881  			case *log_descriptor.LogDescriptorChange_Modified_:
   882  				return tResChange.Modified.GetName()
   883  			case *log_descriptor.LogDescriptorChange_Removed_:
   884  				return tResChange.Removed.GetName()
   885  			case *log_descriptor.LogDescriptorChange_Current_:
   886  				return tResChange.Current.GetLogDescriptor().GetName()
   887  			}
   888  		}
   889  	}
   890  	return (*log_descriptor.Name)(nil)
   891  }
   892  
   893  func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   894  	typedMsg := msg.(*WatchLogDescriptorResponse)
   895  	var asInterface interface{} = h
   896  	override, ok := asInterface.(interface {
   897  		OverrideExtractResourceNames(*WatchLogDescriptorResponse) []*log_descriptor.Name
   898  	})
   899  	if ok {
   900  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
   901  	}
   902  	return nil
   903  }
   904  
   905  func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   906  	typedMsg := msg.(*WatchLogDescriptorResponse)
   907  	var asInterface interface{} = h
   908  	override, ok := asInterface.(interface {
   909  		OverrideExtractCollectionName(*WatchLogDescriptorResponse) *log_descriptor.ParentName
   910  	})
   911  	if ok {
   912  		return override.OverrideExtractCollectionName(typedMsg)
   913  	}
   914  	return nil
   915  }
   916  
   917  func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   918  	typedMsg := msg.(*WatchLogDescriptorResponse)
   919  	var asInterface interface{} = h
   920  	override, ok := asInterface.(interface {
   921  		OverrideExtractResourceBody(*WatchLogDescriptorResponse) *log_descriptor.LogDescriptor
   922  	})
   923  	if ok {
   924  		return override.OverrideExtractResourceBody(typedMsg)
   925  	}
   926  	{
   927  		if resChange := typedMsg.GetChange(); resChange != nil {
   928  			switch tResChange := resChange.ChangeType.(type) {
   929  			case *log_descriptor.LogDescriptorChange_Added_:
   930  				return tResChange.Added.GetLogDescriptor()
   931  			case *log_descriptor.LogDescriptorChange_Modified_:
   932  				return tResChange.Modified.GetLogDescriptor()
   933  			case *log_descriptor.LogDescriptorChange_Current_:
   934  				return tResChange.Current.GetLogDescriptor()
   935  			}
   936  		}
   937  	}
   938  	return (*log_descriptor.LogDescriptor)(nil)
   939  }
   940  
   941  func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   942  	typedMsg := msg.(*WatchLogDescriptorResponse)
   943  	var asInterface interface{} = h
   944  	override, ok := asInterface.(interface {
   945  		OverrideExtractResourceBodies(*WatchLogDescriptorResponse) []*log_descriptor.LogDescriptor
   946  	})
   947  	if ok {
   948  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
   949  	}
   950  	return nil
   951  }
   952  
   953  func GetWatchLogDescriptorDescriptor() *WatchLogDescriptorDescriptor {
   954  	return watchLogDescriptorDescriptor
   955  }
   956  
   957  type WatchLogDescriptorsDescriptor struct{}
   958  
   959  type WatchLogDescriptorsDescriptorClientMsgHandle struct{}
   960  
   961  type WatchLogDescriptorsDescriptorServerMsgHandle struct{}
   962  
   963  func (d *WatchLogDescriptorsDescriptor) NewEmptyClientMsg() proto.Message {
   964  	return &WatchLogDescriptorsRequest{}
   965  }
   966  
   967  func (d *WatchLogDescriptorsDescriptor) NewEmptyServerMsg() proto.Message {
   968  	return &WatchLogDescriptorsResponse{}
   969  }
   970  
   971  func (d *WatchLogDescriptorsDescriptor) IsUnary() bool {
   972  	return false
   973  }
   974  
   975  func (d *WatchLogDescriptorsDescriptor) IsClientStream() bool {
   976  	return false
   977  }
   978  
   979  func (d *WatchLogDescriptorsDescriptor) IsServerStream() bool {
   980  	return true
   981  }
   982  
   983  func (d *WatchLogDescriptorsDescriptor) IsCollection() bool {
   984  	return true
   985  }
   986  
   987  func (d *WatchLogDescriptorsDescriptor) IsPlural() bool {
   988  	return true
   989  }
   990  
   991  func (d *WatchLogDescriptorsDescriptor) HasResource() bool {
   992  	return true
   993  }
   994  
   995  func (d *WatchLogDescriptorsDescriptor) RequestHasResourceBody() bool {
   996  	return false
   997  }
   998  
   999  func (d *WatchLogDescriptorsDescriptor) GetVerb() string {
  1000  	return "watch"
  1001  }
  1002  
  1003  func (d *WatchLogDescriptorsDescriptor) GetMethodName() string {
  1004  	return "WatchLogDescriptors"
  1005  }
  1006  
  1007  func (d *WatchLogDescriptorsDescriptor) GetFullMethodName() string {
  1008  	return "/ntt.logging.v1alpha2.LogDescriptorService/WatchLogDescriptors"
  1009  }
  1010  
  1011  func (d *WatchLogDescriptorsDescriptor) GetProtoPkgName() string {
  1012  	return "ntt.logging.v1alpha2"
  1013  }
  1014  
  1015  func (d *WatchLogDescriptorsDescriptor) GetApiName() string {
  1016  	return "LogDescriptorService"
  1017  }
  1018  
  1019  func (d *WatchLogDescriptorsDescriptor) GetServiceDomain() string {
  1020  	return "logging.edgelq.com"
  1021  }
  1022  
  1023  func (d *WatchLogDescriptorsDescriptor) GetServiceVersion() string {
  1024  	return "v1alpha2"
  1025  }
  1026  
  1027  func (d *WatchLogDescriptorsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1028  	return logDescriptorServiceDescriptor
  1029  }
  1030  
  1031  func (d *WatchLogDescriptorsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1032  	return log_descriptor.GetDescriptor()
  1033  }
  1034  
  1035  func (d *WatchLogDescriptorsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1036  	return &WatchLogDescriptorsDescriptorClientMsgHandle{}
  1037  }
  1038  
  1039  func (d *WatchLogDescriptorsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1040  	return &WatchLogDescriptorsDescriptorServerMsgHandle{}
  1041  }
  1042  
  1043  func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1044  	typedMsg := msg.(*WatchLogDescriptorsRequest)
  1045  	var asInterface interface{} = h
  1046  	override, ok := asInterface.(interface {
  1047  		OverrideExtractResourceName(*WatchLogDescriptorsRequest) *log_descriptor.Name
  1048  	})
  1049  	if ok {
  1050  		return override.OverrideExtractResourceName(typedMsg)
  1051  	}
  1052  	return nil
  1053  }
  1054  
  1055  func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1056  	typedMsg := msg.(*WatchLogDescriptorsRequest)
  1057  	var asInterface interface{} = h
  1058  	override, ok := asInterface.(interface {
  1059  		OverrideExtractResourceNames(*WatchLogDescriptorsRequest) []*log_descriptor.Name
  1060  	})
  1061  	if ok {
  1062  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1063  	}
  1064  	return nil
  1065  }
  1066  
  1067  func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1068  	typedMsg := msg.(*WatchLogDescriptorsRequest)
  1069  	var asInterface interface{} = h
  1070  	override, ok := asInterface.(interface {
  1071  		OverrideExtractCollectionName(*WatchLogDescriptorsRequest) *log_descriptor.ParentName
  1072  	})
  1073  	if ok {
  1074  		return override.OverrideExtractCollectionName(typedMsg)
  1075  	}
  1076  	{
  1077  		if parentName := typedMsg.GetParent(); parentName != nil {
  1078  			return parentName
  1079  		}
  1080  	}
  1081  	return (*log_descriptor.ParentName)(nil)
  1082  }
  1083  
  1084  func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1085  	typedMsg := msg.(*WatchLogDescriptorsRequest)
  1086  	var asInterface interface{} = h
  1087  	override, ok := asInterface.(interface {
  1088  		OverrideExtractResourceBody(*WatchLogDescriptorsRequest) *log_descriptor.LogDescriptor
  1089  	})
  1090  	if ok {
  1091  		return override.OverrideExtractResourceBody(typedMsg)
  1092  	}
  1093  	return nil
  1094  }
  1095  
  1096  func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1097  	typedMsg := msg.(*WatchLogDescriptorsRequest)
  1098  	var asInterface interface{} = h
  1099  	override, ok := asInterface.(interface {
  1100  		OverrideExtractResourceBodies(*WatchLogDescriptorsRequest) []*log_descriptor.LogDescriptor
  1101  	})
  1102  	if ok {
  1103  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1104  	}
  1105  	return nil
  1106  }
  1107  
  1108  func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1109  	typedMsg := msg.(*WatchLogDescriptorsResponse)
  1110  	var asInterface interface{} = h
  1111  	override, ok := asInterface.(interface {
  1112  		OverrideExtractResourceName(*WatchLogDescriptorsResponse) *log_descriptor.Name
  1113  	})
  1114  	if ok {
  1115  		return override.OverrideExtractResourceName(typedMsg)
  1116  	}
  1117  	return nil
  1118  }
  1119  
  1120  func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1121  	typedMsg := msg.(*WatchLogDescriptorsResponse)
  1122  	var asInterface interface{} = h
  1123  	override, ok := asInterface.(interface {
  1124  		OverrideExtractResourceNames(*WatchLogDescriptorsResponse) []*log_descriptor.Name
  1125  	})
  1126  	if ok {
  1127  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1128  	}
  1129  	{
  1130  		if resChanges := typedMsg.GetLogDescriptorChanges(); len(resChanges) > 0 {
  1131  			list := make(log_descriptor.LogDescriptorNameList, 0, len(resChanges))
  1132  			for _, resChange := range resChanges {
  1133  				switch tResChange := resChange.ChangeType.(type) {
  1134  				case *log_descriptor.LogDescriptorChange_Added_:
  1135  					list = append(list, tResChange.Added.GetLogDescriptor().GetName())
  1136  				case *log_descriptor.LogDescriptorChange_Modified_:
  1137  					list = append(list, tResChange.Modified.GetName())
  1138  				case *log_descriptor.LogDescriptorChange_Removed_:
  1139  					list = append(list, tResChange.Removed.GetName())
  1140  				case *log_descriptor.LogDescriptorChange_Current_:
  1141  					list = append(list, tResChange.Current.GetLogDescriptor().GetName())
  1142  				}
  1143  			}
  1144  			return list
  1145  		}
  1146  	}
  1147  	return (log_descriptor.LogDescriptorNameList)(nil)
  1148  }
  1149  
  1150  func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1151  	typedMsg := msg.(*WatchLogDescriptorsResponse)
  1152  	var asInterface interface{} = h
  1153  	override, ok := asInterface.(interface {
  1154  		OverrideExtractCollectionName(*WatchLogDescriptorsResponse) *log_descriptor.ParentName
  1155  	})
  1156  	if ok {
  1157  		return override.OverrideExtractCollectionName(typedMsg)
  1158  	}
  1159  	return nil
  1160  }
  1161  
  1162  func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1163  	typedMsg := msg.(*WatchLogDescriptorsResponse)
  1164  	var asInterface interface{} = h
  1165  	override, ok := asInterface.(interface {
  1166  		OverrideExtractResourceBody(*WatchLogDescriptorsResponse) *log_descriptor.LogDescriptor
  1167  	})
  1168  	if ok {
  1169  		return override.OverrideExtractResourceBody(typedMsg)
  1170  	}
  1171  	return nil
  1172  }
  1173  
  1174  func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1175  	typedMsg := msg.(*WatchLogDescriptorsResponse)
  1176  	var asInterface interface{} = h
  1177  	override, ok := asInterface.(interface {
  1178  		OverrideExtractResourceBodies(*WatchLogDescriptorsResponse) []*log_descriptor.LogDescriptor
  1179  	})
  1180  	if ok {
  1181  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1182  	}
  1183  	{
  1184  		if resChanges := typedMsg.GetLogDescriptorChanges(); len(resChanges) > 0 {
  1185  			list := make(log_descriptor.LogDescriptorList, 0, len(resChanges))
  1186  			for _, resChange := range resChanges {
  1187  				switch tResChange := resChange.ChangeType.(type) {
  1188  				case *log_descriptor.LogDescriptorChange_Added_:
  1189  					list = append(list, tResChange.Added.GetLogDescriptor())
  1190  				case *log_descriptor.LogDescriptorChange_Modified_:
  1191  					list = append(list, tResChange.Modified.GetLogDescriptor())
  1192  				case *log_descriptor.LogDescriptorChange_Current_:
  1193  					list = append(list, tResChange.Current.GetLogDescriptor())
  1194  				}
  1195  			}
  1196  			return list
  1197  		}
  1198  	}
  1199  	return (log_descriptor.LogDescriptorList)(nil)
  1200  }
  1201  
  1202  func GetWatchLogDescriptorsDescriptor() *WatchLogDescriptorsDescriptor {
  1203  	return watchLogDescriptorsDescriptor
  1204  }
  1205  
  1206  type CreateLogDescriptorDescriptor struct{}
  1207  
  1208  type CreateLogDescriptorDescriptorClientMsgHandle struct{}
  1209  
  1210  type CreateLogDescriptorDescriptorServerMsgHandle struct{}
  1211  
  1212  func (d *CreateLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
  1213  	return &CreateLogDescriptorRequest{}
  1214  }
  1215  
  1216  func (d *CreateLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
  1217  	return &log_descriptor.LogDescriptor{}
  1218  }
  1219  
  1220  func (d *CreateLogDescriptorDescriptor) IsUnary() bool {
  1221  	return true
  1222  }
  1223  
  1224  func (d *CreateLogDescriptorDescriptor) IsClientStream() bool {
  1225  	return false
  1226  }
  1227  
  1228  func (d *CreateLogDescriptorDescriptor) IsServerStream() bool {
  1229  	return false
  1230  }
  1231  
  1232  func (d *CreateLogDescriptorDescriptor) IsCollection() bool {
  1233  	return true
  1234  }
  1235  
  1236  func (d *CreateLogDescriptorDescriptor) IsPlural() bool {
  1237  	return false
  1238  }
  1239  
  1240  func (d *CreateLogDescriptorDescriptor) HasResource() bool {
  1241  	return true
  1242  }
  1243  
  1244  func (d *CreateLogDescriptorDescriptor) RequestHasResourceBody() bool {
  1245  	return true
  1246  }
  1247  
  1248  func (d *CreateLogDescriptorDescriptor) GetVerb() string {
  1249  	return "create"
  1250  }
  1251  
  1252  func (d *CreateLogDescriptorDescriptor) GetMethodName() string {
  1253  	return "CreateLogDescriptor"
  1254  }
  1255  
  1256  func (d *CreateLogDescriptorDescriptor) GetFullMethodName() string {
  1257  	return "/ntt.logging.v1alpha2.LogDescriptorService/CreateLogDescriptor"
  1258  }
  1259  
  1260  func (d *CreateLogDescriptorDescriptor) GetProtoPkgName() string {
  1261  	return "ntt.logging.v1alpha2"
  1262  }
  1263  
  1264  func (d *CreateLogDescriptorDescriptor) GetApiName() string {
  1265  	return "LogDescriptorService"
  1266  }
  1267  
  1268  func (d *CreateLogDescriptorDescriptor) GetServiceDomain() string {
  1269  	return "logging.edgelq.com"
  1270  }
  1271  
  1272  func (d *CreateLogDescriptorDescriptor) GetServiceVersion() string {
  1273  	return "v1alpha2"
  1274  }
  1275  
  1276  func (d *CreateLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1277  	return logDescriptorServiceDescriptor
  1278  }
  1279  
  1280  func (d *CreateLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1281  	return log_descriptor.GetDescriptor()
  1282  }
  1283  
  1284  func (d *CreateLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1285  	return &CreateLogDescriptorDescriptorClientMsgHandle{}
  1286  }
  1287  
  1288  func (d *CreateLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1289  	return &CreateLogDescriptorDescriptorServerMsgHandle{}
  1290  }
  1291  
  1292  func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1293  	typedMsg := msg.(*CreateLogDescriptorRequest)
  1294  	var asInterface interface{} = h
  1295  	override, ok := asInterface.(interface {
  1296  		OverrideExtractResourceName(*CreateLogDescriptorRequest) *log_descriptor.Name
  1297  	})
  1298  	if ok {
  1299  		return override.OverrideExtractResourceName(typedMsg)
  1300  	}
  1301  	{
  1302  		res := typedMsg.GetLogDescriptor()
  1303  		if name := res.GetName(); name != nil {
  1304  			return name
  1305  		}
  1306  	}
  1307  	return (*log_descriptor.Name)(nil)
  1308  }
  1309  
  1310  func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1311  	typedMsg := msg.(*CreateLogDescriptorRequest)
  1312  	var asInterface interface{} = h
  1313  	override, ok := asInterface.(interface {
  1314  		OverrideExtractResourceNames(*CreateLogDescriptorRequest) []*log_descriptor.Name
  1315  	})
  1316  	if ok {
  1317  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1318  	}
  1319  	return nil
  1320  }
  1321  
  1322  func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1323  	typedMsg := msg.(*CreateLogDescriptorRequest)
  1324  	var asInterface interface{} = h
  1325  	override, ok := asInterface.(interface {
  1326  		OverrideExtractCollectionName(*CreateLogDescriptorRequest) *log_descriptor.ParentName
  1327  	})
  1328  	if ok {
  1329  		return override.OverrideExtractCollectionName(typedMsg)
  1330  	}
  1331  	{
  1332  		if parentName := typedMsg.GetParent(); parentName != nil {
  1333  			return parentName
  1334  		}
  1335  	}
  1336  	return (*log_descriptor.ParentName)(nil)
  1337  }
  1338  
  1339  func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1340  	typedMsg := msg.(*CreateLogDescriptorRequest)
  1341  	var asInterface interface{} = h
  1342  	override, ok := asInterface.(interface {
  1343  		OverrideExtractResourceBody(*CreateLogDescriptorRequest) *log_descriptor.LogDescriptor
  1344  	})
  1345  	if ok {
  1346  		return override.OverrideExtractResourceBody(typedMsg)
  1347  	}
  1348  	{
  1349  		return typedMsg.GetLogDescriptor()
  1350  	}
  1351  	return (*log_descriptor.LogDescriptor)(nil)
  1352  }
  1353  
  1354  func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1355  	typedMsg := msg.(*CreateLogDescriptorRequest)
  1356  	var asInterface interface{} = h
  1357  	override, ok := asInterface.(interface {
  1358  		OverrideExtractResourceBodies(*CreateLogDescriptorRequest) []*log_descriptor.LogDescriptor
  1359  	})
  1360  	if ok {
  1361  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1362  	}
  1363  	return nil
  1364  }
  1365  
  1366  func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1367  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1368  	var asInterface interface{} = h
  1369  	override, ok := asInterface.(interface {
  1370  		OverrideExtractResourceName(*log_descriptor.LogDescriptor) *log_descriptor.Name
  1371  	})
  1372  	if ok {
  1373  		return override.OverrideExtractResourceName(typedMsg)
  1374  	}
  1375  	{
  1376  		if name := typedMsg.GetName(); name != nil {
  1377  			return name
  1378  		}
  1379  	}
  1380  	return (*log_descriptor.Name)(nil)
  1381  }
  1382  
  1383  func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1384  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1385  	var asInterface interface{} = h
  1386  	override, ok := asInterface.(interface {
  1387  		OverrideExtractResourceNames(*log_descriptor.LogDescriptor) []*log_descriptor.Name
  1388  	})
  1389  	if ok {
  1390  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1391  	}
  1392  	return nil
  1393  }
  1394  
  1395  func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1396  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1397  	var asInterface interface{} = h
  1398  	override, ok := asInterface.(interface {
  1399  		OverrideExtractCollectionName(*log_descriptor.LogDescriptor) *log_descriptor.ParentName
  1400  	})
  1401  	if ok {
  1402  		return override.OverrideExtractCollectionName(typedMsg)
  1403  	}
  1404  	return nil
  1405  }
  1406  
  1407  func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1408  	return msg.(*log_descriptor.LogDescriptor)
  1409  }
  1410  
  1411  func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1412  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1413  	var asInterface interface{} = h
  1414  	override, ok := asInterface.(interface {
  1415  		OverrideExtractResourceBodies(*log_descriptor.LogDescriptor) []*log_descriptor.LogDescriptor
  1416  	})
  1417  	if ok {
  1418  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1419  	}
  1420  	return nil
  1421  }
  1422  
  1423  func GetCreateLogDescriptorDescriptor() *CreateLogDescriptorDescriptor {
  1424  	return createLogDescriptorDescriptor
  1425  }
  1426  
  1427  type UpdateLogDescriptorDescriptor struct{}
  1428  
  1429  type UpdateLogDescriptorDescriptorClientMsgHandle struct{}
  1430  
  1431  type UpdateLogDescriptorDescriptorServerMsgHandle struct{}
  1432  
  1433  func (d *UpdateLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
  1434  	return &UpdateLogDescriptorRequest{}
  1435  }
  1436  
  1437  func (d *UpdateLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
  1438  	return &log_descriptor.LogDescriptor{}
  1439  }
  1440  
  1441  func (d *UpdateLogDescriptorDescriptor) IsUnary() bool {
  1442  	return true
  1443  }
  1444  
  1445  func (d *UpdateLogDescriptorDescriptor) IsClientStream() bool {
  1446  	return false
  1447  }
  1448  
  1449  func (d *UpdateLogDescriptorDescriptor) IsServerStream() bool {
  1450  	return false
  1451  }
  1452  
  1453  func (d *UpdateLogDescriptorDescriptor) IsCollection() bool {
  1454  	return false
  1455  }
  1456  
  1457  func (d *UpdateLogDescriptorDescriptor) IsPlural() bool {
  1458  	return false
  1459  }
  1460  
  1461  func (d *UpdateLogDescriptorDescriptor) HasResource() bool {
  1462  	return true
  1463  }
  1464  
  1465  func (d *UpdateLogDescriptorDescriptor) RequestHasResourceBody() bool {
  1466  	return true
  1467  }
  1468  
  1469  func (d *UpdateLogDescriptorDescriptor) GetVerb() string {
  1470  	return "update"
  1471  }
  1472  
  1473  func (d *UpdateLogDescriptorDescriptor) GetMethodName() string {
  1474  	return "UpdateLogDescriptor"
  1475  }
  1476  
  1477  func (d *UpdateLogDescriptorDescriptor) GetFullMethodName() string {
  1478  	return "/ntt.logging.v1alpha2.LogDescriptorService/UpdateLogDescriptor"
  1479  }
  1480  
  1481  func (d *UpdateLogDescriptorDescriptor) GetProtoPkgName() string {
  1482  	return "ntt.logging.v1alpha2"
  1483  }
  1484  
  1485  func (d *UpdateLogDescriptorDescriptor) GetApiName() string {
  1486  	return "LogDescriptorService"
  1487  }
  1488  
  1489  func (d *UpdateLogDescriptorDescriptor) GetServiceDomain() string {
  1490  	return "logging.edgelq.com"
  1491  }
  1492  
  1493  func (d *UpdateLogDescriptorDescriptor) GetServiceVersion() string {
  1494  	return "v1alpha2"
  1495  }
  1496  
  1497  func (d *UpdateLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1498  	return logDescriptorServiceDescriptor
  1499  }
  1500  
  1501  func (d *UpdateLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1502  	return log_descriptor.GetDescriptor()
  1503  }
  1504  
  1505  func (d *UpdateLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1506  	return &UpdateLogDescriptorDescriptorClientMsgHandle{}
  1507  }
  1508  
  1509  func (d *UpdateLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1510  	return &UpdateLogDescriptorDescriptorServerMsgHandle{}
  1511  }
  1512  
  1513  func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1514  	typedMsg := msg.(*UpdateLogDescriptorRequest)
  1515  	var asInterface interface{} = h
  1516  	override, ok := asInterface.(interface {
  1517  		OverrideExtractResourceName(*UpdateLogDescriptorRequest) *log_descriptor.Name
  1518  	})
  1519  	if ok {
  1520  		return override.OverrideExtractResourceName(typedMsg)
  1521  	}
  1522  	{
  1523  		res := typedMsg.GetLogDescriptor()
  1524  		if name := res.GetName(); name != nil {
  1525  			return name
  1526  		}
  1527  	}
  1528  	return (*log_descriptor.Name)(nil)
  1529  }
  1530  
  1531  func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1532  	typedMsg := msg.(*UpdateLogDescriptorRequest)
  1533  	var asInterface interface{} = h
  1534  	override, ok := asInterface.(interface {
  1535  		OverrideExtractResourceNames(*UpdateLogDescriptorRequest) []*log_descriptor.Name
  1536  	})
  1537  	if ok {
  1538  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1539  	}
  1540  	return nil
  1541  }
  1542  
  1543  func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1544  	typedMsg := msg.(*UpdateLogDescriptorRequest)
  1545  	var asInterface interface{} = h
  1546  	override, ok := asInterface.(interface {
  1547  		OverrideExtractCollectionName(*UpdateLogDescriptorRequest) *log_descriptor.ParentName
  1548  	})
  1549  	if ok {
  1550  		return override.OverrideExtractCollectionName(typedMsg)
  1551  	}
  1552  	return nil
  1553  }
  1554  
  1555  func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1556  	typedMsg := msg.(*UpdateLogDescriptorRequest)
  1557  	var asInterface interface{} = h
  1558  	override, ok := asInterface.(interface {
  1559  		OverrideExtractResourceBody(*UpdateLogDescriptorRequest) *log_descriptor.LogDescriptor
  1560  	})
  1561  	if ok {
  1562  		return override.OverrideExtractResourceBody(typedMsg)
  1563  	}
  1564  	{
  1565  		return typedMsg.GetLogDescriptor()
  1566  	}
  1567  	return (*log_descriptor.LogDescriptor)(nil)
  1568  }
  1569  
  1570  func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1571  	typedMsg := msg.(*UpdateLogDescriptorRequest)
  1572  	var asInterface interface{} = h
  1573  	override, ok := asInterface.(interface {
  1574  		OverrideExtractResourceBodies(*UpdateLogDescriptorRequest) []*log_descriptor.LogDescriptor
  1575  	})
  1576  	if ok {
  1577  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1578  	}
  1579  	return nil
  1580  }
  1581  
  1582  func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1583  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1584  	var asInterface interface{} = h
  1585  	override, ok := asInterface.(interface {
  1586  		OverrideExtractResourceName(*log_descriptor.LogDescriptor) *log_descriptor.Name
  1587  	})
  1588  	if ok {
  1589  		return override.OverrideExtractResourceName(typedMsg)
  1590  	}
  1591  	{
  1592  		if name := typedMsg.GetName(); name != nil {
  1593  			return name
  1594  		}
  1595  	}
  1596  	return (*log_descriptor.Name)(nil)
  1597  }
  1598  
  1599  func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1600  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1601  	var asInterface interface{} = h
  1602  	override, ok := asInterface.(interface {
  1603  		OverrideExtractResourceNames(*log_descriptor.LogDescriptor) []*log_descriptor.Name
  1604  	})
  1605  	if ok {
  1606  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1607  	}
  1608  	return nil
  1609  }
  1610  
  1611  func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1612  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1613  	var asInterface interface{} = h
  1614  	override, ok := asInterface.(interface {
  1615  		OverrideExtractCollectionName(*log_descriptor.LogDescriptor) *log_descriptor.ParentName
  1616  	})
  1617  	if ok {
  1618  		return override.OverrideExtractCollectionName(typedMsg)
  1619  	}
  1620  	return nil
  1621  }
  1622  
  1623  func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1624  	return msg.(*log_descriptor.LogDescriptor)
  1625  }
  1626  
  1627  func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1628  	typedMsg := msg.(*log_descriptor.LogDescriptor)
  1629  	var asInterface interface{} = h
  1630  	override, ok := asInterface.(interface {
  1631  		OverrideExtractResourceBodies(*log_descriptor.LogDescriptor) []*log_descriptor.LogDescriptor
  1632  	})
  1633  	if ok {
  1634  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1635  	}
  1636  	return nil
  1637  }
  1638  
  1639  func GetUpdateLogDescriptorDescriptor() *UpdateLogDescriptorDescriptor {
  1640  	return updateLogDescriptorDescriptor
  1641  }
  1642  
  1643  type DeleteLogDescriptorDescriptor struct{}
  1644  
  1645  type DeleteLogDescriptorDescriptorClientMsgHandle struct{}
  1646  
  1647  type DeleteLogDescriptorDescriptorServerMsgHandle struct{}
  1648  
  1649  func (d *DeleteLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
  1650  	return &DeleteLogDescriptorRequest{}
  1651  }
  1652  
  1653  func (d *DeleteLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
  1654  	return &emptypb.Empty{}
  1655  }
  1656  
  1657  func (d *DeleteLogDescriptorDescriptor) IsUnary() bool {
  1658  	return true
  1659  }
  1660  
  1661  func (d *DeleteLogDescriptorDescriptor) IsClientStream() bool {
  1662  	return false
  1663  }
  1664  
  1665  func (d *DeleteLogDescriptorDescriptor) IsServerStream() bool {
  1666  	return false
  1667  }
  1668  
  1669  func (d *DeleteLogDescriptorDescriptor) IsCollection() bool {
  1670  	return false
  1671  }
  1672  
  1673  func (d *DeleteLogDescriptorDescriptor) IsPlural() bool {
  1674  	return false
  1675  }
  1676  
  1677  func (d *DeleteLogDescriptorDescriptor) HasResource() bool {
  1678  	return true
  1679  }
  1680  
  1681  func (d *DeleteLogDescriptorDescriptor) RequestHasResourceBody() bool {
  1682  	return false
  1683  }
  1684  
  1685  func (d *DeleteLogDescriptorDescriptor) GetVerb() string {
  1686  	return "delete"
  1687  }
  1688  
  1689  func (d *DeleteLogDescriptorDescriptor) GetMethodName() string {
  1690  	return "DeleteLogDescriptor"
  1691  }
  1692  
  1693  func (d *DeleteLogDescriptorDescriptor) GetFullMethodName() string {
  1694  	return "/ntt.logging.v1alpha2.LogDescriptorService/DeleteLogDescriptor"
  1695  }
  1696  
  1697  func (d *DeleteLogDescriptorDescriptor) GetProtoPkgName() string {
  1698  	return "ntt.logging.v1alpha2"
  1699  }
  1700  
  1701  func (d *DeleteLogDescriptorDescriptor) GetApiName() string {
  1702  	return "LogDescriptorService"
  1703  }
  1704  
  1705  func (d *DeleteLogDescriptorDescriptor) GetServiceDomain() string {
  1706  	return "logging.edgelq.com"
  1707  }
  1708  
  1709  func (d *DeleteLogDescriptorDescriptor) GetServiceVersion() string {
  1710  	return "v1alpha2"
  1711  }
  1712  
  1713  func (d *DeleteLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1714  	return logDescriptorServiceDescriptor
  1715  }
  1716  
  1717  func (d *DeleteLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1718  	return log_descriptor.GetDescriptor()
  1719  }
  1720  
  1721  func (d *DeleteLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1722  	return &DeleteLogDescriptorDescriptorClientMsgHandle{}
  1723  }
  1724  
  1725  func (d *DeleteLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1726  	return &DeleteLogDescriptorDescriptorServerMsgHandle{}
  1727  }
  1728  
  1729  func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1730  	typedMsg := msg.(*DeleteLogDescriptorRequest)
  1731  	var asInterface interface{} = h
  1732  	override, ok := asInterface.(interface {
  1733  		OverrideExtractResourceName(*DeleteLogDescriptorRequest) *log_descriptor.Name
  1734  	})
  1735  	if ok {
  1736  		return override.OverrideExtractResourceName(typedMsg)
  1737  	}
  1738  	{
  1739  		if name := typedMsg.GetName(); name != nil {
  1740  			return name
  1741  		}
  1742  	}
  1743  	return (*log_descriptor.Name)(nil)
  1744  }
  1745  
  1746  func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1747  	typedMsg := msg.(*DeleteLogDescriptorRequest)
  1748  	var asInterface interface{} = h
  1749  	override, ok := asInterface.(interface {
  1750  		OverrideExtractResourceNames(*DeleteLogDescriptorRequest) []*log_descriptor.Name
  1751  	})
  1752  	if ok {
  1753  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1754  	}
  1755  	return nil
  1756  }
  1757  
  1758  func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1759  	typedMsg := msg.(*DeleteLogDescriptorRequest)
  1760  	var asInterface interface{} = h
  1761  	override, ok := asInterface.(interface {
  1762  		OverrideExtractCollectionName(*DeleteLogDescriptorRequest) *log_descriptor.ParentName
  1763  	})
  1764  	if ok {
  1765  		return override.OverrideExtractCollectionName(typedMsg)
  1766  	}
  1767  	return nil
  1768  }
  1769  
  1770  func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1771  	typedMsg := msg.(*DeleteLogDescriptorRequest)
  1772  	var asInterface interface{} = h
  1773  	override, ok := asInterface.(interface {
  1774  		OverrideExtractResourceBody(*DeleteLogDescriptorRequest) *log_descriptor.LogDescriptor
  1775  	})
  1776  	if ok {
  1777  		return override.OverrideExtractResourceBody(typedMsg)
  1778  	}
  1779  	return nil
  1780  }
  1781  
  1782  func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1783  	typedMsg := msg.(*DeleteLogDescriptorRequest)
  1784  	var asInterface interface{} = h
  1785  	override, ok := asInterface.(interface {
  1786  		OverrideExtractResourceBodies(*DeleteLogDescriptorRequest) []*log_descriptor.LogDescriptor
  1787  	})
  1788  	if ok {
  1789  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1790  	}
  1791  	return nil
  1792  }
  1793  
  1794  func (h *DeleteLogDescriptorDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1795  	typedMsg := msg.(*emptypb.Empty)
  1796  	var asInterface interface{} = h
  1797  	override, ok := asInterface.(interface {
  1798  		OverrideExtractResourceName(*emptypb.Empty) *log_descriptor.Name
  1799  	})
  1800  	if ok {
  1801  		return override.OverrideExtractResourceName(typedMsg)
  1802  	}
  1803  	return nil
  1804  }
  1805  
  1806  func (h *DeleteLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1807  	typedMsg := msg.(*emptypb.Empty)
  1808  	var asInterface interface{} = h
  1809  	override, ok := asInterface.(interface {
  1810  		OverrideExtractResourceNames(*emptypb.Empty) []*log_descriptor.Name
  1811  	})
  1812  	if ok {
  1813  		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
  1814  	}
  1815  	return nil
  1816  }
  1817  
  1818  func (h *DeleteLogDescriptorDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1819  	typedMsg := msg.(*emptypb.Empty)
  1820  	var asInterface interface{} = h
  1821  	override, ok := asInterface.(interface {
  1822  		OverrideExtractCollectionName(*emptypb.Empty) *log_descriptor.ParentName
  1823  	})
  1824  	if ok {
  1825  		return override.OverrideExtractCollectionName(typedMsg)
  1826  	}
  1827  	return nil
  1828  }
  1829  
  1830  func (h *DeleteLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1831  	typedMsg := msg.(*emptypb.Empty)
  1832  	var asInterface interface{} = h
  1833  	override, ok := asInterface.(interface {
  1834  		OverrideExtractResourceBody(*emptypb.Empty) *log_descriptor.LogDescriptor
  1835  	})
  1836  	if ok {
  1837  		return override.OverrideExtractResourceBody(typedMsg)
  1838  	}
  1839  	return nil
  1840  }
  1841  
  1842  func (h *DeleteLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1843  	typedMsg := msg.(*emptypb.Empty)
  1844  	var asInterface interface{} = h
  1845  	override, ok := asInterface.(interface {
  1846  		OverrideExtractResourceBodies(*emptypb.Empty) []*log_descriptor.LogDescriptor
  1847  	})
  1848  	if ok {
  1849  		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
  1850  	}
  1851  	return nil
  1852  }
  1853  
  1854  func GetDeleteLogDescriptorDescriptor() *DeleteLogDescriptorDescriptor {
  1855  	return deleteLogDescriptorDescriptor
  1856  }
  1857  
  1858  type LogDescriptorServiceDescriptor struct{}
  1859  
  1860  func (d *LogDescriptorServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
  1861  	return []gotenclient.MethodDescriptor{
  1862  		getLogDescriptorDescriptor,
  1863  		batchGetLogDescriptorsDescriptor,
  1864  		listLogDescriptorsDescriptor,
  1865  		watchLogDescriptorDescriptor,
  1866  		watchLogDescriptorsDescriptor,
  1867  		createLogDescriptorDescriptor,
  1868  		updateLogDescriptorDescriptor,
  1869  		deleteLogDescriptorDescriptor,
  1870  	}
  1871  }
  1872  
  1873  func (d *LogDescriptorServiceDescriptor) GetFullAPIName() string {
  1874  	return "/ntt.logging.v1alpha2.LogDescriptorService"
  1875  }
  1876  
  1877  func (d *LogDescriptorServiceDescriptor) GetProtoPkgName() string {
  1878  	return "ntt.logging.v1alpha2"
  1879  }
  1880  
  1881  func (d *LogDescriptorServiceDescriptor) GetApiName() string {
  1882  	return "LogDescriptorService"
  1883  }
  1884  
  1885  func (d *LogDescriptorServiceDescriptor) GetServiceDomain() string {
  1886  	return "logging.edgelq.com"
  1887  }
  1888  
  1889  func (d *LogDescriptorServiceDescriptor) GetServiceVersion() string {
  1890  	return "v1alpha2"
  1891  }
  1892  
  1893  func GetLogDescriptorServiceDescriptor() *LogDescriptorServiceDescriptor {
  1894  	return logDescriptorServiceDescriptor
  1895  }
  1896  
  1897  func initDescriptors() {
  1898  	logDescriptorServiceDescriptor = &LogDescriptorServiceDescriptor{}
  1899  	getLogDescriptorDescriptor = &GetLogDescriptorDescriptor{}
  1900  	batchGetLogDescriptorsDescriptor = &BatchGetLogDescriptorsDescriptor{}
  1901  	listLogDescriptorsDescriptor = &ListLogDescriptorsDescriptor{}
  1902  	watchLogDescriptorDescriptor = &WatchLogDescriptorDescriptor{}
  1903  	watchLogDescriptorsDescriptor = &WatchLogDescriptorsDescriptor{}
  1904  	createLogDescriptorDescriptor = &CreateLogDescriptorDescriptor{}
  1905  	updateLogDescriptorDescriptor = &UpdateLogDescriptorDescriptor{}
  1906  	deleteLogDescriptorDescriptor = &DeleteLogDescriptorDescriptor{}
  1907  	gotenclient.GetRegistry().RegisterApiDescriptor(logDescriptorServiceDescriptor)
  1908  	gotenclient.GetRegistry().RegisterMethodDescriptor(getLogDescriptorDescriptor)
  1909  	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetLogDescriptorsDescriptor)
  1910  	gotenclient.GetRegistry().RegisterMethodDescriptor(listLogDescriptorsDescriptor)
  1911  	gotenclient.GetRegistry().RegisterMethodDescriptor(watchLogDescriptorDescriptor)
  1912  	gotenclient.GetRegistry().RegisterMethodDescriptor(watchLogDescriptorsDescriptor)
  1913  	gotenclient.GetRegistry().RegisterMethodDescriptor(createLogDescriptorDescriptor)
  1914  	gotenclient.GetRegistry().RegisterMethodDescriptor(updateLogDescriptorDescriptor)
  1915  	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteLogDescriptorDescriptor)
  1916  }
  1917  
  1918  func init() {
  1919  	if !descriptorsInitialized {
  1920  		initDescriptors()
  1921  		descriptorsInitialized = true
  1922  	}
  1923  }