internal ProxyGenerator(TypeDefinitionInformation originalInterface, string generatedClientInterfaceName)
{
this.generatedClientInterfaceName = generatedClientInterfaceName;
this.interfaceType = originalInterface;
this.className = generatedClientInterfaceName + "_Implementation";
this.methods = originalInterface.Methods;
}
public MethodInformation(string name, uint i, TypeDefinitionInformation returnType, bool isVoidMethod, bool isImpulseHandler, IEnumerable <ParameterInformation> parameters)
{
this.idNumber = i + 1; // this way 0 is always left open to use as the id for OnFirstStart
this.Name = name;
this.Parameters = parameters; // mi.GetParameters().ToArray();
this.ReturnType = returnType; // Utilities.GetCSharpSourceSyntax(mi.ReturnType);
this.isImpulseHandler = isImpulseHandler;
this.voidMethod = isVoidMethod; // mi.ReturnType.Equals(typeof(void));
}
public static string ComputeArgumentSize(TypeDefinitionInformation t, int position)
{
var sb = new StringBuilder();
if (t.IsByteArray)
{
sb.AppendLine($"arg{position}Bytes = p_{position};");
sb.AppendLine($"arg{position}Size = IntSize(arg{position}Bytes.Length) + arg{position}Bytes.Length;");
}
else
{
sb.AppendLine($"arg{position}Bytes = Ambrosia.BinarySerializer.Serialize<{t.Namespace + "." + t.Name}>(p_{position});");
sb.AppendLine($"arg{position}Size = IntSize(arg{position}Bytes.Length) + arg{position}Bytes.Length;");
}
return(sb.ToString());
}
/// <summary>
/// Assumes that either the type of the value is a byte array or else has either is marked [DataContract] or [Serializable]
/// </summary>
/// <param name="typeName">
/// Must be a valid C# source syntax for the type name.
/// </param>
/// <param name="isByteArray"></param>
/// <param name="variableToAssignTo"></param>
/// <returns></returns>
public static string DeserializeValue(TypeDefinitionInformation typeOfValue, string variableToAssignTo)
{
var sb = new StringBuilder();
sb.AppendLine($"var {variableToAssignTo}_ValueLength = buffer.ReadBufferedInt(cursor);");
sb.AppendLine($"cursor += IntSize({variableToAssignTo}_ValueLength);");
sb.AppendLine($"var {variableToAssignTo}_ValueBuffer = new byte[{variableToAssignTo}_ValueLength];");
sb.AppendLine($"Buffer.BlockCopy(buffer, cursor, {variableToAssignTo}_ValueBuffer, 0, {variableToAssignTo}_ValueLength);");
sb.AppendLine($"cursor += {variableToAssignTo}_ValueLength;");
if (typeOfValue.IsByteArray)
{
sb.AppendLine($"var {variableToAssignTo} = {variableToAssignTo}_ValueBuffer;");
}
else
{
sb.AppendLine($"var {variableToAssignTo} = Ambrosia.BinarySerializer.Deserialize<{typeOfValue.Namespace + "." + typeOfValue.Name}>({variableToAssignTo}_ValueBuffer);");
}
return(sb.ToString());
}
public static TypeDefinitionInformation GetTypeDefinitionInformation(Type t)
{
//if (!CanHandleType(t))
//{
// throw new NotImplementedException($"Need to handle the type: {GetCSharpSourceSyntax(t)}");
//}
var iTypeInfo = new TypeDefinitionInformation()
{
//Name = Utilities.CleanUpIdentifierName(GetCSharpSourceSyntax(t)),
Name = GetTypeDefinitionInformationName(t),
Namespace = t.Namespace,
Methods = t
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Select((m, i) => GetMethodInformation(m, (uint)i)),
IsByteArray = t.IsArray && t.GetElementType().Equals(typeof(byte)),
};
return(iTypeInfo);
}
internal DispatcherGenerator(TypeDefinitionInformation interfaceType)
{
this.interfaceType = interfaceType;
this.className = Utilities.CleanUpIdentifierName(interfaceType.Name) + "_Dispatcher_Implementation";
this.methods = interfaceType.Methods;
}
internal ProxyInterfaceGenerator(TypeDefinitionInformation interfaceType)
{
this.interfaceType = interfaceType;
}
