private BooClassBuilder SetUpEnumerableClassBuilder(Node sourceNode, Method enclosingMethod, IType generatorItemType,
TypeReplacer replacer)
{
var builder = CodeBuilder.CreateClass(
Context.GetUniqueName(enclosingMethod.Name, "Enumerable"),
TypeMemberModifiers.Internal | TypeMemberModifiers.Final);
if (enclosingMethod.DeclaringType.IsTransient)
{
builder.Modifiers |= TypeMemberModifiers.Transient;
}
builder.LexicalInfo = new LexicalInfo(sourceNode.LexicalInfo);
builder.AddAttribute(CodeBuilder.CreateAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)));
foreach (var gen in enclosingMethod.DeclaringType.GenericParameters.Concat(enclosingMethod.GenericParameters))
{
var replacement = builder.AddGenericParameter(gen.Name);
CopyConstraints(gen, replacement);
replacer.Replace((IType)gen.Entity, (IType)replacement.Entity);
}
generatorItemType = replacer.MapType(generatorItemType);
builder.AddBaseType(
TypeSystemServices.Map(typeof(GenericGenerator <>)).GenericInfo.ConstructType(generatorItemType));
return(builder);
}
private BooMethodBuilder SetUpGetEnumeratorMethodBuilder(Node sourceNode, BooClassBuilder builder, IType generatorItemType,
TypeReplacer replacer)
{
generatorItemType = replacer.MapType(generatorItemType);
var getEnumeratorBuilder = builder.AddVirtualMethod(
"GetEnumerator",
TypeSystemServices.IEnumeratorGenericType.GenericInfo.ConstructType(generatorItemType));
getEnumeratorBuilder.Method.LexicalInfo = sourceNode.LexicalInfo;
return(getEnumeratorBuilder);
}
protected Field DeclareFieldInitializedFromConstructorParameter(BooClassBuilder type,
BooMethodBuilder constructor,
string parameterName,
IType parameterType,
TypeReplacer replacer)
{
var internalFieldType = replacer.MapType(parameterType);
Field field = type.AddInternalField(UniqueName(parameterName), internalFieldType);
InitializeFieldFromConstructorParameter(constructor, field, parameterName, internalFieldType);
return(field);
}
/// <summary>
/// Load query handlers during first call.
/// </summary>
static API()
{
// Init query handlers list.
queryHandlers = new List <IQueryHandler>();
// Load query's processors.
System.Reflection.Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
//Console.WriteLine("ASSEMBLIES PROCEED: {0}\n", assemblies.Length);
Console.WriteLine("\nDETECTED QUERIES:");
foreach (System.Reflection.Assembly assembly in assemblies)
{
try
{
Type[] types = assembly.GetTypes();
// Get all types for assembly.
foreach (Type type in assembly.GetTypes())
{
try
{
// Check if this type is subclass of query.
if (type.GetInterface(typeof(IQueryHandler).FullName) != null &&
!type.IsAbstract &&
!type.IsInterface)
{
// Skip if type was replaced by other.
if (TypeReplacer.IsReplaced(type))
{
continue;
}
// Instiniating querie processor.
IQueryHandler instance = (IQueryHandler)Activator.CreateInstance(type);
queryHandlers.Add(instance);
Console.WriteLine("{0}", type.Name);
}
}
catch (Exception ex)
{
Console.WriteLine("Queries asseblies loading failed (qapi10): {0}", ex.Message);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Queries asseblies loading failed (2): {qapi20}", ex.Message);
}
}
// Log
Console.WriteLine("\nRESUME:\nQueriesMonitor established. Session started at {0}\nTotal query processors detected: {1}",
DateTime.Now.ToString("HH:mm:ss"), queryHandlers.Count);
}
private void ProcessClosureInMethodInvocation(GenericParameterInferrer inferrer, BlockExpression closure, ICallableType formalType)
{
var sig = formalType.GetSignature();
var replacer = new TypeReplacer();
var collector = new TypeCollector(delegate(IType t)
{
IGenericParameter gp = t as IGenericParameter;
if (gp == null) return false;
return gp.DeclaringEntity == inferrer.GenericMethod;
});
collector.Visit(formalType);
foreach (var typeParameter in collector.Matches)
{
var inferredType = inferrer.GetInferredType((IGenericParameter)typeParameter);
if (inferredType != null)
replacer.Replace(typeParameter, inferredType);
}
for (var i = 0; i < sig.Parameters.Length; i++)
{
var pd = closure.Parameters[i];
if (pd.Type != null) continue;
pd.Type = CodeBuilder.CreateTypeReference(replacer.MapType(sig.Parameters[i].Type));
}
ProcessClosureBody(closure);
}
/// <summary>
/// Base constructor.
/// Defining operating type.
/// </summary>
public USER_NEW()
{
OperatingType = TypeReplacer.GetValidType(typeof(User));
}
/// <summary>
/// Base constructor.
/// Defining operating type.
/// </summary>
public SET_TOKEN_RIGHTS()
{
OperatingType = TypeReplacer.GetValidType(typeof(User));
}
/// <summary>
/// Base constructor.
/// Defining operating type.
/// </summary>
public USER_LOGON()
{
OperatingType = TypeReplacer.GetValidType(typeof(User));
BanInfoOperatingType = TypeReplacer.GetValidType(typeof(BanInformation));
}
/// <summary>
/// Base constructor.
/// Defining operating type.
/// </summary>
public USER_UPDATE_PASSWORD()
{
OperatingType = TypeReplacer.GetValidType(typeof(User));
}
