// This file illustrates the cross language polymorphism using directors.

using System;

// CEO class, which overrides Employee::getPosition().

class CEO : Manager {
  public CEO(String name) : base(name) {
  }
  public override String getPosition() {
    return "CEO";
  }
  // Public method to stop the SWIG proxy base class from thinking it owns the underlying C++ memory.
  public void disownMemory() {
    swigCMemOwn = false; 
  } 
}


public class runme
{
  static void Main() 
  {
    // Create an instance of CEO, a class derived from the C# proxy of the 
    // underlying C++ class. The calls to getName() and getPosition() are standard,
    // the call to getTitle() uses the director wrappers to call CEO.getPosition().

    CEO e = new CEO("Alice");
    Console.WriteLine( e.getName() + " is a " + e.getPosition() );
    Console.WriteLine( "Just call her \"" + e.getTitle() + "\"" );
    Console.WriteLine( "----------------------" );

    // Create a new EmployeeList instance.  This class does not have a C++
    // director wrapper, but can be used freely with other classes that do.

    using (EmployeeList list = new EmployeeList()) {

    // EmployeeList owns its items, so we must surrender ownership of objects we add.
    e.disownMemory();
    list.addEmployee(e);
    Console.WriteLine( "----------------------" );

    // Now we access the first four items in list (three are C++ objects that
    // EmployeeList's constructor adds, the last is our CEO). The virtual
    // methods of all these instances are treated the same. For items 0, 1, and
    // 2, all methods resolve in C++. For item 3, our CEO, getTitle calls
    // getPosition which resolves in C#. The call to getPosition is
    // slightly different, however, because of the overidden getPosition() call, since
    // now the object reference has been "laundered" by passing through
    // EmployeeList as an Employee*. Previously, C# resolved the call
    // immediately in CEO, but now C# thinks the object is an instance of
    // class Employee. So the call passes through the
    // Employee proxy class and on to the C wrappers and C++ director,
    // eventually ending up back at the C# CEO implementation of getPosition().
    // The call to getTitle() for item 3 runs the C++ Employee::getTitle()
    // method, which in turn calls getPosition(). This virtual method call
    // passes down through the C++ director class to the C# implementation
    // in CEO. All this routing takes place transparently.

    Console.WriteLine( "(position, title) for items 0-3:" );

    Console.WriteLine( "  " + list.get_item(0).getPosition() + ", \"" + list.get_item(0).getTitle() + "\"" );
    Console.WriteLine( "  " + list.get_item(1).getPosition() + ", \"" + list.get_item(1).getTitle() + "\"" );
    Console.WriteLine( "  " + list.get_item(2).getPosition() + ", \"" + list.get_item(2).getTitle() + "\"" );
    Console.WriteLine( "  " + list.get_item(3).getPosition() + ", \"" + list.get_item(3).getTitle() + "\"" );
    Console.WriteLine( "----------------------" );

    // The using statement ensures the EmployeeList.Dispose() will be called, which will delete all the Employee*
    // items it contains. The last item is our CEO, which gets destroyed as well.
    }
    Console.WriteLine( "----------------------" );

    // All done.

    Console.WriteLine( "C# exit" );
  }
}
