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 "git.fd.io/govpp.git/api"
  11         vpe "git.fd.io/govpp.git/binapi/vpe"
  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(&vpe.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 *vpe.ControlPingReply:
  79                 return nil, io.EOF
  80         default:
  81                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  82         }
  83 }
  84
  85 func (c *serviceClient) SrPoliciesDump(ctx context.Context, in *SrPoliciesDump) (RPCService_SrPoliciesDumpClient, error) {
  86         stream, err := c.conn.NewStream(ctx)
  87         if err != nil {
  88                 return nil, err
  89         }
  90         x := &serviceClient_SrPoliciesDumpClient{stream}
  91         if err := x.Stream.SendMsg(in); err != nil {
  92                 return nil, err
  93         }
  94         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  95                 return nil, err
  96         }
  97         return x, nil
  98 }
  99
 100 type RPCService_SrPoliciesDumpClient interface {
 101         Recv() (*SrPoliciesDetails, error)
 102         api.Stream
 103 }
 104
 105 type serviceClient_SrPoliciesDumpClient struct {
 106         api.Stream
 107 }
 108
 109 func (c *serviceClient_SrPoliciesDumpClient) Recv() (*SrPoliciesDetails, error) {
 110         msg, err := c.Stream.RecvMsg()
 111         if err != nil {
 112                 return nil, err
 113         }
 114         switch m := msg.(type) {
 115         case *SrPoliciesDetails:
 116                 return m, nil
 117         case *vpe.ControlPingReply:
 118                 return nil, io.EOF
 119         default:
 120                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 121         }
 122 }
 123
 124 func (c *serviceClient) SrPoliciesWithSlIndexDump(ctx context.Context, in *SrPoliciesWithSlIndexDump) (RPCService_SrPoliciesWithSlIndexDumpClient, error) {
 125         stream, err := c.conn.NewStream(ctx)
 126         if err != nil {
 127                 return nil, err
 128         }
 129         x := &serviceClient_SrPoliciesWithSlIndexDumpClient{stream}
 130         if err := x.Stream.SendMsg(in); err != nil {
 131                 return nil, err
 132         }
 133         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 134                 return nil, err
 135         }
 136         return x, nil
 137 }
 138
 139 type RPCService_SrPoliciesWithSlIndexDumpClient interface {
 140         Recv() (*SrPoliciesWithSlIndexDetails, error)
 141         api.Stream
 142 }
 143
 144 type serviceClient_SrPoliciesWithSlIndexDumpClient struct {
 145         api.Stream
 146 }
 147
 148 func (c *serviceClient_SrPoliciesWithSlIndexDumpClient) Recv() (*SrPoliciesWithSlIndexDetails, error) {
 149         msg, err := c.Stream.RecvMsg()
 150         if err != nil {
 151                 return nil, err
 152         }
 153         switch m := msg.(type) {
 154         case *SrPoliciesWithSlIndexDetails:
 155                 return m, nil
 156         case *vpe.ControlPingReply:
 157                 return nil, io.EOF
 158         default:
 159                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 160         }
 161 }
 162
 163 func (c *serviceClient) SrPolicyAdd(ctx context.Context, in *SrPolicyAdd) (*SrPolicyAddReply, error) {
 164         out := new(SrPolicyAddReply)
 165         err := c.conn.Invoke(ctx, in, out)
 166         if err != nil {
 167                 return nil, err
 168         }
 169         return out, api.RetvalToVPPApiError(out.Retval)
 170 }
 171
 172 func (c *serviceClient) SrPolicyDel(ctx context.Context, in *SrPolicyDel) (*SrPolicyDelReply, error) {
 173         out := new(SrPolicyDelReply)
 174         err := c.conn.Invoke(ctx, in, out)
 175         if err != nil {
 176                 return nil, err
 177         }
 178         return out, api.RetvalToVPPApiError(out.Retval)
 179 }
 180
 181 func (c *serviceClient) SrPolicyMod(ctx context.Context, in *SrPolicyMod) (*SrPolicyModReply, error) {
 182         out := new(SrPolicyModReply)
 183         err := c.conn.Invoke(ctx, in, out)
 184         if err != nil {
 185                 return nil, err
 186         }
 187         return out, api.RetvalToVPPApiError(out.Retval)
 188 }
 189
 190 func (c *serviceClient) SrSetEncapHopLimit(ctx context.Context, in *SrSetEncapHopLimit) (*SrSetEncapHopLimitReply, error) {
 191         out := new(SrSetEncapHopLimitReply)
 192         err := c.conn.Invoke(ctx, in, out)
 193         if err != nil {
 194                 return nil, err
 195         }
 196         return out, api.RetvalToVPPApiError(out.Retval)
 197 }
 198
 199 func (c *serviceClient) SrSetEncapSource(ctx context.Context, in *SrSetEncapSource) (*SrSetEncapSourceReply, error) {
 200         out := new(SrSetEncapSourceReply)
 201         err := c.conn.Invoke(ctx, in, out)
 202         if err != nil {
 203                 return nil, err
 204         }
 205         return out, api.RetvalToVPPApiError(out.Retval)
 206 }
 207
 208 func (c *serviceClient) SrSteeringAddDel(ctx context.Context, in *SrSteeringAddDel) (*SrSteeringAddDelReply, error) {
 209         out := new(SrSteeringAddDelReply)
 210         err := c.conn.Invoke(ctx, in, out)
 211         if err != nil {
 212                 return nil, err
 213         }
 214         return out, api.RetvalToVPPApiError(out.Retval)
 215 }
 216
 217 func (c *serviceClient) SrSteeringPolDump(ctx context.Context, in *SrSteeringPolDump) (RPCService_SrSteeringPolDumpClient, error) {
 218         stream, err := c.conn.NewStream(ctx)
 219         if err != nil {
 220                 return nil, err
 221         }
 222         x := &serviceClient_SrSteeringPolDumpClient{stream}
 223         if err := x.Stream.SendMsg(in); err != nil {
 224                 return nil, err
 225         }
 226         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 227                 return nil, err
 228         }
 229         return x, nil
 230 }
 231
 232 type RPCService_SrSteeringPolDumpClient interface {
 233         Recv() (*SrSteeringPolDetails, error)
 234         api.Stream
 235 }
 236
 237 type serviceClient_SrSteeringPolDumpClient struct {
 238         api.Stream
 239 }
 240
 241 func (c *serviceClient_SrSteeringPolDumpClient) Recv() (*SrSteeringPolDetails, error) {
 242         msg, err := c.Stream.RecvMsg()
 243         if err != nil {
 244                 return nil, err
 245         }
 246         switch m := msg.(type) {
 247         case *SrSteeringPolDetails:
 248                 return m, nil
 249         case *vpe.ControlPingReply:
 250                 return nil, io.EOF
 251         default:
 252                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 253         }
 254 }