New example based on Python version

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@5093 626c5289-ae23-0410-ae9c-e8d60b6d4f22
2003-09-08 22:10:43 +00:00 · 2003-09-08 22:10:43 +00:00 · 9245647ea7
commit 9245647ea7
parent 861fac1d90
6 changed files with 209 additions and 0 deletions
--- a/SWIG/Examples/java/extend/Makefile
+++ b/SWIG/Examples/java/extend/Makefile
@ -0,0 +1,18 @@
+TOP        = ../..
+SWIG       = $(TOP)/../swig
+CXXSRCS    = example.cxx
+TARGET     = example
+INTERFACE  = example.i
+SWIGOPT    =
+
+all::	java
+
+java::
+	$(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+	SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
+	javac *.java
+
+clean::
+	$(MAKE) -f $(TOP)/Makefile java_clean
+
+check: all
--- a/SWIG/Examples/java/extend/example.cxx
+++ b/SWIG/Examples/java/extend/example.cxx
@ -0,0 +1,4 @@
+/* File : example.cxx */
+
+#include "example.h"
+
--- a/SWIG/Examples/java/extend/example.h
+++ b/SWIG/Examples/java/extend/example.h
@ -0,0 +1,56 @@
+/* File : example.h */
+
+#include <cstdio>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cmath>
+
+class Employee {
+private:
+	std::string name;
+public:
+	Employee(const char* n): name(n) {}
+	virtual std::string getTitle() { return getPosition() + " " + getName(); }
+	virtual std::string getName() { return name; }
+	virtual std::string getPosition() const { return "Employee"; }
+	virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+};
+
+
+class Manager: public Employee {
+public:
+	Manager(const char* n): Employee(n) {}
+	virtual std::string getPosition() const { return "Manager"; }
+};
+
+
+class EmployeeList {
+	std::vector<Employee*> list;
+public:
+	EmployeeList() {
+		list.push_back(new Employee("Bob"));
+		list.push_back(new Employee("Jane"));
+		list.push_back(new Manager("Ted"));
+	}
+	void addEmployee(Employee *p) {
+		list.push_back(p);
+		std::cout << "New employee added.   Current employees are:" << std::endl;
+		std::vector<Employee*>::iterator i;
+		for (i=list.begin(); i!=list.end(); i++) {
+			std::cout << "  " << (*i)->getTitle() << std::endl;
+		}
+	}
+	const Employee *get_item(int i) {
+		return list[i];
+	}
+	~EmployeeList() { 
+		std::vector<Employee*>::iterator i;
+		std::cout << "~EmployeeList, deleting " << list.size() << " employees." << std::endl;
+		for (i=list.begin(); i!=list.end(); i++) {
+			delete *i;
+		}
+		std::cout << "~EmployeeList empty." << std::endl;
+	}
+};
+
--- a/SWIG/Examples/java/extend/example.i
+++ b/SWIG/Examples/java/extend/example.i
@ -0,0 +1,15 @@
+/* File : example.i */
+%module(directors="1") example
+%{
+#include "example.h"
+%}
+
+%include "std_vector.i"
+%include "std_string.i"
+
+/* turn on director wrapping for Manager */
+%feature("director") Employee;
+%feature("director") Manager;
+
+%include "example.h"
+
--- a/SWIG/Examples/java/extend/index.html
+++ b/SWIG/Examples/java/extend/index.html
@ -0,0 +1,21 @@
+<html>
+<head>
+<title>SWIG:Examples:java:extend</title>
+</head>
+
+<body bgcolor="#ffffff">
+
+
+<tt>SWIG/Examples/java/extend/</tt>
+<hr>
+
+<H2>Extending a simple C++ class in Java</H2>
+
+<tt>$Header</tt><br>
+
+<p>
+This example illustrates the extending of a C++ class with cross language polymorphism.
+
+<hr>
+</body>
+</html>
--- a/SWIG/Examples/java/extend/main.java
+++ b/SWIG/Examples/java/extend/main.java
@ -0,0 +1,95 @@
+// This file illustrates the cross language polymorphism using directors.
+
+
+// CEO class, which overrides Employee::getPosition().
+
+class CEO extends Manager {
+  public CEO(String name) {
+    super(name);
+    }
+  public String getPosition() {
+    return "CEO";
+    }
+}
+
+
+public class main {
+  static {
+    try {
+        System.loadLibrary("example");
+    } catch (UnsatisfiedLinkError e) {
+      System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+      System.exit(1);
+    }
+  }
+
+  public static void main(String argv[]) 
+  {
+
+    // Create an instance of our employee extension class, CEO. The calls to
+    // getName() and getPosition() are standard, the call to getTitle() uses
+    // the director wrappers to call CEO.getPosition. e = CEO("Alice")
+
+    CEO e = new CEO("Alice");
+    System.out.println( e.getName() + " is a " + e.getPosition() );
+    System.out.println( "Just call her \"" + e.getTitle() + "\"" );
+    System.out.println( "----------------------" );
+
+
+    // Create a new EmployeeList instance.  This class does not have a C++
+    // director wrapper, but can be used freely with other classes that do.
+
+    EmployeeList list = new EmployeeList();
+
+    // EmployeeList owns its items, so we must surrender ownership of objects
+    // we add. This involves first calling the __disown__ method to tell the
+    // C++ director to start reference counting. We reassign the resulting
+    // weakref.proxy to e so that no hard references remain. This can also be
+    // done when the object is constructed, as in: e =
+    // CEO("Alice").__disown__()
+
+//    e = e.__disown__();
+    list.addEmployee(e);
+    System.out.println( "----------------------" );
+
+    // 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, both all methods resolve in C++. For item 3, our CEO, getTitle calls
+    // getPosition which resolves in Java. The call to getPosition is
+    // slightly different, however, from the e.getPosition() call above, since
+    // now the object reference has been "laundered" by passing through
+    // EmployeeList as an Employee*. Previously, Java resolved the call
+    // immediately in CEO, but now Java thinks the object is an instance of
+    // class Employee (actually EmployeePtr). So the call passes through the
+    // Employee proxy class and on to the C wrappers and C++ director,
+    // eventually ending up back at the 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 Java implementation
+    // in CEO. All this routing takes place transparently.
+
+    System.out.println( "(position, title) for items 0-3:" );
+
+    System.out.println( "  " + list.get_item(0).getPosition() + ", \"" + list.get_item(0).getTitle() + "\"" );
+    System.out.println( "  " + list.get_item(1).getPosition() + ", \"" + list.get_item(1).getTitle() + "\"" );
+    System.out.println( "  " + list.get_item(2).getPosition() + ", \"" + list.get_item(2).getTitle() + "\"" );
+    System.out.println( "  " + list.get_item(3).getPosition() + ", \"" + list.get_item(3).getTitle() + "\"" );
+    System.out.println( "----------------------" );
+
+    // Time to delete the EmployeeList, which will delete all the Employee*
+    // items it contains. The last item is our CEO, which gets destroyed as its
+    // reference count goes to zero. The Java destructor runs, and is still
+    // able to call self.getName() since the underlying C++ object still
+    // exists. After this destructor runs the remaining C++ destructors run as
+    // usual to destroy the object.
+
+    list.delete();
+    System.out.println( "----------------------" );
+
+    // All done.
+
+    System.out.println( "java exit" );
+
+  }
+}