refactor: finish refactor ExpFctsAnalyzer in BMapBinder

Assets/CodeGen/BMapBinder/ExpFctsAnalyzer/ExpFctsHelper.java

@@ -0,0 +1,248 @@
+import java.util.Collections;
+import java.util.Vector;
+import java.util.stream.Collectors;
+
+public class ExpFctsHelper {
+
+	/**
+	 * The class represent the type of each parameters and function return value.
+	 */
+	public static class VariableType {
+		/**
+		 * The base type of this variable removing all ending stars (remove all pointer levels).
+		 * Each item in this Vector is a part of namespace and the last one must be the type itself
+		 * (without any namespace constraint).
+		 * If no namespace constraint 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 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.");
+
+			// get pointer part and name part
+			int len = ctype.length();
+			int star_pos = ctype.indexOf('*');
+			String namepart;
+			if (star_pos == -1) {
+				// no star
+				namepart = ctype;
+				mPointerLevel = 0;
+			} else {
+				// has star
+				if (star_pos == 0)
+					throw new IllegalArgumentException("base type not found.");
+				namepart = ctype.substring(0, star_pos);
+				mPointerLevel = len - star_pos;
+			}
+
+			// resolve name part
+			mBaseType.clear();
+			for (String item : namepart.split("::")) {
+				mBaseType.add(item);
+			}
+		}
+
+		/**
+		 * 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);
+		}
+
+	}
+
+
+	/**
+	 * The class represent a single parameter (argument) of function. This class
+	 * usually is the member of {@linkplain ExpFct}.
+	 */
+	public static class ExpFctParam {
+
+		/**
+		 * The type of this parameter.
+		 */
+		public VariableType mVarType;
+		/**
+		 * The name of this parameter.
+		 */
+		public String mVarName;
+		/**
+		 * True if this paramter is marked as input parameter, otherwise false.
+		 * <p>
+		 * Input parameter and output paramter is commonly used in C/C++ code. By using
+		 * this feature, each function can receive multiple arguments and return
+		 * multiple arguments without defining a struct to hold it.
+		 * <p>
+		 * The type of input parameter is itself. However, the type of output parameter
+		 * is the pointer of itself. So you may need get its pointer type when
+		 * processing output paramter, especially for the scenario that the target
+		 * language do not support explicit output parameter keyword.
+		 */
+		public boolean mIsInput;
+		/**
+		 * The description of this parameter.
+		 * <p>
+		 * This description is generated by this program. It will indicate the
+		 * underlying C++ type to tell end user how to treat this paramter because some
+		 * target languages' native calling style can not represent these detail.
+		 * <p>
+		 * In this program, this field must be written as a annotation of corresponding
+		 * function.
+		 */
+		public String mVarDesc;
+
+		public ExpFctParam() {
+			mVarType = new VariableType();
+			mVarName = "";
+			mVarDesc = "";
+			mIsInput = true;
+		}
+
+	}
+
+	/**
+	 * The class represent an export BMap function.
+	 */
+	public static class ExpFct {
+
+		/**
+		 * The name of this function.
+		 */
+		public String mFctName;
+		/**
+		 * The return value type of this function.
+		 */
+		public VariableType mFctRetType;
+		/**
+		 * The parameters (arguments) list of this function. Each items are
+		 * {@linkplain ExpFctParam} and represent parameter one by one from left to
+		 * right.
+		 */
+		public Vector<ExpFctParam> mFctParams;
+
+		public ExpFct() {
+			mFctName = "";
+			mFctRetType = new VariableType();
+			mFctParams = new Vector<ExpFctParam>();
+		}
+
+	}
+
+	/**
+	 * The class represent a collection of export BMap functions.
+	 */
+	public static class ExpFctCollection {
+		/**
+		 * The collection of exported BMap functions.
+		 */
+		public Vector<ExpFct> mFcts;
+
+		public ExpFctCollection() {
+			mFcts = new Vector<ExpFct>();
+		}
+	}
+
+}