binapi/bier/bier_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package bier
   4
   5 import (
   6         "context"
   7         "fmt"
   8         "io"
   9
  10         api "git.fd.io/govpp.git/api"
  11         memclnt "git.fd.io/govpp.git/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service bier.
  15 type RPCService interface {
  16         BierDispEntryAddDel(ctx context.Context, in *BierDispEntryAddDel) (*BierDispEntryAddDelReply, error)
  17         BierDispEntryDump(ctx context.Context, in *BierDispEntryDump) (RPCService_BierDispEntryDumpClient, error)
  18         BierDispTableAddDel(ctx context.Context, in *BierDispTableAddDel) (*BierDispTableAddDelReply, error)
  19         BierDispTableDump(ctx context.Context, in *BierDispTableDump) (RPCService_BierDispTableDumpClient, error)
  20         BierImpAdd(ctx context.Context, in *BierImpAdd) (*BierImpAddReply, error)
  21         BierImpDel(ctx context.Context, in *BierImpDel) (*BierImpDelReply, error)
  22         BierImpDump(ctx context.Context, in *BierImpDump) (RPCService_BierImpDumpClient, error)
  23         BierRouteAddDel(ctx context.Context, in *BierRouteAddDel) (*BierRouteAddDelReply, error)
  24         BierRouteDump(ctx context.Context, in *BierRouteDump) (RPCService_BierRouteDumpClient, error)
  25         BierTableAddDel(ctx context.Context, in *BierTableAddDel) (*BierTableAddDelReply, error)
  26         BierTableDump(ctx context.Context, in *BierTableDump) (RPCService_BierTableDumpClient, 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) BierDispEntryAddDel(ctx context.Context, in *BierDispEntryAddDel) (*BierDispEntryAddDelReply, error) {
  38         out := new(BierDispEntryAddDelReply)
  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) BierDispEntryDump(ctx context.Context, in *BierDispEntryDump) (RPCService_BierDispEntryDumpClient, error) {
  47         stream, err := c.conn.NewStream(ctx)
  48         if err != nil {
  49                 return nil, err
  50         }
  51         x := &serviceClient_BierDispEntryDumpClient{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_BierDispEntryDumpClient interface {
  62         Recv() (*BierDispEntryDetails, error)
  63         api.Stream
  64 }
  65
  66 type serviceClient_BierDispEntryDumpClient struct {
  67         api.Stream
  68 }
  69
  70 func (c *serviceClient_BierDispEntryDumpClient) Recv() (*BierDispEntryDetails, error) {
  71         msg, err := c.Stream.RecvMsg()
  72         if err != nil {
  73                 return nil, err
  74         }
  75         switch m := msg.(type) {
  76         case *BierDispEntryDetails:
  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) BierDispTableAddDel(ctx context.Context, in *BierDispTableAddDel) (*BierDispTableAddDelReply, error) {
  90         out := new(BierDispTableAddDelReply)
  91         err := c.conn.Invoke(ctx, in, out)
  92         if err != nil {
  93                 return nil, err
  94         }
  95         return out, api.RetvalToVPPApiError(out.Retval)
  96 }
  97
  98 func (c *serviceClient) BierDispTableDump(ctx context.Context, in *BierDispTableDump) (RPCService_BierDispTableDumpClient, error) {
  99         stream, err := c.conn.NewStream(ctx)
 100         if err != nil {
 101                 return nil, err
 102         }
 103         x := &serviceClient_BierDispTableDumpClient{stream}
 104         if err := x.Stream.SendMsg(in); err != nil {
 105                 return nil, err
 106         }
 107         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 108                 return nil, err
 109         }
 110         return x, nil
 111 }
 112
 113 type RPCService_BierDispTableDumpClient interface {
 114         Recv() (*BierDispTableDetails, error)
 115         api.Stream
 116 }
 117
 118 type serviceClient_BierDispTableDumpClient struct {
 119         api.Stream
 120 }
 121
 122 func (c *serviceClient_BierDispTableDumpClient) Recv() (*BierDispTableDetails, error) {
 123         msg, err := c.Stream.RecvMsg()
 124         if err != nil {
 125                 return nil, err
 126         }
 127         switch m := msg.(type) {
 128         case *BierDispTableDetails:
 129                 return m, nil
 130         case *memclnt.ControlPingReply:
 131                 err = c.Stream.Close()
 132                 if err != nil {
 133                         return nil, err
 134                 }
 135                 return nil, io.EOF
 136         default:
 137                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 138         }
 139 }
 140
 141 func (c *serviceClient) BierImpAdd(ctx context.Context, in *BierImpAdd) (*BierImpAddReply, error) {
 142         out := new(BierImpAddReply)
 143         err := c.conn.Invoke(ctx, in, out)
 144         if err != nil {
 145                 return nil, err
 146         }
 147         return out, api.RetvalToVPPApiError(out.Retval)
 148 }
 149
 150 func (c *serviceClient) BierImpDel(ctx context.Context, in *BierImpDel) (*BierImpDelReply, error) {
 151         out := new(BierImpDelReply)
 152         err := c.conn.Invoke(ctx, in, out)
 153         if err != nil {
 154                 return nil, err
 155         }
 156         return out, api.RetvalToVPPApiError(out.Retval)
 157 }
 158
 159 func (c *serviceClient) BierImpDump(ctx context.Context, in *BierImpDump) (RPCService_BierImpDumpClient, error) {
 160         stream, err := c.conn.NewStream(ctx)
 161         if err != nil {
 162                 return nil, err
 163         }
 164         x := &serviceClient_BierImpDumpClient{stream}
 165         if err := x.Stream.SendMsg(in); err != nil {
 166                 return nil, err
 167         }
 168         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 169                 return nil, err
 170         }
 171         return x, nil
 172 }
 173
 174 type RPCService_BierImpDumpClient interface {
 175         Recv() (*BierImpDetails, error)
 176         api.Stream
 177 }
 178
 179 type serviceClient_BierImpDumpClient struct {
 180         api.Stream
 181 }
 182
 183 func (c *serviceClient_BierImpDumpClient) Recv() (*BierImpDetails, error) {
 184         msg, err := c.Stream.RecvMsg()
 185         if err != nil {
 186                 return nil, err
 187         }
 188         switch m := msg.(type) {
 189         case *BierImpDetails:
 190                 return m, nil
 191         case *memclnt.ControlPingReply:
 192                 err = c.Stream.Close()
 193                 if err != nil {
 194                         return nil, err
 195                 }
 196                 return nil, io.EOF
 197         default:
 198                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 199         }
 200 }
 201
 202 func (c *serviceClient) BierRouteAddDel(ctx context.Context, in *BierRouteAddDel) (*BierRouteAddDelReply, error) {
 203         out := new(BierRouteAddDelReply)
 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) BierRouteDump(ctx context.Context, in *BierRouteDump) (RPCService_BierRouteDumpClient, error) {
 212         stream, err := c.conn.NewStream(ctx)
 213         if err != nil {
 214                 return nil, err
 215         }
 216         x := &serviceClient_BierRouteDumpClient{stream}
 217         if err := x.Stream.SendMsg(in); err != nil {
 218                 return nil, err
 219         }
 220         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 221                 return nil, err
 222         }
 223         return x, nil
 224 }
 225
 226 type RPCService_BierRouteDumpClient interface {
 227         Recv() (*BierRouteDetails, error)
 228         api.Stream
 229 }
 230
 231 type serviceClient_BierRouteDumpClient struct {
 232         api.Stream
 233 }
 234
 235 func (c *serviceClient_BierRouteDumpClient) Recv() (*BierRouteDetails, error) {
 236         msg, err := c.Stream.RecvMsg()
 237         if err != nil {
 238                 return nil, err
 239         }
 240         switch m := msg.(type) {
 241         case *BierRouteDetails:
 242                 return m, nil
 243         case *memclnt.ControlPingReply:
 244                 err = c.Stream.Close()
 245                 if err != nil {
 246                         return nil, err
 247                 }
 248                 return nil, io.EOF
 249         default:
 250                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 251         }
 252 }
 253
 254 func (c *serviceClient) BierTableAddDel(ctx context.Context, in *BierTableAddDel) (*BierTableAddDelReply, error) {
 255         out := new(BierTableAddDelReply)
 256         err := c.conn.Invoke(ctx, in, out)
 257         if err != nil {
 258                 return nil, err
 259         }
 260         return out, api.RetvalToVPPApiError(out.Retval)
 261 }
 262
 263 func (c *serviceClient) BierTableDump(ctx context.Context, in *BierTableDump) (RPCService_BierTableDumpClient, error) {
 264         stream, err := c.conn.NewStream(ctx)
 265         if err != nil {
 266                 return nil, err
 267         }
 268         x := &serviceClient_BierTableDumpClient{stream}
 269         if err := x.Stream.SendMsg(in); err != nil {
 270                 return nil, err
 271         }
 272         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 273                 return nil, err
 274         }
 275         return x, nil
 276 }
 277
 278 type RPCService_BierTableDumpClient interface {
 279         Recv() (*BierTableDetails, error)
 280         api.Stream
 281 }
 282
 283 type serviceClient_BierTableDumpClient struct {
 284         api.Stream
 285 }
 286
 287 func (c *serviceClient_BierTableDumpClient) Recv() (*BierTableDetails, error) {
 288         msg, err := c.Stream.RecvMsg()
 289         if err != nil {
 290                 return nil, err
 291         }
 292         switch m := msg.(type) {
 293         case *BierTableDetails:
 294                 return m, nil
 295         case *memclnt.ControlPingReply:
 296                 err = c.Stream.Close()
 297                 if err != nil {
 298                         return nil, err
 299                 }
 300                 return nil, io.EOF
 301         default:
 302                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 303         }
 304 }