ParametersViewModel GetParameters(Member member)
{
var parameters = member.GetParametersOrNull();
if (parameters == null)
{
return(null);
}
var invisibleParams = parameters.Where(e => e.Type.IsArray
? !Exportable.IsExportableAndVisible(e.Type.ElementType)
: !Exportable.IsExportableAndVisible(e.Type))
.ToList();
if (invisibleParams.Count > 0)
{
var names = new List <string>();
foreach (var p in invisibleParams)
{
var paramType = p.Type.IsArray ? p.Type.ElementType : p.Type;
names.Add($"{p.Name} ({paramType.FullName})");
}
throw new Exception($"Found {invisibleParams.Count} parameters for member {member.FullName} that have non-exportable types: {string.Join(", ", names)}");
}
var list = parameters.Select(param => GetParameterViewModelForParameter(param)).ToList();
return(new ParametersViewModel(list));
}
void AddAttachedMemberToTarget(string name, MemberType memberType, Method underlyingMethod, DataType returnType, DataType parentDataType, HashSet <DocumentViewModel> target)
{
var uxAttribute = underlyingMethod.Attributes.SingleOrDefault(e => e.ReturnType.QualifiedName == ExportConstants.UxAttachedPropertySetterAttributeName ||
e.ReturnType.QualifiedName == ExportConstants.UxAttachedEventAdderAttributeName);
if (uxAttribute == null)
{
throw new ArgumentException($"UX attached attribute not found on {underlyingMethod.UnoName}");
}
var uxAttributeName = uxAttribute.Arguments.Length == 0 ? null : uxAttribute.Arguments[0].ConstantString;
if (string.IsNullOrWhiteSpace(uxAttributeName))
{
throw new ArgumentException($"UX attached attribute did not contain any on {underlyingMethod.UnoName}");
}
uxAttributeName = uxAttributeName.ToLowerInvariant()
.Replace(".", "_");
var id = parentDataType.GetUri() + "/" + uxAttributeName + "_" + underlyingMethod.GetUriSignature();
var titles = new TitlesViewModel(Naming.GetPageTitle(underlyingMethod),
uxAttribute.Arguments[0].ConstantString,
uxAttribute.Arguments[0].ConstantString,
Naming.GetNavigationTitle(underlyingMethod),
Naming.GetFullIndexTitle(underlyingMethod));
var declaredIn = new DataTypeBuilder(Naming, Syntax, Exportable, AttachedMembers, _commentParser).BuildReference(underlyingMethod.DeclaringType);
var parameters = GetParameters(underlyingMethod);
var returns = GetReturns(underlyingMethod, returnType);
var values = BuildValues(returnType);
var source = new AttachedMemberSourceViewModel(underlyingMethod.DeclaringType.GetUri(), Naming.GetIndexTitle(underlyingMethod.DeclaringType));
var comment = _commentParser.Read(underlyingMethod);
if (!Exportable.IsExportableAndVisible(underlyingMethod.DeclaringType))
{
throw new Exception($"Found attached UX member {underlyingMethod.FullName} declared inside non-exportable class {underlyingMethod.DeclaringType.FullName}");
}
var viewModel = new AttachedMemberViewModel(new DocumentIdViewModel(id, parentDataType.GetUri(), "AttachedUx" + memberType.ToString("G"), new List <string>()),
new DocumentUriViewModel(id, underlyingMethod.GetUri(), true),
titles,
declaredIn,
parameters,
returns,
values,
source,
new CommentViewModel(comment),
underlyingMethod);
target.AddIfNotExists(viewModel);
}
ReturnsViewModel GetReturns(Member member, DataType returnDataType)
{
var dataType = returnDataType.IsArray ? returnDataType.ElementType : returnDataType;
var suffix = returnDataType.IsArray ? "[]" : "";
if (!Exportable.IsExportableAndVisible(dataType))
{
throw new Exception($"Found return type for member {member.FullName} that have non-exportable return type: {dataType.FullName}");
}
return(new ReturnsViewModel(GetDataTypeUri(dataType),
dataType.IsVirtualType(),
Naming.GetIndexTitle(dataType) + suffix,
Naming.GetFullIndexTitle(dataType) + suffix));
}
private AttributesViewModel BuildAttributes(DataType dataType)
{
var models = new List <AttributeViewModel>();
foreach (var attr in dataType.Attributes ?? new NewObject[0])
{
if (!Exportable.IsExportableAndVisible(attr.ReturnType))
{
continue;
}
var parameters = attr.Arguments.Select(e => e.ConstantString).ToList();
var reference = BuildReference(attr.ReturnType);
models.Add(new AttributeViewModel(reference.Id, reference.Uri, reference.Titles, parameters));
}
return(new AttributesViewModel(models));
}
AttributesViewModel BuildAttributes(Member member)
{
var models = new List <AttributeViewModel>();
foreach (var attr in member.Attributes ?? new NewObject[0])
{
if (!Exportable.IsExportableAndVisible(attr.ReturnType))
{
continue;
}
var parameters = attr.Arguments.Select(e => e.ConstantString).ToList();
var reference = new DataTypeBuilder(Naming, Syntax, Exportable, AttachedMembers, _commentParser).BuildReference(attr.ReturnType);
models.Add(new AttributeViewModel(reference.Id, reference.Uri, reference.Titles, parameters));
}
return(new AttributesViewModel(models));
}
private ReturnsViewModel BuildReturns(DataType dataType)
{
var delegateType = dataType as DelegateType;
if (delegateType == null || delegateType.ReturnType.FullName == ExportConstants.VoidTypeName)
{
return(null);
}
if (!Exportable.IsExportableAndVisible(delegateType.ReturnType))
{
throw new Exception($"Found return type for delegate {delegateType.FullName} that have non-exportable return type: {delegateType.ReturnType.FullName}");
}
return(new ReturnsViewModel(delegateType.GetUri(),
delegateType.IsVirtualType(),
Naming.GetIndexTitle(delegateType.ReturnType),
Naming.GetFullIndexTitle(delegateType.ReturnType)));
}
private void ExportMembers(IEnumerable <Member> members, DataType dataType, HashSet <DocumentViewModel> target, HashSet <string> seenMembers)
{
var invisibleMembers = members.Where(e => Exportable.IsExportableAndVisible(e) && !Exportable.IsExportableAndVisible(e.DeclaringType)).ToList();
if (invisibleMembers.Count > 0)
{
throw new Exception($"Found members inside {dataType.FullName} declared on non-exportable parent type: {string.Join(", ", invisibleMembers.Select(e => e.FullName))}");
}
var exportableMembers = members.Where(e => Exportable.IsExportableAndVisible(e) && Exportable.IsExportableAndVisible(e.DeclaringType)).ToList();
exportableMembers.ForEach(member =>
{
var id = dataType.GetUri() + "/" + member.GetUriSignature();
if (!seenMembers.Contains(id))
{
GetMemberBuilder().Build(member, dataType, target);
seenMembers.Add(id);
}
});
}
private ImplementedInterfacesViewModel BuildImplementedInterfaces(DataType dataType)
{
var result = new List <ImplementedInterfaceViewModel>();
foreach (var iface in GetAllInterfaces(dataType))
{
if (!Exportable.IsExportableAndVisible(iface))
{
continue;
}
var comment = _commentParser.Read(iface);
var id = BuildDataTypeId(iface, comment);
var uri = BuildDataTypeUri(iface);
var titles = BuildDataTypeIndexTitles(iface);
var viewModel = new ImplementedInterfaceViewModel(id, uri, titles, new BasicCommentViewModel(comment));
result.Add(viewModel);
}
return(new ImplementedInterfacesViewModel(result));
}
private ParametersViewModel GetParameters(DataType dataType)
{
var parameters = dataType.GetParametersOrNull();
if (parameters == null)
{
return(null);
}
var invisibleParams = parameters.Where(e => e.Type.IsArray
? !Exportable.IsExportableAndVisible(e.Type.ElementType)
: !Exportable.IsExportableAndVisible(e.Type))
.ToList();
if (invisibleParams.Count > 0)
{
var names = new List <string>();
foreach (var p in invisibleParams)
{
var paramType = p.Type.IsArray ? p.Type.ElementType : p.Type;
names.Add($"{p.Name} ({paramType.FullName})");
}
throw new Exception($"Found {invisibleParams.Count} parameters for type {dataType.FullName} that have non-exportable types: {string.Join(", ", names)}");
}
var list = parameters.Select(param => param.Type.IsArray
? new ParameterViewModel(param.Name,
param.Type.ElementType.GetUri(),
param.Type.ElementType.IsVirtualType(),
Naming.GetIndexTitle(param.Type.ElementType),
Naming.GetFullIndexTitle(param.Type.ElementType))
: new ParameterViewModel(param.Name,
param.Type.GetUri(),
param.Type.IsVirtualType(),
Naming.GetIndexTitle(param.Type),
Naming.GetFullIndexTitle(param.Type)))
.ToList();
return(new ParametersViewModel(list));
}
