internal TypeDefinitionSyntax(FileScope pScope, TypeSyntax pType, TypeSyntax pImplements, DefinitionTypes pDefinitionType, List <TypedIdentifierSyntax> pFields, List <MethodSyntax> pMethods) { System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(pType.Value), "Define name cannot be empty"); System.Diagnostics.Debug.Assert(pDefinitionType != DefinitionTypes.Unknown); Scope = pScope; DeclaredType = pType; DefinitionType = pDefinitionType; AppliesTo = pImplements; Fields = pFields; Methods = pMethods; var tp = new List <string>(); foreach (var pa in DeclaredType.GenericArguments) { tp.Add(pa.Value); } TypeParameters = tp; _typeMappings = new List <Dictionary <string, SmallType> >(); }
public static TypeDefinitionSyntax TypeDefinition(FileScope pScope, TypeSyntax pType, TypeSyntax pImplements, DefinitionTypes pDefinitionType, List <MethodSyntax> pMethods, List <TypedIdentifierSyntax> pFields) { return(new TypeDefinitionSyntax(pScope, pType, pImplements, pDefinitionType, pFields, pMethods)); }
/// <summary> /// Defines a length in a UIContainer /// </summary> /// <param name="definitionType"> /// Fixed: A length you can specify here as an integer. /// Auto: Takes up only the space of its largest item. /// Fill: Takes up all remaining space in the container, divided evenly between the other Fill definitions of this dimension.</param> public Definition(DefinitionTypes definitionType) { this.DefinitionType = definitionType; }
public void CreateDefinitionCoverageReport() { var result = new StringBuilder(); foreach (var definitionType in DefinitionTypes.OrderBy(d => d.Name)) { var allProps = definitionType.GetProperties().OrderBy(p => p.Name); var validatedProps = allProps.Where(p => p.GetCustomAttributes(typeof(ExpectValidationAttribute)).Any()); var updatableProps = allProps.Where(p => p.GetCustomAttributes(true).Any(a => (a as ExpectUpdate) != null)); Trace.WriteLine(definitionType.Name); result.Append("<table class='table table-bordered table-striped'>"); result.Append("<thead>"); result.Append("<tr>"); result.AppendFormat("<th style='width: 150px;'>{0}</th>", definitionType.Name); result.Append("<th>Property</th>"); result.Append("<th>Validated</th>"); result.Append("<th>Updated</th>"); result.Append("</tr>"); result.Append("</thead>"); result.Append("<tr>"); bool isFirst = true; foreach (var prop in allProps) { if (!isFirst) { result.Append("<tr>"); } var isValidated = validatedProps.Any(p => p.Name == prop.Name); var isUpdated = updatableProps.Any(p => p.Name == prop.Name); result.AppendFormat("<td></td>"); result.AppendFormat("<td>{0}</td>", prop.Name); result.AppendFormat("<td>{0}</td>", isValidated); result.AppendFormat("<td>{0}</td>", isUpdated); Trace.WriteLine(string.Format("{0}{1} - validated:{2} updated:{3}", '\t', prop.Name, isValidated, isUpdated)); isFirst = false; if (!isFirst) { result.Append("</tr>"); } } result.Append("</table>"); result.Append("<br/>"); result.Append("<br/>"); } var reportHtml = result.ToString(); Trace.WriteLine(reportHtml); }
protected Definition(DefinitionTypes definitionType) { DefinitionType = definitionType; Properties = new Dictionary <string, string>(); }
/// <summary> /// Ensures the execution type system has a type entry for the specified type reference, type, or structural input type node. /// </summary> /// <param name="context"></param> public ExecutionTypeNode_I Ensure(ExecutionEnsureContext context) { //if (inputType.InputStructuralNode.CecilTypeReference.Name != "<Module>") //{ // Execution.Types.Ensuring.Ensure(conversion.RuntimicSystem, inputType); //} if (context?.TypeReference?.FullName == "<PrivateImplementationDetails>" ) { } // Step 1 - Get Strcutral input type node if (context.StructuralInputTypeNode == null) { if (context.TypeReference != null) { context.StructuralInputTypeNode = Infrastructure.Structural.Types.Ensure(context.RuntimicSystem, context.TypeReference, null, context.MethodReference); } else if (context.UnderlyingType != null) { context.StructuralInputTypeNode = Infrastructure.Structural.Types.Ensure(context.RuntimicSystem, context.UnderlyingType); } else { throw new Exception("A bound or converted type entry cannot be ensured without either a 'metadata type definition/reference' " + "or a 'runtime type' (System.Type)."); } } if (context.TypeReference == null) { context.TypeReference = context.StructuralInputTypeNode.CecilTypeReference; } var metadataToken = context.StructuralInputTypeNode.MetadataToken; context.RowId = metadataToken & 0x00FFFFFF; // Step 3 - Build out the execution node if (context.StructuralInputTypeNode.IsByReferenceType) { return(ByReferences.Ensure(context)); } // Depends upon the underlying unified entry if (context.StructuralInputTypeNode.IsPointerType) { return(Pointers.Ensure(context)); } // Depends upon the underlying unified entry if (context.StructuralInputTypeNode.IsArrayType) { return(Arrays.Ensure(context)); } // Depends upon the underlying unified entry if (context.StructuralInputTypeNode.IsGenericParameter) { // You cannot create a generic parameter directly. It is created when its parent type creates it. return(GenericParameters.Ensure(context)); } context.IsConverted = IsConverted(context); if (context.StructuralInputTypeNode.IsGenericInstance) { // You cannot create a generic parameter directly. It is created when its parent type creates it. return(GenericInstanceTypes.Ensure(context)); } return(DefinitionTypes.Ensure(context)); }