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