text: /**
   * This test demonstrates director classes when the types are classes. Shown are
   * virtual function calls which use classes passed by
   *  - Value
   *  - Reference
   *  - Pointer
   * as both parameters and return values
   *
   * The test also demonstrates directors used with:
   *  - method overloading
   *  - default parameters
   *
   * Note: Methods with default parameters that call up from C++ cannot call the
   * overloaded D methods, see DefaultParms method.
  
   * Expected output if PrintDebug enabled:
   * ------------ Start ------------
   * Base - Val(444.555)
   * Base - Ref(444.555)
   * Base - Ptr(444.555)
   * Base - ConstPtrRef(444.555)
   * Base - FullyOverloaded(int 10)
   * Base - FullyOverloaded(bool 1)
   * Base - SemiOverloaded(int -678)
   * Base - SemiOverloaded(bool 1)
   * Base - DefaultParms(10, 2.2)
   * Base - DefaultParms(10, 1.1)
   * --------------------------------
   * Derived - Val(444.555)
   * Derived - Ref(444.555)
   * Derived - Ptr(444.555)
   * Derived - ConstPtrRef(444.555)
   * Derived - FullyOverloaded(int 10)
   * Derived - FullyOverloaded(bool 1)
   * Derived - SemiOverloaded(int -678)
   * Base - SemiOverloaded(bool 1)
   * Derived - DefaultParms(10, 2.2)
   * Derived - DefaultParms(10, 1.1)
   * --------------------------------
   * DDerived - Val(444.555)
   * DDerived - Ref(444.555)
   * DDerived - Ptr(444.555)
   * DDerived - ConstPtrRef(444.555)
   * DDerived - FullyOverloaded(int 10)
   * DDerived - FullyOverloaded(bool True)
   * DDerived - SemiOverloaded(-678)
   * Base - SemiOverloaded(bool 1)
   * DDerived - DefaultParms(10, 2.2)
   * DDerived - DefaultParms(10, 1.1)
   * ------------ Finish ------------
   */
  module director_classes_runme;
  
  import tango.io.Stdout;
  import tango.text.Util;
  import director_classes.director_classes;
  import director_classes.Caller;
  import director_classes.Base;
  import director_classes.Derived;
  import director_classes.DoubleHolder;
  
  void main() {
    if (PrintDebug) Stdout.formatln("------------ Start ------------");
  
    auto myCaller = new Caller();
  
    // Test C++ base class.
    {
      scope myBase = new Base(100.0);
      makeCalls(myCaller, myBase);
    }
  
    if (PrintDebug) Stdout.formatln("--------------------------------");
  
    // Test vanilla C++ wrapped derived class.
    {
      scope myBase = new Derived(200.0);
      makeCalls(myCaller, myBase);
    }
  
    if (PrintDebug) Stdout.formatln("--------------------------------");
  
    // Test director / D derived class.
    {
      scope myBase = new DDerived(300.0);
      makeCalls(myCaller, myBase);
    }
  
    if (PrintDebug) Stdout.formatln("------------ Finish ------------");
  }
  
  void makeCalls(Caller myCaller, Base myBase) {
    char[] myBaseType = myBase.classinfo.name.split(".")[$-1];
    myCaller.set(myBase);
  
    DoubleHolder dh = new DoubleHolder(444.555);
  
    // Class pointer, reference and pass by value tests
    if (myCaller.ValCall(dh).val != dh.val) throw new Exception("[1] failed");
    if (myCaller.RefCall(dh).val != dh.val) throw new Exception("[2] failed");
    if (myCaller.PtrCall(dh).val != dh.val) throw new Exception("[3] failed");
    if (myCaller.ConstPtrRefCall(dh).val != dh.val) throw new Exception("[3] failed");
  
    // Fully overloaded method test (all methods in base class are overloaded)
    if (myCaller.FullyOverloadedCall(10) != myBaseType ~ "::FullyOverloaded(int)") throw new Exception("[4] failed");
    if (myCaller.FullyOverloadedCall(true) != myBaseType ~ "::FullyOverloaded(bool)") throw new Exception("[5] failed");
  
    // Semi overloaded method test (some methods in base class are overloaded)
    if (myCaller.SemiOverloadedCall(-678) != myBaseType ~ "::SemiOverloaded(int)") throw new Exception("[6] failed");
    if (myCaller.SemiOverloadedCall(true) != "Base" ~ "::SemiOverloaded(bool)") throw new Exception("[7] failed");
  
    // Default parameters methods test
    if (myCaller.DefaultParmsCall(10, 2.2) != myBaseType ~ "::DefaultParms(int, double)") throw new Exception("[8] failed");
    if (myBase.classinfo == DDerived.classinfo) { // special handling for D derived classes, there is no way to do this any other way
      if (myCaller.DefaultParmsCall(10) != myBaseType ~ "::DefaultParms(int, double)") throw new Exception("[9] failed");
    } else {
      if (myCaller.DefaultParmsCall(10) != myBaseType ~ "::DefaultParms(int)") throw new Exception("[10] failed");
    }
  
    myCaller.reset();
  }
  
  public class DDerived : Base {
    public this(double dd) {
      super(dd);
    }
  
    public override DoubleHolder Val(DoubleHolder x) {
      if (PrintDebug) Stdout.formatln("DDerived - Val({0:d3})", x.val);
      return x;
    }
  
    public override DoubleHolder Ref(DoubleHolder x) {
      if (PrintDebug) Stdout.formatln("DDerived - Ref({0:d3})", x.val);
      return x;
    }
  
    public override DoubleHolder Ptr(DoubleHolder x) {
      if (PrintDebug) Stdout.formatln("DDerived - Ptr({0:d3})", x.val);
      return x;
    }
  
    public override DoubleHolder ConstPtrRef(DoubleHolder x) {
      if (PrintDebug) Stdout.formatln("DDerived - ConstPtrRef({0:d3})", x.val);
      return x;
    }
  
    public override char[] FullyOverloaded(int x) {
      if (PrintDebug) Stdout.formatln("DDerived - FullyOverloaded(int {0})", x);
      return "DDerived::FullyOverloaded(int)";
    }
  
    public override char[] FullyOverloaded(bool x) {
      if (PrintDebug) Stdout.formatln("DDerived - FullyOverloaded(bool {0})", x);
      return "DDerived::FullyOverloaded(bool)";
    }
  
    public override char[] SemiOverloaded(int x) {
      char[] ret = "DDerived::SemiOverloaded(int)";
      if (PrintDebug) Stdout.formatln("DDerived - SemiOverloaded({0})", x);
      return ret;
    }
    alias Base.SemiOverloaded SemiOverloaded; // Alias in SemiOverloaded(bool x).
  
    public override char[] DefaultParms(int x, double y) {
      char[] ret = "DDerived::DefaultParms(int, double)";
      if (PrintDebug) Stdout.formatln("DDerived - DefaultParms({0}, {1:d1})", x, y);
      return ret;
    }
    // This method will never be called from C++ code because the two-parameter
    // DefaultParams() has a default value for the second parameter there. It is
    // only here to ensure consistent behavior for calls from C++ and D code.
    public override char[] DefaultParms(int x) {
      if (PrintDebug) Stdout.formatln("DDerived - DefaultParms({0})", x);
      return DefaultParms(x, 1.1/*use C++ default here*/);
    }
  }
  