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         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  bier.
  14 type RPCService interface {
  15         BierDispEntryAddDel(ctx context.Context, in *BierDispEntryAddDel) (*BierDispEntryAddDelReply, error)
  16         BierDispEntryDump(ctx context.Context, in *BierDispEntryDump) (RPCService_BierDispEntryDumpClient, error)
  17         BierDispTableAddDel(ctx context.Context, in *BierDispTableAddDel) (*BierDispTableAddDelReply, error)
  18         BierDispTableDump(ctx context.Context, in *BierDispTableDump) (RPCService_BierDispTableDumpClient, error)
  19         BierImpAdd(ctx context.Context, in *BierImpAdd) (*BierImpAddReply, error)
  20         BierImpDel(ctx context.Context, in *BierImpDel) (*BierImpDelReply, error)
  21         BierImpDump(ctx context.Context, in *BierImpDump) (RPCService_BierImpDumpClient, error)
  22         BierRouteAddDel(ctx context.Context, in *BierRouteAddDel) (*BierRouteAddDelReply, error)
  23         BierRouteDump(ctx context.Context, in *BierRouteDump) (RPCService_BierRouteDumpClient, error)
  24         BierTableAddDel(ctx context.Context, in *BierTableAddDel) (*BierTableAddDelReply, error)
  25         BierTableDump(ctx context.Context, in *BierTableDump) (RPCService_BierTableDumpClient, 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) BierDispEntryAddDel(ctx context.Context, in *BierDispEntryAddDel) (*BierDispEntryAddDelReply, error) {
  37         out := new(BierDispEntryAddDelReply)
  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) BierDispEntryDump(ctx context.Context, in *BierDispEntryDump) (RPCService_BierDispEntryDumpClient, error) {
  46         stream, err := c.conn.NewStream(ctx)
  47         if err != nil {
  48                 return nil, err
  49         }
  50         x := &serviceClient_BierDispEntryDumpClient{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_BierDispEntryDumpClient interface {
  61         Recv() (*BierDispEntryDetails, error)
  62         api.Stream
  63 }
  64
  65 type serviceClient_BierDispEntryDumpClient struct {
  66         api.Stream
  67 }
  68
  69 func (c *serviceClient_BierDispEntryDumpClient) Recv() (*BierDispEntryDetails, error) {
  70         msg, err := c.Stream.RecvMsg()
  71         if err != nil {
  72                 return nil, err
  73         }
  74         switch m := msg.(type) {
  75         case *BierDispEntryDetails:
  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) BierDispTableAddDel(ctx context.Context, in *BierDispTableAddDel) (*BierDispTableAddDelReply, error) {
  85         out := new(BierDispTableAddDelReply)
  86         err := c.conn.Invoke(ctx, in, out)
  87         if err != nil {
  88                 return nil, err
  89         }
  90         return out, nil
  91 }
  92
  93 func (c *serviceClient) BierDispTableDump(ctx context.Context, in *BierDispTableDump) (RPCService_BierDispTableDumpClient, error) {
  94         stream, err := c.conn.NewStream(ctx)
  95         if err != nil {
  96                 return nil, err
  97         }
  98         x := &serviceClient_BierDispTableDumpClient{stream}
  99         if err := x.Stream.SendMsg(in); err != nil {
 100                 return nil, err
 101         }
 102         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 103                 return nil, err
 104         }
 105         return x, nil
 106 }
 107
 108 type RPCService_BierDispTableDumpClient interface {
 109         Recv() (*BierDispTableDetails, error)
 110         api.Stream
 111 }
 112
 113 type serviceClient_BierDispTableDumpClient struct {
 114         api.Stream
 115 }
 116
 117 func (c *serviceClient_BierDispTableDumpClient) Recv() (*BierDispTableDetails, error) {
 118         msg, err := c.Stream.RecvMsg()
 119         if err != nil {
 120                 return nil, err
 121         }
 122         switch m := msg.(type) {
 123         case *BierDispTableDetails:
 124                 return m, nil
 125         case *vpe.ControlPingReply:
 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) BierImpAdd(ctx context.Context, in *BierImpAdd) (*BierImpAddReply, error) {
 133         out := new(BierImpAddReply)
 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) BierImpDel(ctx context.Context, in *BierImpDel) (*BierImpDelReply, error) {
 142         out := new(BierImpDelReply)
 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) BierImpDump(ctx context.Context, in *BierImpDump) (RPCService_BierImpDumpClient, error) {
 151         stream, err := c.conn.NewStream(ctx)
 152         if err != nil {
 153                 return nil, err
 154         }
 155         x := &serviceClient_BierImpDumpClient{stream}
 156         if err := x.Stream.SendMsg(in); err != nil {
 157                 return nil, err
 158         }
 159         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 160                 return nil, err
 161         }
 162         return x, nil
 163 }
 164
 165 type RPCService_BierImpDumpClient interface {
 166         Recv() (*BierImpDetails, error)
 167         api.Stream
 168 }
 169
 170 type serviceClient_BierImpDumpClient struct {
 171         api.Stream
 172 }
 173
 174 func (c *serviceClient_BierImpDumpClient) Recv() (*BierImpDetails, error) {
 175         msg, err := c.Stream.RecvMsg()
 176         if err != nil {
 177                 return nil, err
 178         }
 179         switch m := msg.(type) {
 180         case *BierImpDetails:
 181                 return m, nil
 182         case *vpe.ControlPingReply:
 183                 return nil, io.EOF
 184         default:
 185                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 186         }
 187 }
 188
 189 func (c *serviceClient) BierRouteAddDel(ctx context.Context, in *BierRouteAddDel) (*BierRouteAddDelReply, error) {
 190         out := new(BierRouteAddDelReply)
 191         err := c.conn.Invoke(ctx, in, out)
 192         if err != nil {
 193                 return nil, err
 194         }
 195         return out, nil
 196 }
 197
 198 func (c *serviceClient) BierRouteDump(ctx context.Context, in *BierRouteDump) (RPCService_BierRouteDumpClient, error) {
 199         stream, err := c.conn.NewStream(ctx)
 200         if err != nil {
 201                 return nil, err
 202         }
 203         x := &serviceClient_BierRouteDumpClient{stream}
 204         if err := x.Stream.SendMsg(in); err != nil {
 205                 return nil, err
 206         }
 207         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 208                 return nil, err
 209         }
 210         return x, nil
 211 }
 212
 213 type RPCService_BierRouteDumpClient interface {
 214         Recv() (*BierRouteDetails, error)
 215         api.Stream
 216 }
 217
 218 type serviceClient_BierRouteDumpClient struct {
 219         api.Stream
 220 }
 221
 222 func (c *serviceClient_BierRouteDumpClient) Recv() (*BierRouteDetails, error) {
 223         msg, err := c.Stream.RecvMsg()
 224         if err != nil {
 225                 return nil, err
 226         }
 227         switch m := msg.(type) {
 228         case *BierRouteDetails:
 229                 return m, nil
 230         case *vpe.ControlPingReply:
 231                 return nil, io.EOF
 232         default:
 233                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 234         }
 235 }
 236
 237 func (c *serviceClient) BierTableAddDel(ctx context.Context, in *BierTableAddDel) (*BierTableAddDelReply, error) {
 238         out := new(BierTableAddDelReply)
 239         err := c.conn.Invoke(ctx, in, out)
 240         if err != nil {
 241                 return nil, err
 242         }
 243         return out, nil
 244 }
 245
 246 func (c *serviceClient) BierTableDump(ctx context.Context, in *BierTableDump) (RPCService_BierTableDumpClient, error) {
 247         stream, err := c.conn.NewStream(ctx)
 248         if err != nil {
 249                 return nil, err
 250         }
 251         x := &serviceClient_BierTableDumpClient{stream}
 252         if err := x.Stream.SendMsg(in); err != nil {
 253                 return nil, err
 254         }
 255         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 256                 return nil, err
 257         }
 258         return x, nil
 259 }
 260
 261 type RPCService_BierTableDumpClient interface {
 262         Recv() (*BierTableDetails, error)
 263         api.Stream
 264 }
 265
 266 type serviceClient_BierTableDumpClient struct {
 267         api.Stream
 268 }
 269
 270 func (c *serviceClient_BierTableDumpClient) Recv() (*BierTableDetails, error) {
 271         msg, err := c.Stream.RecvMsg()
 272         if err != nil {
 273                 return nil, err
 274         }
 275         switch m := msg.(type) {
 276         case *BierTableDetails:
 277                 return m, nil
 278         case *vpe.ControlPingReply:
 279                 return nil, io.EOF
 280         default:
 281                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 282         }
 283 }