public EmpProc(IDbProvider provider) : base(provider, "TEST.Get1CurOut")
{
//DeriveParameters();
DeclaredParameters.AddOut("P_CURSOR1", OracleType.Cursor);
AddRowMapper("employees", new EmployeeRowMapper());
Compile();
}
/// <summary>
/// Invoke the expression with the given parameters values.
/// </summary>
/// <param name="args">Order of parameters must be the same of the parameters used during parse (DeclaredParameters).</param>
/// <returns></returns>
public object Invoke(params object[] args)
{
var parameters = new List <Parameter>();
var declaredParameters = DeclaredParameters.ToArray();
if (args != null)
{
if (declaredParameters.Length != args.Length)
{
throw new InvalidOperationException("Arguments count mismatch.");
}
for (var i = 0; i < args.Length; i++)
{
var parameter = new Parameter(
declaredParameters[i].Name,
declaredParameters[i].Type,
args[i]);
parameters.Add(parameter);
}
}
return(Invoke(parameters));
}
internal static bool TryAppendParse(string text, ref DeclaredParameters parameters, out string errorDescription)
{
errorDescription = "";
text = text.Trim();
int asStringValueLength = text.Length;
int currentPos = 0;
while (currentPos < asStringValueLength && errorDescription == "")
{
int separatorPos = text.IndexOf(NameValueSeparator, currentPos);
if (separatorPos < 0)
{
errorDescription = string.Format(Properties.Resources.DeclaredParametersFormatter_TryParse_ParameterMissingSeparator, currentPos);
}
else
{
string name = text.Substring(currentPos, separatorPos - currentPos).Trim();
string value;
if (ExtractValue(text, name, separatorPos + 1, out value, out currentPos, out errorDescription))
{
parameters.Add(name, value);
}
;
};
}
;
return(errorDescription == "");
}
internal static string ToLine2Text(DeclaredParameters parameters)
{
DeclaredParameters.Rec[] recArray;
int recCount;
parameters.GetAllRecsExceptVersion(out recArray, out recCount);
return(ToText(recArray, recCount));
}
public void DeriveParameters(bool includeReturnParameter)
{
//TODO does this account for offsets?
IDataParameter[] derivedParameters = AdoTemplate.DeriveParameters(Sql, includeReturnParameter);
for (int i = 0; i < derivedParameters.Length; i++)
{
IDataParameter parameter = derivedParameters[i];
DeclaredParameters.AddParameter(parameter);
}
usingDerivedParameters = true;
}
internal LambdaExpression LambdaExpression(Type delegateType)
{
var types = delegateType.GetGenericArguments();
// return type
types[types.Length - 1] = _expression.Type;
var genericType = delegateType.GetGenericTypeDefinition();
var inferredDelegateType = genericType.MakeGenericType(types);
return(Expression.Lambda(inferredDelegateType, _expression, DeclaredParameters.Select(p => p.Expression).ToArray()));
}
public TestObjectQuery(IDbProvider dbProvider)
: base(dbProvider, sql)
{
//DeclaredParameters = new DbParameters(dbProvider);
try
{
DeclaredParameters.Add("UName", SqlDbType.VarChar, 50);
} catch (Exception e)
{
Console.WriteLine(e);
}
CommandType = CommandType.Text;
Compile();
}
internal static string ToSignatureLineText(DeclaredParameters parameters)
{
DeclaredParameters.Rec versionRec;
if (!parameters.TryGetVersionRec(out versionRec))
{
throw FtInternalException.Create(InternalError.DeclaredParametersFormatter_ToSignatureLineText_VersionNotSpecified);
}
else
{
DeclaredParameters.Rec[] recArray = new DeclaredParameters.Rec[1];
recArray[0] = versionRec;
return(ToText(recArray, 1));
}
}
public NullArg(IDbProvider provider)
: base(provider, "takes_null")
{
DeclaredParameters.Add("ptest", DbType.String);
Compile();
}
/// <summary>
/// Generate a lambda expression.
/// </summary>
/// <returns>The lambda expression.</returns>
/// <typeparam name="TDelegate">The delegate to generate. Delegate parameters must match the one defined when creating the expression, see UsedParameters.</typeparam>
public Expression <TDelegate> LambdaExpression <TDelegate>()
{
return(Expression.Lambda <TDelegate>(_expression, DeclaredParameters.Select(p => p.Expression).ToArray()));
}
public override string GetSignatureString() => ReturnParameter.GetSignatureString() + " " + Name + GetFullTypeParametersString()
+ "(" + string.Join(",", DeclaredParameters.Select(x => x.GetSignatureString())) + ")";
// TODO: Generic arguments (and on ConstructorInfo)
public override string ToString() => ReturnType.Name + " " + Name + "(" + string.Join(", ",
DeclaredParameters.Select(x => x.ParameterType.IsByRef? x.ParameterType.Name.TrimEnd('&') + " ByRef" : x.ParameterType.Name)) + ")";
public CreateTestObjectNonQuery(IDbProvider dbProvider) : base(dbProvider, sql)
{
DeclaredParameters.Add("Age", DbType.Int32);
DeclaredParameters.Add("Name", SqlDbType.NVarChar, 16);
Compile();
}
public override string ToString() => DeclaringType.Name + "(" + string.Join(", ", DeclaredParameters.Select(x => x.ParameterType.Name)) + ")";
internal static bool TryParse(string text, out DeclaredParameters parameters, out string errorDescription)
{
parameters = new DeclaredParameters();
return(TryAppendParse(text, ref parameters, out errorDescription));
}
// TODO: ReturnTypeCustomAttributes
public MethodInfo(Il2CppInspector pkg, int methodIndex, TypeInfo declaringType) :
base(declaringType)
{
Definition = pkg.Metadata.Methods[methodIndex];
Index = methodIndex;
if (Definition.methodIndex >= 0)
{
VirtualAddress = pkg.Binary.MethodPointers[Definition.methodIndex];
HasBody = true;
}
Name = pkg.Strings[Definition.nameIndex];
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == Il2CppConstants.METHOD_ATTRIBUTE_PRIVATE)
{
Attributes |= MethodAttributes.Private;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == Il2CppConstants.METHOD_ATTRIBUTE_PUBLIC)
{
Attributes |= MethodAttributes.Public;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == Il2CppConstants.METHOD_ATTRIBUTE_FAM_AND_ASSEM)
{
Attributes |= MethodAttributes.FamANDAssem;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == Il2CppConstants.METHOD_ATTRIBUTE_ASSEM)
{
Attributes |= MethodAttributes.Assembly;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == Il2CppConstants.METHOD_ATTRIBUTE_FAMILY)
{
Attributes |= MethodAttributes.Family;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == Il2CppConstants.METHOD_ATTRIBUTE_FAM_OR_ASSEM)
{
Attributes |= MethodAttributes.FamORAssem;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_VIRTUAL) != 0)
{
Attributes |= MethodAttributes.Virtual;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_ABSTRACT) != 0)
{
Attributes |= MethodAttributes.Abstract;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_STATIC) != 0)
{
Attributes |= MethodAttributes.Static;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_FINAL) != 0)
{
Attributes |= MethodAttributes.Final;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_HIDE_BY_SIG) != 0)
{
Attributes |= MethodAttributes.HideBySig;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_VTABLE_LAYOUT_MASK) == Il2CppConstants.METHOD_ATTRIBUTE_NEW_SLOT)
{
Attributes |= MethodAttributes.NewSlot;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_PINVOKE_IMPL) != 0)
{
Attributes |= MethodAttributes.PinvokeImpl;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_SPECIAL_NAME) != 0)
{
Attributes |= MethodAttributes.SpecialName;
}
if ((Definition.flags & Il2CppConstants.METHOD_ATTRIBUTE_UNMANAGED_EXPORT) != 0)
{
Attributes |= MethodAttributes.UnmanagedExport;
}
// Add return parameter
returnType = pkg.TypeUsages[Definition.returnType];
ReturnParameter = new ParameterInfo(pkg, -1, this);
// Add arguments
for (var p = Definition.parameterStart; p < Definition.parameterStart + Definition.parameterCount; p++)
{
DeclaredParameters.Add(new ParameterInfo(pkg, p, this));
}
}
