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 "go.fd.io/govpp/api"
  11         memclnt "go.fd.io/govpp/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service ipfix_export.
  15 type RPCService interface {
  16         IpfixAllExporterGet(ctx context.Context, in *IpfixAllExporterGet) (RPCService_IpfixAllExporterGetClient, error)
  17         IpfixClassifyStreamDump(ctx context.Context, in *IpfixClassifyStreamDump) (RPCService_IpfixClassifyStreamDumpClient, error)
  18         IpfixClassifyTableAddDel(ctx context.Context, in *IpfixClassifyTableAddDel) (*IpfixClassifyTableAddDelReply, error)
  19         IpfixClassifyTableDump(ctx context.Context, in *IpfixClassifyTableDump) (RPCService_IpfixClassifyTableDumpClient, error)
  20         IpfixExporterCreateDelete(ctx context.Context, in *IpfixExporterCreateDelete) (*IpfixExporterCreateDeleteReply, error)
  21         IpfixExporterDump(ctx context.Context, in *IpfixExporterDump) (RPCService_IpfixExporterDumpClient, error)
  22         IpfixFlush(ctx context.Context, in *IpfixFlush) (*IpfixFlushReply, error)
  23         SetIpfixClassifyStream(ctx context.Context, in *SetIpfixClassifyStream) (*SetIpfixClassifyStreamReply, error)
  24         SetIpfixExporter(ctx context.Context, in *SetIpfixExporter) (*SetIpfixExporterReply, error)
  25 }
  26
  27 type serviceClient struct {
  28         conn api.Connection
  29 }
  30
  31 func NewServiceClient(conn api.Connection) RPCService {
  32         return &serviceClient{conn}
  33 }
  34
  35 func (c *serviceClient) IpfixAllExporterGet(ctx context.Context, in *IpfixAllExporterGet) (RPCService_IpfixAllExporterGetClient, error) {
  36         stream, err := c.conn.NewStream(ctx)
  37         if err != nil {
  38                 return nil, err
  39         }
  40         x := &serviceClient_IpfixAllExporterGetClient{stream}
  41         if err := x.Stream.SendMsg(in); err != nil {
  42                 return nil, err
  43         }
  44         return x, nil
  45 }
  46
  47 type RPCService_IpfixAllExporterGetClient interface {
  48         Recv() (*IpfixAllExporterDetails, error)
  49         api.Stream
  50 }
  51
  52 type serviceClient_IpfixAllExporterGetClient struct {
  53         api.Stream
  54 }
  55
  56 func (c *serviceClient_IpfixAllExporterGetClient) Recv() (*IpfixAllExporterDetails, error) {
  57         msg, err := c.Stream.RecvMsg()
  58         if err != nil {
  59                 return nil, err
  60         }
  61         switch m := msg.(type) {
  62         case *IpfixAllExporterDetails:
  63                 return m, nil
  64         case *IpfixAllExporterGetReply:
  65                 err = c.Stream.Close()
  66                 if err != nil {
  67                         return nil, err
  68                 }
  69                 return nil, io.EOF
  70         default:
  71                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  72         }
  73 }
  74
  75 func (c *serviceClient) IpfixClassifyStreamDump(ctx context.Context, in *IpfixClassifyStreamDump) (RPCService_IpfixClassifyStreamDumpClient, error) {
  76         stream, err := c.conn.NewStream(ctx)
  77         if err != nil {
  78                 return nil, err
  79         }
  80         x := &serviceClient_IpfixClassifyStreamDumpClient{stream}
  81         if err := x.Stream.SendMsg(in); err != nil {
  82                 return nil, err
  83         }
  84         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  85                 return nil, err
  86         }
  87         return x, nil
  88 }
  89
  90 type RPCService_IpfixClassifyStreamDumpClient interface {
  91         Recv() (*IpfixClassifyStreamDetails, error)
  92         api.Stream
  93 }
  94
  95 type serviceClient_IpfixClassifyStreamDumpClient struct {
  96         api.Stream
  97 }
  98
  99 func (c *serviceClient_IpfixClassifyStreamDumpClient) Recv() (*IpfixClassifyStreamDetails, error) {
 100         msg, err := c.Stream.RecvMsg()
 101         if err != nil {
 102                 return nil, err
 103         }
 104         switch m := msg.(type) {
 105         case *IpfixClassifyStreamDetails:
 106                 return m, nil
 107         case *memclnt.ControlPingReply:
 108                 err = c.Stream.Close()
 109                 if err != nil {
 110                         return nil, err
 111                 }
 112                 return nil, io.EOF
 113         default:
 114                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 115         }
 116 }
 117
 118 func (c *serviceClient) IpfixClassifyTableAddDel(ctx context.Context, in *IpfixClassifyTableAddDel) (*IpfixClassifyTableAddDelReply, error) {
 119         out := new(IpfixClassifyTableAddDelReply)
 120         err := c.conn.Invoke(ctx, in, out)
 121         if err != nil {
 122                 return nil, err
 123         }
 124         return out, api.RetvalToVPPApiError(out.Retval)
 125 }
 126
 127 func (c *serviceClient) IpfixClassifyTableDump(ctx context.Context, in *IpfixClassifyTableDump) (RPCService_IpfixClassifyTableDumpClient, error) {
 128         stream, err := c.conn.NewStream(ctx)
 129         if err != nil {
 130                 return nil, err
 131         }
 132         x := &serviceClient_IpfixClassifyTableDumpClient{stream}
 133         if err := x.Stream.SendMsg(in); err != nil {
 134                 return nil, err
 135         }
 136         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 137                 return nil, err
 138         }
 139         return x, nil
 140 }
 141
 142 type RPCService_IpfixClassifyTableDumpClient interface {
 143         Recv() (*IpfixClassifyTableDetails, error)
 144         api.Stream
 145 }
 146
 147 type serviceClient_IpfixClassifyTableDumpClient struct {
 148         api.Stream
 149 }
 150
 151 func (c *serviceClient_IpfixClassifyTableDumpClient) Recv() (*IpfixClassifyTableDetails, error) {
 152         msg, err := c.Stream.RecvMsg()
 153         if err != nil {
 154                 return nil, err
 155         }
 156         switch m := msg.(type) {
 157         case *IpfixClassifyTableDetails:
 158                 return m, nil
 159         case *memclnt.ControlPingReply:
 160                 err = c.Stream.Close()
 161                 if err != nil {
 162                         return nil, err
 163                 }
 164                 return nil, io.EOF
 165         default:
 166                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 167         }
 168 }
 169
 170 func (c *serviceClient) IpfixExporterCreateDelete(ctx context.Context, in *IpfixExporterCreateDelete) (*IpfixExporterCreateDeleteReply, error) {
 171         out := new(IpfixExporterCreateDeleteReply)
 172         err := c.conn.Invoke(ctx, in, out)
 173         if err != nil {
 174                 return nil, err
 175         }
 176         return out, api.RetvalToVPPApiError(out.Retval)
 177 }
 178
 179 func (c *serviceClient) IpfixExporterDump(ctx context.Context, in *IpfixExporterDump) (RPCService_IpfixExporterDumpClient, error) {
 180         stream, err := c.conn.NewStream(ctx)
 181         if err != nil {
 182                 return nil, err
 183         }
 184         x := &serviceClient_IpfixExporterDumpClient{stream}
 185         if err := x.Stream.SendMsg(in); err != nil {
 186                 return nil, err
 187         }
 188         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 189                 return nil, err
 190         }
 191         return x, nil
 192 }
 193
 194 type RPCService_IpfixExporterDumpClient interface {
 195         Recv() (*IpfixExporterDetails, error)
 196         api.Stream
 197 }
 198
 199 type serviceClient_IpfixExporterDumpClient struct {
 200         api.Stream
 201 }
 202
 203 func (c *serviceClient_IpfixExporterDumpClient) Recv() (*IpfixExporterDetails, error) {
 204         msg, err := c.Stream.RecvMsg()
 205         if err != nil {
 206                 return nil, err
 207         }
 208         switch m := msg.(type) {
 209         case *IpfixExporterDetails:
 210                 return m, nil
 211         case *memclnt.ControlPingReply:
 212                 err = c.Stream.Close()
 213                 if err != nil {
 214                         return nil, err
 215                 }
 216                 return nil, io.EOF
 217         default:
 218                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 219         }
 220 }
 221
 222 func (c *serviceClient) IpfixFlush(ctx context.Context, in *IpfixFlush) (*IpfixFlushReply, error) {
 223         out := new(IpfixFlushReply)
 224         err := c.conn.Invoke(ctx, in, out)
 225         if err != nil {
 226                 return nil, err
 227         }
 228         return out, api.RetvalToVPPApiError(out.Retval)
 229 }
 230
 231 func (c *serviceClient) SetIpfixClassifyStream(ctx context.Context, in *SetIpfixClassifyStream) (*SetIpfixClassifyStreamReply, error) {
 232         out := new(SetIpfixClassifyStreamReply)
 233         err := c.conn.Invoke(ctx, in, out)
 234         if err != nil {
 235                 return nil, err
 236         }
 237         return out, api.RetvalToVPPApiError(out.Retval)
 238 }
 239
 240 func (c *serviceClient) SetIpfixExporter(ctx context.Context, in *SetIpfixExporter) (*SetIpfixExporterReply, error) {
 241         out := new(SetIpfixExporterReply)
 242         err := c.conn.Invoke(ctx, in, out)
 243         if err != nil {
 244                 return nil, err
 245         }
 246         return out, api.RetvalToVPPApiError(out.Retval)
 247 }