private void WriteCSharpInterface(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline) { string ResultType = EntityType.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); string PropertyName = CSharpNames.ToCSharpIdentifier(Name); string Accessors = null; if (IsForcedReadWrite) { Accessors = "{ get; set; }"; } else { switch (Source.PropertyKind) { case BaseNode.UtilityType.ReadOnly: Accessors = "{ get; }"; break; case BaseNode.UtilityType.WriteOnly: Accessors = "{ set; }"; break; case BaseNode.UtilityType.ReadWrite: Accessors = "{ get; set; }"; break; } } Debug.Assert(Accessors != null); writer.WriteIndentedLine($"{ResultType} {PropertyName} {Accessors}"); isMultiline = false; }
/// <summary> /// Writes down the C# feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isLocal">True if the feature is local to the class.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public override void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline) { if (!WriteDown) { return; } writer.WriteDocumentation(Source); bool ClassHasSingleConstructor = isLocal && Owner.ClassConstructorType == CSharpConstructorTypes.OneConstructor; string NameString; if (ClassHasSingleConstructor) { NameString = Owner.BasicClassName2CSharpClassName(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None); } else { NameString = CSharpNames.ToCSharpIdentifier(Name); } foreach (ICSharpCommandOverload Overload in OverloadList) { Overload.WriteCSharp(writer, featureTextType, IsOverride, NameString, exportStatus, ClassHasSingleConstructor, ref isFirstFeature, ref isMultiline); } }
/// <summary> /// Writes down the C# feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isLocal">True if the feature is local to the class.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public override void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline) { if (!WriteDown) { return; } isMultiline = false; if (featureTextType == CSharpFeatureTextTypes.Implementation) { WriteCSharpImplementation(writer, exportStatus, ref isFirstFeature, ref isMultiline); } }
/// <summary> /// Writes down the C# feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isLocal">True if the feature is local to the class.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public override void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline) { if (!WriteDown) { return; } writer.WriteDocumentation(Source); string NameString = CSharpNames.ToCSharpIdentifier(Name); foreach (ICSharpCommandOverload Overload in OverloadList) { Overload.WriteCSharp(writer, featureTextType, IsOverride, NameString, exportStatus, false, ref isFirstFeature, ref isMultiline); } }
private void WriteCSharpImplementation(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline) { writer.WriteDocumentation(Source); string ResultType = EntityType.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); string PropertyName = CSharpNames.ToCSharpIdentifier(Name); bool IsHandled = false; if (IsForcedReadWrite) { WriteCSharpForcedReadWriteProperty(writer, IsOverride, exportStatus, PropertyName, ResultType, ref isFirstFeature, ref isMultiline); IsHandled = true; } else { switch (Source.PropertyKind) { case BaseNode.UtilityType.ReadOnly: WriteCSharpReadOnlyProperty(writer, IsOverride, exportStatus, PropertyName, ResultType, ref isFirstFeature, ref isMultiline); IsHandled = true; break; case BaseNode.UtilityType.WriteOnly: WriteCSharpWriteOnlyProperty(writer, IsOverride, exportStatus, PropertyName, ResultType, ref isFirstFeature, ref isMultiline); IsHandled = true; break; case BaseNode.UtilityType.ReadWrite: WriteCSharpReadWriteProperty(writer, IsOverride, exportStatus, PropertyName, ResultType, ref isFirstFeature, ref isMultiline); IsHandled = true; break; } } Debug.Assert(IsHandled); if (HasSideBySideAttribute && !Instance.InheritBySideAttribute) { writer.WriteIndentedLine($"protected {ResultType} _{PropertyName};"); isMultiline = true; } }
/// <summary> /// Writes down the C# overload of a feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="isOverride">True if the feature is an override.</param> /// <param name="nameString">The composed feature name.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isConstructor">True if the feature is a constructor.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline) { Debug.Assert(WriteDown); bool IsHandled = false; switch (featureTextType) { case CSharpFeatureTextTypes.Implementation: WriteCSharpImplementation(writer, isOverride, nameString, exportStatus, isConstructor, ref isFirstFeature, ref isMultiline); IsHandled = true; break; case CSharpFeatureTextTypes.Interface: WriteCSharpInterface(writer, isOverride, nameString, exportStatus, isConstructor, ref isFirstFeature, ref isMultiline); IsHandled = true; break; } Debug.Assert(IsHandled); }
/// <summary> /// Writes down the C# feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isLocal">True if the feature is local to the class.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public override void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline) { if (!WriteDown) { return; } bool IsHandled = false; switch (featureTextType) { case CSharpFeatureTextTypes.Implementation: WriteCSharpImplementation(writer, featureTextType, exportStatus, isLocal, ref isFirstFeature, ref isMultiline); IsHandled = true; break; case CSharpFeatureTextTypes.Interface: WriteCSharpInterface(writer, featureTextType, exportStatus, isLocal, ref isFirstFeature, ref isMultiline); IsHandled = true; break; } Debug.Assert(IsHandled); }
/// <summary> /// Writes down the C# overload of a feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="isOverride">True if the feature is an override.</param> /// <param name="nameString">The composed feature name.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isConstructor">True if the feature is a constructor.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline) { Debug.Assert(WriteDown); IList <ICSharpParameter> SelectedParameterList = ParameterList; IList <ICSharpParameter> SelectedResultList = ResultList; if (isOverride && Precursor != null) { SelectedParameterList = Precursor.ParameterList; SelectedResultList = Precursor.ResultList; } CSharpArgument.BuildParameterList(writer, SelectedParameterList, SelectedResultList, featureTextType, out string ArgumentEntityList, out string ArgumentNameList, out string ResultType); string ExportStatusText; if (featureTextType == CSharpFeatureTextTypes.Implementation) { bool IsHandled = false; switch (Body) { case ICSharpDeferredBody AsDeferredBody: CSharpAssertion.WriteContract(writer, AsDeferredBody.RequireList, AsDeferredBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline); ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus); writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList});"); isMultiline = false; IsHandled = true; break; case ICSharpEffectiveBody AsEffectiveBody: CSharpAssertion.WriteContract(writer, AsEffectiveBody.RequireList, AsEffectiveBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline); CSharpBodyFlags Flags = CSharpBodyFlags.MandatoryCurlyBrackets; string ResultString = string.Empty; List <string> InitialisationStringList = new List <string>(); if (ResultList.Count == 1) { Flags |= CSharpBodyFlags.HasResult; ICSharpParameter Result = ResultList[0]; ResultString = Result.Feature.Type.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); } else { if (ResultType != "void") { Flags |= CSharpBodyFlags.HasResult; ResultString = ResultType; } foreach (ICSharpParameter Item in ResultList) { string InitValueString; ICSharpType ResultEntityType = Item.Feature.Type; if (ResultEntityType is ICSharpClassType AsClassType) { // TODO: when the type inherit from Enumeration if (AsClassType.Class.Source.ClassGuid == LanguageClasses.AnyOptionalReference.Guid) { InitValueString = "new OptionalReference<>(null)"; // TODO } else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.String.Guid) { InitValueString = "\"\""; } else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Boolean.Guid) { InitValueString = "false"; } else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Character.Guid) { InitValueString = "'\0'"; } else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Number.Guid) { InitValueString = "0"; } else { InitValueString = "null"; } } else { InitValueString = "null"; // TODO : tuples } string InitNameString = CSharpNames.ToCSharpIdentifier(Item.Name); InitialisationStringList.Add($"{InitNameString} = {InitValueString};"); } } ExportStatusText = CSharpNames.ComposedExportStatus(isOverride, false, false, exportStatus); writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList})"); AsEffectiveBody.WriteCSharp(writer, Flags, ResultString, false, InitialisationStringList); isMultiline = true; IsHandled = true; break; case ICSharpPrecursorBody AsPrecursorBody: if (isMultiline) { writer.WriteEmptyLine(); } ExportStatusText = CSharpNames.ComposedExportStatus(true, false, false, exportStatus); writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList})"); writer.WriteIndentedLine("{"); writer.IncreaseIndent(); writer.WriteIndentedLine($"return base.{nameString}({ArgumentNameList});"); writer.DecreaseIndent(); writer.WriteIndentedLine("}"); isMultiline = true; IsHandled = true; break; } Debug.Assert(IsHandled); } else { writer.WriteIndentedLine($"{ResultType} {nameString}({ArgumentEntityList});"); isMultiline = false; } }
/// <summary> /// Writes down the C# feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isLocal">True if the feature is local to the class.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public abstract void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline);
/// <summary> /// Writes down the C# overload of a feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="isOverride">True if the feature is an override.</param> /// <param name="nameString">The composed feature name.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isConstructor">True if the feature is a constructor.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline) { //TODO }
/// <summary> /// Writes down the C# feature. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="exportStatus">The feature export status.</param> /// <param name="isLocal">True if the feature is local to the class.</param> /// <param name="isFirstFeature">True if the feature is the first in a list.</param> /// <param name="isMultiline">True if there is a separating line above.</param> public override void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline) { WriteCSharp(writer); }
/// <summary> /// Builds a list of parameters, with and without their type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="parameterList">The list of parameters.</param> /// <param name="resultList">The list of results.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="parameterListText">The list of parameters with type upon return.</param> /// <param name="parameterNameListText">The list of parameters without type upon return.</param> /// <param name="resultTypeText">The type text upon return.</param> public static void BuildParameterList(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> parameterList, IList <ICSharpParameter> resultList, CSharpFeatureTextTypes featureTextType, out string parameterListText, out string parameterNameListText, out string resultTypeText) { parameterListText = string.Empty; parameterNameListText = string.Empty; foreach (ICSharpParameter Parameter in parameterList) { if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } string ParameterName = Parameter.Name; ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string ParameterNameText = CSharpNames.ToCSharpIdentifier(ParameterName); parameterListText += $"{ParameterText} {ParameterNameText}"; parameterNameListText += ParameterNameText; } if (resultList.Count == 1) { BuildResultListSingle(usingCollection, resultList, out resultTypeText); } else { int ResultIndex = -1; for (int i = 0; i < resultList.Count; i++) { ICSharpParameter Result = resultList[i]; if (Result.Name == nameof(BaseNode.Keyword.Result)) { ResultIndex = i; break; } } if (ResultIndex < 0) { BuildResultListNoResult(usingCollection, resultList, ref parameterListText, ref parameterNameListText, out resultTypeText); } else { BuildResultListWithResult(usingCollection, resultList, ResultIndex, ref parameterListText, ref parameterNameListText, out resultTypeText); } } }