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);
}
}
}
