private CodeDocRepositorySearchContext(ReadOnlyCollection<ICodeDocMemberRepository> allRepositories, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full)
{
Contract.Requires(allRepositories != null);
_visitedRepositories = new HashSet<ICodeDocMemberRepository>();
AllRepositories = allRepositories;
DetailLevel = detailLevel;
}
/// <summary>
/// Clones this search context with only the given repository marked as unvisited and an overridden detail level.
/// </summary>
/// <param name="targetRepository">The repository that is to be unvisited.</param>
/// <param name="detailLevel">The desired detail level.</param>
/// <returns>A search context.</returns>
public CodeDocRepositorySearchContext CloneWithOneUnvisited(ICodeDocMemberRepository targetRepository, CodeDocMemberDetailLevel detailLevel)
{
Contract.Ensures(Contract.Result<CodeDocRepositorySearchContext>() != null);
var result = CloneWithoutVisits(detailLevel);
foreach (var repository in result.AllRepositories)
if (repository != targetRepository)
result.Visit(repository);
return result;
}
/// <summary>
/// Creates a member model for the given code reference.
/// </summary>
/// <param name="cRef">The code reference to generate a model for.</param>
/// <param name="searchContext">The serach context to use when locating related members.</param>
/// <param name="detailLevel">Indicates the desired detail level of the generated model.</param>
/// <returns>The generated member if possible.</returns>
public virtual ICodeDocMember GetMemberModel(CRefIdentifier cRef, CodeDocRepositorySearchContext searchContext = null, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full)
{
return CreateGenerator(searchContext).GetMemberModel(cRef, detailLevel);
}
/// <summary>
/// Gets a type model for the given code reference or creates a new one.
/// </summary>
/// <param name="cRef">The code reference to get a model for.</param>
/// <param name="detailLevel">Indicates the desired detail level of the generated model.</param>
/// <returns>A code doc model for the given code reference.</returns>
protected CodeDocType GetOrConvertType(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
Contract.Ensures(Contract.Result<ICodeDocMember>() != null);
return ToTypeModel(GetOrConvert(cRef, detailLevel));
}
protected CodeDocType GetOnlyType(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToTypeModel(GetOnly(cRef, detailLevel));
}
protected CodeDocMethod GetOnlyMethod(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToMethodModel(GetOnly(cRef, detailLevel));
}
protected ICodeDocMember GetOnly(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
if(HasSearchContext){
var searchContext = SearchContext.CloneWithoutVisits(detailLevel);
var searchResult = searchContext.Search(cRef);
if (searchResult != null)
return searchResult;
}
if (!HasSearchContext || !SearchContext.IsReferenced(Repository)) {
var localModel = GetMemberModel(cRef, detailLevel);
if (localModel != null)
return localModel;
}
return null;
}
private CodeDocType ConvertToModel(Type type, CodeDocMemberDetailLevel detailLevel, ICodeDocMemberDataProvider extraMemberDataProvider = null)
{
Contract.Requires(type != null);
Contract.Ensures(Contract.Result<CodeDocType>() != null);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocType>().ShortName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocType>().FullName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocType>().Title));
Contract.Ensures(Contract.Result<CodeDocType>().Title == Contract.Result<CodeDocType>().ShortName);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocType>().SubTitle));
var includeExceptions = detailLevel != CodeDocMemberDetailLevel.Minimum;
var appendXmlDoc = detailLevel.HasFlag(CodeDocMemberDetailLevel.Summary) || detailLevel.HasFlag(CodeDocMemberDetailLevel.AdditionalContents);
var provideXmlDoc = includeExceptions || detailLevel != CodeDocMemberDetailLevel.Minimum;
var includeMembers = detailLevel.HasFlag(CodeDocMemberDetailLevel.Members);
var includeInheritance = detailLevel.HasFlag(CodeDocMemberDetailLevel.Inheritance);
var includeParameters = detailLevel != CodeDocMemberDetailLevel.Minimum;
var cRef = GetCRefIdentifier(type);
var model = type.IsDelegateType()
? new CodeDocDelegate(cRef)
: new CodeDocType(cRef);
model.Uri = GetUri(type);
var delegateModel = model as CodeDocDelegate;
var memberDataProvider = new CodeDocMemberInfoProvider<Type>(type);
XmlDocMember xmlDocs = null;
if (provideXmlDoc) {
xmlDocs = XmlDocs.GetMember(cRef.FullCRef);
if (xmlDocs != null)
memberDataProvider.Add(new CodeDocMemberXmlDataProvider(xmlDocs));
}
if (extraMemberDataProvider != null)
memberDataProvider.Add(extraMemberDataProvider);
if (includeInheritance && type.BaseType != null) {
if (ImplicitlyInheritDataProvider(type.BaseType) || (xmlDocs != null && xmlDocs.HasInheritDoc)) {
var baseModel = GetOrConvert(type.BaseType, detailLevel);
memberDataProvider.Add(new CodeDocMemberDataProvider(baseModel));
}
}
if (appendXmlDoc)
ApplyContentXmlDocs(model, memberDataProvider);
model.ExternalVisibility = memberDataProvider.ExternalVisibility ?? ExternalVisibilityKind.Public;
model.ShortName = RegularTypeDisplayNameOverlay.GetDisplayName(type);
model.FullName = FullTypeDisplayNameOverlay.GetDisplayName(type);
model.Title = model.ShortName;
model.NamespaceName = type.Namespace;
if (type.IsEnum)
model.SubTitle = "Enumeration";
else if (type.IsValueType)
model.SubTitle = "Structure";
else if (type.IsInterface)
model.SubTitle = "Interface";
else if (type.IsDelegateType())
model.SubTitle = "Delegate";
else
model.SubTitle = "Class";
model.Namespace = GetOrCreateNamespaceByName(type.Namespace);
model.Assembly = GetCodeDocAssembly(type.Assembly);
model.IsEnum = type.IsEnum;
model.IsFlagsEnum = type.IsEnum && type.HasAttribute(typeof(FlagsAttribute));
model.IsSealed = type.IsSealed;
model.IsValueType = type.IsValueType;
model.IsStatic = memberDataProvider.IsStatic.GetValueOrDefault();
model.IsObsolete = memberDataProvider.IsObsolete.GetValueOrDefault();
if (type.DeclaringType != null)
model.DeclaringType = GetOrConvert(type.DeclaringType, CodeDocMemberDetailLevel.Minimum);
if (delegateModel != null)
delegateModel.IsPure = memberDataProvider.IsPure.GetValueOrDefault();
if (includeInheritance && !type.IsInterface) {
var currentBase = type.BaseType;
if (null != currentBase) {
var baseChain = new List<CodeDocType>() {
GetOrConvert(currentBase, detailLevel)
};
currentBase = currentBase.BaseType;
while (currentBase != null) {
baseChain.Add(GetOrConvert(currentBase, CodeDocMemberDetailLevel.Minimum));
currentBase = currentBase.BaseType;
}
model.BaseChain = baseChain;
}
var implementedInterfaces = type.GetInterfaces();
if (implementedInterfaces.Length > 0) {
model.Interfaces = Array.ConvertAll(
implementedInterfaces,
t => GetOrConvert(t, CodeDocMemberDetailLevel.Minimum));
}
}
if (includeParameters && type.IsGenericType) {
var genericDefinition = type.IsGenericTypeDefinition
? type
: type.GetGenericTypeDefinition();
if (genericDefinition != null) {
var genericArguments = genericDefinition.GetGenericArguments();
if (type.IsNested && genericArguments.Length > 0) {
Contract.Assume(type.DeclaringType != null);
var parentGenericArguments = type.DeclaringType.GetGenericArguments();
genericArguments = genericArguments
.Where(a => parentGenericArguments.All(p => p.Name != a.Name))
.ToArray();
}
if (genericArguments.Length > 0) {
model.GenericParameters = CreateGenericTypeParameters(
genericArguments,
memberDataProvider);
}
}
}
if (delegateModel != null) {
if (includeParameters) {
delegateModel.Parameters = Array.ConvertAll(
type.GetDelegateTypeParameters(),
p => CreateArgument(p, memberDataProvider));
var returnParameter = type.GetDelegateReturnParameter();
if (returnParameter != null && returnParameter.ParameterType != typeof (void))
delegateModel.Return = CreateReturn(returnParameter, memberDataProvider);
}
if (includeExceptions) {
if (memberDataProvider.HasExceptions)
delegateModel.Exceptions = CreateExceptionModels(memberDataProvider.GetExceptions()).ToArray();
if (memberDataProvider.HasEnsures)
delegateModel.Ensures = memberDataProvider.GetEnsures().ToArray();
if (memberDataProvider.HasRequires)
delegateModel.Requires = memberDataProvider.GetRequires().ToArray();
}
}
if (includeMembers) {
var nestedTypeModels = new List<ICodeDocMember>();
var nestedDelegateModels = new List<ICodeDocMember>();
foreach (var nestedType in type.GetAllNestedTypes().Where(ReflectionRepository.MemberFilter)) {
var nestedTypeModel = GetOrConvert(nestedType, CodeDocMemberDetailLevel.QuickSummary);
if (nestedType.IsDelegateType())
nestedDelegateModels.Add(nestedTypeModel);
else
nestedTypeModels.Add(nestedTypeModel);
}
model.NestedTypes = nestedTypeModels;
model.NestedDelegates = nestedDelegateModels;
var methodModels = new List<ICodeDocMember>();
var operatorModels = new List<ICodeDocMember>();
foreach (var methodInfo in type.GetAllMethods().Where(ReflectionRepository.MemberFilter)) {
var methodModel = GetOrConvert(methodInfo, CodeDocMemberDetailLevel.QuickSummary);
if (methodInfo.IsOperatorOverload())
operatorModels.Add(methodModel);
else
methodModels.Add(methodModel);
}
model.Methods = methodModels;
model.Operators = operatorModels;
model.Constructors = type
.GetAllConstructors()
.Where(ReflectionRepository.MemberFilter)
.Select(methodInfo => GetOrConvert(methodInfo, CodeDocMemberDetailLevel.QuickSummary))
.ToArray();
model.Properties = type
.GetAllProperties()
.Where(ReflectionRepository.MemberFilter)
.Select(propertyInfo => GetOrConvert(propertyInfo, CodeDocMemberDetailLevel.QuickSummary))
.ToArray();
model.Fields = type
.GetAllFields()
.Where(ReflectionRepository.MemberFilter)
.Select(fieldInfo => GetOrConvert(fieldInfo, CodeDocMemberDetailLevel.QuickSummary))
.ToArray();
model.Events = type
.GetAllEvents()
.Where(ReflectionRepository.MemberFilter)
.Select(eventInfo => GetOrConvert(eventInfo, CodeDocMemberDetailLevel.QuickSummary))
.ToArray();
}
return model;
}
private CodeDocMethod GetOrConvert(MethodBase methodBase, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(methodBase != null);
Contract.Ensures(Contract.Result<CodeDocMethod>() != null);
var getResult = GetOnlyMethod(GetCRefIdentifier(methodBase), detailLevel);
return getResult ?? ConvertToModel(methodBase, detailLevel);
}
private CodeDocType GetOrConvert(Type type, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(type != null);
Contract.Ensures(Contract.Result<CodeDocType>() != null);
var getResult = GetOnlyType(GetCRefIdentifier(type), detailLevel);
return getResult ?? ConvertToModel(type, detailLevel);
}
/// <summary>
/// Constructs a new search context with the given repositories and detail level.
/// </summary>
/// <param name="repository">The repository that is to be searched.</param>
/// <param name="detailLevel">The desired detail level.</param>
public CodeDocRepositorySearchContext(ICodeDocMemberRepository repository, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full)
: this(new ReadOnlyCollection<ICodeDocMemberRepository>(new[] { repository }), detailLevel)
{
if(repository == null) throw new ArgumentNullException("repository");
Contract.EndContractBlock();
}
/// <summary>
/// Constructs a new search context with the given repositories and detail level.
/// </summary>
/// <param name="allRepositories">The repositories that are to be searched.</param>
/// <param name="detailLevel">The desired detail level.</param>
public CodeDocRepositorySearchContext(IEnumerable<ICodeDocMemberRepository> allRepositories, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full)
: this(new ReadOnlyCollection<ICodeDocMemberRepository>(allRepositories.ToArray()), detailLevel)
{
Contract.Requires(allRepositories != null);
}
/// <summary>
/// Clones this search context with only the given repository marked as visited and an overridden detail level.
/// </summary>
/// <param name="repository">The repository that is to be marked as visited.</param>
/// <param name="detailLevel">The desired detail level.</param>
/// <returns>A search context.</returns>
public CodeDocRepositorySearchContext CloneWithSingleVisit(ICodeDocMemberRepository repository, CodeDocMemberDetailLevel detailLevel)
{
if(repository == null) throw new ArgumentNullException("repository");
Contract.Ensures(Contract.Result<CodeDocRepositorySearchContext>() != null);
var result = CloneWithoutVisits(detailLevel);
result.Visit(repository);
return result;
}
/// <summary>
/// Clones this search context with no repositories visited and an overridden detail level.
/// </summary>
/// <param name="detailLevel">The desired detail level.</param>
/// <returns>A search context.</returns>
public CodeDocRepositorySearchContext CloneWithoutVisits(CodeDocMemberDetailLevel detailLevel)
{
Contract.Ensures(Contract.Result<CodeDocRepositorySearchContext>() != null);
return new CodeDocRepositorySearchContext(AllRepositories, detailLevel);
}
private CodeDocProperty ConvertToModel(PropertyInfo propertyInfo, CodeDocMemberDetailLevel detailLevel, ICodeDocMemberDataProvider extraMemberDataProvider = null)
{
Contract.Requires(propertyInfo != null);
Contract.Ensures(Contract.Result<CodeDocProperty>() != null);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocProperty>().ShortName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocProperty>().FullName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocProperty>().Title));
Contract.Ensures(Contract.Result<CodeDocProperty>().Title == Contract.Result<CodeDocProperty>().ShortName);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocProperty>().SubTitle));
var includeExceptions = detailLevel != CodeDocMemberDetailLevel.Minimum;
var appendXmlDoc = detailLevel.HasFlag(CodeDocMemberDetailLevel.Summary) || detailLevel.HasFlag(CodeDocMemberDetailLevel.AdditionalContents);
var provideXmlDoc = includeExceptions || detailLevel != CodeDocMemberDetailLevel.Minimum;
var includeInheritance = detailLevel.HasFlag(CodeDocMemberDetailLevel.Inheritance);
var includeParameters = detailLevel != CodeDocMemberDetailLevel.Minimum;
var propertyCRef = GetCRefIdentifier(propertyInfo);
var model = new CodeDocProperty(propertyCRef);
model.Uri = GetUri(propertyInfo);
var memberDataProvider = new CodeDocMemberInfoProvider<PropertyInfo>(propertyInfo);
XmlDocMember xmlDocs = null;
if (provideXmlDoc) {
xmlDocs = XmlDocs.GetMember(propertyCRef.FullCRef);
if (xmlDocs != null)
memberDataProvider.Add(new CodeDocMemberXmlDataProvider(xmlDocs));
}
if (extraMemberDataProvider != null)
memberDataProvider.Add(extraMemberDataProvider);
if (includeInheritance) {
var propertyBase = propertyInfo.FindNextAncestor();
if (propertyBase != null) {
var propertyBaseModel = GetOnly(GetCRefIdentifier(propertyBase), detailLevel);
if (propertyBaseModel != null)
memberDataProvider.Add(new CodeDocMemberDataProvider(propertyBaseModel));
}
}
if (appendXmlDoc) {
ApplyContentXmlDocs(model, memberDataProvider);
model.ValueDescriptionContents = memberDataProvider.GeValueDescriptionContents().ToArray();
}
model.ExternalVisibility = memberDataProvider.ExternalVisibility ?? ExternalVisibilityKind.Public;
model.ShortName = RegularTypeDisplayNameOverlay.GetDisplayName(propertyInfo);
model.FullName = FullTypeDisplayNameOverlay.GetDisplayName(propertyInfo);
model.Title = model.ShortName;
Contract.Assume(propertyInfo.DeclaringType != null);
model.NamespaceName = propertyInfo.DeclaringType.Namespace;
model.SubTitle = propertyInfo.IsItemIndexerProperty() ? "Indexer" : "Property";
model.IsStatic = memberDataProvider.IsStatic.GetValueOrDefault();
model.IsObsolete = memberDataProvider.IsObsolete.GetValueOrDefault();
model.ValueType = GetOrConvert(propertyInfo.PropertyType, CodeDocMemberDetailLevel.Minimum);
Contract.Assume(propertyInfo.DeclaringType != null);
model.Namespace = GetOrCreateNamespaceByName(propertyInfo.DeclaringType.Namespace);
model.Assembly = GetCodeDocAssembly(propertyInfo.DeclaringType.Assembly);
model.DeclaringType = GetOrConvert(propertyInfo.DeclaringType, CodeDocMemberDetailLevel.Minimum);
if (includeParameters) {
var parameters = propertyInfo.GetIndexParameters();
if (parameters.Length > 0)
model.Parameters = Array.ConvertAll(parameters, p => CreateArgument(p, memberDataProvider));
}
var getterMethodInfo = propertyInfo.GetGetMethod(true);
if (getterMethodInfo != null && ReflectionRepository.MemberFilter(getterMethodInfo, true)) {
var accessorExtraProvider = (xmlDocs != null && xmlDocs.HasGetterElement)
? new CodeDocMemberXmlDataProvider(xmlDocs.GetterElement)
: null;
model.Getter = ConvertToModel(getterMethodInfo, detailLevel, accessorExtraProvider);
}
var setterMethodInfo = propertyInfo.GetSetMethod(true);
if (setterMethodInfo != null && ReflectionRepository.MemberFilter(setterMethodInfo, true)) {
var accessorExtraProvider = (xmlDocs != null && xmlDocs.HasSetterElement)
? new CodeDocMemberXmlDataProvider(xmlDocs.SetterElement)
: null;
model.Setter = ConvertToModel(setterMethodInfo, detailLevel, accessorExtraProvider);
}
return model;
}
private CodeDocProperty GetOrConvert(PropertyInfo propertyInfo, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(propertyInfo != null);
Contract.Ensures(Contract.Result<CodeDocProperty>() != null);
var getResult = GetOnlyProperty(GetCRefIdentifier(propertyInfo), detailLevel);
return getResult ?? ConvertToModel(propertyInfo, detailLevel);
}
private CodeDocMethod ConvertToModel(MethodBase methodBase, CodeDocMemberDetailLevel detailLevel, ICodeDocMemberDataProvider extraMemberDataProvider = null)
{
Contract.Requires(methodBase != null);
Contract.Ensures(Contract.Result<CodeDocMethod>() != null);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocMethod>().ShortName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocMethod>().FullName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocMethod>().Title));
Contract.Ensures(Contract.Result<CodeDocMethod>().Title == Contract.Result<CodeDocMethod>().ShortName);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocMethod>().SubTitle));
var includeExceptions = detailLevel != CodeDocMemberDetailLevel.Minimum;
var appendXmlDoc = detailLevel.HasFlag(CodeDocMemberDetailLevel.Summary) || detailLevel.HasFlag(CodeDocMemberDetailLevel.AdditionalContents);
var provideXmlDoc = includeExceptions || detailLevel != CodeDocMemberDetailLevel.Minimum;
var includeInheritance = detailLevel.HasFlag(CodeDocMemberDetailLevel.Inheritance);
var includeParameters = detailLevel != CodeDocMemberDetailLevel.Minimum;
var methodInfo = methodBase as MethodInfo;
var methodCRef = GetCRefIdentifier(methodBase);
var model = new CodeDocMethod(methodCRef);
model.Uri = GetUri(methodBase);
var memberDataProvider = new CodeDocMemberInfoProvider<MethodBase>(methodBase);
if (provideXmlDoc) {
var xmlDocs = XmlDocs.GetMember(methodCRef.FullCRef);
if (xmlDocs != null)
memberDataProvider.Add(new CodeDocMemberXmlDataProvider(xmlDocs));
}
if (extraMemberDataProvider != null)
memberDataProvider.Add(extraMemberDataProvider);
if (includeInheritance && methodInfo != null) {
var baseDefinition = methodInfo.FindNextAncestor();
if (baseDefinition != null) {
var baseDefinitionModel = GetOnly(GetCRefIdentifier(baseDefinition), detailLevel);
if (baseDefinitionModel != null)
memberDataProvider.Add(new CodeDocMemberDataProvider(baseDefinitionModel));
}
}
if (appendXmlDoc)
ApplyContentXmlDocs(model, memberDataProvider);
model.ExternalVisibility = memberDataProvider.ExternalVisibility ?? ExternalVisibilityKind.Public;
model.ShortName = RegularTypeDisplayNameOverlay.GetDisplayName(methodBase);
model.FullName = FullTypeDisplayNameOverlay.GetDisplayName(methodBase);
model.Title = model.ShortName;
Contract.Assume(methodBase.DeclaringType != null);
model.NamespaceName = methodBase.DeclaringType.Namespace;
if (includeParameters) {
model.Parameters = Array.ConvertAll(
methodBase.GetParameters(),
p => CreateArgument(p, memberDataProvider));
if (methodInfo != null && methodInfo.ReturnParameter != null &&
methodInfo.ReturnType != typeof (void))
model.Return = CreateReturn(methodInfo.ReturnParameter, memberDataProvider);
}
if (methodBase.IsConstructor)
model.SubTitle = "Constructor";
else if (model.Parameters != null && model.Parameters.Count == 1 && model.HasReturn && CSharpOperatorNameSymbolMap.IsConversionOperatorMethodName(methodBase.Name)) {
model.SubTitle = "Conversion";
string conversionOperationName;
if (methodBase.Name.EndsWith("Explicit", StringComparison.OrdinalIgnoreCase))
conversionOperationName = "Explicit";
else if (methodBase.Name.EndsWith("Implicit", StringComparison.OrdinalIgnoreCase))
conversionOperationName = "Implicit";
else
conversionOperationName = String.Empty;
var conversionParameterPart = String.Concat(
model.Parameters[0].ParameterType.ShortName,
" to ",
model.Return.ParameterType.ShortName);
model.ShortName = String.IsNullOrEmpty(conversionOperationName)
? conversionParameterPart
: String.Concat(conversionOperationName, ' ', conversionParameterPart);
model.Title = model.ShortName;
}
else if (methodBase.IsOperatorOverload())
model.SubTitle = "Operator";
else
model.SubTitle = "Method";
Contract.Assume(methodBase.DeclaringType != null);
model.Namespace = GetOrCreateNamespaceByName(methodBase.DeclaringType.Namespace);
model.Assembly = GetCodeDocAssembly(methodBase.DeclaringType.Assembly);
model.DeclaringType = GetOrConvert(methodBase.DeclaringType, CodeDocMemberDetailLevel.Minimum);
model.IsOperatorOverload = methodBase.IsOperatorOverload();
model.IsExtensionMethod = methodBase.IsExtensionMethod();
model.IsSealed = methodBase.IsSealed();
model.IsStatic = memberDataProvider.IsStatic.GetValueOrDefault();
model.IsObsolete = memberDataProvider.IsObsolete.GetValueOrDefault();
model.IsPure = memberDataProvider.IsPure.GetValueOrDefault();
if (methodBase.DeclaringType != null && !methodBase.DeclaringType.IsInterface) {
if (methodBase.IsAbstract)
model.IsAbstract = true;
else if (methodBase.IsVirtual && !methodBase.IsFinal && methodBase.Attributes.HasFlag(MethodAttributes.NewSlot))
model.IsVirtual = true;
}
if (includeExceptions){
if (memberDataProvider.HasExceptions)
model.Exceptions = CreateExceptionModels(memberDataProvider.GetExceptions()).ToArray();
if (memberDataProvider.HasEnsures)
model.Ensures = memberDataProvider.GetEnsures().ToArray();
if (memberDataProvider.HasRequires)
model.Requires = memberDataProvider.GetRequires().ToArray();
}
if (includeParameters && methodBase.IsGenericMethod) {
var genericDefinition = methodBase.IsGenericMethodDefinition
? methodBase
: methodInfo == null ? null : methodInfo.GetGenericMethodDefinition();
if (genericDefinition != null) {
var genericArguments = genericDefinition.GetGenericArguments();
if (genericArguments.Length > 0) {
model.GenericParameters = CreateGenericTypeParameters(
genericArguments,
memberDataProvider);
}
}
}
return model;
}
private CodeDocField GetOrConvert(FieldInfo fieldInfo, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(fieldInfo != null);
Contract.Ensures(Contract.Result<CodeDocField>() != null);
var getResult = GetOnlyField(GetCRefIdentifier(fieldInfo), detailLevel);
return getResult ?? ConvertToModel(fieldInfo, detailLevel);
}
/// <summary> /// Creates a member model for the given code reference. /// </summary> /// <param name="cRef">The code reference to generate a model for.</param> /// <param name="detailLevel">Indicates the desired detail level of the generated model.</param> /// <returns>The generated member if possible.</returns> public abstract ICodeDocMember GetMemberModel(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel);
private CodeDocEvent GetOrConvert(EventInfo eventInfo, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(eventInfo != null);
Contract.Ensures(Contract.Result<CodeDocEvent>() != null);
var getResult = GetOnlyEvent(GetCRefIdentifier(eventInfo), detailLevel);
return getResult ?? ConvertToModel(eventInfo, detailLevel);
}
protected CodeDocEvent GetOnlyEvent(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToEventModel(GetOnly(cRef, detailLevel));
}
/// <summary>
/// Gets a code doc model for a reflected member.
/// </summary>
/// <param name="cRef">The code reference of a reflected member to create a model from.</param>
/// <param name="detailLevel">Indicates the desired detail level of the model.</param>
/// <returns>A code doc model.</returns>
public override ICodeDocMember GetMemberModel(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
if (cRef == null) throw new ArgumentNullException("cRef");
Contract.EndContractBlock();
if ("N".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
return ToFullNamespace(GetCodeDocSimpleNamespace(cRef));
if ("A".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
return GetCodeDocSimpleAssembly(cRef);
var memberInfo = ReflectionRepository.CRefLookup.GetMember(cRef);
if (memberInfo == null || !ReflectionRepository.MemberFilter(memberInfo))
return null;
return ConvertToModel(memberInfo, detailLevel);
}
protected CodeDocProperty GetOnlyProperty(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToPropertyModel(GetOnly(cRef, detailLevel));
}
/// <summary>
/// Converts a reflected member to a code doc model.
/// </summary>
/// <param name="memberInfo">A reflected member.</param>
/// <param name="detailLevel">Indicates the desired detail level of the model.</param>
/// <param name="extraMemberDataProvider">A member data provider to include additional information that may be be easily obtained from normal sources.</param>
/// <returns>A code doc model for the given member.</returns>
protected virtual CodeDocMemberContentBase ConvertToModel(MemberInfo memberInfo, CodeDocMemberDetailLevel detailLevel, ICodeDocMemberDataProvider extraMemberDataProvider = null)
{
if (memberInfo == null) throw new ArgumentNullException("memberInfo");
Contract.Ensures(Contract.Result<ICodeDocMember>() != null);
if (memberInfo is Type)
return ConvertToModel((Type)memberInfo, detailLevel, extraMemberDataProvider);
if (memberInfo is FieldInfo)
return ConvertToModel((FieldInfo)memberInfo, detailLevel, extraMemberDataProvider);
if (memberInfo is MethodBase)
return ConvertToModel((MethodBase)memberInfo, detailLevel, extraMemberDataProvider);
if (memberInfo is EventInfo)
return ConvertToModel((EventInfo)memberInfo, detailLevel, extraMemberDataProvider);
if (memberInfo is PropertyInfo)
return ConvertToModel((PropertyInfo)memberInfo, detailLevel, extraMemberDataProvider);
throw new NotSupportedException();
}
/// <summary>
/// Gets a model for the given code reference or creates a new one.
/// </summary>
/// <param name="cRef">The code reference to get a model for.</param>
/// <param name="detailLevel">Indicates the desired detail level of the generated model.</param>
/// <returns>A code doc model for the given code reference.</returns>
protected ICodeDocMember GetOrConvert(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
Contract.Ensures(Contract.Result<ICodeDocMember>() != null);
return GetOnly(cRef, detailLevel)
?? CreateGeneralMemberPlaceholder(cRef);
}
private CodeDocEvent ConvertToModel(EventInfo eventInfo, CodeDocMemberDetailLevel detailLevel, ICodeDocMemberDataProvider extraMemberDataProvider = null)
{
Contract.Requires(eventInfo != null);
Contract.Ensures(Contract.Result<CodeDocEvent>() != null);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocEvent>().ShortName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocEvent>().FullName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocEvent>().Title));
Contract.Ensures(Contract.Result<CodeDocEvent>().Title == Contract.Result<CodeDocEvent>().ShortName);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocEvent>().SubTitle));
var includeInheritance = detailLevel.HasFlag(CodeDocMemberDetailLevel.Inheritance);
var appendXmlDoc = detailLevel.HasFlag(CodeDocMemberDetailLevel.Summary) || detailLevel.HasFlag(CodeDocMemberDetailLevel.AdditionalContents);
var provideXmlDoc = detailLevel != CodeDocMemberDetailLevel.Minimum;
var eventCRef = GetCRefIdentifier(eventInfo);
var model = new CodeDocEvent(eventCRef);
model.Uri = GetUri(eventInfo);
var memberDataProvider = new CodeDocMemberInfoProvider<EventInfo>(eventInfo);
if (provideXmlDoc) {
var xmlDocs = XmlDocs.GetMember(eventCRef.FullCRef);
if (xmlDocs != null)
memberDataProvider.Add(new CodeDocMemberXmlDataProvider(xmlDocs));
}
if (extraMemberDataProvider != null)
memberDataProvider.Add(extraMemberDataProvider);
if (includeInheritance) {
var baseEvent = eventInfo.FindNextAncestor();
if (baseEvent != null) {
var baseEventModel = GetOnly(GetCRefIdentifier(baseEvent), detailLevel);
if (baseEventModel != null)
memberDataProvider.Add(new CodeDocMemberDataProvider(baseEventModel));
}
}
if (appendXmlDoc)
ApplyContentXmlDocs(model, memberDataProvider);
model.ExternalVisibility = memberDataProvider.ExternalVisibility ?? ExternalVisibilityKind.Public;
model.ShortName = RegularTypeDisplayNameOverlay.GetDisplayName(memberDataProvider.Member);
model.FullName = FullTypeDisplayNameOverlay.GetDisplayName(memberDataProvider.Member);
model.Title = model.ShortName;
Contract.Assume(memberDataProvider.Member.DeclaringType != null);
model.NamespaceName = memberDataProvider.Member.DeclaringType.Namespace;
model.SubTitle = "Event";
model.DelegateType = GetOrConvert(eventInfo.EventHandlerType, CodeDocMemberDetailLevel.Minimum);
Contract.Assume(eventInfo.DeclaringType != null);
model.Namespace = GetOrCreateNamespaceByName(eventInfo.DeclaringType.Namespace);
model.Assembly = GetCodeDocAssembly(eventInfo.DeclaringType.Assembly);
model.DeclaringType = GetOrConvert(eventInfo.DeclaringType, CodeDocMemberDetailLevel.Minimum);
model.IsStatic = memberDataProvider.IsStatic.GetValueOrDefault();
model.IsObsolete = memberDataProvider.IsObsolete.GetValueOrDefault();
return model;
}
/// <inheritdoc/>
public ICodeDocMember GetMemberModel(string cRef, CodeDocRepositorySearchContext searchContext = null, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full)
{
if (String.IsNullOrEmpty(cRef)) throw new ArgumentException("Code reference is not valid.", "cRef");
Contract.EndContractBlock();
return GetMemberModel(new CRefIdentifier(cRef), searchContext, detailLevel);
}
private CodeDocField ConvertToModel(FieldInfo fieldInfo, CodeDocMemberDetailLevel detailLevel, ICodeDocMemberDataProvider extraMemberDataProvider = null)
{
Contract.Requires(fieldInfo != null);
Contract.Ensures(Contract.Result<CodeDocField>() != null);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocField>().ShortName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocField>().FullName));
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocField>().Title));
Contract.Ensures(Contract.Result<CodeDocField>().Title == Contract.Result<CodeDocField>().ShortName);
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<CodeDocField>().SubTitle));
var appendXmlDoc = detailLevel.HasFlag(CodeDocMemberDetailLevel.Summary) || detailLevel.HasFlag(CodeDocMemberDetailLevel.AdditionalContents);
var provideXmlDoc = detailLevel != CodeDocMemberDetailLevel.Minimum;
var fieldCRef = GetCRefIdentifier(fieldInfo);
var model = new CodeDocField(fieldCRef);
model.Uri = GetUri(fieldInfo);
var memberDataProvider = new CodeDocMemberInfoProvider<FieldInfo>(fieldInfo);
if (provideXmlDoc) {
var xmlDocs = XmlDocs.GetMember(fieldCRef.FullCRef);
if (xmlDocs != null)
memberDataProvider.Add(new CodeDocMemberXmlDataProvider(xmlDocs));
}
if (extraMemberDataProvider != null)
memberDataProvider.Add(extraMemberDataProvider);
if (appendXmlDoc) {
model.ValueDescriptionContents = memberDataProvider.GeValueDescriptionContents().ToArray();
ApplyContentXmlDocs(model, memberDataProvider);
}
model.ExternalVisibility = memberDataProvider.ExternalVisibility ?? ExternalVisibilityKind.Public;
model.ShortName = RegularTypeDisplayNameOverlay.GetDisplayName(fieldInfo);
model.FullName = FullTypeDisplayNameOverlay.GetDisplayName(fieldInfo);
model.Title = model.ShortName;
Contract.Assume(fieldInfo.DeclaringType != null);
model.NamespaceName = fieldInfo.DeclaringType.Namespace;
model.SubTitle = fieldInfo.IsLiteral ? "Constant" : "Field";
model.ValueType = GetOrConvert(fieldInfo.FieldType, CodeDocMemberDetailLevel.Minimum);
model.IsLiteral = fieldInfo.IsLiteral;
model.IsInitOnly = fieldInfo.IsInitOnly;
model.IsStatic = memberDataProvider.IsStatic.GetValueOrDefault();
model.IsObsolete = memberDataProvider.IsObsolete.GetValueOrDefault();
Contract.Assume(fieldInfo.DeclaringType != null);
model.Namespace = GetOrCreateNamespaceByName(fieldInfo.DeclaringType.Namespace);
model.Assembly = GetCodeDocAssembly(fieldInfo.DeclaringType.Assembly);
model.DeclaringType = GetOrConvert(fieldInfo.DeclaringType, CodeDocMemberDetailLevel.Minimum);
return model;
}
/// <inheritdoc/> public abstract ICodeDocMember GetMemberModel(CRef.CRefIdentifier cRef, CodeDocRepositorySearchContext searchContext = null, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full);
/// <summary>
/// Generates a model that is extracted from MTPS data.
/// </summary>
/// <param name="cRef">The code reference to search for.</param>
/// <param name="searchContext">The search context for locating related items.</param>
/// <param name="detailLevel">The desired detail level of the generated model.</param>
/// <returns>A code doc member model if found.</returns>
public ICodeDocMember GetMemberModel(CRefIdentifier cRef, CodeDocRepositorySearchContext searchContext = null, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full)
{
if(cRef == null) throw new ArgumentNullException("cRef");
Contract.EndContractBlock();
var stopwatch = new Stopwatch();
stopwatch.Start();
var tocResults = SearchToc(cRef.FullCRef);
var bestTocResult = tocResults.FirstOrDefault();
stopwatch.Stop();
Debug.WriteLine("Search for {0} returned in {1}", cRef, stopwatch.Elapsed);
if (bestTocResult == null)
return null;
Uri uri;
if (!Uri.TryCreate(GetUrl(bestTocResult), UriKind.Absolute, out uri))
uri = cRef.ToUri();
CodeDocSimpleMember model = null;
if (detailLevel != CodeDocMemberDetailLevel.Minimum) {
var contentXml = GetContent(bestTocResult.ContentId);
if (contentXml != null) {
bool? isSealed = null;
bool? isValueType = null;
bool? isReferenceType = null;
bool? isEnum = null;
bool? isVirtual = null;
bool? isAbstract = null;
bool? isMethod = null;
ExternalVisibilityKind? visibility = null;
var titleDiv = contentXml.GetElementsByTagName("div")
.OfType<XmlElement>()
.FirstOrDefault(x => "TITLE".Equals(x.GetAttribute("class"), StringComparison.OrdinalIgnoreCase));
if (titleDiv != null) {
var innerTitleText = titleDiv.InnerText.Trim();
if (innerTitleText.EndsWith("Method", StringComparison.OrdinalIgnoreCase)) {
isMethod = true;
}
}
var syntaxElement = contentXml.GetElementsByTagName("mtps:CollapsibleArea")
.OfType<XmlElement>()
.FirstOrDefault(x => "SYNTAX".Equals(x.GetAttribute("Title"), StringComparison.OrdinalIgnoreCase));
var codeSnippets = syntaxElement.GetElementsByTagName("mtps:CodeSnippet").OfType<XmlElement>().ToList();
foreach (var snippet in codeSnippets) {
var inputSpans = snippet.GetElementsByTagName("span")
.OfType<XmlElement>()
.Where(e => e.GetAttribute("class") == "input")
.ToList();
if (snippet.GetAttribute("Language") == "CSharp") {
foreach (var inputSpan in inputSpans) {
var innerText = inputSpan.InnerText;
if ("PUBLIC".Equals(innerText, StringComparison.OrdinalIgnoreCase))
visibility = ExternalVisibilityKind.Public;
else if ("PROTECTED".Equals(innerText, StringComparison.OrdinalIgnoreCase))
visibility = ExternalVisibilityKind.Protected;
else if ("SEALED".Equals(innerText, StringComparison.OrdinalIgnoreCase))
isSealed = true;
else if ("CLASS".Equals(innerText, StringComparison.OrdinalIgnoreCase))
isReferenceType = true;
else if ("STRUCT".Equals(innerText, StringComparison.OrdinalIgnoreCase))
isValueType = true;
else if ("ENUM".Equals(innerText, StringComparison.OrdinalIgnoreCase))
isEnum = true;
else if ("VIRTUAL".Equals(innerText, StringComparison.OrdinalIgnoreCase))
isVirtual = true;
else if ("ABSTRACT".Equals(innerText, StringComparison.OrdinalIgnoreCase))
isAbstract = true;
}
}
}
if (model == null) {
if (isReferenceType ?? isValueType ?? isEnum ?? false) {
var typeModel = new CodeDocType(cRef);
typeModel.IsSealed = isSealed;
typeModel.IsValueType = isValueType;
typeModel.IsEnum = isEnum;
model = typeModel;
}
else if (isMethod ?? false) {
var methodModel = new CodeDocMethod(cRef);
methodModel.IsSealed = isSealed;
methodModel.IsVirtual = isVirtual;
methodModel.IsAbstract = isAbstract;
model = methodModel;
}
else {
model = new CodeDocSimpleMember(cRef);
}
model.ExternalVisibility = visibility ?? ExternalVisibilityKind.Hidden;
}
XmlNode summaryElement = contentXml.GetElementsByTagName("div")
.OfType<XmlElement>()
.FirstOrDefault(x => String.Equals(x.GetAttribute("class"), "summary", StringComparison.OrdinalIgnoreCase));
if (summaryElement != null) {
if (summaryElement.ChildNodes.Count == 1 && summaryElement.ChildNodes[0].Name == "p") {
// unwrap the lone p tag.
summaryElement = summaryElement.ChildNodes[0];
}
var summaryXmlDoc = XmlDocParser.Default.Parse(summaryElement);
model.SummaryContents = summaryXmlDoc.Children;
}
}
}
if (model == null)
model = new CodeDocSimpleMember(cRef);
if(model.ExternalVisibility == ExternalVisibilityKind.Hidden)
model.ExternalVisibility = ExternalVisibilityKind.Public;
model.Uri = uri;
model.FullName = bestTocResult.GetFullName();
int lastTitleSpaceIndex = bestTocResult.Title.LastIndexOf(' ');
if (lastTitleSpaceIndex >= 0) {
model.Title = bestTocResult.Title.Substring(0, lastTitleSpaceIndex);
model.SubTitle = bestTocResult.Title.Substring(lastTitleSpaceIndex + 1);
}
else {
model.Title = bestTocResult.Title;
model.SubTitle = String.Empty;
}
model.ShortName = model.Title;
if (String.IsNullOrEmpty(model.NamespaceName)) {
MtpsNodeCore namespaceNode = bestTocResult;
while (namespaceNode != null && !namespaceNode.IsNamespace) {
namespaceNode = namespaceNode.Parent;
}
if (namespaceNode != null) {
model.NamespaceName = namespaceNode.GetNamespaceName();
model.Namespace = GetNamespaceByName(model.NamespaceName);
}
}
return model;
}
