feat: add csharp interop code generation but no test.

- add csharp interop code generation without testing.
- add annotation for bmap binding project.
- fix README.

CodeGen/BMapBindings/VariableType.java

@@ -2,28 +2,51 @@ import java.util.Collections;
 import java.util.Vector;
 import java.util.stream.Collectors;
 
+/**
+ * The class represent the type of each parameters and function return value.
+ */
 public class VariableType {
 	/**
-	 * The base type of this variable which remove all ending stars. Each item is a
-	 * part of namespace string. If no namespace, this Vector will only have one
-	 * item.
+	 * The base type of this variable removing all ending stars (remove all pointer
+	 * levels) Each item in this a part of namespace and the last one must be the
+	 * type itself (without any namespace restriction). If no namespace restriction
+	 * for this type, this Vector will only have one item.
+	 * <p>
+	 * For end user, it is enough that knowing the last item is type itself.
 	 */
 	private Vector<String> mBaseType;
 	/**
-	 * The pointer level of this type. It is equal with the count of stars.
+	 * The pointer level of this type. It is equal to the count of trailing star of
+	 * this field in C style representation.
 	 */
 	private int mPointerLevel;
 
+	/**
+	 * Construct an empty varible type. This is commonly used constructor.
+	 */
 	public VariableType() {
 		mBaseType = new Vector<String>();
 		mPointerLevel = 0;
 	}
 
+	/**
+	 * The constructor used for cloning self. This constructor is only can be used
+	 * by self.
+	 * 
+	 * @param base_type     The hierarchy of the variable type.
+	 * @param pointer_level The pointer level of new created variable type.
+	 */
 	private VariableType(Vector<String> base_type, int pointer_level) {
 		mBaseType = (Vector<String>) base_type.clone();
 		mPointerLevel = pointer_level;
 	}
 
+	/**
+	 * Set this variable type with a type string in C/C++ style. For example
+	 * "NSTest::NSTest2::MyType**".
+	 * 
+	 * @param ctype The type string in C/C++ style.
+	 */
 	public void fromCType(String ctype) {
 		if (ctype.isEmpty())
 			throw new IllegalArgumentException("empty string can not be parsed.");
@@ -43,7 +66,7 @@ public class VariableType {
 			namepart = ctype.substring(0, star_pos);
 			mPointerLevel = len - star_pos;
 		}
-		
+
 		// resolve name part
 		mBaseType.clear();
 		for (String item : namepart.split("::")) {
@@ -51,31 +74,78 @@ public class VariableType {
 		}
 	}
 
+	/**
+	 * Build a type string represented by this variable type in C/C++ style.
+	 * 
+	 * @return The type string in C/C++ style.
+	 */
 	public String toCType() {
 		return mBaseType.stream().collect(Collectors.joining("::"))
 				+ String.join("", Collections.nCopies(mPointerLevel, "*"));
 	}
 
+	/**
+	 * Get the base type of this variable type without any namespace. It just simply
+	 * get the last entry in type hierarchy.
+	 * 
+	 * @return The base type string without namespace prefix.
+	 */
 	public String getBaseType() {
 		return mBaseType.lastElement();
 	}
 
+	/**
+	 * Check whether this variable type is a pointer. This function just check
+	 * whether the pointer level of this variavle type is zero.
+	 * 
+	 * @return True if it is pointer, otherwise false.
+	 */
 	public boolean isPointer() {
 		return mPointerLevel != 0;
 	}
-	
+
+	/**
+	 * Return the pointer level of this variable type. You can simply assume the
+	 * pointer level is equal to the count of trailing star.
+	 * 
+	 * @return The pointer level integer. Zero means that this type is not a
+	 *         pointer.
+	 */
 	public int getPointerLevel() {
 		return mPointerLevel;
 	}
-	
+
+	/**
+	 * Return the clone of the type hierarchy of this variable type.
+	 * <p>
+	 * It is rarely used. This only should be used when you need the namespace
+	 * hierarchy of this variable type.
+	 * 
+	 * @return The clone of current variable type hierarchy.
+	 */
 	public Vector<String> getBaseTypeHierarchy() {
 		return (Vector<String>) mBaseType.clone();
 	}
 
+	/**
+	 * Check whether this type is a valid one. It actually check whether type
+	 * hierarchy include at least one entry.
+	 * 
+	 * @return True if no problem of this type, otherwise false.
+	 */
 	public boolean isValid() {
 		return mBaseType.size() != 0;
 	}
 
+	/**
+	 * Return a new created variable type which is the pointer of this variable
+	 * type.
+	 * <p>
+	 * In internal implementation, it just create a clone of current variable type
+	 * with the increase of pointer level by 1.
+	 * 
+	 * @return The new created pointer type of this variable type.
+	 */
 	public VariableType getPointerOfThis() {
 		return new VariableType(mBaseType, mPointerLevel + 1);
 	}