/// <summary> /// Validates that all the child names are unique. /// </summary> /// <exception cref="InvalidOperationException">Two child objects were found with the same name.</exception> private void ValidateChildNames() { List <BaseTypeInfo> childList = new List <BaseTypeInfo>(); childList.AddRange(DeclaredTypes); childList.AddRange(Functions); childList.AddRange(Procedures); childList.AddRange(SubModule.GetUniqueComponents(SubModules, true)); childList.AddRange(Signals); childList.AddRange(Aliases); childList.AddRange(AttributeDeclarationInfo.GetUniqueAttributeDeclarations(Attributes)); childList.AddRange(Processes); childList.AddRange(Generates); childList.AddRange(SubModules); BaseTypeInfo.ValidateNoDuplicates(childList.ToArray(), Entity.Name, "module"); }
/// <summary> /// Validates that all the child names are unique. /// </summary> /// <exception cref="InvalidOperationException">Two child objects were found with the same name.</exception> private void ValidateChildNames() { List <BaseTypeInfo> childList = new List <BaseTypeInfo>(Generates.Count + Processes.Count + SubModules.Count); foreach (ProcessInfo info in Processes) { childList.Add(info); } foreach (GenerateInfo info in Generates) { childList.Add(info); } foreach (SubModule info in SubModules) { childList.Add(info); } BaseTypeInfo.ValidateNoDuplicates(childList.ToArray(), Name, "generate"); }
/// <summary> /// Writes the declarations to a stream. /// </summary> /// <param name="wr"><see cref="StreamWriter"/> object to write the declarations to.</param> /// <param name="declarations">Array of <see cref="DeclarationInfo"/> objects to write to the stream.</param> /// <param name="indentOffset">Number of indents to add before any documentation begins.</param> /// <param name="parentName">Name of the parent object.</param> /// <param name="parentType">Type of the parent object.</param> /// <remarks>Use this method over the base class method to perform additional checks and better sorting.</remarks> /// <exception cref="ArgumentException"><paramref name="parentName"/>, or <paramref name="parentType"/> is an empty string.</exception> /// <exception cref="ArgumentNullException"><paramref name="wr"/>, <paramref name="parentName"/>, or <paramref name="parentType"/> is a null reference.</exception> /// <exception cref="InvalidOperationException">A circular dependency exists or duplicate name is found in the <paramref name="declarations"/>.</exception> /// <exception cref="IOException">An error occurred while writing to the <see cref="StreamWriter"/> object.</exception> public static void WriteDeclarations(StreamWriter wr, DeclarationInfo[] declarations, int indentOffset, string parentName, string parentType) { if (wr == null) { throw new ArgumentNullException("wr"); } if (declarations == null) { throw new ArgumentNullException("declarations"); } if (parentName == null) { throw new ArgumentNullException("parentName"); } if (parentName.Length == 0) { throw new ArgumentException("parentName is an empty string"); } if (parentType == null) { throw new ArgumentNullException("parentType"); } if (parentType.Length == 0) { throw new ArgumentException("parentType is an empty string"); } if (indentOffset < 0) { indentOffset = 0; } // Write nothing if array is empty. if (declarations.Length == 0) { return; } // Validate that we don't have duplicate names. BaseTypeInfo.ValidateNoDuplicates(declarations, parentName, parentType); // Validate that no circular dependencies exist. foreach (DeclarationInfo dec in declarations) { ValidateDependencies(dec, new DeclarationInfo[0]); } // Validate that all dependencies are in the main list. List <DeclarationInfo> decList = new List <DeclarationInfo>(declarations); foreach (DeclarationInfo dec in declarations) { ValidateDependenciesExist(dec, decList); } // Sort the Values by type. DeclarationInfo[] sorted = SortDeclarations(declarations); DocumentationHelper.WriteRegionStart(wr, "Constants & Types", indentOffset); for (int i = 0; i < sorted.Length; i++) { sorted[i].Write(wr, indentOffset); if (i != sorted.Length - 1) { DocumentationHelper.WriteLine(wr); // Leave a line between declarations. } } DocumentationHelper.WriteRegionEnd(wr, "Constants & Types", indentOffset); }
/// <summary> /// Writes the attributes to a stream. /// </summary> /// <param name="wr"><see cref="StreamWriter"/> object to write the types to.</param> /// <param name="attributes">Array of <see cref="AttributeSpecificationInfo"/> objects to write to the stream.</param> /// <param name="indentOffset">Number of indents to add before any documentation begins.</param> /// <param name="parentName">Name of the parent object.</param> /// <param name="parentType">Type of the parent object.</param> /// <exception cref="ArgumentException"><paramref name="parentName"/>, or <paramref name="parentType"/> is an empty string.</exception> /// <exception cref="ArgumentNullException"><paramref name="wr"/>, <paramref name="parentName"/>, or <paramref name="parentType"/> is a null reference.</exception> /// <exception cref="InvalidOperationException">A duplicate object or name is found in the <paramref name="attributes"/>.</exception> /// <exception cref="IOException">An error occurred while writing to the <see cref="StreamWriter"/> object.</exception> public static void WriteAttributes(StreamWriter wr, AttributeSpecificationInfo[] attributes, int indentOffset, string parentName, string parentType) { if (wr == null) { throw new ArgumentNullException("wr"); } if (attributes == null) { throw new ArgumentNullException("attributes"); } if (parentName == null) { throw new ArgumentNullException("parentName"); } if (parentName.Length == 0) { throw new ArgumentException("parentName is an empty string"); } if (parentType == null) { throw new ArgumentNullException("parentType"); } if (parentType.Length == 0) { throw new ArgumentException("parentType is an empty string"); } if (indentOffset < 0) { indentOffset = 0; } // Write nothing if array is empty. if (attributes.Length == 0) { return; } // TODO: should validate that there aren't duplicate declaration/signal combination. - RD Dictionary <AttributeDeclarationInfo, List <AttributeSpecificationInfo> > lookup = new Dictionary <AttributeDeclarationInfo, List <AttributeSpecificationInfo> >(); foreach (AttributeSpecificationInfo info in attributes) { if (!lookup.ContainsKey(info.Declaration)) { lookup.Add(info.Declaration, new List <AttributeSpecificationInfo>()); } lookup[info.Declaration].Add(info); } // Validate that we don't have duplicate names in the declarations. List <AttributeDeclarationInfo> list = new List <AttributeDeclarationInfo>(lookup.Keys); BaseTypeInfo.ValidateNoDuplicates(list.ToArray(), parentName, parentType); list.Sort(); DocumentationHelper.WriteRegionStart(wr, "Attributes", indentOffset); for (int i = 0; i < list.Count; i++) { list[i].Write(wr, indentOffset); DocumentationHelper.WriteLine(wr); for (int j = 0; j < lookup[list[i]].Count; j++) { lookup[list[i]][j].Write(wr, indentOffset); if (j != lookup[list[i]].Count - 1) { DocumentationHelper.WriteLine(wr); // Leave a line between specifications. } } if (i != list.Count - 1) { DocumentationHelper.WriteLine(wr); // Leave a line between declarations. } } DocumentationHelper.WriteRegionEnd(wr, "Attributes", indentOffset); }