public int GetCountFor(IIntermediateNamespaceParent parent) { int result = 0; foreach (var element in this.Values) { if (element.Parent == parent) { result++; } else { foreach (var part in element.Parts) { if (part.Parent == parent) { result++; } } } } return(result); }
private void VisitNamespaceParent(IIntermediateNamespaceParent nsParent, DefaultAssemblyFilenameVisitorContext context) { VisitTypeParent(nsParent, context); foreach (var @namespace in nsParent.Namespaces.ExclusivelyOnParent()) { if (context.CurrentResult != null) { return; } @namespace.Value.Accept(this, context); } if (context.CurrentResult == null) { var fields = nsParent.Fields.ExclusivelyOnParent().Count() > 0; var methods = nsParent.Methods.ExclusivelyOnParent().Count() > 0; bool metadata = false; var assemTarget = nsParent as IIntermediateAssembly; if (assemTarget != null && assemTarget.IsRoot) { metadata = assemTarget.Metadata.Count > 0; } if (fields || methods || metadata) { int offset = 0; if (assemTarget != null && assemTarget.IsRoot) { context.CurrentResult = @".\AssemblyInfo"; } else { context.CurrentResult = string.Format(@".\{0}", context.RootAssembly.Name); } } } }
/// <summary> /// Creates a new <see cref="IntermediateNamespaceDeclaration"/> /// with the <paramref name="name"/> and <paramref name="parent"/> provided. /// </summary> /// <param name="name">The <see cref="String"/> value representing the /// <see cref="IntermediateNamespaceDeclaration"/>'s name.</param> /// <param name="parent">The <see cref="IIntermediateNamespaceParent"/> /// which contains the <see cref="IntermediateNamespaceDeclaration"/>.</param> public IntermediateNamespaceDeclaration(string name, IIntermediateNamespaceParent parent) : base() { base.AssignName(name); this.parent = parent; }
/// <summary> /// Disposes the <see cref="IntermediateNamespaceDeclaration"/> /// </summary> /// <param name="disposing">whether to dispose the managed /// resources as well as the unmanaged resources.</param> protected override void Dispose(bool disposing) { try { if (disposing) { lock (this.SyncObject) { this.parent = null; if (this.methods != null) { this.methods.Dispose(); this.methods = null; } if (this.fields != null) { this.fields.Dispose(); this.fields = null; } if (this.members != null) { if (this.IsRoot) { this.members.Dispose(); } else { this.members.ConditionalRemove(this); } this.members = null; } if (this.classes != null) { this.classes.Dispose(); this.classes = null; } if (this.enums != null) { this.enums.Dispose(); this.enums = null; } if (this.delegates != null) { this.delegates.Dispose(); this.delegates = null; } if (this.interfaces != null) { this.interfaces.Dispose(); this.interfaces = null; } if (this.structs != null) { this.structs.Dispose(); this.structs = null; } if (this.types != null) { if (this.IsRoot) { this.types.Dispose(); } else { this.types.ConditionalRemove(this); } this.types = null; } if (this.namespaces != null) { this.namespaces.Dispose(); this.namespaces = null; } this.scopeCoercions = null; } } } finally { base.Dispose(disposing); } }
/// <summary> /// Creates a new <see cref="IntermediateNamespaceDeclaration"/> /// instance with the root namespace declaration provided. /// </summary> /// <param name="rootDeclaration">The <see cref="IntermediateNamespaceDeclaration"/> /// which is the root instance.</param> /// <param name="parent">The <see cref="IIntermediateNamespaceParent"/> /// which contains the <see cref="IntermediateNamespaceDeclaration"/>.</param> public IntermediateNamespaceDeclaration(IntermediateNamespaceDeclaration rootDeclaration, IIntermediateNamespaceParent parent) : base(rootDeclaration) { this.parent = parent; }
protected void TranslateNamespaceParent(IIntermediateNamespaceParent parent) { this.TranslateFieldParent <ITopLevelFieldMember, IIntermediateTopLevelFieldMember, INamespaceParent, IIntermediateNamespaceParent>(parent); this.TranslateMethodSignatures(parent.Methods); this.TranslateTypeParent(parent); }
/// <summary> /// Adds a new <see cref="IIntermediateNamespaceDeclaration"/> to the /// <see cref="IntermediateNamespaceDictionary"/>. /// </summary> /// <param name="path">The <see cref="String"/> representing the namespace's /// fully qualified path.</param> /// <returns>A new <see cref="IIntermediateNamespaceDeclaration"/> /// instance that results from the operation.</returns> /// <remarks>The <paramref name="name"/> is segmented and delimited by periods (Full Stops, U+002E) /// which make up the invidual sub-namespaces of the <see cref="IIntermediateNamespaceDeclaration"/> /// that results.</remarks> /// <exception cref="System.ArgumentException"><paramref name="path"/> exists /// already; <paramref name="path"/> is <see cref="String.Empty"/>; or /// <paramref name="path"/> consists of periods (Full Stops, U+002E) only.</exception> /// <exception cref="System.ArgumentNullException">thrown when <paramref name="name"/> /// is null.</exception> public virtual IIntermediateNamespaceDeclaration Add(string path) { if (path == null) { throw new ArgumentNullException("path"); } if (path == string.Empty) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.path, ExceptionMessageId.ArgumentCannotBeEmpty, ThrowHelper.GetArgumentName(ArgumentWithException.path)); } IIntermediateNamespaceCtorLanguageService ctorService = null; if (this.Parent != null && this.Parent.Assembly != null && this.Parent.Assembly.Provider != null) { this.Parent.Assembly.Provider.TryGetService(LanguageGuids.Services.IntermediateNamespaceCreatorService, out ctorService); } string separator = ctorService == null ? "." : ctorService.IdentitySeparator; if (path.Contains(separator)) { var pathVariants = path.NamespacePathBreakdown(); if (this.Parent is INamespaceDeclaration) { pathVariants = pathVariants.Except(((INamespaceDeclaration)(this.Parent)).FullName.NamespacePathBreakdown(separator)).ToArray(); } var names = pathVariants.ToArray(); //It was comprised of dots only. if (names.Length == 0) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.path, ExceptionMessageId.PathCannotBeDotsOnly); } if (names.Length == 1) { return(this.Add(names[0].Name)); } IIntermediateNamespaceParent parent = this.Parent; bool hadNonExistant = false; for (int i = 0; i < names.Length; i++) { if (parent.Namespaces.ContainsKey(names[i])) { parent = parent.Namespaces[names[i]]; } else { if (!hadNonExistant) { hadNonExistant = true; } parent = parent.Namespaces.Add(names[i].Name.GetNamespaceFinalPathPart(separator)); } } //The path already exists. if (!hadNonExistant) { throw new ArgumentException(string.Format("The provided path '{0}' already exists at this level.", path), "path"); } return((IIntermediateNamespaceDeclaration)parent); } else { if (this.ContainsKey(path)) { throw new ArgumentException(string.Format("The provided path {0} already exists at this level.", path), "path"); } IIntermediateNamespaceDeclaration newNamespace = ctorService != null ? ctorService.New(path, this.Parent) : new IntermediateNamespaceDeclaration(path, this.Parent); this._Add(newNamespace.UniqueIdentifier, newNamespace); return(newNamespace); } }
/// <summary> /// Creates a new instance of an <see cref="IntermediateNamespaceDictionary"/> /// with the <paramref name="parent"/> provided. /// </summary> /// <param name="parent">The <see cref="IIntermediateNamespaceParent"/> /// which contains the <see cref="IntermediateNamespaceDictionary"/> /// and its elements.</param> /// <param name="toWrap">The <see cref="IntermediateNamespaceDictionary"/> /// to wrap the elements of.</param> public IntermediateNamespaceDictionary(IIntermediateNamespaceParent parent, IntermediateNamespaceDictionary toWrap) : base(toWrap) { this.parent = parent; }
/// <summary> /// Creates a new instance of an <see cref="IntermediateNamespaceDictionary"/> with /// the <paramref name="parent"/> provided. /// </summary> /// <param name="parent">The <see cref="IIntermediateNamespaceParent"/> /// which contains the <see cref="IntermediateNamespaceDictionary"/> /// and its elements.</param> public IntermediateNamespaceDictionary(IIntermediateNamespaceParent parent) : base() { this.parent = parent; }