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         memclnt "git.fd.io/govpp.git/binapi/memclnt"
  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(&memclnt.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 *memclnt.ControlPingReply:
 117                 err = c.Stream.Close()
 118                 if err != nil {
 119                         return nil, err
 120                 }
 121                 return nil, io.EOF
 122         default:
 123                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 124         }
 125 }
 126
 127 func (c *serviceClient) Nat64GetTimeouts(ctx context.Context, in *Nat64GetTimeouts) (*Nat64GetTimeoutsReply, error) {
 128         out := new(Nat64GetTimeoutsReply)
 129         err := c.conn.Invoke(ctx, in, out)
 130         if err != nil {
 131                 return nil, err
 132         }
 133         return out, api.RetvalToVPPApiError(out.Retval)
 134 }
 135
 136 func (c *serviceClient) Nat64InterfaceDump(ctx context.Context, in *Nat64InterfaceDump) (RPCService_Nat64InterfaceDumpClient, error) {
 137         stream, err := c.conn.NewStream(ctx)
 138         if err != nil {
 139                 return nil, err
 140         }
 141         x := &serviceClient_Nat64InterfaceDumpClient{stream}
 142         if err := x.Stream.SendMsg(in); err != nil {
 143                 return nil, err
 144         }
 145         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 146                 return nil, err
 147         }
 148         return x, nil
 149 }
 150
 151 type RPCService_Nat64InterfaceDumpClient interface {
 152         Recv() (*Nat64InterfaceDetails, error)
 153         api.Stream
 154 }
 155
 156 type serviceClient_Nat64InterfaceDumpClient struct {
 157         api.Stream
 158 }
 159
 160 func (c *serviceClient_Nat64InterfaceDumpClient) Recv() (*Nat64InterfaceDetails, error) {
 161         msg, err := c.Stream.RecvMsg()
 162         if err != nil {
 163                 return nil, err
 164         }
 165         switch m := msg.(type) {
 166         case *Nat64InterfaceDetails:
 167                 return m, nil
 168         case *memclnt.ControlPingReply:
 169                 err = c.Stream.Close()
 170                 if err != nil {
 171                         return nil, err
 172                 }
 173                 return nil, io.EOF
 174         default:
 175                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 176         }
 177 }
 178
 179 func (c *serviceClient) Nat64PluginEnableDisable(ctx context.Context, in *Nat64PluginEnableDisable) (*Nat64PluginEnableDisableReply, error) {
 180         out := new(Nat64PluginEnableDisableReply)
 181         err := c.conn.Invoke(ctx, in, out)
 182         if err != nil {
 183                 return nil, err
 184         }
 185         return out, api.RetvalToVPPApiError(out.Retval)
 186 }
 187
 188 func (c *serviceClient) Nat64PoolAddrDump(ctx context.Context, in *Nat64PoolAddrDump) (RPCService_Nat64PoolAddrDumpClient, error) {
 189         stream, err := c.conn.NewStream(ctx)
 190         if err != nil {
 191                 return nil, err
 192         }
 193         x := &serviceClient_Nat64PoolAddrDumpClient{stream}
 194         if err := x.Stream.SendMsg(in); err != nil {
 195                 return nil, err
 196         }
 197         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 198                 return nil, err
 199         }
 200         return x, nil
 201 }
 202
 203 type RPCService_Nat64PoolAddrDumpClient interface {
 204         Recv() (*Nat64PoolAddrDetails, error)
 205         api.Stream
 206 }
 207
 208 type serviceClient_Nat64PoolAddrDumpClient struct {
 209         api.Stream
 210 }
 211
 212 func (c *serviceClient_Nat64PoolAddrDumpClient) Recv() (*Nat64PoolAddrDetails, error) {
 213         msg, err := c.Stream.RecvMsg()
 214         if err != nil {
 215                 return nil, err
 216         }
 217         switch m := msg.(type) {
 218         case *Nat64PoolAddrDetails:
 219                 return m, nil
 220         case *memclnt.ControlPingReply:
 221                 err = c.Stream.Close()
 222                 if err != nil {
 223                         return nil, err
 224                 }
 225                 return nil, io.EOF
 226         default:
 227                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 228         }
 229 }
 230
 231 func (c *serviceClient) Nat64PrefixDump(ctx context.Context, in *Nat64PrefixDump) (RPCService_Nat64PrefixDumpClient, error) {
 232         stream, err := c.conn.NewStream(ctx)
 233         if err != nil {
 234                 return nil, err
 235         }
 236         x := &serviceClient_Nat64PrefixDumpClient{stream}
 237         if err := x.Stream.SendMsg(in); err != nil {
 238                 return nil, err
 239         }
 240         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 241                 return nil, err
 242         }
 243         return x, nil
 244 }
 245
 246 type RPCService_Nat64PrefixDumpClient interface {
 247         Recv() (*Nat64PrefixDetails, error)
 248         api.Stream
 249 }
 250
 251 type serviceClient_Nat64PrefixDumpClient struct {
 252         api.Stream
 253 }
 254
 255 func (c *serviceClient_Nat64PrefixDumpClient) Recv() (*Nat64PrefixDetails, error) {
 256         msg, err := c.Stream.RecvMsg()
 257         if err != nil {
 258                 return nil, err
 259         }
 260         switch m := msg.(type) {
 261         case *Nat64PrefixDetails:
 262                 return m, nil
 263         case *memclnt.ControlPingReply:
 264                 err = c.Stream.Close()
 265                 if err != nil {
 266                         return nil, err
 267                 }
 268                 return nil, io.EOF
 269         default:
 270                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 271         }
 272 }
 273
 274 func (c *serviceClient) Nat64SetTimeouts(ctx context.Context, in *Nat64SetTimeouts) (*Nat64SetTimeoutsReply, error) {
 275         out := new(Nat64SetTimeoutsReply)
 276         err := c.conn.Invoke(ctx, in, out)
 277         if err != nil {
 278                 return nil, err
 279         }
 280         return out, api.RetvalToVPPApiError(out.Retval)
 281 }
 282
 283 func (c *serviceClient) Nat64StDump(ctx context.Context, in *Nat64StDump) (RPCService_Nat64StDumpClient, error) {
 284         stream, err := c.conn.NewStream(ctx)
 285         if err != nil {
 286                 return nil, err
 287         }
 288         x := &serviceClient_Nat64StDumpClient{stream}
 289         if err := x.Stream.SendMsg(in); err != nil {
 290                 return nil, err
 291         }
 292         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 293                 return nil, err
 294         }
 295         return x, nil
 296 }
 297
 298 type RPCService_Nat64StDumpClient interface {
 299         Recv() (*Nat64StDetails, error)
 300         api.Stream
 301 }
 302
 303 type serviceClient_Nat64StDumpClient struct {
 304         api.Stream
 305 }
 306
 307 func (c *serviceClient_Nat64StDumpClient) Recv() (*Nat64StDetails, error) {
 308         msg, err := c.Stream.RecvMsg()
 309         if err != nil {
 310                 return nil, err
 311         }
 312         switch m := msg.(type) {
 313         case *Nat64StDetails:
 314                 return m, nil
 315         case *memclnt.ControlPingReply:
 316                 err = c.Stream.Close()
 317                 if err != nil {
 318                         return nil, err
 319                 }
 320                 return nil, io.EOF
 321         default:
 322                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 323         }
 324 }