Public Member Functions
	ExternalRoutineInfo (Type type, Type[] argTypes)

	ExternalRoutineInfo (Type type)

	ExternalRoutineInfo (Type type, string methodName)

	ExternalRoutineInfo (Type type, string methodName, Type[] argTypes)

	ExternalRoutineInfo (string typeString, string methodName)

	ExternalRoutineInfo (string typeString, string methodName, string[] argNames)

MethodInfo	ResolveMethod (TType[] paramTypes)

override string	ToString ()

Static Public Member Functions
static ExternalRoutineInfo	Parse (string s)

static string	FormatString (Type type)

static string	FormatString (Type type, Type[] argTypes)

static string	FormatString (Type type, string methodName)

static string	FormatString (Type type, string methodName, Type[] argTypes)

Properties
string	TypeName `[get, private set]`

string	MethodName `[get, private set]`

bool	HasMethodName `[get]`

string[]	Arguments `[get, private set]`

Static Private Member Functions
static string[]	ToTypeNames (Type[] argTypes)

static Type	ResolveToType (string typeString)
	Resolves a type specification string to a Type. More...

Detailed Description

Definition at line 25 of file ExternalRoutineInfo.cs.

Constructor & Destructor Documentation

Deveel.Data.Routines.ExternalRoutineInfo.ExternalRoutineInfo	(	Type	type,
		Type[]	argTypes
	)

inline

Definition at line 26 of file ExternalRoutineInfo.cs.

27 : this(type, null, argTypes) {

28 }

Deveel.Data.Routines.ExternalRoutineInfo.ExternalRoutineInfo ( Type type )

inline

Definition at line 30 of file ExternalRoutineInfo.cs.

31 : this(type, String.Empty) {

32 }

Deveel.Data.Types.SqlTypeCode.String

A long string in the system.

Deveel.Data.Routines.ExternalRoutineInfo.ExternalRoutineInfo	(	Type	type,
		string	methodName
	)

inline

Definition at line 34 of file ExternalRoutineInfo.cs.

35 : this(type, methodName, Type.EmptyTypes) {

36 }

Deveel.Data.Sql.DbObjectType.Type

A user-defined TYPE that holds complex objects in a database column.

Deveel.Data.Routines.ExternalRoutineInfo.ExternalRoutineInfo	(	Type	type,
		string	methodName,
		Type[]	argTypes
	)

inline

Definition at line 38 of file ExternalRoutineInfo.cs.

39 : this(type.FullName, methodName, ToTypeNames(argTypes)) {

40 }

Deveel.Data.Routines.ExternalRoutineInfo.ToTypeNames

static string[] ToTypeNames(Type[] argTypes)

Definition: ExternalRoutineInfo.cs:62

Deveel.Data.Routines.ExternalRoutineInfo.ExternalRoutineInfo	(	string	typeString,
		string	methodName
	)

inline

Definition at line 42 of file ExternalRoutineInfo.cs.

43 : this(typeString, methodName, new string[0]) {

44 }

Deveel.Data.Routines.ExternalRoutineInfo.ExternalRoutineInfo	(	string	typeString,
		string	methodName,
		string[]	argNames
	)

inline

Definition at line 46 of file ExternalRoutineInfo.cs.

                                                                                             {
             this.TypeName = typeString;
             this.MethodName = methodName;
             this.Arguments = argNames;
         }

Member Function Documentation

static string Deveel.Data.Routines.ExternalRoutineInfo.FormatString ( Type type )

inlinestatic

Definition at line 278 of file ExternalRoutineInfo.cs.

                                                      {
             return FormatString(type, Type.EmptyTypes);
         }

static string Deveel.Data.Routines.ExternalRoutineInfo.FormatString	(	Type	type,
		Type[]	argTypes
	)

inlinestatic

Definition at line 282 of file ExternalRoutineInfo.cs.

                                                                       {
             return FormatString(type, null, argTypes);
         }

static string Deveel.Data.Routines.ExternalRoutineInfo.FormatString	(	Type	type,
		string	methodName
	)

inlinestatic

Definition at line 286 of file ExternalRoutineInfo.cs.

                                                                         {
             return FormatString(type, methodName, Type.EmptyTypes);
         }

static string Deveel.Data.Routines.ExternalRoutineInfo.FormatString	(	Type	type,
		string	methodName,
		Type[]	argTypes
	)

inlinestatic

Definition at line 290 of file ExternalRoutineInfo.cs.

                                                                                          {
             var routineInfo = new ExternalRoutineInfo(type, methodName, argTypes);
             return routineInfo.ToString();
         }

static ExternalRoutineInfo Deveel.Data.Routines.ExternalRoutineInfo.Parse ( string s )

inlinestatic

