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