public virtual CodeConditionStatement FinishInArguments(string idlMethodName, MarshalBuilderHelper codebuilder, CodeConditionStatement condMethodSignature
, CodeConditionStatement condIn, CodeConditionStatement condInIter, CodeThrowExceptionStatement throwargInPrev)
{
if (condIn != null) // If got arguments to add
{
if (condInIter != null && condInIter != condIn) // If multiple arguments
{
// Check the final argument is ok.
// * if (this.result != 0) { throw UdbusMessageMethodArgumentInException.Create(...); }
condInIter.TrueStatements.Add(codebuilder.ThrowArgInException(throwargInPrev));
} // Ends if multiple arguments
condMethodSignature.TrueStatements.Add(condIn);
condIn = condMethodSignature;
CodeConditionStatement condMethodResult = codebuilder.AddBodyLength(idlMethodName);
condMethodResult.TrueStatements.Add(condIn);
condIn = condMethodResult;
} // Ends if got arguments to add
return condIn;
}
static public CodeMemberMethod MakeMethod(CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn,
Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
IDLInterface idlIntf,
IDLMethod idlMethod,
MarshalBuilderHelper codebuilder)
{
CodeMemberMethod method = new CodeMemberMethod();
CodeComment commentMethod = new CodeComment(idlMethod.Name);
method.Comments.Add(new CodeCommentStatement(idlMethod.Name));
method.Name = idlMethod.Name;
method.Attributes = MemberAttributes.Public;
foreach (IDLMethodArgument idlMethodArg in idlMethod.Arguments)
{
method.Comments.Add(new CodeCommentStatement(string.Format("{0} {1} \"{2}\"", idlMethodArg.Direction, idlMethodArg.Name, idlMethodArg.Type)));
}
// Context used for all arguments in method.
Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolder);
MakeMethodParameters(codetypefactoryOut, codetypefactoryIn,
declarationHolder,
idlIntf,
method.Name,
idlMethod.Name,
idlMethod.Arguments,
method.Parameters,
method.Statements,
context,
codebuilder
);
return method;
}
static public void MakeSignalParameters(CodeTypeDeclaration typedeclArgs,
CodeTypeFactory codetypefactoryOut,
Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
IDLInterface idlIntf,
string methodName,
string idlSignalName,
IList<IDLSignalArgument> arguments,
CodeParameterDeclarationExpressionCollection parameters,
CodeStatementCollection statements,
Udbus.Parsing.BuildContext context,
MarshalBuilderHelper codebuilder)
{
CodeStatementCollection statementsTryRecv = new CodeStatementCollection();
int nOutArgCounter = 0;
List<CodeMethodInvokeExpression> invokemethodsBuild = new List<CodeMethodInvokeExpression>();
CodeConditionStatement condOut = null; // Root if statement for out parameters.
CodeConditionStatement condOutIter = null; // Most nested if statement for out parameters.
CodeStatementCollection stmtsFinishResult = new CodeStatementCollection();
CodeTypeReference typerefParamIter = CodeBuilderCommon.typerefUnknownParameters;
string argNameIter = arguments != null && arguments.Count > 0 ? arguments[0].Name : "UnknownParameters";
CodeThrowExceptionStatement throwargOutPrev = codebuilder.CreateArgumentOutException(idlSignalName);
// WAXME
//CodeConstructor constructorArgs = new CodeConstructor();
//constructorArgs.Attributes = MemberAttributes.Public;
foreach (IDLSignalArgument idlSignalArg in arguments)
{
argNameIter = idlSignalArg.Name;
// Parse the type string for the argument, creating required structs as we go, and returning a type for the argument.
//Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod, idlMethodArg);
Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLArgumentTypeNameBuilder(idlIntf, methodName);
ParamCodeTypeHolderMarshalBase paramtypeHolder = null;
CodeTypeReference typerefParam = null;
if (condOut == null)
{
codebuilder.PrefixOutParams(ref condOut, ref condOutIter, idlSignalName, ref nOutArgCounter, ref throwargOutPrev);
}
// Handle the signal argument in the message.
CodeConditionStatement condVarResult;
codebuilder.MakeOutArgument(statements
, stmtsFinishResult
, idlSignalName
, codetypefactoryOut // Yeah I messed up the naming
, ref nOutArgCounter
, context
, ref throwargOutPrev
, idlSignalArg
, nameBuilder
, ref paramtypeHolder
, ref typerefParam
, out condVarResult
);
codebuilder.StoreCondIterator(ref condOut, ref condOutIter, condVarResult);
// WAXME
// Add a field to the <signal>Args class.
//string argFieldName = CodeBuilderCommon.GetSignalArgFieldName(idlSignalArg.Name);
//CodeFieldReferenceExpression fielrefdRefArgField = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), argFieldName);
//typedeclArgs.Members.Add(new CodeMemberField(paramtypeHolder.paramtype.CodeType, argFieldName));
//CodeMemberProperty propArgField = new CodeMemberProperty();
//propArgField.Attributes = MemberAttributes.Public | MemberAttributes.Final;
//propArgField.Type = paramtypeHolder.paramtype.CodeType;
//propArgField.Name = PropertyNameFromFieldName(argFieldName);
//propArgField.GetStatements.Add(new CodeMethodReturnStatement(fielrefdRefArgField));
//typedeclArgs.Members.Add(propArgField);
//constructorArgs.Parameters.Add(new CodeParameterDeclarationExpression(paramtypeHolder.paramtype.CodeType, argFieldName));
//// * this.<signal_arg> = <signal_arg>;
//constructorArgs.Statements.Add(new CodeAssignStatement(fielrefdRefArgField, new CodeArgumentReferenceExpression(argFieldName)));
} // Ends loop over arguments
//typedeclArgs.Members.Add(constructorArgs);
codebuilder.AssignResults(statementsTryRecv, condOut, condOutIter, stmtsFinishResult, throwargOutPrev
, idlSignalName, ref nOutArgCounter
);
List<CodeStatement> statementsReponse = new List<CodeStatement>();
// Now receive the response.
// Create message reader.
// * Udbus.Core.UdbusMessageReader reader = new Udbus.Core.UdbusMessageReader(msgHandleResp);
statementsTryRecv.Insert(0, codebuilder.CreateMessageReader());
statementsReponse.AddRange(statementsTryRecv.Cast<CodeStatement>());
statements.Add(new CodeConditionStatement(exprResultOk, statementsReponse.ToArray()));
}
static public CodeMemberMethod MakeSignal(CodeNamespace ns, CodeTypeDeclaration typeMarshal, CodeTypeFactory codetypefactoryOut,
Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
IDLInterface idlIntf,
IDLSignal idlSignal,
MarshalBuilderHelper codebuilder)
{
string signalMethodName = "Handle" + CodeBuilderCommon.GetSignalTypeName(idlSignal.Name);
//// * public class <signal_as_type>Args : EventArgs
CodeTypeDeclaration typeArgs = new CodeTypeDeclaration(CodeBuilderCommon.GetSignalEventTypeName(idlSignal.Name));
//typeArgs.BaseTypes.Add(typerefSignalEventArgs);
// * const string StorageSpaceLowMatchRule = "type=\'signal\',interface=\'<interface>\',member=\'<signal>'";
CodeMemberField fieldMatchRule = new CodeMemberField(typeof(string), CodeBuilderCommon.GetSignalCompilableName(idlSignal.Name) + "MatchRule");
fieldMatchRule.InitExpression = new CodePrimitiveExpression(string.Format("type='signal',interface='{0}',member='{1}'", idlIntf.Name, idlSignal.Name));
fieldMatchRule.Attributes = MemberAttributes.Private | MemberAttributes.Const;
typeMarshal.Members.Add(fieldMatchRule);
CodeFieldReferenceExpression fieldrefMatchrule = new CodeFieldReferenceExpression(null, fieldMatchRule.Name);
// * private Udbus.Core.SignalKey StorageSpaceLowSignalKey { get { return new Udbus.Core.SignalKey(this.ConnectionParameters.Path, this.ConnectionParameters.Interface, "storage_space_low"); } }
// * private Udbus.Core.SignalEntry StorageSpaceLowSignalEntry { get { return new Udbus.Core.SignalEntry(this.StorageSpaceLowSignalKey, this.HandleStorageSpaceLow); } }
CodeMethodReferenceExpression methodrefSignal = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), signalMethodName);
CodeMemberProperty propSignalKey = new CodeMemberProperty();
propSignalKey.Name = CodeBuilderCommon.GetSignalCompilableName(idlSignal.Name) + "Key";
propSignalKey.Type = typerefSignalKey;
propSignalKey.Attributes = MemberAttributes.Private | MemberAttributes.Final;
propSignalKey.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(typerefSignalKey
, proprefConnectionParametersPath, proprefConnectionParametersInterface, new CodePrimitiveExpression(idlSignal.Name)
)));
CodeMemberProperty propSignalEntry = new CodeMemberProperty();
propSignalEntry.Name = CodeBuilderCommon.GetSignalCompilableName(idlSignal.Name) + "Entry";
propSignalEntry.Type = typerefSignalEntry;
propSignalEntry.Attributes = MemberAttributes.Private | MemberAttributes.Final;
propSignalEntry.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(typerefSignalEntry
, new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), propSignalKey.Name)
, methodrefSignal
)));
typeMarshal.Members.Add(propSignalKey);
typeMarshal.Members.Add(propSignalEntry);
// * public virtual void RegisterForStorageSpaceLow()
// * {
// * this.RegisterForSignal(StorageSpaceLowMatchRule, this.StorageSpaceLowSignalEntry, this.RegisterSignalHandlers);
// * }
CodeMemberMethod methodRegisterForSpecificSignal = new CodeMemberMethod();
methodRegisterForSpecificSignal.Name = CodeBuilderCommon.GetSignalRegisterFunction(idlSignal.Name);
methodRegisterForSpecificSignal.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), RegisterForSignal
, fieldrefMatchrule
, new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), propSignalEntry.Name)
, new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), proprefRegisterSignalHandlers.PropertyName)
));
typeMarshal.Members.Add(methodRegisterForSpecificSignal);
CodeMemberEvent eventSignal = CodeBuilderCommon.CreateSignalEvent(idlSignal);
CodeVariableReferenceExpression varrefSignalHandler = new CodeVariableReferenceExpression("signalHandler");
CodeEventReferenceExpression eventrefSignalHandlerSignal = new CodeEventReferenceExpression(varrefSignalHandler, eventSignal.Name);
CodeMethodInvokeExpression invokeGetSignalHandler = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), GetSignalHandler);
CodeTypeReference typerefMarshal = new CodeTypeReference(typeMarshal.Name);
CodeMemberProperty propEventSignal = new CodeMemberProperty();
propEventSignal.Name = CodeBuilderCommon.GetSignalEventPropertyName(idlSignal.Name);
propEventSignal.Attributes = MemberAttributes.Public | MemberAttributes.Final;
propEventSignal.Type = eventSignal.Type;
// * return this.GetSignalHandler().storageSpaceLowEvent;
propEventSignal.GetStatements.Add(new CodeMethodReturnStatement(new CodeEventReferenceExpression(invokeGetSignalHandler, eventSignal.Name)));
// * <service> signalHandler = this.GetSignalHandler();
propEventSignal.SetStatements.Add(new CodeVariableDeclarationStatement(typerefMarshal, varrefSignalHandler.VariableName, invokeGetSignalHandler));
// * if (signalHandler.<signal>Event == null)
propEventSignal.SetStatements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(eventrefSignalHandlerSignal, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null))
// * signalHandler.RegisterFor<signal>();
, new CodeExpressionStatement(new CodeMethodInvokeExpression(varrefSignalHandler, methodRegisterForSpecificSignal.Name))
));
// * signalHandler.<signal>Event = value;
propEventSignal.SetStatements.Add(
new CodeAssignStatement(eventrefSignalHandlerSignal, new CodePropertySetValueReferenceExpression())
);
// * private event System.EventHandler< <signal>Args > <signal>Event { ... }
// * public System.EventHandler< <signal>Args > <signal>;
typeMarshal.Members.Add(eventSignal);
typeMarshal.Members.Add(propEventSignal);
// * public event System.EventHandler< <signal>Args > <signal>;
//string eventPropertyName = CodeBuilderCommon.GetSignalEventName(idlSignal.Name);
//CodeMemberEvent eventSignal = new CodeMemberEvent();
//eventSignal.Attributes = MemberAttributes.Public;
//eventSignal.Name = CodeBuilderCommon.GetSignalEventName(idlSignal.Name);
//CodeTypeReference typerefEvent = new CodeTypeReference(typeof(System.EventHandler<>));
//typerefEvent.TypeArguments.Add(new CodeTypeReference(CodeBuilderCommon.GetSignalEventTypeName(idlSignal.Name)));
//eventSignal.Type = typerefEvent;
//typeMarshal.Members.Add(eventSignal);
//// * public void RegisterFor<signal_compilable>()
//// * {
//// * this.AddMatchInternal("type='signal',interface='<interface>',member='<signal>'");
//// * }
//CodeMemberMethod methodRegister = new CodeMemberMethod();
//methodRegister.Attributes = MemberAttributes.Public;
//methodRegister.Name = GetSignalRegisterFunctionName(idlSignal.Name);
//methodRegister.Statements.Add(
// new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), AddMatchInternal.Name
// ,new CodePrimitiveExpression(string.Format(
// "type='signal',interface='{0}',member='{1}'", idlIntf.Name, idlSignal.Name
// ))
// )
//);
//typeMarshal.Members.Add(methodRegister);
//CodeMemberMethod methodRegisterWithInterface = new CodeMemberMethod();
//methodRegisterWithInterface.Attributes = MemberAttributes.Public;
//methodRegisterWithInterface.Name = methodRegister.Name;
//methodRegisterWithInterface.Parameters.Add(new CodeParameterDeclarationExpression(typerefIRegisterSignalHandlers, register));
//methodRegisterWithInterface.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), methodRegister.Name));
//// * new Udbus.Core.SignalEntry(new Udbus.Core.SignalKey(this.ConnectionParameters.Path, this.ConnectionParameters.Interface, "storage_space_low")
//methodRegisterWithInterface.Statements.Add(new CodeMethodInvokeExpression(argrefRegister, AddSignalHandler
// , new CodeObjectCreateExpression(typerefSignalEntry
// , new CodeObjectCreateExpression(typerefSignalKey
// , MarshalBuilderHelper.proprefThisConnectionParametersPath
// , MarshalBuilderHelper.proprefThisConnectionParametersInterface
// , new CodePrimitiveExpression(idlSignal.Name)
// )
// , methodrefSignal
// )
//));
//typeMarshal.Members.Add(methodRegisterWithInterface);
// * Handle<signal>(<signal>Args args)
CodeMemberMethod method = new CodeMemberMethod();
CodeComment commentMethod = new CodeComment(idlSignal.Name);
method.Comments.Add(new CodeCommentStatement(idlSignal.Name));
method.Name = signalMethodName;
method.Attributes = MemberAttributes.Public;
method.Parameters.Add(MarshalBuilderHelper.paramdeclMessageResponse);
foreach (IDLSignalArgument idlSignalArg in idlSignal.Arguments)
{
method.Comments.Add(new CodeCommentStatement(string.Format(" {0} \"{1}\"", idlSignalArg.Name, idlSignalArg.Type)));
}
// Context used for all arguments in method.
Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolder);
MakeSignalParameters(typeArgs, codetypefactoryOut,
declarationHolder,
idlIntf,
method.Name,
idlSignal.Name,
idlSignal.Arguments,
method.Parameters,
method.Statements,
context,
codebuilder
);
//ns.Types.Add(typeArgs);
return method;
}
private static CodeMemberProperty MakePropertySet(CodeMemberProperty property, CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn,
Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
IDLInterface idlIntf,
IDLProperty idlProperty,
Udbus.Parsing.BuildContext context,
MarshalBuilderHelper codebuilder)
{
List<IDLMethodArgument> arguments = new List<IDLMethodArgument>(new IDLMethodArgument[]
{
//<arg name="interface_name" type="s"/>
//<arg name="property_name" type="s"/>
new IDLMethodArgument{ Name="interface_name", Type="s", Direction="in" },
new IDLMethodArgument{ Name="property_name", Type="s", Direction="in" },
//<arg name="value" type="<PropertyType>"/>
new IDLMethodArgument{ Name="value", Type=idlProperty.Type, Direction="in"}
}
);
MakeMethodParameters(codetypefactoryOut, codetypefactoryIn,
declarationHolder,
idlIntf,
"Set",
idlProperty.Name,
arguments,
new CodeParameterDeclarationExpressionCollection(),
property.SetStatements,
context,
codebuilder
);
return property;
}
static public void MakeMethodParameters(CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn,
Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
IDLInterface idlIntf,
string methodName,
string idlMethodName,
IList<IDLMethodArgument> arguments,
CodeParameterDeclarationExpressionCollection parameters,
CodeStatementCollection statements,
Udbus.Parsing.BuildContext context,
MarshalBuilderHelper codebuilder)
{
CodeStatementCollection statementsTryRecv = new CodeStatementCollection();
CodeConditionStatement condMethodSignature = new CodeConditionStatement(
exprResultOk
, new CodeStatement[]
{
codebuilder.SetSignature()
}
, new CodeStatement[]
{
// * throw Udbus.Core.Exceptions.UdbusMessageBuilderException.Create("BodyAdd", serial, "<method_name>", this.result, this.ConnectionParameters);
codebuilder.ThrowMessageBuilderException(idlMethodName, "BodyAdd")
}
);
// Check for in parameters.
bool bInParameters = codebuilder.InitialiseSignature(arguments, statements);
int nInArgSigCounter = 0;
int nInArgCounter = 0;
int nOutArgCounter = 0;
List<CodeMethodInvokeExpression> invokemethodsBuild = new List<CodeMethodInvokeExpression>();
CodeConditionStatement condOut = null; // Root if statement for out parameters.
CodeConditionStatement condOutIter = null; // Most nested if statement for out parameters.
CodeConditionStatement condIn = null; // Root if statement for in parameters.
CodeConditionStatement condInIter = null; // Most nested if statement for in parameters.
CodeStatementCollection stmtsFinishResult = new CodeStatementCollection();
//Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolder);
CodeTypeReference typerefParamIter = CodeBuilderCommon.typerefUnknownParameters;
string argNameIter = arguments != null && arguments.Count > 0 ? arguments[0].Name : "UnknownParameters";
CodeThrowExceptionStatement throwargOutPrev = codebuilder.CreateArgumentOutException(idlMethodName);
CodeThrowExceptionStatement throwargInPrev = codebuilder.ThrowMessageBuilderException(idlMethodName, "SetSignature");
foreach (IDLMethodArgument idlMethodArg in arguments)
{
argNameIter = idlMethodArg.Name;
// Parse the type string for the argument, creating required structs as we go, and returning a type for the argument.
//Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod, idlMethodArg);
Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLArgumentTypeNameBuilder(idlIntf, methodName);
ParamCodeTypeHolderMarshalBase paramtypeHolder = null;
CodeParameterDeclarationExpression param = null;
CodeTypeReference typerefParam = null;
if (idlMethodArg.Direction == "out") // If output parameter
{
if (condOut == null)
{
codebuilder.PrefixOutParams(ref condOut, ref condOutIter, idlMethodName, ref nOutArgCounter, ref throwargOutPrev);
}
CodeConditionStatement condVarResult;
codebuilder.MakeOutArgument(statements
, stmtsFinishResult
, idlMethodName
, codetypefactoryOut // Yeah I messed up the naming
, ref nOutArgCounter
, context
, ref throwargOutPrev
, idlMethodArg
, nameBuilder
, ref paramtypeHolder
, ref typerefParam
, out condVarResult
);
codebuilder.StoreCondIterator(ref condOut, ref condOutIter, condVarResult);
} // Ends if output parameter
else // Else not output parameter
{
// Add signature for argument.
nInArgSigCounter = codebuilder.DeclareSignature(statements, nInArgSigCounter, idlMethodArg.Type);
CodeConditionStatement condVarResult;
codebuilder.MakeInArgument(codetypefactoryIn // Yeah I messed up the naming
//, method.Statements
, idlMethodName
, ref nInArgCounter
, context
, ref throwargInPrev
, idlMethodArg
, nameBuilder
, ref paramtypeHolder
, ref typerefParam
, out condVarResult
);
codebuilder.StoreCondIterator(ref condIn, ref condInIter, condVarResult);
} // Ends else not output parameter
param = codebuilder.AddParameter(parameters, idlMethodArg.Name, idlMethodArg.Direction, typerefParam);
} // Ends loop over arguments
codebuilder.AssignResults(statementsTryRecv, condOut, condOutIter, stmtsFinishResult, throwargOutPrev
,idlMethodName, ref nOutArgCounter
);
codebuilder.TerminateSignature(statements, bInParameters, nInArgSigCounter);
codebuilder.AddSerialNumber(statements);
codebuilder.InitialiseMessageBuilder(statements);
codebuilder.DeclareMessageHandle(statements);
CodeStatement stmtBuildMethod = codebuilder.InvokeBuild(statements, methodName);
condIn = codebuilder.FinishInArguments(idlMethodName, codebuilder, condMethodSignature, condIn, condInIter, throwargInPrev);
// Add a using statement ??? Nope. Add a try/finally statement. Ahhh CodeDOM is there no construct you can't mangle ?
CodeVariableReferenceExpression varrefSendHandle = codebuilder.DeclareSendHandle();
CodeStatementCollection statementsTrySend = new CodeStatementCollection();
#if !USE_FLUID_MESSAGE_BUILDER
// Use individual statements to build message.
statementsTrySend.Add(stmtBuildMethod);
if (condIn != null)
{
statementsTrySend.Add(condIn);
}
else
{
// Need to set the signature even for methods with no parameters (?).
//statementsTrySend.Add(condMethodSignature);
}
#endif // !USE_FLUID_MESSAGE_BUILDER
codebuilder.CallSend(idlMethodName, varrefSendHandle, statementsTrySend);
codebuilder.TryCatchSend(statements, varrefSendHandle, statementsTrySend);
List<CodeStatement> statementsReponse = new List<CodeStatement>();
// Now receive the response.
codebuilder.HandleResponse(idlMethodName, statementsTryRecv, statementsReponse);
statements.Add(new CodeConditionStatement(exprResultOk,
statementsReponse.ToArray()
));
}