Definition at line 246 of file ExternalRoutineInfo.cs.

                                                           {
             // Look for the first parenthese
             int parentheseDelim = s.IndexOf("(", StringComparison.InvariantCulture);
 
             if (parentheseDelim != -1) {
                 // This represents type/method
                 string typeMethod = s.Substring(0, parentheseDelim);
                 // This will be deliminated by a '.'
                 int methodDelim = typeMethod.LastIndexOf(".", StringComparison.InvariantCulture);
                 if (methodDelim == -1)
                     throw new FormatException("Incorrectly formatted method string: " + s);
 
                 string typeString = typeMethod.Substring(0, methodDelim);
                 string methodString = typeMethod.Substring(methodDelim + 1);
 
                 // Next parse the argument list
                 int endParentheseDelim = s.LastIndexOf(")", StringComparison.InvariantCulture);
                 if (endParentheseDelim == -1)
                     throw new FormatException("Incorrectly formatted method string: " + s);
 
                 string argListStr = s.Substring(parentheseDelim + 1, endParentheseDelim - (parentheseDelim + 1));
 
                 // Now parse the list of arguments
                 string[] args = argListStr.Split(new[]{','}, StringSplitOptions.RemoveEmptyEntries);
 
                 return new ExternalRoutineInfo(typeString, methodString, args);
             }
 
             // No parenthese so we assume this is a class
             return new ExternalRoutineInfo(s, null);
         }

MethodInfo Deveel.Data.Routines.ExternalRoutineInfo.ResolveMethod ( TType[] paramTypes )

inline

Definition at line 155 of file ExternalRoutineInfo.cs.

                                                             {
             // The name of the class
             String typeName;
             // The name of the invokation method in the class.
             String methodName;
             // The object specification that must be matched.  If any entry is 'null'
             // then the argument parameter is discovered.
             Type[] argTypes;
             bool firstProcedureConnectionIgnore;
 
             if (!HasMethodName) {
                 // This means the typeString only specifies a class name, so we use
                 // 'Invoke' as the static method to call, and discover the arguments.
                 typeName = TypeName;
                 methodName = "Invoke";
                 // All null which means we discover the arg types dynamically
                 argTypes = new Type[paramTypes.Length];
                 // ignore IProcedureConnection is first argument
                 firstProcedureConnectionIgnore = true;
             } else {
                 // This means we specify a class and method name and argument
                 // specification.
                 typeName = TypeName;
                 methodName = MethodName;
                 argTypes = new Type[Arguments.Length];
 
                 for (int i = 0; i < Arguments.Length; ++i) {
                     String typeSpec = Arguments[i];
                     argTypes[i] = ResolveToType(typeSpec);
                 }
 
                 firstProcedureConnectionIgnore = false;
             }
 
             Type routineType = Type.GetType(typeName, false, true);
             if (routineType == null)
                 throw new Exception("Procedure class not found: " + typeName);
 
             // Get all the methods in this class
             MethodInfo[] methods = routineType.GetMethods(BindingFlags.Public | BindingFlags.Static);
             MethodInfo invokeMethod = null;
             // Search for the invoke method
             foreach (MethodInfo method in methods) {
                 if (method.Name.Equals(methodName)) {
                     bool paramsMatch;
 
                     // Get the parameters for this method
                     ParameterInfo[] methodArgs = method.GetParameters();
 
                     // If no methods, and object_specification has no args then this is a
                     // match.
                     if (methodArgs.Length == 0 && argTypes.Length == 0) {
                         paramsMatch = true;
                     } else {
                         int searchStart = 0;
                         // Is the first arugments a IProcedureConnection implementation?
                         if (firstProcedureConnectionIgnore &&
                             typeof(IProcedureConnection).IsAssignableFrom(methodArgs[0].ParameterType)) {
                             searchStart = 1;
                         }
 
                         // Do the number of arguments match
                         if (argTypes.Length == methodArgs.Length - searchStart) {
                             // Do they match the specification?
                             bool matchSpec = true;
                             for (int n = 0; n < argTypes.Length && matchSpec; ++n) {
                                 Type argType = argTypes[n];
                                 if (argType != null &&
                                     argType != methodArgs[n + searchStart].ParameterType) {
                                     matchSpec = false;
                                 }
                             }
                             paramsMatch = matchSpec;
                         } else {
                             paramsMatch = false;
                         }
                     }
 
                     if (paramsMatch) {
                         if (invokeMethod != null)
                             throw new Exception("Ambiguous public static " + methodName + " methods in stored procedure class '" + typeName + "'");
 
                         invokeMethod = method;
                     }
                 }
             }
 
             // Return the invoke method we found
             return invokeMethod;
         }

static Type Deveel.Data.Routines.ExternalRoutineInfo.ResolveToType ( string typeString )

