public static bool Attribute_AliasDefinition(string attributeCode, out string attrinuteName, out string mirrorParameter1, out string mirrorClass, out string mirrorMethodName)
{
List <string> parameters;
ClassNTAttributes_Methods.Attribute_Parts(attributeCode, out attrinuteName, out parameters);
// Default values
mirrorParameter1 = null;
mirrorClass = null;
mirrorMethodName = null;
if (BlueprintMethodRuleAlias(attrinuteName) == false)
{
return(false); //<================================================
}
// Parse the parameters
foreach (string parameter in parameters)
{
if (parameter.Contains("MirrorParameter1"))
{
mirrorParameter1 = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
if (parameter.Contains("MirrorClass"))
{
mirrorClass = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
if (parameter.Contains("MirrorMethodName"))
{
mirrorMethodName = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
}
return(true);
}
public static bool Method_Attributes(string attributeCode, out string name, out bool ignore, out string shortcutClassName, out string shortcutMethodName)
{
List <string> parameters;
ClassNTAttributes_Methods.Attribute_Parts(attributeCode, out name, out parameters);
// Default values
ignore = false;
shortcutClassName = null;
shortcutMethodName = null;
if (BlueprintMethodRule(name) == false)
{
return(false); //<================================================
}
// Parse the parameters
foreach (string parameter in parameters)
{
if (parameter.Contains("Ignore"))
{
ignore = parameter.zvar_Value("=").zTo_Bool();
}
if (parameter.Contains("ShortcutClassName"))
{
shortcutClassName = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
if (parameter.Contains("ShortcutMethodName"))
{
shortcutMethodName = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
}
return(true);
}
public static ClassNTAttribute_ Create(string attributeStr)
{
var result = new ClassNTAttribute_();
List <string> parameterList;
ClassNTAttributes_Methods.Attribute_Parts(attributeStr, out result.AttributeName, out parameterList);
foreach (string parameterStr in parameterList)
{
var parameter = ClassNTAttribute_Parameter_.Create(result.AttributeName, parameterStr);
result.Parameters.Add(parameter);
}
return(result);
}
public static void Attribute_Parts_Test()
{
string name;
List <string> parameters;
#region Test1: [Test]
// ==============================================================
var attributeCode1 = "[Test]";
ClassNTAttributes_Methods.Attribute_Parts(attributeCode1, out name, out parameters);
Assert.Equal("Test", name);
Assert.Equal(0, parameters.Count);
#endregion
#region Test2: [TestedMethod_("Attribute_Parts()")]
// =============================================================
var attributeCode2 = "[TestedMethod_(\"Attribute_Parts()\")]";
ClassNTAttributes_Methods.Attribute_Parts(attributeCode2, out name, out parameters);
Assert.Equal("TestedMethod_", name);
Assert.Equal("\"Attribute_Parts()\"", parameters[0]);
Assert.Equal(1, parameters.Count);
#endregion
#region Test3: [ActiveTemplate_(Description = "This code will link different classes into a CTI network", Parameter1_Caption = "Class typename:\", Parameter1_Name= \"ClassHeading_NewTypeName\", Parameter1_Value= enATemplate_Value.Value_FromClipboard, Parameter2_Caption = "Property name:", Parameter2_Name = "NewTypeName")]
// =======================================================
// [ActiveTemplate_(Description = "This code will link different classes into a CTI network",
// Parameter1_Caption = "Class typename:", Parameter1_Name= "ClassHeading_NewTypeName", Parameter1_Value= enATemplate_Value.Value_FromClipboard,
// Parameter2_Caption = "Property name:", Parameter2_Name = "NewTypeName")]
var attLine = "[ActiveTemplate_(Description = \"This code will link different classes into a CTI network\", Parameter1_Caption = \"Class typename:\", Parameter1_Name= \"ClassHeading_NewTypeName\", Parameter1_Value= enATemplate_Value.Value_FromClipboard, Parameter2_Caption = \"Property name:\", Parameter2_Name = \"NewTypeName\")]";
ClassNTAttributes_Methods.Attribute_Parts(attLine, out name, out parameters);
Assert.Equal("ActiveTemplate_", name);
Assert.Equal("Description = \"This code will link different classes into a CTI network\"", parameters[0]);
Assert.Equal("Parameter1_Caption = \"Class typename:\"", parameters[1]);
Assert.Equal("Parameter1_Name= \"ClassHeading_NewTypeName\"", parameters[2]);
Assert.Equal("Parameter1_Value= enATemplate_Value.Value_FromClipboard", parameters[3]);
Assert.Equal("Parameter2_Caption = \"Property name:\"", parameters[4]);
Assert.Equal("Parameter2_Name = \"NewTypeName\"", parameters[5]);
Assert.Equal(6, parameters.Count);
#endregion
#region Test4: Illigal input "", "[bla", "bla]"
Assert.Throws <InvalidOperationException>(() => ClassNTAttributes_Methods.Attribute_Parts("", out name, out parameters));
Assert.Throws <InvalidOperationException>(() => ClassNTAttributes_Methods.Attribute_Parts("[bla", out name, out parameters));
Assert.Throws <InvalidOperationException>(() => ClassNTAttributes_Methods.Attribute_Parts("bla]", out name, out parameters));
#endregion
}
public static bool BlueprintRule_Attributes(string attributeCode, out string name, out List <string> parameters, out enBlueprint_ClassNetworkType classNetworkType,
out string ignore1, out string ignore2, out string ignore3, out string ignore4)
{
ClassNTAttributes_Methods.Attribute_Parts(attributeCode, out name, out parameters);
// Default values
classNetworkType = enBlueprint_ClassNetworkType.Undefined;
ignore1 = null;
ignore2 = null;
ignore3 = null;
ignore4 = null;
if (BlueprintRuleClass(name) == false)
{
return(false); //<================================================
}
// Test the parameters
// The first parameter is the enBlueprintClassNetworkType
var parm1 = parameters[0];
classNetworkType = parm1.zEnum_To_EnumValue <enBlueprint_ClassNetworkType>();
//var value = parm1.zvar_Value(".");
//classNetworkType = value.zEnum_To_EnumValue<enBlueprintClassNetworkType>();
foreach (string parameter in parameters)
{
if (parameter.Contains("Ignore_Namespace1"))
{
ignore1 = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
if (parameter.Contains("Ignore_Namespace2"))
{
ignore2 = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
if (parameter.Contains("Ignore_Namespace3"))
{
ignore3 = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
if (parameter.Contains("Ignore_Namespace4"))
{
ignore4 = parameter.zvar_Value("=").zRemove_DoubleQuotes();
}
}
return(true);
}
public static void Attributes_FromCode_Test()
{
var source = new List <string>();
List <string> attributeLines;
#region Test1: [Test], [Pure]
// =======================================================
source.Add(" [Test]");
source.Add(" [Pure]");
attributeLines = ClassNTAttributes_Methods.Attributes_FromCode(source);
Assert.Equal("[Test]", attributeLines[0]);
Assert.Equal("[Pure]", attributeLines[1]);
Assert.Equal(2, attributeLines.Count);
#endregion
#region Test2: [Fact, Test_Method("Attributes_FromCode()")]
// =======================================================
source.Clear();
source.Add(" [Fact, Test_Method(\"Attributes_FromCode()\")]");
source.Add(" [BlueprintCodeInjection_(typeof(Controller_BlueprintLogger), true)]");
attributeLines = ClassNTAttributes_Methods.Attributes_FromCode(source);
Assert.Equal(3, attributeLines.Count);
Assert.Equal("[Fact]", attributeLines[0]);
Assert.Equal("[Test_Method(\"Attributes_FromCode()\")]", attributeLines[1]);
Assert.Equal("[BlueprintCodeInjection_(typeof(Controller_BlueprintLogger), true)]", attributeLines[2]);
#endregion
#region Test3: [Test, TestedMethod("Key_Add()"), TestedMethod("Key_Find()"), TestedMethod("Key_Remove()")]
// =======================================================
// [Pure]
// [Category("Appearance")]
// [Description("Set Cancel Visible property")]
// [Test, TestedMethod("Key_Add()"), TestedMethod("Key_Find()"), TestedMethod("Key_Remove()")]
source.Clear();
source.Add(" [Pure]");
source.Add(" [Category(\"Appearance\")]");
source.Add(" [Description(\"Set Cancel Visible property\")]");
source.Add(" [Test, TestedMethod(\"Key_Add()\"), TestedMethod(\"Key_Find()\"), TestedMethod(\"Key_Remove()\")]");
attributeLines = ClassNTAttributes_Methods.Attributes_FromCode(source);
Assert.Equal("[Pure]", attributeLines[0]);
Assert.Equal("[Category(\"Appearance\")]", attributeLines[1]);
Assert.Equal("[Description(\"Set Cancel Visible property\")]", attributeLines[2]);
Assert.Equal("[Test]", attributeLines[3]);
Assert.Equal("[TestedMethod(\"Key_Add()\")]", attributeLines[4]);
Assert.Equal("[TestedMethod(\"Key_Find()\")]", attributeLines[5]);
Assert.Equal("[TestedMethod(\"Key_Remove()\")]", attributeLines[6]);
Assert.Equal(7, attributeLines.Count);
#endregion
#region Test4: [ActiveTemplate_(Description = "This code will link different classes into a CTI network", Parameter1_Caption = "Class typename:", Parameter1_Name= "ClassHeading_NewTypeName", Parameter1_Value= enATemplate_Value.Value_FromClipboard, Parameter2_Caption = "Property name:", Parameter2_Name = "NewTypeName")]
// =======================================================
// [ActiveTemplate_(Description = "This code will link different classes into a CTI network",
// Parameter1_Caption = "Class typename:", Parameter1_Name= "ClassHeading_NewTypeName", Parameter1_Value= enATemplate_Value.Value_FromClipboard,
// Parameter2_Caption = "Property name:", Parameter2_Name = "NewTypeName")]
source.Clear();
source.Add(" [ActiveTemplate_(Description = \"This code will link different classes into a CTI network\",");
source.Add(" Parameter1_Caption = \"Class typename:\", Parameter1_Name= \"ClassHeading_NewTypeName\", Parameter1_Value= enATemplate_Value.Value_FromClipboard, ");
source.Add(" Parameter2_Caption = \"Property name:\", Parameter2_Name = \"NewTypeName\")]");
attributeLines = ClassNTAttributes_Methods.Attributes_FromCode(source);
var attLine = "[ActiveTemplate_(Description = \"This code will link different classes into a CTI network\", Parameter1_Caption = \"Class typename:\", Parameter1_Name= \"ClassHeading_NewTypeName\", Parameter1_Value= enATemplate_Value.Value_FromClipboard, Parameter2_Caption = \"Property name:\", Parameter2_Name = \"NewTypeName\")]";
Assert.Equal(attLine, attributeLines[0]);
Assert.Equal(1, attributeLines.Count);
#endregion
}
/// <summary>
/// Converts the method's documentation to intermediate lines list.
/// </summary>
/// <param name="sourceLines">The header lines list</param>
/// <param name="ii">The ii indexer reference variable</param>
/// <param name="statistics"></param>
/// <param name="commentLines">The documentation lines.</param>
/// <param name="summaryLine">The summary line.</param>
/// <param name="attributeLines">The attribute lines.</param>
/// <param name="returnLine">The return line.</param>
/// <param name="ctiCodeLine">The cti code line.</param>
public static void Documentation_Parts(List <string> sourceLines, ref int ii, ClassNTStats_ statistics, out List <string> commentLines, out string summaryLine,
out List <string> attributeLines, out string returnLine, out string ctiCodeLine)
{
// <summary>Determines whether the specified input string contains index. This is supposed to be faster than IndexOf()</summary>
bool summaryStart = false;
bool returnStart = false;
//bool codeStart = false;
commentLines = new List <string>();
attributeLines = new List <string>();
returnLine = "";
summaryLine = "";
ctiCodeLine = "";
string line = sourceLines[ii].Trim();
while (line == "" || line.Contains("///") || line.Substring(0, 1) == "[")
{
statistics.ClassTotalLines++;
if (line.Substring(0, 1) == "[")
{
// Attributes
attributeLines.AddRange(ClassNTAttributes_Methods.Attributes_FromCodeLine(line));
statistics.TotalAttributes++;
statistics.ClassTotalCodeLines++;
}
else if (line.Contains("////") == false && line != "")
{
// This is not a comment or this is an empty line -> This is the documentation
statistics.ClassTotalCommentLines++;
line = line.Replace("///", "").Trim();
#region Summary =======================================================
if (summaryStart)
{
summaryLine += line;
if (line.Contains("</summary>"))
{
summaryStart = false;
line = summaryLine;
}
}
else if (line.Contains("<summary>"))
{
summaryLine = line;
if (line.Contains("</summary>") == false)
{
summaryStart = true;
}
}
#endregion
#region Return ======================================================
if (returnStart)
{
returnLine += line;
if (line.Contains("</returns>"))
{
returnStart = false;
line = returnLine;
}
}
else if (line.Contains("<returns>"))
{
returnLine = line;
if (line.Contains("</returns>") == false)
{
returnStart = true;
}
}
#endregion ==============================================================
#region Code ======================================================
// Code tag is no longer used
//if (codeStart)
//{
// ctiCodeLine += line;
// if (ctiCodeLine.Contains("</code>"))
// {
// codeStart = false;
// line = ctiCodeLine;
// }
//}
//else
//if (line.Contains("<code "))
//{
// ctiCodeLine = line;
// if (line.Contains("</code>") == false) codeStart = true;
//}
#endregion ==============================================================
// Only add the line if we know what the return value is -> we want to compress the XML to viewer lines as it is then more readable
if (summaryStart == false && returnStart == false)
{
commentLines.Add(line);
}
}
ii++;
line = sourceLines[ii].Trim(); // Move to the next line
}
summaryLine = summaryLine.zConvert_XML_ValueBetweenTags("summary");
}
