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         "io"
   9
  10         api "go.fd.io/govpp/api"
  11         memclnt "go.fd.io/govpp/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service sr.
  15 type RPCService interface {
  16         SrLocalsidAddDel(ctx context.Context, in *SrLocalsidAddDel) (*SrLocalsidAddDelReply, error)
  17         SrLocalsidsDump(ctx context.Context, in *SrLocalsidsDump) (RPCService_SrLocalsidsDumpClient, error)
  18         SrPoliciesDump(ctx context.Context, in *SrPoliciesDump) (RPCService_SrPoliciesDumpClient, error)
  19         SrPoliciesWithSlIndexDump(ctx context.Context, in *SrPoliciesWithSlIndexDump) (RPCService_SrPoliciesWithSlIndexDumpClient, error)
  20         SrPolicyAdd(ctx context.Context, in *SrPolicyAdd) (*SrPolicyAddReply, error)
  21         SrPolicyDel(ctx context.Context, in *SrPolicyDel) (*SrPolicyDelReply, error)
  22         SrPolicyMod(ctx context.Context, in *SrPolicyMod) (*SrPolicyModReply, error)
  23         SrSetEncapHopLimit(ctx context.Context, in *SrSetEncapHopLimit) (*SrSetEncapHopLimitReply, error)
  24         SrSetEncapSource(ctx context.Context, in *SrSetEncapSource) (*SrSetEncapSourceReply, error)
  25         SrSteeringAddDel(ctx context.Context, in *SrSteeringAddDel) (*SrSteeringAddDelReply, error)
  26         SrSteeringPolDump(ctx context.Context, in *SrSteeringPolDump) (RPCService_SrSteeringPolDumpClient, error)
  27 }
  28
  29 type serviceClient struct {
  30         conn api.Connection
  31 }
  32
  33 func NewServiceClient(conn api.Connection) RPCService {
  34         return &serviceClient{conn}
  35 }
  36
  37 func (c *serviceClient) SrLocalsidAddDel(ctx context.Context, in *SrLocalsidAddDel) (*SrLocalsidAddDelReply, error) {
  38         out := new(SrLocalsidAddDelReply)
  39         err := c.conn.Invoke(ctx, in, out)
  40         if err != nil {
  41                 return nil, err
  42         }
  43         return out, api.RetvalToVPPApiError(out.Retval)
  44 }
  45
  46 func (c *serviceClient) SrLocalsidsDump(ctx context.Context, in *SrLocalsidsDump) (RPCService_SrLocalsidsDumpClient, error) {
  47         stream, err := c.conn.NewStream(ctx)
  48         if err != nil {
  49                 return nil, err
  50         }
  51         x := &serviceClient_SrLocalsidsDumpClient{stream}
  52         if err := x.Stream.SendMsg(in); err != nil {
  53                 return nil, err
  54         }
  55         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  56                 return nil, err
  57         }
  58         return x, nil
  59 }
  60
  61 type RPCService_SrLocalsidsDumpClient interface {
  62         Recv() (*SrLocalsidsDetails, error)
  63         api.Stream
  64 }
  65
  66 type serviceClient_SrLocalsidsDumpClient struct {
  67         api.Stream
  68 }
  69
  70 func (c *serviceClient_SrLocalsidsDumpClient) Recv() (*SrLocalsidsDetails, error) {
  71         msg, err := c.Stream.RecvMsg()
  72         if err != nil {
  73                 return nil, err
  74         }
  75         switch m := msg.(type) {
  76         case *SrLocalsidsDetails:
  77                 return m, nil
  78         case *memclnt.ControlPingReply:
  79                 err = c.Stream.Close()
  80                 if err != nil {
  81                         return nil, err
  82                 }
  83                 return nil, io.EOF
  84         default:
  85                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  86         }
  87 }
  88
  89 func (c *serviceClient) SrPoliciesDump(ctx context.Context, in *SrPoliciesDump) (RPCService_SrPoliciesDumpClient, error) {
  90         stream, err := c.conn.NewStream(ctx)
  91         if err != nil {
  92                 return nil, err
  93         }
  94         x := &serviceClient_SrPoliciesDumpClient{stream}
  95         if err := x.Stream.SendMsg(in); err != nil {
  96                 return nil, err
  97         }
  98         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  99                 return nil, err
 100         }
 101         return x, nil
 102 }
 103
 104 type RPCService_SrPoliciesDumpClient interface {
 105         Recv() (*SrPoliciesDetails, error)
 106         api.Stream
 107 }
 108
 109 type serviceClient_SrPoliciesDumpClient struct {
 110         api.Stream
 111 }
 112
 113 func (c *serviceClient_SrPoliciesDumpClient) Recv() (*SrPoliciesDetails, error) {
 114         msg, err := c.Stream.RecvMsg()
 115         if err != nil {
 116                 return nil, err
 117         }
 118         switch m := msg.(type) {
 119         case *SrPoliciesDetails:
 120                 return m, nil
 121         case *memclnt.ControlPingReply:
 122                 err = c.Stream.Close()
 123                 if err != nil {
 124                         return nil, err
 125                 }
 126                 return nil, io.EOF
 127         default:
 128                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 129         }
 130 }
 131
 132 func (c *serviceClient) SrPoliciesWithSlIndexDump(ctx context.Context, in *SrPoliciesWithSlIndexDump) (RPCService_SrPoliciesWithSlIndexDumpClient, error) {
 133         stream, err := c.conn.NewStream(ctx)
 134         if err != nil {
 135                 return nil, err
 136         }
 137         x := &serviceClient_SrPoliciesWithSlIndexDumpClient{stream}
 138         if err := x.Stream.SendMsg(in); err != nil {
 139                 return nil, err
 140         }
 141         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 142                 return nil, err
 143         }
 144         return x, nil
 145 }
 146
 147 type RPCService_SrPoliciesWithSlIndexDumpClient interface {
 148         Recv() (*SrPoliciesWithSlIndexDetails, error)
 149         api.Stream
 150 }
 151
 152 type serviceClient_SrPoliciesWithSlIndexDumpClient struct {
 153         api.Stream
 154 }
 155
 156 func (c *serviceClient_SrPoliciesWithSlIndexDumpClient) Recv() (*SrPoliciesWithSlIndexDetails, error) {
 157         msg, err := c.Stream.RecvMsg()
 158         if err != nil {
 159                 return nil, err
 160         }
 161         switch m := msg.(type) {
 162         case *SrPoliciesWithSlIndexDetails:
 163                 return m, nil
 164         case *memclnt.ControlPingReply:
 165                 err = c.Stream.Close()
 166                 if err != nil {
 167                         return nil, err
 168                 }
 169                 return nil, io.EOF
 170         default:
 171                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 172         }
 173 }
 174
 175 func (c *serviceClient) SrPolicyAdd(ctx context.Context, in *SrPolicyAdd) (*SrPolicyAddReply, error) {
 176         out := new(SrPolicyAddReply)
 177         err := c.conn.Invoke(ctx, in, out)
 178         if err != nil {
 179                 return nil, err
 180         }
 181         return out, api.RetvalToVPPApiError(out.Retval)
 182 }
 183
 184 func (c *serviceClient) SrPolicyDel(ctx context.Context, in *SrPolicyDel) (*SrPolicyDelReply, error) {
 185         out := new(SrPolicyDelReply)
 186         err := c.conn.Invoke(ctx, in, out)
 187         if err != nil {
 188                 return nil, err
 189         }
 190         return out, api.RetvalToVPPApiError(out.Retval)
 191 }
 192
 193 func (c *serviceClient) SrPolicyMod(ctx context.Context, in *SrPolicyMod) (*SrPolicyModReply, error) {
 194         out := new(SrPolicyModReply)
 195         err := c.conn.Invoke(ctx, in, out)
 196         if err != nil {
 197                 return nil, err
 198         }
 199         return out, api.RetvalToVPPApiError(out.Retval)
 200 }
 201
 202 func (c *serviceClient) SrSetEncapHopLimit(ctx context.Context, in *SrSetEncapHopLimit) (*SrSetEncapHopLimitReply, error) {
 203         out := new(SrSetEncapHopLimitReply)
 204         err := c.conn.Invoke(ctx, in, out)
 205         if err != nil {
 206                 return nil, err
 207         }
 208         return out, api.RetvalToVPPApiError(out.Retval)
 209 }
 210
 211 func (c *serviceClient) SrSetEncapSource(ctx context.Context, in *SrSetEncapSource) (*SrSetEncapSourceReply, error) {
 212         out := new(SrSetEncapSourceReply)
 213         err := c.conn.Invoke(ctx, in, out)
 214         if err != nil {
 215                 return nil, err
 216         }
 217         return out, api.RetvalToVPPApiError(out.Retval)
 218 }
 219
 220 func (c *serviceClient) SrSteeringAddDel(ctx context.Context, in *SrSteeringAddDel) (*SrSteeringAddDelReply, error) {
 221         out := new(SrSteeringAddDelReply)
 222         err := c.conn.Invoke(ctx, in, out)
 223         if err != nil {
 224                 return nil, err
 225         }
 226         return out, api.RetvalToVPPApiError(out.Retval)
 227 }
 228
 229 func (c *serviceClient) SrSteeringPolDump(ctx context.Context, in *SrSteeringPolDump) (RPCService_SrSteeringPolDumpClient, error) {
 230         stream, err := c.conn.NewStream(ctx)
 231         if err != nil {
 232                 return nil, err
 233         }
 234         x := &serviceClient_SrSteeringPolDumpClient{stream}
 235         if err := x.Stream.SendMsg(in); err != nil {
 236                 return nil, err
 237         }
 238         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 239                 return nil, err
 240         }
 241         return x, nil
 242 }
 243
 244 type RPCService_SrSteeringPolDumpClient interface {
 245         Recv() (*SrSteeringPolDetails, error)
 246         api.Stream
 247 }
 248
 249 type serviceClient_SrSteeringPolDumpClient struct {
 250         api.Stream
 251 }
 252
 253 func (c *serviceClient_SrSteeringPolDumpClient) Recv() (*SrSteeringPolDetails, error) {
 254         msg, err := c.Stream.RecvMsg()
 255         if err != nil {
 256                 return nil, err
 257         }
 258         switch m := msg.(type) {
 259         case *SrSteeringPolDetails:
 260                 return m, nil
 261         case *memclnt.ControlPingReply:
 262                 err = c.Stream.Close()
 263                 if err != nil {
 264                         return nil, err
 265                 }
 266                 return nil, io.EOF
 267         default:
 268                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 269         }
 270 }