inlinestaticprivate

Resolves a type specification string to a Type.

Parameters

typeString

Returns

Definition at line 79 of file ExternalRoutineInfo.cs.

                                                              {
             // Trim the string
             typeString = typeString.Trim();
 
             // Is this an array?  Count the number of array dimensions.
             int dimensions = -1;
             int lastIndex = typeString.Length;
             while (lastIndex > 0) {
                 ++dimensions;
                 lastIndex = typeString.LastIndexOf("[]", lastIndex, StringComparison.InvariantCulture) - 1;
             }
 
             // Remove the array part
             int arrayEnd = typeString.Length - (dimensions * 2);
             String typePart = typeString.Substring(0, arrayEnd);
             // Check there's no array parts in the class part
             if (typePart.IndexOf("[]", StringComparison.InvariantCulture) != -1)
                 throw new Exception("Type specification incorrectly formatted: " + typeString);
 
             // Convert the specification to a .NET Type.  For example,
             // String is converted to typeof(System.String), etc.
             Type cl;
             // Is there a '.' in the class specification?
             if (typePart.IndexOf('.') != -1) {
                 // Must be a specification such as 'System.Uri' or 'System.Collection.IList'.
                 try {
                     cl = Type.GetType(typePart);
                 } catch (TypeLoadException) {
                     throw new Exception("Type not found: " + typePart);
                 }
             }
 
                 // Try for a primitive types
             else if (typePart.Equals("boolean") ||
                      typePart.Equals("bool")) {
                 cl = typeof(bool);
             } else if (typePart.Equals("byte")) {
                 cl = typeof(byte);
             } else if (typePart.Equals("short")) {
                 cl = typeof(short);
             } else if (typePart.Equals("char")) {
                 cl = typeof(char);
             } else if (typePart.Equals("int")) {
                 cl = typeof(int);
             } else if (typePart.Equals("long")) {
                 cl = typeof(long);
             } else if (typePart.Equals("float")) {
                 cl = typeof(float);
             } else if (typePart.Equals("double")) {
                 cl = typeof(double);
             } else {
                 // Not a primitive type so try resolving against System.* or some
                 // key classes in Deveel.Data.*
                 if (typePart.Equals("IProcedureConnection")) {
                     cl = typeof(IProcedureConnection);
                 } else {
                     try {
                         cl = Type.GetType("System." + typePart);
                     } catch (TypeLoadException) {
                         // No luck so give up,
                         throw new Exception("Type not found: " + typePart);
                     }
                 }
             }
 
             // Finally make into a dimension if necessary
             if (dimensions > 0) {
                 // This is a little untidy way of doing this.  Perhaps a better approach
                 // would be to make an array encoded string.
                 cl = Array.CreateInstance(cl, new int[dimensions]).GetType();
             }
 
             return cl;
         }

override string Deveel.Data.Routines.ExternalRoutineInfo.ToString ( )

inline

Definition at line 295 of file ExternalRoutineInfo.cs.

                                           {
             var sb = new StringBuilder(TypeName);
             if (HasMethodName) {
                 sb.Append('.');
                 sb.Append(MethodName);
             }
 
             sb.Append('(');
             if (Arguments != null && Arguments.Length > 0) {
                 for (int i = 0; i < Arguments.Length; i++) {
                     sb.Append(Arguments[i]);
 
                     if (i < Arguments.Length - 1)
                         sb.Append(", ");
                 }
             }
 
             sb.Append(')');
             return sb.ToString();
         }

static string [] Deveel.Data.Routines.ExternalRoutineInfo.ToTypeNames ( Type[] argTypes )

inlinestaticprivate

Definition at line 62 of file ExternalRoutineInfo.cs.

                                                              {
             if (argTypes == null || argTypes.Length == 0)
                 return new string[0];
 
             var argNames = new string[argTypes.Length];
             for (var i = 0; i < argTypes.Length; i++) {
                 argNames[i] = argTypes[i].FullName;
             }
 
             return argNames;
         }

Property Documentation

string [] Deveel.Data.Routines.ExternalRoutineInfo.Arguments

getprivate set

Definition at line 60 of file ExternalRoutineInfo.cs.

bool Deveel.Data.Routines.ExternalRoutineInfo.HasMethodName

get

Definition at line 56 of file ExternalRoutineInfo.cs.

string Deveel.Data.Routines.ExternalRoutineInfo.MethodName

getprivate set

Definition at line 54 of file ExternalRoutineInfo.cs.

string Deveel.Data.Routines.ExternalRoutineInfo.TypeName

getprivate set

Definition at line 52 of file ExternalRoutineInfo.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Routines/ExternalRoutineInfo.cs

Public Member Functions

Static Public Member Functions

Properties

Static Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Property Documentation