binapi/sr/sr_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package sr
   4
   5 import (
   6         "context"
   7         "fmt"
   8         api "git.fd.io/govpp.git/api"
   9         vpe "git.fd.io/govpp.git/binapi/vpe"
  10         "io"
  11 )
  12
  13 // RPCService defines RPC service  sr.
  14 type RPCService interface {
  15         SrLocalsidAddDel(ctx context.Context, in *SrLocalsidAddDel) (*SrLocalsidAddDelReply, error)
  16         SrLocalsidsDump(ctx context.Context, in *SrLocalsidsDump) (RPCService_SrLocalsidsDumpClient, error)
  17         SrPoliciesDump(ctx context.Context, in *SrPoliciesDump) (RPCService_SrPoliciesDumpClient, error)
  18         SrPolicyAdd(ctx context.Context, in *SrPolicyAdd) (*SrPolicyAddReply, error)
  19         SrPolicyDel(ctx context.Context, in *SrPolicyDel) (*SrPolicyDelReply, error)
  20         SrPolicyMod(ctx context.Context, in *SrPolicyMod) (*SrPolicyModReply, error)
  21         SrSetEncapHopLimit(ctx context.Context, in *SrSetEncapHopLimit) (*SrSetEncapHopLimitReply, error)
  22         SrSetEncapSource(ctx context.Context, in *SrSetEncapSource) (*SrSetEncapSourceReply, error)
  23         SrSteeringAddDel(ctx context.Context, in *SrSteeringAddDel) (*SrSteeringAddDelReply, error)
  24         SrSteeringPolDump(ctx context.Context, in *SrSteeringPolDump) (RPCService_SrSteeringPolDumpClient, error)
  25 }
  26
  27 type serviceClient struct {
  28         conn api.Connection
  29 }
  30
  31 func NewServiceClient(conn api.Connection) RPCService {
  32         return &serviceClient{conn}
  33 }
  34
  35 func (c *serviceClient) SrLocalsidAddDel(ctx context.Context, in *SrLocalsidAddDel) (*SrLocalsidAddDelReply, error) {
  36         out := new(SrLocalsidAddDelReply)
  37         err := c.conn.Invoke(ctx, in, out)
  38         if err != nil {
  39                 return nil, err
  40         }
  41         return out, nil
  42 }
  43
  44 func (c *serviceClient) SrLocalsidsDump(ctx context.Context, in *SrLocalsidsDump) (RPCService_SrLocalsidsDumpClient, error) {
  45         stream, err := c.conn.NewStream(ctx)
  46         if err != nil {
  47                 return nil, err
  48         }
  49         x := &serviceClient_SrLocalsidsDumpClient{stream}
  50         if err := x.Stream.SendMsg(in); err != nil {
  51                 return nil, err
  52         }
  53         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  54                 return nil, err
  55         }
  56         return x, nil
  57 }
  58
  59 type RPCService_SrLocalsidsDumpClient interface {
  60         Recv() (*SrLocalsidsDetails, error)
  61         api.Stream
  62 }
  63
  64 type serviceClient_SrLocalsidsDumpClient struct {
  65         api.Stream
  66 }
  67
  68 func (c *serviceClient_SrLocalsidsDumpClient) Recv() (*SrLocalsidsDetails, error) {
  69         msg, err := c.Stream.RecvMsg()
  70         if err != nil {
  71                 return nil, err
  72         }
  73         switch m := msg.(type) {
  74         case *SrLocalsidsDetails:
  75                 return m, nil
  76         case *vpe.ControlPingReply:
  77                 return nil, io.EOF
  78         default:
  79                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  80         }
  81 }
  82
  83 func (c *serviceClient) SrPoliciesDump(ctx context.Context, in *SrPoliciesDump) (RPCService_SrPoliciesDumpClient, error) {
  84         stream, err := c.conn.NewStream(ctx)
  85         if err != nil {
  86                 return nil, err
  87         }
  88         x := &serviceClient_SrPoliciesDumpClient{stream}
  89         if err := x.Stream.SendMsg(in); err != nil {
  90                 return nil, err
  91         }
  92         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  93                 return nil, err
  94         }
  95         return x, nil
  96 }
  97
  98 type RPCService_SrPoliciesDumpClient interface {
  99         Recv() (*SrPoliciesDetails, error)
 100         api.Stream
 101 }
 102
 103 type serviceClient_SrPoliciesDumpClient struct {
 104         api.Stream
 105 }
 106
 107 func (c *serviceClient_SrPoliciesDumpClient) Recv() (*SrPoliciesDetails, error) {
 108         msg, err := c.Stream.RecvMsg()
 109         if err != nil {
 110                 return nil, err
 111         }
 112         switch m := msg.(type) {
 113         case *SrPoliciesDetails:
 114                 return m, nil
 115         case *vpe.ControlPingReply:
 116                 return nil, io.EOF
 117         default:
 118                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 119         }
 120 }
 121
 122 func (c *serviceClient) SrPolicyAdd(ctx context.Context, in *SrPolicyAdd) (*SrPolicyAddReply, error) {
 123         out := new(SrPolicyAddReply)
 124         err := c.conn.Invoke(ctx, in, out)
 125         if err != nil {
 126                 return nil, err
 127         }
 128         return out, nil
 129 }
 130
 131 func (c *serviceClient) SrPolicyDel(ctx context.Context, in *SrPolicyDel) (*SrPolicyDelReply, error) {
 132         out := new(SrPolicyDelReply)
 133         err := c.conn.Invoke(ctx, in, out)
 134         if err != nil {
 135                 return nil, err
 136         }
 137         return out, nil
 138 }
 139
 140 func (c *serviceClient) SrPolicyMod(ctx context.Context, in *SrPolicyMod) (*SrPolicyModReply, error) {
 141         out := new(SrPolicyModReply)
 142         err := c.conn.Invoke(ctx, in, out)
 143         if err != nil {
 144                 return nil, err
 145         }
 146         return out, nil
 147 }
 148
 149 func (c *serviceClient) SrSetEncapHopLimit(ctx context.Context, in *SrSetEncapHopLimit) (*SrSetEncapHopLimitReply, error) {
 150         out := new(SrSetEncapHopLimitReply)
 151         err := c.conn.Invoke(ctx, in, out)
 152         if err != nil {
 153                 return nil, err
 154         }
 155         return out, nil
 156 }
 157
 158 func (c *serviceClient) SrSetEncapSource(ctx context.Context, in *SrSetEncapSource) (*SrSetEncapSourceReply, error) {
 159         out := new(SrSetEncapSourceReply)
 160         err := c.conn.Invoke(ctx, in, out)
 161         if err != nil {
 162                 return nil, err
 163         }
 164         return out, nil
 165 }
 166
 167 func (c *serviceClient) SrSteeringAddDel(ctx context.Context, in *SrSteeringAddDel) (*SrSteeringAddDelReply, error) {
 168         out := new(SrSteeringAddDelReply)
 169         err := c.conn.Invoke(ctx, in, out)
 170         if err != nil {
 171                 return nil, err
 172         }
 173         return out, nil
 174 }
 175
 176 func (c *serviceClient) SrSteeringPolDump(ctx context.Context, in *SrSteeringPolDump) (RPCService_SrSteeringPolDumpClient, error) {
 177         stream, err := c.conn.NewStream(ctx)
 178         if err != nil {
 179                 return nil, err
 180         }
 181         x := &serviceClient_SrSteeringPolDumpClient{stream}
 182         if err := x.Stream.SendMsg(in); err != nil {
 183                 return nil, err
 184         }
 185         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 186                 return nil, err
 187         }
 188         return x, nil
 189 }
 190
 191 type RPCService_SrSteeringPolDumpClient interface {
 192         Recv() (*SrSteeringPolDetails, error)
 193         api.Stream
 194 }
 195
 196 type serviceClient_SrSteeringPolDumpClient struct {
 197         api.Stream
 198 }
 199
 200 func (c *serviceClient_SrSteeringPolDumpClient) Recv() (*SrSteeringPolDetails, error) {
 201         msg, err := c.Stream.RecvMsg()
 202         if err != nil {
 203                 return nil, err
 204         }
 205         switch m := msg.(type) {
 206         case *SrSteeringPolDetails:
 207                 return m, nil
 208         case *vpe.ControlPingReply:
 209                 return nil, io.EOF
 210         default:
 211                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 212         }
 213 }