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         vpe "git.fd.io/govpp.git/binapi/vpe"
  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, nil
  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(&vpe.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 *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) BierDispTableAddDel(ctx context.Context, in *BierDispTableAddDel) (*BierDispTableAddDelReply, error) {
  86         out := new(BierDispTableAddDelReply)
  87         err := c.conn.Invoke(ctx, in, out)
  88         if err != nil {
  89                 return nil, err
  90         }
  91         return out, nil
  92 }
  93
  94 func (c *serviceClient) BierDispTableDump(ctx context.Context, in *BierDispTableDump) (RPCService_BierDispTableDumpClient, error) {
  95         stream, err := c.conn.NewStream(ctx)
  96         if err != nil {
  97                 return nil, err
  98         }
  99         x := &serviceClient_BierDispTableDumpClient{stream}
 100         if err := x.Stream.SendMsg(in); err != nil {
 101                 return nil, err
 102         }
 103         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 104                 return nil, err
 105         }
 106         return x, nil
 107 }
 108
 109 type RPCService_BierDispTableDumpClient interface {
 110         Recv() (*BierDispTableDetails, error)
 111         api.Stream
 112 }
 113
 114 type serviceClient_BierDispTableDumpClient struct {
 115         api.Stream
 116 }
 117
 118 func (c *serviceClient_BierDispTableDumpClient) Recv() (*BierDispTableDetails, error) {
 119         msg, err := c.Stream.RecvMsg()
 120         if err != nil {
 121                 return nil, err
 122         }
 123         switch m := msg.(type) {
 124         case *BierDispTableDetails:
 125                 return m, nil
 126         case *vpe.ControlPingReply:
 127                 return nil, io.EOF
 128         default:
 129                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 130         }
 131 }
 132
 133 func (c *serviceClient) BierImpAdd(ctx context.Context, in *BierImpAdd) (*BierImpAddReply, error) {
 134         out := new(BierImpAddReply)
 135         err := c.conn.Invoke(ctx, in, out)
 136         if err != nil {
 137                 return nil, err
 138         }
 139         return out, nil
 140 }
 141
 142 func (c *serviceClient) BierImpDel(ctx context.Context, in *BierImpDel) (*BierImpDelReply, error) {
 143         out := new(BierImpDelReply)
 144         err := c.conn.Invoke(ctx, in, out)
 145         if err != nil {
 146                 return nil, err
 147         }
 148         return out, nil
 149 }
 150
 151 func (c *serviceClient) BierImpDump(ctx context.Context, in *BierImpDump) (RPCService_BierImpDumpClient, error) {
 152         stream, err := c.conn.NewStream(ctx)
 153         if err != nil {
 154                 return nil, err
 155         }
 156         x := &serviceClient_BierImpDumpClient{stream}
 157         if err := x.Stream.SendMsg(in); err != nil {
 158                 return nil, err
 159         }
 160         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 161                 return nil, err
 162         }
 163         return x, nil
 164 }
 165
 166 type RPCService_BierImpDumpClient interface {
 167         Recv() (*BierImpDetails, error)
 168         api.Stream
 169 }
 170
 171 type serviceClient_BierImpDumpClient struct {
 172         api.Stream
 173 }
 174
 175 func (c *serviceClient_BierImpDumpClient) Recv() (*BierImpDetails, error) {
 176         msg, err := c.Stream.RecvMsg()
 177         if err != nil {
 178                 return nil, err
 179         }
 180         switch m := msg.(type) {
 181         case *BierImpDetails:
 182                 return m, nil
 183         case *vpe.ControlPingReply:
 184                 return nil, io.EOF
 185         default:
 186                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 187         }
 188 }
 189
 190 func (c *serviceClient) BierRouteAddDel(ctx context.Context, in *BierRouteAddDel) (*BierRouteAddDelReply, error) {
 191         out := new(BierRouteAddDelReply)
 192         err := c.conn.Invoke(ctx, in, out)
 193         if err != nil {
 194                 return nil, err
 195         }
 196         return out, nil
 197 }
 198
 199 func (c *serviceClient) BierRouteDump(ctx context.Context, in *BierRouteDump) (RPCService_BierRouteDumpClient, error) {
 200         stream, err := c.conn.NewStream(ctx)
 201         if err != nil {
 202                 return nil, err
 203         }
 204         x := &serviceClient_BierRouteDumpClient{stream}
 205         if err := x.Stream.SendMsg(in); err != nil {
 206                 return nil, err
 207         }
 208         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 209                 return nil, err
 210         }
 211         return x, nil
 212 }
 213
 214 type RPCService_BierRouteDumpClient interface {
 215         Recv() (*BierRouteDetails, error)
 216         api.Stream
 217 }
 218
 219 type serviceClient_BierRouteDumpClient struct {
 220         api.Stream
 221 }
 222
 223 func (c *serviceClient_BierRouteDumpClient) Recv() (*BierRouteDetails, error) {
 224         msg, err := c.Stream.RecvMsg()
 225         if err != nil {
 226                 return nil, err
 227         }
 228         switch m := msg.(type) {
 229         case *BierRouteDetails:
 230                 return m, nil
 231         case *vpe.ControlPingReply:
 232                 return nil, io.EOF
 233         default:
 234                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 235         }
 236 }
 237
 238 func (c *serviceClient) BierTableAddDel(ctx context.Context, in *BierTableAddDel) (*BierTableAddDelReply, error) {
 239         out := new(BierTableAddDelReply)
 240         err := c.conn.Invoke(ctx, in, out)
 241         if err != nil {
 242                 return nil, err
 243         }
 244         return out, nil
 245 }
 246
 247 func (c *serviceClient) BierTableDump(ctx context.Context, in *BierTableDump) (RPCService_BierTableDumpClient, error) {
 248         stream, err := c.conn.NewStream(ctx)
 249         if err != nil {
 250                 return nil, err
 251         }
 252         x := &serviceClient_BierTableDumpClient{stream}
 253         if err := x.Stream.SendMsg(in); err != nil {
 254                 return nil, err
 255         }
 256         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 257                 return nil, err
 258         }
 259         return x, nil
 260 }
 261
 262 type RPCService_BierTableDumpClient interface {
 263         Recv() (*BierTableDetails, error)
 264         api.Stream
 265 }
 266
 267 type serviceClient_BierTableDumpClient struct {
 268         api.Stream
 269 }
 270
 271 func (c *serviceClient_BierTableDumpClient) Recv() (*BierTableDetails, error) {
 272         msg, err := c.Stream.RecvMsg()
 273         if err != nil {
 274                 return nil, err
 275         }
 276         switch m := msg.(type) {
 277         case *BierTableDetails:
 278                 return m, nil
 279         case *vpe.ControlPingReply:
 280                 return nil, io.EOF
 281         default:
 282                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 283         }
 284 }