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);
}
internal ShellCodeInterface(CodeInterface2 codeInterface) : base(codeInterface as CodeElement2)
{
_codeInterface = codeInterface;
}
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;
}
public CodeInterfaceNodeFactory(CodeInterface2 element) : base(element as CodeElement)
{
_interface = element;
}
/// <summary>
///
/// </summary>
public virtual InterfaceInfo CreateInterface(NodeItem parent, CodeInterface2 item)
{
return new InterfaceInfo(parent, item);
}
private CodeDomInterfaceMetadata(CodeInterface2 codeInterface, CodeDomFileMetadata file)
{
this.codeInterface = codeInterface;
this.file = file;
}
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);
}
