Mapping Contents

By default, all the public constructors, public methods and public inner classes are exported. You can select which of theses items you wants in your resulting C++ proxies. You have two ways for selecting items :

export all items, and manually lists items you don't want to generate
export no items, and manually lists items you want to generate

Public constructors

You can select which of the public constructors of a Java class will be present in the resulting C++ proxy.

Annotation case:

package demo;
@Java4Cpp
public class Sample {
   public Sample() {}

   @Java4CppNoWrappe
   public Sample(double a) {}
}

package demo;
@Java4Cpp(all = false)
public class Sample {
   @Java4CppWrappe
   public Sample() {}

   public Sample(double a) {}
}

XML case:

You locate the constructor by specifying his parameters JNI signature's. Default constructor with no parameter is simply an empty string.

<mappings>
   <classes>
      <class class="demo.Sample">
         <constructors>
	    <noWrappes>
	       <noWrappe>D</noWrappe>
	    </noWrappes>
         </constructors>
      </class>
   </classes>
</mappings>

<mappings>
   <classes>
      <class class="demo.Sample" exportAll="false">
         <constructors>
	    <wrappes>
	       <wrappe></wrappe>
	    </wrappes>
         </constructors>
      </class>
   </classes>
</mappings>

will produce

namespace demo {
   class Sample {
   public:
      Sample();
   };
}

Public methods

You can select which of the public methods (static or not) of a Java class will be present in the resulting C++ proxy.

Annotation case:

package demo;
@Java4Cpp
public class Sample {
   public String method(double a) {}

   @Java4CppNoWrappe
   public void method(String a) {}
}

package demo;
@Java4Cpp(all = false)
public class Sample {
   @Java4CppWrappe
   public String method(double a) {}

   public void method(String a) {}
}

XML case:

You locate the method by specifying is name following by his parameters JNI signature's in parenthesis.

<mappings>
   <classes>
      <class class="demo.Sample">
         <methods>
	    <noWrappes>
	       <noWrappe>method(Ljava.lang.String;)</noWrappe>
	    </noWrappes>
         </methods>
      </class>
   </classes>
</mappings>

<mappings>
   <classes>
      <class class="demo.Sample" exportAll="false">
         <methods>
	    <wrappes>
	       <wrappe>method(D)</wrappe>
	    </wrappes>
         </methods>
      </class>
   </classes>
</mappings>

will produce

namespace demo {
   class Sample {
   public:
      java::lang::String method(double arg1);
   };
}

Public static fields

You can select which of the public static fields of a Java class will be present in the resulting C++ proxy.

Annotation case:

package demo;
@Java4Cpp
public class Sample {
   public static Double field1;

   @Java4CppNoWrappe
   public static String field2;
}

package demo;
@Java4Cpp(staticFields = false)
public class Sample {
   @Java4CppWrappe
   public static Double field1;

   public static String field2;
}

XML case:

You locate the static field by specifying is name.

<mappings>
   <classes>
      <class class="demo.Sample">
         <staticFields>
	    <noWrappes>
	       <noWrappe>field2</noWrappe>
	    </noWrappes>
         </staticFields>
      </class>
   </classes>
</mappings>

<mappings>
   <classes>
      <class class="demo.Sample" staticFields="false">
         <staticFields>
	    <wrappes>
	       <wrappe>field1</wrappe>
	    </wrappes>
         </staticFields>
      </class>
   </classes>
</mappings>

will produce

namespace demo {
   class Sample {
   public:
      static java::lang::Double getField1();
   };
}

Public inner classes

You can select which of the public inner (static or not) classes (or enums) of a Java class will be present in the resulting C++ proxy.

Annotation case:

For inner classes, you have the choice of using Java4CppWrappe like for other items, or using Java4Cpp for a more precise control of the mapping for this inner class.

package demo;
@Java4Cpp
public class Sample {
   public class Inner1 {
   }

   @Java4CppNoWrappe
   public static class Inner2 {
   }
}

package demo;
@Java4Cpp(all = false)
public class Sample {
   @Java4CppWrappe
   public class Inner1 {
   }

   public static class Inner2 {
   }
}

XML case:

You locate the static inner class by specifying is name.

<mappings>
   <classes>
      <class class="demo.Sample">
         <innerClasses>
	    <noWrappes>
	       <noWrappe>Inner2</noWrappe>
	    </noWrappes>
         </innerClasses>
      </class>
   </classes>
</mappings>

<mappings>
   <classes>
      <class class="demo.Sample" exportAll="false">
         <innerClasses>
	    <wrappes>
	       <wrappe>Inner1</wrappe>
	    </wrappes>
         </innerClasses>
      </class>
   </classes>
</mappings>

will produce

namespace demo {
   class Sample {
   public:
      class Inner1 {
      };
   };
}