binapi/nat64/nat64_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package nat64
   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 nat64.
  15 type RPCService interface {
  16         Nat64AddDelInterface(ctx context.Context, in *Nat64AddDelInterface) (*Nat64AddDelInterfaceReply, error)
  17         Nat64AddDelInterfaceAddr(ctx context.Context, in *Nat64AddDelInterfaceAddr) (*Nat64AddDelInterfaceAddrReply, error)
  18         Nat64AddDelPoolAddrRange(ctx context.Context, in *Nat64AddDelPoolAddrRange) (*Nat64AddDelPoolAddrRangeReply, error)
  19         Nat64AddDelPrefix(ctx context.Context, in *Nat64AddDelPrefix) (*Nat64AddDelPrefixReply, error)
  20         Nat64AddDelStaticBib(ctx context.Context, in *Nat64AddDelStaticBib) (*Nat64AddDelStaticBibReply, error)
  21         Nat64BibDump(ctx context.Context, in *Nat64BibDump) (RPCService_Nat64BibDumpClient, error)
  22         Nat64GetTimeouts(ctx context.Context, in *Nat64GetTimeouts) (*Nat64GetTimeoutsReply, error)
  23         Nat64InterfaceDump(ctx context.Context, in *Nat64InterfaceDump) (RPCService_Nat64InterfaceDumpClient, error)
  24         Nat64PluginEnableDisable(ctx context.Context, in *Nat64PluginEnableDisable) (*Nat64PluginEnableDisableReply, error)
  25         Nat64PoolAddrDump(ctx context.Context, in *Nat64PoolAddrDump) (RPCService_Nat64PoolAddrDumpClient, error)
  26         Nat64PrefixDump(ctx context.Context, in *Nat64PrefixDump) (RPCService_Nat64PrefixDumpClient, error)
  27         Nat64SetTimeouts(ctx context.Context, in *Nat64SetTimeouts) (*Nat64SetTimeoutsReply, error)
  28         Nat64StDump(ctx context.Context, in *Nat64StDump) (RPCService_Nat64StDumpClient, error)
  29 }
  30
  31 type serviceClient struct {
  32         conn api.Connection
  33 }
  34
  35 func NewServiceClient(conn api.Connection) RPCService {
  36         return &serviceClient{conn}
  37 }
  38
  39 func (c *serviceClient) Nat64AddDelInterface(ctx context.Context, in *Nat64AddDelInterface) (*Nat64AddDelInterfaceReply, error) {
  40         out := new(Nat64AddDelInterfaceReply)
  41         err := c.conn.Invoke(ctx, in, out)
  42         if err != nil {
  43                 return nil, err
  44         }
  45         return out, api.RetvalToVPPApiError(out.Retval)
  46 }
  47
  48 func (c *serviceClient) Nat64AddDelInterfaceAddr(ctx context.Context, in *Nat64AddDelInterfaceAddr) (*Nat64AddDelInterfaceAddrReply, error) {
  49         out := new(Nat64AddDelInterfaceAddrReply)
  50         err := c.conn.Invoke(ctx, in, out)
  51         if err != nil {
  52                 return nil, err
  53         }
  54         return out, api.RetvalToVPPApiError(out.Retval)
  55 }
  56
  57 func (c *serviceClient) Nat64AddDelPoolAddrRange(ctx context.Context, in *Nat64AddDelPoolAddrRange) (*Nat64AddDelPoolAddrRangeReply, error) {
  58         out := new(Nat64AddDelPoolAddrRangeReply)
  59         err := c.conn.Invoke(ctx, in, out)
  60         if err != nil {
  61                 return nil, err
  62         }
  63         return out, api.RetvalToVPPApiError(out.Retval)
  64 }
  65
  66 func (c *serviceClient) Nat64AddDelPrefix(ctx context.Context, in *Nat64AddDelPrefix) (*Nat64AddDelPrefixReply, error) {
  67         out := new(Nat64AddDelPrefixReply)
  68         err := c.conn.Invoke(ctx, in, out)
  69         if err != nil {
  70                 return nil, err
  71         }
  72         return out, api.RetvalToVPPApiError(out.Retval)
  73 }
  74
  75 func (c *serviceClient) Nat64AddDelStaticBib(ctx context.Context, in *Nat64AddDelStaticBib) (*Nat64AddDelStaticBibReply, error) {
  76         out := new(Nat64AddDelStaticBibReply)
  77         err := c.conn.Invoke(ctx, in, out)
  78         if err != nil {
  79                 return nil, err
  80         }
  81         return out, api.RetvalToVPPApiError(out.Retval)
  82 }
  83
  84 func (c *serviceClient) Nat64BibDump(ctx context.Context, in *Nat64BibDump) (RPCService_Nat64BibDumpClient, error) {
  85         stream, err := c.conn.NewStream(ctx)
  86         if err != nil {
  87                 return nil, err
  88         }
  89         x := &serviceClient_Nat64BibDumpClient{stream}
  90         if err := x.Stream.SendMsg(in); err != nil {
  91                 return nil, err
  92         }
  93         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  94                 return nil, err
  95         }
  96         return x, nil
  97 }
  98
  99 type RPCService_Nat64BibDumpClient interface {
 100         Recv() (*Nat64BibDetails, error)
 101         api.Stream
 102 }
 103
 104 type serviceClient_Nat64BibDumpClient struct {
 105         api.Stream
 106 }
 107
 108 func (c *serviceClient_Nat64BibDumpClient) Recv() (*Nat64BibDetails, error) {
 109         msg, err := c.Stream.RecvMsg()
 110         if err != nil {
 111                 return nil, err
 112         }
 113         switch m := msg.(type) {
 114         case *Nat64BibDetails:
 115                 return m, nil
 116         case *vpe.ControlPingReply:
 117                 return nil, io.EOF
 118         default:
 119                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 120         }
 121 }
 122
 123 func (c *serviceClient) Nat64GetTimeouts(ctx context.Context, in *Nat64GetTimeouts) (*Nat64GetTimeoutsReply, error) {
 124         out := new(Nat64GetTimeoutsReply)
 125         err := c.conn.Invoke(ctx, in, out)
 126         if err != nil {
 127                 return nil, err
 128         }
 129         return out, api.RetvalToVPPApiError(out.Retval)
 130 }
 131
 132 func (c *serviceClient) Nat64InterfaceDump(ctx context.Context, in *Nat64InterfaceDump) (RPCService_Nat64InterfaceDumpClient, error) {
 133         stream, err := c.conn.NewStream(ctx)
 134         if err != nil {
 135                 return nil, err
 136         }
 137         x := &serviceClient_Nat64InterfaceDumpClient{stream}
 138         if err := x.Stream.SendMsg(in); err != nil {
 139                 return nil, err
 140         }
 141         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 142                 return nil, err
 143         }
 144         return x, nil
 145 }
 146
 147 type RPCService_Nat64InterfaceDumpClient interface {
 148         Recv() (*Nat64InterfaceDetails, error)
 149         api.Stream
 150 }
 151
 152 type serviceClient_Nat64InterfaceDumpClient struct {
 153         api.Stream
 154 }
 155
 156 func (c *serviceClient_Nat64InterfaceDumpClient) Recv() (*Nat64InterfaceDetails, error) {
 157         msg, err := c.Stream.RecvMsg()
 158         if err != nil {
 159                 return nil, err
 160         }
 161         switch m := msg.(type) {
 162         case *Nat64InterfaceDetails:
 163                 return m, nil
 164         case *vpe.ControlPingReply:
 165                 return nil, io.EOF
 166         default:
 167                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 168         }
 169 }
 170
 171 func (c *serviceClient) Nat64PluginEnableDisable(ctx context.Context, in *Nat64PluginEnableDisable) (*Nat64PluginEnableDisableReply, error) {
 172         out := new(Nat64PluginEnableDisableReply)
 173         err := c.conn.Invoke(ctx, in, out)
 174         if err != nil {
 175                 return nil, err
 176         }
 177         return out, api.RetvalToVPPApiError(out.Retval)
 178 }
 179
 180 func (c *serviceClient) Nat64PoolAddrDump(ctx context.Context, in *Nat64PoolAddrDump) (RPCService_Nat64PoolAddrDumpClient, error) {
 181         stream, err := c.conn.NewStream(ctx)
 182         if err != nil {
 183                 return nil, err
 184         }
 185         x := &serviceClient_Nat64PoolAddrDumpClient{stream}
 186         if err := x.Stream.SendMsg(in); err != nil {
 187                 return nil, err
 188         }
 189         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 190                 return nil, err
 191         }
 192         return x, nil
 193 }
 194
 195 type RPCService_Nat64PoolAddrDumpClient interface {
 196         Recv() (*Nat64PoolAddrDetails, error)
 197         api.Stream
 198 }
 199
 200 type serviceClient_Nat64PoolAddrDumpClient struct {
 201         api.Stream
 202 }
 203
 204 func (c *serviceClient_Nat64PoolAddrDumpClient) Recv() (*Nat64PoolAddrDetails, error) {
 205         msg, err := c.Stream.RecvMsg()
 206         if err != nil {
 207                 return nil, err
 208         }
 209         switch m := msg.(type) {
 210         case *Nat64PoolAddrDetails:
 211                 return m, nil
 212         case *vpe.ControlPingReply:
 213                 return nil, io.EOF
 214         default:
 215                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 216         }
 217 }
 218
 219 func (c *serviceClient) Nat64PrefixDump(ctx context.Context, in *Nat64PrefixDump) (RPCService_Nat64PrefixDumpClient, error) {
 220         stream, err := c.conn.NewStream(ctx)
 221         if err != nil {
 222                 return nil, err
 223         }
 224         x := &serviceClient_Nat64PrefixDumpClient{stream}
 225         if err := x.Stream.SendMsg(in); err != nil {
 226                 return nil, err
 227         }
 228         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 229                 return nil, err
 230         }
 231         return x, nil
 232 }
 233
 234 type RPCService_Nat64PrefixDumpClient interface {
 235         Recv() (*Nat64PrefixDetails, error)
 236         api.Stream
 237 }
 238
 239 type serviceClient_Nat64PrefixDumpClient struct {
 240         api.Stream
 241 }
 242
 243 func (c *serviceClient_Nat64PrefixDumpClient) Recv() (*Nat64PrefixDetails, error) {
 244         msg, err := c.Stream.RecvMsg()
 245         if err != nil {
 246                 return nil, err
 247         }
 248         switch m := msg.(type) {
 249         case *Nat64PrefixDetails:
 250                 return m, nil
 251         case *vpe.ControlPingReply:
 252                 return nil, io.EOF
 253         default:
 254                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 255         }
 256 }
 257
 258 func (c *serviceClient) Nat64SetTimeouts(ctx context.Context, in *Nat64SetTimeouts) (*Nat64SetTimeoutsReply, error) {
 259         out := new(Nat64SetTimeoutsReply)
 260         err := c.conn.Invoke(ctx, in, out)
 261         if err != nil {
 262                 return nil, err
 263         }
 264         return out, api.RetvalToVPPApiError(out.Retval)
 265 }
 266
 267 func (c *serviceClient) Nat64StDump(ctx context.Context, in *Nat64StDump) (RPCService_Nat64StDumpClient, error) {
 268         stream, err := c.conn.NewStream(ctx)
 269         if err != nil {
 270                 return nil, err
 271         }
 272         x := &serviceClient_Nat64StDumpClient{stream}
 273         if err := x.Stream.SendMsg(in); err != nil {
 274                 return nil, err
 275         }
 276         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 277                 return nil, err
 278         }
 279         return x, nil
 280 }
 281
 282 type RPCService_Nat64StDumpClient interface {
 283         Recv() (*Nat64StDetails, error)
 284         api.Stream
 285 }
 286
 287 type serviceClient_Nat64StDumpClient struct {
 288         api.Stream
 289 }
 290
 291 func (c *serviceClient_Nat64StDumpClient) Recv() (*Nat64StDetails, error) {
 292         msg, err := c.Stream.RecvMsg()
 293         if err != nil {
 294                 return nil, err
 295         }
 296         switch m := msg.(type) {
 297         case *Nat64StDetails:
 298                 return m, nil
 299         case *vpe.ControlPingReply:
 300                 return nil, io.EOF
 301         default:
 302                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 303         }
 304 }