public static CodeElements GetCodeElementMembers(CodeElement codeElement) { if (codeElement.Kind == vsCMElement.vsCMElementClass) { CodeClass2 codeClass = (CodeClass2)codeElement; return(codeClass.Members); } else if (codeElement.Kind == vsCMElement.vsCMElementInterface) { CodeInterface2 codeInterface = (CodeInterface2)codeElement; return(codeInterface.Members); } else if (codeElement.Kind == vsCMElement.vsCMElementStruct) { CodeStruct2 codeStruct = (CodeStruct2)codeElement; return(codeStruct.Members); } else if (codeElement.Kind == vsCMElement.vsCMElementEnum) { CodeEnum codeEnum = (CodeEnum)codeElement; return(codeEnum.Members); } else if (codeElement.Kind == vsCMElement.vsCMElementNamespace) { CodeNamespace codeNamespace = (CodeNamespace)codeElement; return(codeNamespace.Members); } return(null); }
/// <summary> /// /// </summary> public InterfaceInfo(NodeItem parent, CodeInterface2 item) : base(null, item as CodeElement2) { this.Parent = parent; this.item = item; this.IsInterface = true; this.Access = ObjectFactory.Convert(this.item.Access); this.IsAbstract = true; this.IsShared = false; this.IsGeneric = this.item.IsGeneric; this.Namespace = item.Namespace.FullName; this.DocComment = this.item.DocComment; IsPublic = this.IsPublic_Impl(this.item.Access); IsPrivate = this.IsPrivate_Impl(this.item.Access); IsProtected = this.IsProtected_Impl(this.item.Access); IsFamilyOrProtected = this.IsFamilyOrProtected_Impl(this.item.Access); this.IsStatic = false; this.IsStruct = false; //this.item.Children //this.item.DerivedTypes //this.item.InfoLocation //this.item.InheritanceKind //this.item.Kind = vsCMElement. //this.item.Parent //this.item.PartialClasses //this.item.Parts }
/// <summary> /// Visit given element. /// </summary> /// <param name="e">Element to visit.</param> public virtual void VisitInterface(CodeInterface2 e) { if (!RecursiveVisit) { //stop recursion visitUnhandled(e); return; } foreach (CodeElement child in e.Children) { VisitElement(child); } }
protected virtual void GetImplementedInterface([NotNull] CodeInterface2 implementedInterface, [NotNull] ICollection <string> baseFields) { Debug.ArgumentNotNull(implementedInterface, nameof(implementedInterface)); Debug.ArgumentNotNull(baseFields, nameof(baseFields)); foreach (var property in implementedInterface.Members.OfType <CodeProperty2>()) { if (!baseFields.Contains(property.Name)) { baseFields.Add(property.Name); } } foreach (var i in implementedInterface.Bases.OfType <CodeInterface2>()) { GetImplementedInterface(i, baseFields); } }
protected virtual void ProcessClassAttributes([NotNull] CodeInterface2 codeClass, [NotNull] Template template) { Debug.ArgumentNotNull(codeClass, nameof(codeClass)); Debug.ArgumentNotNull(template, nameof(template)); var sitecoreClass = codeClass.Attributes.OfType <CodeAttribute2>().FirstOrDefault(a => a.Name == "SitecoreClass" || a.Name == "SitecoreClassAttribute"); if (sitecoreClass != null) { foreach (var argument in sitecoreClass.Arguments.OfType <CodeAttributeArgument>()) { var value = argument.Value; if (value.StartsWith("\"") && value.EndsWith("\"")) { value = value.Mid(1, value.Length - 2); } if (argument.Name == "ParentPath") { template.ParentPath = value; } } } var parentPath = codeClass.Attributes.OfType <CodeAttribute2>().FirstOrDefault(a => a.Name == "ParentPath" || a.Name == "ParentPathAttribute"); if (parentPath != null) { var argument = parentPath.Arguments.OfType <CodeAttribute>().FirstOrDefault(); if (argument != null) { var value = argument.Value; if (value.StartsWith("\"") && value.EndsWith("\"")) { value = value.Mid(1, value.Length - 2); } template.ParentPath = value; } } }
protected virtual void ProcessTemplate([NotNull] FileCodeModel fileCodeModel, [NotNull] Template template, [NotNull] CodeInterface2 codeInterface) { Debug.ArgumentNotNull(fileCodeModel, nameof(fileCodeModel)); Debug.ArgumentNotNull(template, nameof(template)); Debug.ArgumentNotNull(codeInterface, nameof(codeInterface)); template.Name = codeInterface.Name; template.TemplateItemId = new ItemId(fileCodeModel.GetHash(codeInterface.Attributes, codeInterface.Name)); var baseTemplates = new List <string>(); GetImplementedInterfaces(fileCodeModel, codeInterface, baseTemplates); ProcessClassAttributes(codeInterface, template); template.BaseTemplates = string.Join("|", baseTemplates); ProcessTemplateSections(fileCodeModel, template, codeInterface); }
protected virtual void GetImplementedInterfaces([NotNull] FileCodeModel fileCodeModel, [NotNull] CodeInterface2 codeInterface, [NotNull] ICollection <string> baseTemplates) { Debug.ArgumentNotNull(fileCodeModel, nameof(fileCodeModel)); Debug.ArgumentNotNull(codeInterface, nameof(codeInterface)); Debug.ArgumentNotNull(baseTemplates, nameof(baseTemplates)); foreach (var implementedInterface in codeInterface.Bases.OfType <CodeInterface2>()) { var baseTemplateId = fileCodeModel.GetHash(implementedInterface.Attributes, implementedInterface.Name).Format(); baseTemplates.Add(baseTemplateId); } }
private List<CodeInterface2> GetUnResolvedInterfaces(CodeInterface2 @interface) { var interfaces = new List<CodeInterface2>(); if (@interface.Bases.Count <= 0) return interfaces; foreach (CodeInterface2 baseInterface in @interface.Bases) { interfaces.Add(baseInterface); interfaces.AddRange(GetUnResolvedInterfaces(baseInterface)); } return interfaces; }
internal ShellCodeInterface(CodeInterface2 codeInterface) : base(codeInterface as CodeElement2) { _codeInterface = codeInterface; }
private CodeDomInterfaceMetadata(CodeInterface2 codeInterface, CodeDomFileMetadata file) { this.codeInterface = codeInterface; this.file = file; }
/// <summary> /// Returns a flag indicating whether a CodeElement is a generic, /// and also returns the element's generic name. /// </summary> /// <param name="element">The CodeElement to test.</param> /// <param name="name">The returned generic name.</param> /// <returns>true if the delegate is a generic, otherwise false.</returns> public static bool IsGeneric(CodeElement element, out string name) { bool isGen = false; string postfix = null; if (element == null) { throw new ArgumentNullException("element"); } switch (element.Kind) { case vsCMElement.vsCMElementClass: CodeClass2 codeClass = element as CodeClass2; if ((codeClass != null) && codeClass.IsGeneric) { isGen = true; } break; //union declaration is used to represent variant types case vsCMElement.vsCMElementUnion: CodeClass2 codeVariant = element as CodeClass2; if ((codeVariant != null) && codeVariant.IsGeneric) { isGen = true; } break; case vsCMElement.vsCMElementInterface: CodeInterface2 codeInterface = element as CodeInterface2; if ((codeInterface != null) && codeInterface.IsGeneric) { isGen = true; } break; case vsCMElement.vsCMElementFunction: CodeFunction2 codeFunction = element as CodeFunction2; if ((codeFunction != null) && codeFunction.IsGeneric) { // Get information about the parameters, which is appended to the function name later. postfix = ExtractMethodParameters(codeFunction); isGen = true; } break; case vsCMElement.vsCMElementProperty: CodeProperty2 codeProperty = element as CodeProperty2; if ((codeProperty != null) && codeProperty.IsGeneric) { isGen = true; } break; case vsCMElement.vsCMElementVariable: CodeVariable2 codeVariable = element as CodeVariable2; if ((codeVariable != null) && codeVariable.IsGeneric) { isGen = true; } break; case vsCMElement.vsCMElementDelegate: CodeDelegate2 codeDelegate = element as CodeDelegate2; if ((codeDelegate != null) && codeDelegate.IsGeneric) { isGen = true; } break; } if (isGen) { // postfix is not null if the CodeElement is a generic function. name = ExtractGenericNameFromFullName(element) + postfix; } else { name = null; } return(isGen); }
public CodeInterfaceNodeFactory(CodeInterface2 element) : base(element as CodeElement) { _interface = element; }
public static bool IsCodeElementPrivate(CodeElement codeElement) { switch (codeElement.Kind) { case vsCMElement.vsCMElementVariable: CodeVariable2 codeVariable = (CodeVariable2)codeElement; if (codeVariable.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; case vsCMElement.vsCMElementFunction: CodeFunction2 codeFunction = (CodeFunction2)codeElement; if (codeFunction.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; case vsCMElement.vsCMElementProperty: CodeProperty codeProperty = (CodeProperty)codeElement; if (codeProperty.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; case vsCMElement.vsCMElementClass: CodeClass2 codeClass = (CodeClass2)codeElement; if (codeClass.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; case vsCMElement.vsCMElementDelegate: CodeDelegate2 codeDelegate = (CodeDelegate2)codeElement; if (codeDelegate.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; case vsCMElement.vsCMElementEvent: CodeEvent codeEvent = (CodeEvent)codeElement; if (codeEvent.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; case vsCMElement.vsCMElementInterface: CodeInterface2 codeInterface = (CodeInterface2)codeElement; if (codeInterface.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; case vsCMElement.vsCMElementStruct: CodeStruct2 codeStruct = (CodeStruct2)codeElement; if (codeStruct.Access == vsCMAccess.vsCMAccessPrivate) { return(true); } break; } return(false); }
/// <summary> /// /// </summary> public virtual bool AcceptInterface(CodeInterface2 c) { return true; }
/// <summary> /// /// </summary> public virtual InterfaceInfo CreateInterface(NodeItem parent, CodeInterface2 item) { return new InterfaceInfo(parent, item); }
protected virtual void ProcessTemplateSections([NotNull] FileCodeModel fileCodeModel, [NotNull] Template template, [NotNull] CodeInterface2 codeInterface) { Debug.ArgumentNotNull(fileCodeModel, nameof(fileCodeModel)); Debug.ArgumentNotNull(template, nameof(template)); Debug.ArgumentNotNull(codeInterface, nameof(codeInterface)); var templateSection = new TemplateSection(); template.Sections.Add(templateSection); templateSection.Name = "Data"; templateSection.TemplateSectionItemId = new ItemId(GuidExtensions.Hash(template.Name + @"/" + templateSection.Name)); foreach (var property in codeInterface.Members.OfType <CodeProperty2>()) { ProcessTemplateField(fileCodeModel, template, templateSection, property); } }
private CodeDomInterfaceMetadata(CodeInterface2 codeInterface, CodeDomFileMetadata file) { _codeInterface = codeInterface; _file = file; }
private void ParseInterface(CodeInterface2 codeInterface, List<Namespace> usings, Namespace @namespace, string currentFile) { WriteLine("ParseInterface" + " " + codeInterface.Name); var @interface = new Interface { Namespace = @namespace, Name = codeInterface.Name, Usings = usings, Type = codeInterface.Name, FileName = currentFile}; foreach (CodeAttribute2 codeElement in codeInterface.Attributes) { ParseAttribute(codeElement, @interface, currentFile); } foreach (var element in codeInterface.Members.Cast<CodeElement2>()) { switch (element.Kind) { case vsCMElement.vsCMElementFunction: var function = ParseFunction((CodeFunction2)element, currentFile); @interface.Functions.Add(function); break; case vsCMElement.vsCMElementProperty: var property = ParseProperty((CodeProperty) element, currentFile); @interface.Properties.Add(property); break; case vsCMElement.vsCMElementEvent: var @event = ParseEvent((CodeEvent) element, currentFile); @interface.Events.Add(@event); break; } } var interfaces = GetUnResolvedInterfaces(codeInterface); if (interfaces.Count > 0) { unresolvedInterfaces.Add(@interface, interfaces); } Interfaces.Add(@interface); }