binapi/qos/qos_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package qos
   4
   5 import (
   6         "context"
   7         "fmt"
   8         "io"
   9
  10         api "git.fd.io/govpp.git/api"
  11         memclnt "git.fd.io/govpp.git/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service qos.
  15 type RPCService interface {
  16         QosEgressMapDelete(ctx context.Context, in *QosEgressMapDelete) (*QosEgressMapDeleteReply, error)
  17         QosEgressMapDump(ctx context.Context, in *QosEgressMapDump) (RPCService_QosEgressMapDumpClient, error)
  18         QosEgressMapUpdate(ctx context.Context, in *QosEgressMapUpdate) (*QosEgressMapUpdateReply, error)
  19         QosMarkDump(ctx context.Context, in *QosMarkDump) (RPCService_QosMarkDumpClient, error)
  20         QosMarkEnableDisable(ctx context.Context, in *QosMarkEnableDisable) (*QosMarkEnableDisableReply, error)
  21         QosRecordDump(ctx context.Context, in *QosRecordDump) (RPCService_QosRecordDumpClient, error)
  22         QosRecordEnableDisable(ctx context.Context, in *QosRecordEnableDisable) (*QosRecordEnableDisableReply, error)
  23         QosStoreDump(ctx context.Context, in *QosStoreDump) (RPCService_QosStoreDumpClient, error)
  24         QosStoreEnableDisable(ctx context.Context, in *QosStoreEnableDisable) (*QosStoreEnableDisableReply, 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) QosEgressMapDelete(ctx context.Context, in *QosEgressMapDelete) (*QosEgressMapDeleteReply, error) {
  36         out := new(QosEgressMapDeleteReply)
  37         err := c.conn.Invoke(ctx, in, out)
  38         if err != nil {
  39                 return nil, err
  40         }
  41         return out, api.RetvalToVPPApiError(out.Retval)
  42 }
  43
  44 func (c *serviceClient) QosEgressMapDump(ctx context.Context, in *QosEgressMapDump) (RPCService_QosEgressMapDumpClient, error) {
  45         stream, err := c.conn.NewStream(ctx)
  46         if err != nil {
  47                 return nil, err
  48         }
  49         x := &serviceClient_QosEgressMapDumpClient{stream}
  50         if err := x.Stream.SendMsg(in); err != nil {
  51                 return nil, err
  52         }
  53         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  54                 return nil, err
  55         }
  56         return x, nil
  57 }
  58
  59 type RPCService_QosEgressMapDumpClient interface {
  60         Recv() (*QosEgressMapDetails, error)
  61         api.Stream
  62 }
  63
  64 type serviceClient_QosEgressMapDumpClient struct {
  65         api.Stream
  66 }
  67
  68 func (c *serviceClient_QosEgressMapDumpClient) Recv() (*QosEgressMapDetails, error) {
  69         msg, err := c.Stream.RecvMsg()
  70         if err != nil {
  71                 return nil, err
  72         }
  73         switch m := msg.(type) {
  74         case *QosEgressMapDetails:
  75                 return m, nil
  76         case *memclnt.ControlPingReply:
  77                 err = c.Stream.Close()
  78                 if err != nil {
  79                         return nil, err
  80                 }
  81                 return nil, io.EOF
  82         default:
  83                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  84         }
  85 }
  86
  87 func (c *serviceClient) QosEgressMapUpdate(ctx context.Context, in *QosEgressMapUpdate) (*QosEgressMapUpdateReply, error) {
  88         out := new(QosEgressMapUpdateReply)
  89         err := c.conn.Invoke(ctx, in, out)
  90         if err != nil {
  91                 return nil, err
  92         }
  93         return out, api.RetvalToVPPApiError(out.Retval)
  94 }
  95
  96 func (c *serviceClient) QosMarkDump(ctx context.Context, in *QosMarkDump) (RPCService_QosMarkDumpClient, error) {
  97         stream, err := c.conn.NewStream(ctx)
  98         if err != nil {
  99                 return nil, err
 100         }
 101         x := &serviceClient_QosMarkDumpClient{stream}
 102         if err := x.Stream.SendMsg(in); err != nil {
 103                 return nil, err
 104         }
 105         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 106                 return nil, err
 107         }
 108         return x, nil
 109 }
 110
 111 type RPCService_QosMarkDumpClient interface {
 112         Recv() (*QosMarkDetails, error)
 113         api.Stream
 114 }
 115
 116 type serviceClient_QosMarkDumpClient struct {
 117         api.Stream
 118 }
 119
 120 func (c *serviceClient_QosMarkDumpClient) Recv() (*QosMarkDetails, error) {
 121         msg, err := c.Stream.RecvMsg()
 122         if err != nil {
 123                 return nil, err
 124         }
 125         switch m := msg.(type) {
 126         case *QosMarkDetails:
 127                 return m, nil
 128         case *memclnt.ControlPingReply:
 129                 err = c.Stream.Close()
 130                 if err != nil {
 131                         return nil, err
 132                 }
 133                 return nil, io.EOF
 134         default:
 135                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 136         }
 137 }
 138
 139 func (c *serviceClient) QosMarkEnableDisable(ctx context.Context, in *QosMarkEnableDisable) (*QosMarkEnableDisableReply, error) {
 140         out := new(QosMarkEnableDisableReply)
 141         err := c.conn.Invoke(ctx, in, out)
 142         if err != nil {
 143                 return nil, err
 144         }
 145         return out, api.RetvalToVPPApiError(out.Retval)
 146 }
 147
 148 func (c *serviceClient) QosRecordDump(ctx context.Context, in *QosRecordDump) (RPCService_QosRecordDumpClient, error) {
 149         stream, err := c.conn.NewStream(ctx)
 150         if err != nil {
 151                 return nil, err
 152         }
 153         x := &serviceClient_QosRecordDumpClient{stream}
 154         if err := x.Stream.SendMsg(in); err != nil {
 155                 return nil, err
 156         }
 157         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 158                 return nil, err
 159         }
 160         return x, nil
 161 }
 162
 163 type RPCService_QosRecordDumpClient interface {
 164         Recv() (*QosRecordDetails, error)
 165         api.Stream
 166 }
 167
 168 type serviceClient_QosRecordDumpClient struct {
 169         api.Stream
 170 }
 171
 172 func (c *serviceClient_QosRecordDumpClient) Recv() (*QosRecordDetails, error) {
 173         msg, err := c.Stream.RecvMsg()
 174         if err != nil {
 175                 return nil, err
 176         }
 177         switch m := msg.(type) {
 178         case *QosRecordDetails:
 179                 return m, nil
 180         case *memclnt.ControlPingReply:
 181                 err = c.Stream.Close()
 182                 if err != nil {
 183                         return nil, err
 184                 }
 185                 return nil, io.EOF
 186         default:
 187                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 188         }
 189 }
 190
 191 func (c *serviceClient) QosRecordEnableDisable(ctx context.Context, in *QosRecordEnableDisable) (*QosRecordEnableDisableReply, error) {
 192         out := new(QosRecordEnableDisableReply)
 193         err := c.conn.Invoke(ctx, in, out)
 194         if err != nil {
 195                 return nil, err
 196         }
 197         return out, api.RetvalToVPPApiError(out.Retval)
 198 }
 199
 200 func (c *serviceClient) QosStoreDump(ctx context.Context, in *QosStoreDump) (RPCService_QosStoreDumpClient, error) {
 201         stream, err := c.conn.NewStream(ctx)
 202         if err != nil {
 203                 return nil, err
 204         }
 205         x := &serviceClient_QosStoreDumpClient{stream}
 206         if err := x.Stream.SendMsg(in); err != nil {
 207                 return nil, err
 208         }
 209         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 210                 return nil, err
 211         }
 212         return x, nil
 213 }
 214
 215 type RPCService_QosStoreDumpClient interface {
 216         Recv() (*QosStoreDetails, error)
 217         api.Stream
 218 }
 219
 220 type serviceClient_QosStoreDumpClient struct {
 221         api.Stream
 222 }
 223
 224 func (c *serviceClient_QosStoreDumpClient) Recv() (*QosStoreDetails, error) {
 225         msg, err := c.Stream.RecvMsg()
 226         if err != nil {
 227                 return nil, err
 228         }
 229         switch m := msg.(type) {
 230         case *QosStoreDetails:
 231                 return m, nil
 232         case *memclnt.ControlPingReply:
 233                 err = c.Stream.Close()
 234                 if err != nil {
 235                         return nil, err
 236                 }
 237                 return nil, io.EOF
 238         default:
 239                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 240         }
 241 }
 242
 243 func (c *serviceClient) QosStoreEnableDisable(ctx context.Context, in *QosStoreEnableDisable) (*QosStoreEnableDisableReply, error) {
 244         out := new(QosStoreEnableDisableReply)
 245         err := c.conn.Invoke(ctx, in, out)
 246         if err != nil {
 247                 return nil, err
 248         }
 249         return out, api.RetvalToVPPApiError(out.Retval)
 250 }