binapi/ipfix_export/ipfix_export_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package ipfix_export
   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  ipfix_export.
  15 type RPCService interface {
  16         IpfixClassifyStreamDump(ctx context.Context, in *IpfixClassifyStreamDump) (RPCService_IpfixClassifyStreamDumpClient, error)
  17         IpfixClassifyTableAddDel(ctx context.Context, in *IpfixClassifyTableAddDel) (*IpfixClassifyTableAddDelReply, error)
  18         IpfixClassifyTableDump(ctx context.Context, in *IpfixClassifyTableDump) (RPCService_IpfixClassifyTableDumpClient, error)
  19         IpfixExporterDump(ctx context.Context, in *IpfixExporterDump) (RPCService_IpfixExporterDumpClient, error)
  20         IpfixFlush(ctx context.Context, in *IpfixFlush) (*IpfixFlushReply, error)
  21         SetIpfixClassifyStream(ctx context.Context, in *SetIpfixClassifyStream) (*SetIpfixClassifyStreamReply, error)
  22         SetIpfixExporter(ctx context.Context, in *SetIpfixExporter) (*SetIpfixExporterReply, error)
  23 }
  24
  25 type serviceClient struct {
  26         conn api.Connection
  27 }
  28
  29 func NewServiceClient(conn api.Connection) RPCService {
  30         return &serviceClient{conn}
  31 }
  32
  33 func (c *serviceClient) IpfixClassifyStreamDump(ctx context.Context, in *IpfixClassifyStreamDump) (RPCService_IpfixClassifyStreamDumpClient, error) {
  34         stream, err := c.conn.NewStream(ctx)
  35         if err != nil {
  36                 return nil, err
  37         }
  38         x := &serviceClient_IpfixClassifyStreamDumpClient{stream}
  39         if err := x.Stream.SendMsg(in); err != nil {
  40                 return nil, err
  41         }
  42         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  43                 return nil, err
  44         }
  45         return x, nil
  46 }
  47
  48 type RPCService_IpfixClassifyStreamDumpClient interface {
  49         Recv() (*IpfixClassifyStreamDetails, error)
  50         api.Stream
  51 }
  52
  53 type serviceClient_IpfixClassifyStreamDumpClient struct {
  54         api.Stream
  55 }
  56
  57 func (c *serviceClient_IpfixClassifyStreamDumpClient) Recv() (*IpfixClassifyStreamDetails, error) {
  58         msg, err := c.Stream.RecvMsg()
  59         if err != nil {
  60                 return nil, err
  61         }
  62         switch m := msg.(type) {
  63         case *IpfixClassifyStreamDetails:
  64                 return m, nil
  65         case *vpe.ControlPingReply:
  66                 return nil, io.EOF
  67         default:
  68                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  69         }
  70 }
  71
  72 func (c *serviceClient) IpfixClassifyTableAddDel(ctx context.Context, in *IpfixClassifyTableAddDel) (*IpfixClassifyTableAddDelReply, error) {
  73         out := new(IpfixClassifyTableAddDelReply)
  74         err := c.conn.Invoke(ctx, in, out)
  75         if err != nil {
  76                 return nil, err
  77         }
  78         return out, nil
  79 }
  80
  81 func (c *serviceClient) IpfixClassifyTableDump(ctx context.Context, in *IpfixClassifyTableDump) (RPCService_IpfixClassifyTableDumpClient, error) {
  82         stream, err := c.conn.NewStream(ctx)
  83         if err != nil {
  84                 return nil, err
  85         }
  86         x := &serviceClient_IpfixClassifyTableDumpClient{stream}
  87         if err := x.Stream.SendMsg(in); err != nil {
  88                 return nil, err
  89         }
  90         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  91                 return nil, err
  92         }
  93         return x, nil
  94 }
  95
  96 type RPCService_IpfixClassifyTableDumpClient interface {
  97         Recv() (*IpfixClassifyTableDetails, error)
  98         api.Stream
  99 }
 100
 101 type serviceClient_IpfixClassifyTableDumpClient struct {
 102         api.Stream
 103 }
 104
 105 func (c *serviceClient_IpfixClassifyTableDumpClient) Recv() (*IpfixClassifyTableDetails, error) {
 106         msg, err := c.Stream.RecvMsg()
 107         if err != nil {
 108                 return nil, err
 109         }
 110         switch m := msg.(type) {
 111         case *IpfixClassifyTableDetails:
 112                 return m, nil
 113         case *vpe.ControlPingReply:
 114                 return nil, io.EOF
 115         default:
 116                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 117         }
 118 }
 119
 120 func (c *serviceClient) IpfixExporterDump(ctx context.Context, in *IpfixExporterDump) (RPCService_IpfixExporterDumpClient, error) {
 121         stream, err := c.conn.NewStream(ctx)
 122         if err != nil {
 123                 return nil, err
 124         }
 125         x := &serviceClient_IpfixExporterDumpClient{stream}
 126         if err := x.Stream.SendMsg(in); err != nil {
 127                 return nil, err
 128         }
 129         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 130                 return nil, err
 131         }
 132         return x, nil
 133 }
 134
 135 type RPCService_IpfixExporterDumpClient interface {
 136         Recv() (*IpfixExporterDetails, error)
 137         api.Stream
 138 }
 139
 140 type serviceClient_IpfixExporterDumpClient struct {
 141         api.Stream
 142 }
 143
 144 func (c *serviceClient_IpfixExporterDumpClient) Recv() (*IpfixExporterDetails, error) {
 145         msg, err := c.Stream.RecvMsg()
 146         if err != nil {
 147                 return nil, err
 148         }
 149         switch m := msg.(type) {
 150         case *IpfixExporterDetails:
 151                 return m, nil
 152         case *vpe.ControlPingReply:
 153                 return nil, io.EOF
 154         default:
 155                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 156         }
 157 }
 158
 159 func (c *serviceClient) IpfixFlush(ctx context.Context, in *IpfixFlush) (*IpfixFlushReply, error) {
 160         out := new(IpfixFlushReply)
 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) SetIpfixClassifyStream(ctx context.Context, in *SetIpfixClassifyStream) (*SetIpfixClassifyStreamReply, error) {
 169         out := new(SetIpfixClassifyStreamReply)
 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) SetIpfixExporter(ctx context.Context, in *SetIpfixExporter) (*SetIpfixExporterReply, error) {
 178         out := new(SetIpfixExporterReply)
 179         err := c.conn.Invoke(ctx, in, out)
 180         if err != nil {
 181                 return nil, err
 182         }
 183         return out, nil
 184 }