Mirror of forum.nim-lang.org

8090 :: Using nim `method` to wrap C++ methods

• haxscramper_ (orginal) [2021-06-06T10:29:03+02:00] view original

  When interfacing with C++ classes and methods it is necessary to re-wrap methods as procedures for each derived class. E.g. if I have Base and Derived I would have to repeat wrapping of the Base methods for Derived type. I tried using method, but it gives me 'invalid pragma: importcpp: "#.toOverride(@)"' error on the following code:

  {.emit: """/*TYPESECTION*/
  struct Base {
    int baseField;
    int baseMethod() { return 12; }
    virtual int toOverride() { return 42; }
  
  };
  struct Derived : public Base {
    int derivedField;
    int toOverride() override { return 45; }
  };
  """.}
  
  type
    CxxBase {.importcpp: "Base", bycopy, inheritable.} = object
      baseField: cint
    
    CxxDerived {.importcpp: "Derived", bycopy.} = object of CxxBase
      derivedField: cint
  
  # All methods of the base class must be repeated for each derived. For
  # cases like `QWidget` that has 214 base classes and 37 derived it results
  # in **7918!** repetitions.
  proc baseMethod(base: CxxBase): cint {.importcpp: "#.baseMethod(@)".}
  proc baseMethod(base: CxxDerived): cint {.importcpp: "#.baseMethod(@)".}
  
  proc toOverride(base: CxxBase): cint {.importcpp: "#.toOverride(@)".}
  proc toOverride(base: CxxDerived): cint {.importcpp: "#.toOverride(@)".}
  
  proc toOverrideTypeclass(base: CxxBase | CxxDerived): cint {.importcpp: "#.toOverride(@)".}
  
  
  # Ideally I would like to import C++ methods as **methods**, but I get
  # 'Error: invalid pragma: importcpp: "#.toOverride(@)"'
  
  when false:
    method toOverrideMethod(base: CxxBase): cint {.importcpp: "#.toOverride(@)".}
  
  block:
    let derived = CxxDerived(baseField: 123123)
    echo derived.baseField
    
    echo CxxBase().toOverride()
    echo CxxDerived().toOverride()
    
    echo CxxBase().toOverrideTypeclass()
    echo CxxDerived().toOverrideTypeclass()
  
  type
    NimBase {.inheritable.} = object
      baseField: cint
    
    NimDerived = object of NimBase
      derivedField: cint
  
  method baseMethod(base: NimBase): int {.base.} = 12
  method toOverride(base: NimBase): int {.base.} = 42
  method toOverride(base: NimDerived): int = 45
  
  block:
    let derived = NimDerived(baseField: 123123)
    echo derived.baseField
    
    echo NimBase().toOverride()
    echo NimDerived().toOverride()
  Run

  I specifically repeated the implementation in nim as well to illustrate how I would like wrapper to behave. It is not difficult to generate additional wrappers for all derived classes, but as indicated in comment it could lead to multi-thousand repetitions (again QWidget has 37 derived classes and it would repeat at least 214 methods for each of them. And I used QWidget as and example. With QObject it could be even bigger).

  I though about possible solutions, but they don't seem particularly plausible to me:

  1. Using typeclasses - proc toOverride(base: CxxBase | CxxDerived): cint {.importcpp: "#.toOverride(@)".}. It might look fine for such small example, but in the end it would mean putting all derived class wrappers in a single file, and declare all procedures afterwards, creating one giant file from a library instead of keeping things separated.
  2. Implementing wrappers as a macro that checks if argument has been derived from required base class - this might work, but it seems like a horrible hack where I have to mix {.emit.} with macro code and traverse full inheritance tree on each call encountered in code.

---