private void AddSenderReceiverMenu_Click(object sender, RoutedEventArgs e)
{
SenderReceiverInterface srInterface = senderReceiverInterfaceController.CreateSenderReceiverInterface();
AutosarTree.UpdateAutosarTreeView(srInterface);
AutosarTree.Focus();
}
protected void TestSenderReceiver(SenderReceiverInterface elem)
{
bool withoutErrors = true;
if (elem.Fields.Count == 0)
{
AppendText(elem.Name + " : does not have any fields!", Error: true);
}
/* Check if there is an fields with similar names */
withoutErrors &= CheckSimilarNames(elem.Fields.ConvertAll(x => x as IGUID), elem.Name + ": fields");
/* Check datatypes */
foreach (SenderReceiverInterfaceField field in elem.Fields)
{
if (field.DataTypeName.Equals(AutosarApplication.ErrorDataType))
{
AppendText(elem.Name + " : " + field.Name + " doesn't have specified datatype ", Error: true);
withoutErrors = false;
}
}
if (withoutErrors)
{
AppendText(elem.Name);
}
}
public bool Delete(SenderReceiverInterface srInterface)
{
if (isCSenderReceiverInterfaceUsed(srInterface) == false)
{
SenderReceiverInterfaces.Remove(srInterface);
return(true);
}
else
{
/* datatype is used and we cannot delete it */
return(false);
}
}
void CreateRteReadFunctions(StreamWriter writer, ComponentDefenition compDefenition)
{
foreach (PortDefenition port in compDefenition.Ports)
{
if (port.PortType == PortType.Receiver)
{
SenderReceiverInterface srInterface = port.InterfaceDatatype as SenderReceiverInterface;
if (srInterface != null) // prevent for unselected interface for port
{
foreach (SenderReceiverInterfaceField field in srInterface.Fields)
{
GenerateRteReadPortFieldFunction(writer, compDefenition, port, field);
}
}
}
}
}
public SenderReceiverInterface CreateSenderReceiverInterface()
{
string templateName = "iSenderReceiver";
if (AutosarApplication.GetInstance().SenderReceiverInterfaces.FindObject(templateName) != null)
{
int index = 0;
while (AutosarApplication.GetInstance().SenderReceiverInterfaces.FindObject(templateName) != null)
{
index++;
templateName = "iSenderReceiver" + index.ToString();
}
}
SenderReceiverInterface srInterface = DataTypeFabric.Instance().CreateSenderReceiverInterface(templateName);
AutosarApplication.GetInstance().SenderReceiverInterfaces.Add(srInterface);
return(srInterface);
}
void GenerateComponentsDataTypes(StreamWriter writer)
{
foreach (ComponentDefenition compDef in AutosarApplication.GetInstance().ComponentDefenitionsList)
{
writer.WriteLine("/* Datatype for " + compDef.Name + " */");
writer.WriteLine("typedef struct");
writer.WriteLine("{");
/* Create index for components with multipleinstantiation */
if (compDef.MultipleInstantiation == true)
{
writer.WriteLine(" uint32 index;");
}
foreach(PimDefenition pimDefenition in compDef.PerInstanceMemoryList)
{
GenerateDataTypeForPim(writer, compDef, pimDefenition);
}
foreach (CDataDefenition cdata in compDef.CDataDefenitions)
{
GenerateDataTypeForCData(writer, compDef, cdata);
}
foreach (PortDefenition portDef in compDef.Ports)
{
if (portDef.PortType == PortType.Sender)
{
SenderReceiverInterface srInterface = AutosarApplication.GetInstance().SenderReceiverInterfaces.FindObject(portDef.InterfaceGUID);
if (srInterface != null)
{
foreach (SenderReceiverInterfaceField field in srInterface.Fields)
{
GenerateFieldsForSenderPorts(writer, compDef, portDef, field);
}
}
}
}
writer.WriteLine("} " + compDef.Name + ";");
writer.WriteLine();
}
}
public SenderReceiverInterface CreateSenderReceiverInterface(string Name)
{
SenderReceiverInterface srinterface = new SenderReceiverInterface();
srinterface.Name = Name;
return srinterface;
}
public bool isCSenderReceiverInterfaceUsed(SenderReceiverInterface srInterface)
{
return(false);
}
/* Generate funcitons for Sender-Receiver ports and call operations from client ports */
public void CreateRteIncludes(String dir, ComponentDefenition componentDefenition)
{
String filename = dir + "\\" + "Rte_" + componentDefenition.Name + ".h";
StreamWriter writer = new StreamWriter(filename);
RteFunctionsGenerator.GenerateFileTitle(writer, filename, "Implementation for " + componentDefenition.Name + " header file");
string guardDefine = RteFunctionsGenerator.OpenGuardDefine(writer);
writer.WriteLine("");
writer.WriteLine(RteFunctionsGenerator.IncludesLine);
RteFunctionsGenerator.AddInclude(writer, Properties.Resources.SYSTEM_ERRORS_H_FILENAME);
RteFunctionsGenerator.AddInclude(writer, Properties.Resources.RTE_DATATYPES_H_FILENAME);
writer.WriteLine("");
writer.WriteLine(RteFunctionsGenerator.EndOfIncludesLine);
writer.WriteLine("");
/* MACROS */
writer.WriteLine("");
writer.WriteLine(RteFunctionsGenerator.MacrosLine);
/* Write all runnables frequences */
writer.WriteLine("/* Runnables frequences */");
foreach (PeriodicRunnableDefenition runnable in componentDefenition.Runnables)
{
String runnableFreqMacroName = "Rte_Period_" + componentDefenition.Name + "_ru" + runnable.Name;
String define = RteFunctionsGenerator.CreateDefine(runnableFreqMacroName, (runnable.PeriodMs * 1000).ToString() + "UL");
writer.WriteLine(define);
}
/* Write all pims */
foreach (PimDefenition pim in componentDefenition.PerInstanceMemoryList)
{
String define = RteFunctionsGenerator.CreateDefine(RteFunctionsGenerator.GenerateShortPimFunctionName(pim), RteFunctionsGenerator.GenerateFullPimFunctionName(componentDefenition, pim), false);
writer.WriteLine(define);
}
/* Write all cdata */
foreach (CDataDefenition cdata in componentDefenition.CDataDefenitions)
{
String define = RteFunctionsGenerator.CreateDefine(RteFunctionsGenerator.GenerateShortCDataFunctionName(cdata), RteFunctionsGenerator.GenerateFullCDataFunctionName(componentDefenition, cdata), false);
writer.WriteLine(define);
}
String externFunctions = "";
/* Add defines for all ports */
foreach (PortDefenition portDefenition in componentDefenition.Ports)
{
if ((portDefenition.PortType == PortType.Sender) || (portDefenition.PortType == PortType.Receiver))
{
SenderReceiverInterface srInterface = AutosarApplication.GetInstance().SenderReceiverInterfaces.FindObject(portDefenition.InterfaceGUID);
foreach (SenderReceiverInterfaceField field in srInterface.Fields)
{
String funcName = RteFunctionsGenerator.GenerateReadWriteFunctionName(portDefenition, field);
String RteFuncName = RteFunctionsGenerator.GenerateReadWriteConnectionFunctionName(portDefenition, field);
writer.WriteLine(RteFunctionsGenerator.CreateDefine(funcName, RteFuncName, false));
String fieldVariable = RteFunctionsGenerator.GenerateSenderReceiverInterfaceArguments(field, portDefenition.PortType, componentDefenition.MultipleInstantiation);
externFunctions += Properties.Resources.STD_RETURN_TYPE + funcName + fieldVariable + ";" + Environment.NewLine;
}
}
else if (portDefenition.PortType == PortType.Client)
{
ClientServerInterface csInterface = AutosarApplication.GetInstance().ClientServerInterfaces.FindObject(portDefenition.InterfaceGUID);
foreach (ClientServerOperation operation in csInterface.Operations)
{
String funcName = RteFunctionsGenerator.Generate_RteCall_FunctionName(portDefenition, operation);
String RteFuncName = RteFunctionsGenerator.Generate_RteCall_ConnectionGroup_FunctionName(componentDefenition, portDefenition, operation);
String funcArgument = RteFunctionsGenerator.GenerateClientServerInterfaceArguments(operation, componentDefenition.MultipleInstantiation);
writer.WriteLine(RteFunctionsGenerator.CreateDefine(funcName, RteFuncName, false));
externFunctions += Properties.Resources.STD_RETURN_TYPE + funcName + funcArgument + ";" + Environment.NewLine;
}
}
else if (portDefenition.PortType == PortType.Server)
{
ClientServerInterface csInterface = AutosarApplication.GetInstance().ClientServerInterfaces.FindObject(portDefenition.InterfaceGUID);
foreach (ClientServerOperation operation in csInterface.Operations)
{
String funcName = RteFunctionsGenerator.Generate_RteCall_FunctionName(portDefenition, operation);
String RteFuncName = RteFunctionsGenerator.Generate_RteCall_ConnectionGroup_FunctionName(componentDefenition, portDefenition, operation);
String funcArgument = RteFunctionsGenerator.GenerateClientServerInterfaceArguments(operation, componentDefenition.MultipleInstantiation);
writer.WriteLine(RteFunctionsGenerator.CreateDefine(funcName, RteFuncName, false));
}
}
}
writer.WriteLine("");
writer.WriteLine(RteFunctionsGenerator.EndOfMacrosLine);
writer.WriteLine("");
writer.WriteLine("");
writer.WriteLine(RteFunctionsGenerator.RteFunctionsDefenitionsLine);
writer.WriteLine("");
/* Add function */
writer.Write(externFunctions);
/* Add Pim's functions */
foreach (PimDefenition pimDefenition in componentDefenition.PerInstanceMemoryList)
{
String datatype = pimDefenition.DataTypeName;
String pimFuncName = RteFunctionsGenerator.GenerateShortPimFunctionName(pimDefenition);
String arguments = "(";
if (componentDefenition.MultipleInstantiation)
{
arguments += RteFunctionsGenerator.ComponentInstancePointerDatatype + " instance";
}
arguments += ");";
writer.WriteLine(datatype + " * " + pimFuncName + arguments);
}
/* Add CData functions */
foreach (CDataDefenition cdataDefenition in componentDefenition.CDataDefenitions)
{
String datatype = cdataDefenition.DataTypeName;
String cdataFuncName = RteFunctionsGenerator.GenerateShortCDataFunctionName(cdataDefenition);
String arguments = "(";
if (componentDefenition.MultipleInstantiation)
{
arguments += RteFunctionsGenerator.ComponentInstancePointerDatatype + " instance";
}
arguments += ");";
writer.WriteLine(datatype + " " + cdataFuncName + arguments);
}
writer.WriteLine(RteFunctionsGenerator.EndOfRteFunctionsDefenitionsLine);
writer.WriteLine("");
writer.WriteLine("");
RteFunctionsGenerator.CloseGuardDefine(writer);
writer.Close();
}
private static void WriteAllFunctionWhichComponentCouldUse(ComponentDefenition compDefenition, StreamWriter writer)
{
List <String> lines = new List <string>();
/* Write function name and its body */
foreach (PimDefenition pimDefenition in compDefenition.PerInstanceMemoryList)
{
lines.Add(" * " + RteFunctionsGenerator.GenerateShortPimFunctionName(pimDefenition));
}
foreach (CDataDefenition cdataDefenition in compDefenition.CDataDefenitions)
{
lines.Add(" * " + RteFunctionsGenerator.GenerateShortCDataFunctionName(cdataDefenition));
}
foreach (PortDefenition port in compDefenition.Ports)
{
if (port.PortType == PortType.Receiver)
{
SenderReceiverInterface srInterface = AutosarApplication.GetInstance().SenderReceiverInterfaces.FindObject(port.InterfaceGUID);
foreach (SenderReceiverInterfaceField field in srInterface.Fields)
{
lines.Add(" * " + RteFunctionsGenerator.GenerateReadWriteFunctionName(port, field));
}
}
}
foreach (PortDefenition port in compDefenition.Ports)
{
if (port.PortType == PortType.Sender)
{
SenderReceiverInterface srInterface = AutosarApplication.GetInstance().SenderReceiverInterfaces.FindObject(port.InterfaceGUID);
foreach (SenderReceiverInterfaceField field in srInterface.Fields)
{
lines.Add(" * " + RteFunctionsGenerator.GenerateReadWriteFunctionName(port, field));
}
}
}
foreach (PortDefenition port in compDefenition.Ports)
{
if (port.PortType == PortType.Client)
{
ClientServerInterface csInterface = AutosarApplication.GetInstance().ClientServerInterfaces.FindObject(port.InterfaceGUID);
foreach (ClientServerOperation operation in csInterface.Operations)
{
lines.Add(" * " + RteFunctionsGenerator.Generate_RteCall_FunctionName(port, operation));
}
}
}
if (lines.Count > 0)
{
writer.WriteLine("/* ");
writer.WriteLine(" * This RTE function could be used: ");
foreach (String str in lines)
{
writer.WriteLine(str);
}
writer.WriteLine(" */");
}
}
void WriteZeroDefaultValueForSenderPort(StreamWriter writer, PortDefenition portDef, SenderReceiverInterface srInterface)
{
for (int j = 0; j < srInterface.Fields.Count; j++)
{
SenderReceiverInterfaceField field = srInterface.Fields[j];
writer.Write(" ." + RteFunctionsGenerator.GenerateRteWriteFieldInComponentDefenitionStruct(portDef, field) + " = ");
WriteZeroDefaultValue(writer, field.DataType);
if (j < srInterface.Fields.Count - 1)
{
writer.WriteLine(",");
}
}
}
void GenerateComponentInstance(StreamWriter writer, ComponentInstance component)
{
ComponentDefenition compDefenition = component.ComponentDefenition;
int elementsCount = compDefenition.Ports.PortsWithSenderInterface().Count + compDefenition.CDataDefenitions.Count + compDefenition.PerInstanceMemoryList.Count;
if ((elementsCount == 0) && (compDefenition.MultipleInstantiation == false))
{
return; // because nothing to generate.
}
writer.WriteLine("/* Component instance :" + component.Name + " */");
String compDefString = RteFunctionsGenerator.FillStringForCount(compDefenition.Name, ' ', 50);
String compName = RteFunctionsGenerator.GenerateComponentName(component.Name);
writer.WriteLine(compDefString + compName + " = ");
writer.WriteLine("{");
/* Fill variables */
/* Component index */
if (compDefenition.MultipleInstantiation)
{
ComponentInstancesList compInstances = AutosarApplication.GetInstance().GetComponentInstanceByDefenition(compDefenition);
int compIndex = compInstances.IndexOf(component);
writer.WriteLine(" .index = " + compIndex.ToString() + ", ");
}
/* Pim*/
int count = 0;
for (int i = 0; i < compDefenition.PerInstanceMemoryList.Count; i++)
{
PimDefenition pimDef = compDefenition.PerInstanceMemoryList[i];
count++;
PimInstance pimInstance = component.PerInstanceMemories.GetPim(pimDef.GUID);
writer.Write(" ." + RteFunctionsGenerator.GenerateRtePimFieldInComponentDefenitionStruct(component.ComponentDefenition, pimDef) + " = ");
IGUID datatype = pimDef.DataType;
if ((datatype is BaseDataType) || (datatype is SimpleDataType) || (datatype is EnumDataType))
{
RteFunctionsGenerator.WriteDefaultValueForPimDefenition(writer, component, pimInstance);
}
else if (datatype is ArrayDataType)
{
writer.Write(" {{ ");
if (!((datatype as ArrayDataType).DataType is PlainDataType))
{
writer.Write("{ ");
}
writer.Write(" 0 ");
if (!((datatype as ArrayDataType).DataType is PlainDataType))
{
writer.Write("} ");
}
writer.Write(" }}");
}
else if (datatype is ComplexDataType)
{
writer.Write("{ 0 }");
}
if ((i != compDefenition.PerInstanceMemoryList.Count - 1) || ((compDefenition.CDataDefenitions.Count > 0) || (compDefenition.Ports.PortsWithSenderInterface().Count > 0)))
{
writer.WriteLine(",");
}
}
/* CData */
for (int i = 0; i < compDefenition.CDataDefenitions.Count; i++)
{
count++;
CDataDefenition cdataDef = compDefenition.CDataDefenitions[i];
CDataInstance cdataInstance = component.CDataInstances.GetCData(cdataDef.GUID);
writer.Write(" ." + RteFunctionsGenerator.GenerateRteCDataFieldInComponentDefenitionStruct(component.ComponentDefenition, cdataDef) + " = ");
IGUID datatype = cdataDef.DataType;
if ((datatype is BaseDataType) || (datatype is SimpleDataType) || (datatype is EnumDataType))
{
RteFunctionsGenerator.WriteDefaultValueForCDataDefenition(writer, component, cdataInstance);
}
else if (datatype is ArrayDataType)
{
writer.Write(" {{ ");
if (!((datatype as ArrayDataType).DataType is PlainDataType))
{
writer.Write("{ ");
}
writer.Write(" 0 ");
if (!((datatype as ArrayDataType).DataType is PlainDataType))
{
writer.Write("} ");
}
writer.Write(" }}");
}
else if (datatype is ComplexDataType)
{
writer.WriteLine(" { 0 }");
}
if ((i != compDefenition.CDataDefenitions.Count - 1) || (compDefenition.Ports.PortsWithSenderInterface().Count > 0))
{
writer.WriteLine(",");
}
}
/* Port */
PortDefenitionsList senderPorts = component.ComponentDefenition.Ports.PortsWithSenderInterface();
for (int i = 0; i < senderPorts.Count; i++)
{
SenderReceiverInterface srInterface = (SenderReceiverInterface)senderPorts[i].InterfaceDatatype;
WriteZeroDefaultValueForSenderPort(writer, senderPorts[i], srInterface);
if (i < senderPorts.Count - 1)
{
writer.WriteLine(",");
}
}
writer.WriteLine();
writer.WriteLine("};");
writer.WriteLine("");
}
void CreateTestArtefactStructure(StreamWriter writer, ComponentDefenition compDef)
{
writer.WriteLine("typedef struct");
writer.WriteLine("{");
/* Write All CData structures */
foreach (CDataDefenition cdataDef in compDef.CDataDefenitions)
{
writer.WriteLine(" struct");
writer.WriteLine(" {");
writer.WriteLine(" uint32 " + CallCount + ";");
writer.WriteLine(" " + cdataDef.DataType.Name + " Value;");
writer.WriteLine(" } " + RteFunctionsGenerator.GenerateShortCDataFunctionName(cdataDef) + ";");
writer.WriteLine();
}
/* Write All Rte Read structures */
foreach (PortDefenition portDef in compDef.Ports)
{
if (portDef.InterfaceDatatype is SenderReceiverInterface)
{
SenderReceiverInterface srInterface = (SenderReceiverInterface)portDef.InterfaceDatatype;
foreach (SenderReceiverInterfaceField srField in srInterface.Fields)
{
writer.WriteLine(" struct");
writer.WriteLine(" {");
writer.WriteLine(" uint32 " + CallCount + ";");
writer.WriteLine(" Std_ReturnType ReturnValue;");
writer.WriteLine(" struct");
writer.WriteLine(" {");
writer.WriteLine(" " + srField.DataTypeName + " data;");
writer.WriteLine(" } Arguments;");
String fieldName = RteFunctionsGenerator.GenerateReadWriteFunctionName(portDef, srField);
writer.WriteLine(" } " + fieldName + ";");
writer.WriteLine();
}
}
}
/* Write All pims */
foreach (PimDefenition pimDef in compDef.PerInstanceMemoryList)
{
writer.WriteLine(" struct");
writer.WriteLine(" {");
writer.WriteLine(" uint32 " + CallCount + ";");
writer.WriteLine(" " + pimDef.DataTypeName + " data;");
string pimFieldName = RteFunctionsGenerator.GenerateShortPimFunctionName(pimDef);
writer.WriteLine(" } " + pimFieldName + ";");
writer.WriteLine();
}
/* Write all client calls */
foreach (PortDefenition portDef in compDef.Ports)
{
if (portDef.InterfaceDatatype is ClientServerInterface)
{
ClientServerInterface srInterface = (ClientServerInterface)portDef.InterfaceDatatype;
foreach (ClientServerOperation csOperation in srInterface.Operations)
{
writer.WriteLine(" struct");
writer.WriteLine(" {");
writer.WriteLine(" uint32 " + CallCount + ";");
writer.WriteLine(" Std_ReturnType ReturnValue;");
writer.WriteLine(" struct");
writer.WriteLine(" {");
foreach (var field in csOperation.Fields)
{
writer.WriteLine(" " + field.DataTypeName + " " + field.Name + ";");
}
writer.WriteLine(" } Arguments;");
String operationName = RteFunctionsGenerator.Generate_RteCall_FunctionName(portDef, csOperation);
writer.WriteLine(" } " + operationName + ";");
writer.WriteLine();
}
}
}
writer.WriteLine("} " + TestArtefactsStructureDataType + ";");
writer.WriteLine();
writer.WriteLine("extern " + TestArtefactsStructureDataType + " " + TestArtefactsVariable + ";");
writer.WriteLine();
}
void GenerateTestInitializationFile(ComponentDefenition compDef, String outputDir)
{
String FileName = outputDir + "\\" + Properties.Resources.TEST_INITIALIZATION_FILENAME;
StreamWriter writer = new StreamWriter(FileName);
RteFunctionsGenerator.GenerateFileTitle(writer, Properties.Resources.TEST_RTE_C_FILENAME, "This file contains functions for component initialization before each test");
String guardDefine = RteFunctionsGenerator.OpenGuardDefine(writer);
/* Add includes */
RteFunctionsGenerator.AddInclude(writer, Properties.Resources.TEST_RTE_H_FILENAME);
RteFunctionsGenerator.AddInclude(writer, Properties.Resources.RTE_DATATYPES_H_FILENAME);
writer.WriteLine();
/* Write parameters count as equal value to component instances */
ComponentInstancesList componentInstances = AutosarApplication.GetInstance().GetComponentInstanceByDefenition(compDef);
writer.WriteLine("const int " + ParametersCount + " = " + componentInstances.Count.ToString() + ";");
writer.WriteLine();
/* Add function for component variable initialization */
writer.WriteLine("/* User function for variable initialization */");
writer.WriteLine("extern void VariableInitialization();");
writer.WriteLine();
/* Declare test initialization function */
writer.WriteLine("void " + TestInitializationFunctionName + "(int paramIndex)");
writer.WriteLine("{");
/* Clear test structure */
writer.WriteLine(" memset(&" + TestArtefactsVariable + ", 0, sizeof(" + TestArtefactsStructureDataType + " ));");
if (componentInstances.Count > 0)
{
/* Fill CData constants */
writer.WriteLine(" switch(paramIndex)");
writer.WriteLine(" {");
for (int i = 0; i < componentInstances.Count; i++)
{
writer.WriteLine(" case " + i.ToString() + ":");
writer.WriteLine(" {");
/* CDATA */
for (int j = 0; j < compDef.CDataDefenitions.Count; j++)
{
CDataDefenition cdataDef = compDef.CDataDefenitions[j];
CDataInstance cdataInstance = componentInstances[i].CDataInstances.GetCData(cdataDef.GUID);
writer.Write(" " + TestArtefactsVariable + "." + RteFunctionsGenerator.GenerateShortCDataFunctionName(cdataDef) + ".Value = ");
IGUID datatype = cdataDef.DataType;
if ((datatype is BaseDataType) || (datatype is SimpleDataType) || (datatype is EnumDataType))
{
RteFunctionsGenerator.WriteDefaultValueForCDataDefenition(writer, componentInstances[i], cdataInstance);
}
writer.WriteLine(";");
}
for (int j = 0; j < compDef.PerInstanceMemoryList.Count; j++)
{
PimDefenition pimDef = compDef.PerInstanceMemoryList[j];
PimInstance pimInstance = componentInstances[i].PerInstanceMemories.GetPim(pimDef.GUID);
WritePIMDefaultValues(writer, pimInstance);
}
writer.WriteLine(" break;");
writer.WriteLine(" }");
}
writer.WriteLine(" }");
}
/* Write RTE_OK to all return functions */
foreach (PortDefenition portDef in compDef.Ports)
{
if (portDef.InterfaceDatatype is SenderReceiverInterface)
{
SenderReceiverInterface srInterface = (SenderReceiverInterface)portDef.InterfaceDatatype;
foreach (SenderReceiverInterfaceField srField in srInterface.Fields)
{
String fieldName = RteFunctionsGenerator.GenerateReadWriteFunctionName(portDef, srField);
writer.WriteLine(" " + TestArtefactsVariable + "." + fieldName + ".ReturnValue = RTE_E_OK;");
}
}
}
writer.WriteLine();
/* Initialize component variables */
writer.WriteLine(" VariableInitialization();");
writer.WriteLine("}");
RteFunctionsGenerator.CloseGuardDefine(writer);
RteFunctionsGenerator.WriteEndOfFile(writer);
writer.Close();
}
