node_contract.go

package v1

import (
	"errors"
	"fmt"
	vvc "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	types "k8s.io/apimachinery/pkg/types"
	"k8s.io/client-go/kubernetes/typed/core/v1"
)

/*autogenerated contract adapter*/

//NodeCreateRequest represents request
type NodeCreateRequest struct {
	service_ v1.NodeInterface
	*vvc.Node
}

//NodeUpdateRequest represents request
type NodeUpdateRequest struct {
	service_ v1.NodeInterface
	*vvc.Node
}

//NodeUpdateStatusRequest represents request
type NodeUpdateStatusRequest struct {
	service_ v1.NodeInterface
	*vvc.Node
}

//NodeDeleteRequest represents request
type NodeDeleteRequest struct {
	service_ v1.NodeInterface
	Name     string
	*metav1.DeleteOptions
}

//NodeDeleteCollectionRequest represents request
type NodeDeleteCollectionRequest struct {
	service_ v1.NodeInterface
	*metav1.DeleteOptions
	ListOptions metav1.ListOptions
}

//NodeGetRequest represents request
type NodeGetRequest struct {
	service_ v1.NodeInterface
	Name     string
	metav1.GetOptions
}

//NodeListRequest represents request
type NodeListRequest struct {
	service_ v1.NodeInterface
	metav1.ListOptions
}

//NodeWatchRequest represents request
type NodeWatchRequest struct {
	service_ v1.NodeInterface
	metav1.ListOptions
}

//NodePatchRequest represents request
type NodePatchRequest struct {
	service_     v1.NodeInterface
	Name         string
	Pt           types.PatchType
	Data         []byte
	Subresources []string
}

func init() {
	register(&NodeCreateRequest{})
	register(&NodeUpdateRequest{})
	register(&NodeUpdateStatusRequest{})
	register(&NodeDeleteRequest{})
	register(&NodeDeleteCollectionRequest{})
	register(&NodeGetRequest{})
	register(&NodeListRequest{})
	register(&NodeWatchRequest{})
	register(&NodePatchRequest{})
}

func (r *NodeCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.Create(r.Node)
	return result, err
}

func (r *NodeCreateRequest) GetId() string {
	return "v1.Node.Create"
}

func (r *NodeUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.Update(r.Node)
	return result, err
}

func (r *NodeUpdateRequest) GetId() string {
	return "v1.Node.Update"
}

func (r *NodeUpdateStatusRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeUpdateStatusRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.UpdateStatus(r.Node)
	return result, err
}

func (r *NodeUpdateStatusRequest) GetId() string {
	return "v1.Node.UpdateStatus"
}

func (r *NodeDeleteRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeDeleteRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.Delete(r.Name, r.DeleteOptions)
	return result, err
}

func (r *NodeDeleteRequest) GetId() string {
	return "v1.Node.Delete"
}

func (r *NodeDeleteCollectionRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeDeleteCollectionRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.DeleteCollection(r.DeleteOptions, r.ListOptions)
	return result, err
}

func (r *NodeDeleteCollectionRequest) GetId() string {
	return "v1.Node.DeleteCollection"
}

func (r *NodeGetRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeGetRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.Get(r.Name, r.GetOptions)
	return result, err
}

func (r *NodeGetRequest) GetId() string {
	return "v1.Node.Get"
}

func (r *NodeListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.List(r.ListOptions)
	return result, err
}

func (r *NodeListRequest) GetId() string {
	return "v1.Node.List"
}

func (r *NodeWatchRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodeWatchRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.Watch(r.ListOptions)
	return result, err
}

func (r *NodeWatchRequest) GetId() string {
	return "v1.Node.Watch"
}

func (r *NodePatchRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(v1.NodeInterface); !ok {
		return fmt.Errorf("invalid service type: %T, expected: v1.NodeInterface", service)
	}
	return nil
}

func (r *NodePatchRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.Patch(r.Name, r.Pt, r.Data, r.Subresources...)
	return result, err
}

func (r *NodePatchRequest) GetId() string {
	return "v1.Node.Patch"
}