Beispiel #1
0
        /// <summary>
        /// Checks a type definition to see if it inherits a target interface.
        /// </summary>
        /// <param name="source">Type to check for inheritance </param>
        /// <param name="interfaceName">The name of the interface</param>
        /// <param name="interfaceNamespace">Optional parameter that contains the target namespace for the interface.</param>
        /// <returns>True if inherited or false if not.</returns>
        public static bool InheritsInterface(this CsType source, string interfaceName,
                                             string interfaceNamespace = null)
        {
            if (source == null)
            {
                return(false);
            }
            if (!source.IsLoaded)
            {
                return(false);
            }
            if (!source.IsClass & !source.IsStructure)
            {
                return(false);
            }

            CsContainer containerData = source.IsClass ? source.GetClassModel() as CsContainer
                : source.GetStructureModel() as CsContainer;

            if (containerData == null)
            {
                return(false);
            }
            if (!containerData.IsLoaded)
            {
                return(false);
            }
            if (!containerData.InheritedInterfaces.Any())
            {
                return(false);
            }

            var interfaceData = interfaceNamespace == null
                ? containerData.InheritedInterfaces.FirstOrDefault(i => interfaceName == i.Name)
                : containerData.InheritedInterfaces.FirstOrDefault(i =>
                                                                   (interfaceNamespace == i.Namespace & interfaceName == i.Name));

            return(interfaceData != null);
        }
Beispiel #2
0
        /// <summary>
        /// Flag that determines if the type has a base class that is inherited by the type.
        /// </summary>
        /// <param name="source">The target type to check for base class implementation.</param>
        /// <param name="baseClassName">The name of the base class that is inherited.</param>
        /// <param name="baseClassNamespace">Optional parameter for the namespace of the base class.</param>
        /// <returns>True if inherited or false if not found.</returns>
        public static bool InheritsBaseClass(this CsType source, string baseClassName, string baseClassNamespace = null)
        {
            if (source == null)
            {
                return(false);
            }
            if (!source.IsLoaded)
            {
                return(false);
            }
            if (!source.IsClass)
            {
                return(false);
            }
            var classData = source.GetClassModel();

            if (classData == null)
            {
                return(false);
            }

            return(classData.InheritsBaseClass(baseClassName, baseClassNamespace));
        }
        /// <summary>
        /// Extension method that creates the array portion definition of a type definition in C# syntax.
        /// </summary>
        /// <param name="source">The source type to get the array information to format.</param>
        /// <returns>The formatted array syntax for the target type, or null if no array data was provided in the type definition.</returns>
        public static string FormatCSharpArraySignatureSyntax(this CsType source)
        {
            var dotNetType = source as IDotNetType;

            return(dotNetType.FormatCSharpArraySignatureSyntax());
        }
        /// <summary>
        /// Extension method that generates the fully qualified type name from the <see cref="ICsType"/> model in the C# format.
        /// </summary>
        /// <param name="source">The source type to get the full type name from.</param>
        /// <returns>The fully qualified namespace and full type definition. Null if the type is missing or not loaded. </returns>
        public static string FormatCSharpFullTypeName(this CsType source)
        {
            var dotNetType = source as IDotNetType;

            return(dotNetType.FormatCSharpFullTypeName());
        }
        /// <summary>
        /// Extension method that returns a value declaration in the c# language format.
        /// </summary>
        /// <param name="source">The target type to create the value definition for.</param>
        /// <param name="value">The value to be formatted.</param>
        /// <returns>The definition of the value formatted for C#</returns>
        public static string FormatCSharpValueSyntax(this CsType source, string value)
        {
            var dotNetType = source as IDotNetType;

            return(dotNetType.FormatCSharpValueSyntax(value));
        }
        /// <summary>
        /// Extension method that generates the default value syntax for a parameter in the C# language.
        /// </summary>
        /// <param name="source">The target default value to format.</param>
        /// <param name="type">The target type of the value to be formatted.</param>
        /// <returns>The fully formatted syntax for the default value or null if data was missing.</returns>
        public static string FormatCSharpParameterDefaultValueSyntax(this CsParameterDefaultValue source, CsType type)
        {
            var dotNetParameterDefaultValue = source as IDotNetParameterDefaultValue;
            var dotNetType = type as IDotNetType;

            return(dotNetParameterDefaultValue.FormatCSharpParameterDefaultValueSyntax(dotNetType));
        }
Beispiel #7
0
 /// <summary>
 /// Constructor for the <see cref="CsParameter"/>
 /// </summary>
 /// <param name="isLoaded">Flag that determines if the model was loaded.</param>
 /// <param name="hasErrors">Flag that determine if errors were found creating the model.</param>
 /// <param name="loadedFromSource">Flag that determines if the model was loaded from source code or from an existing library.</param>
 /// <param name="language">The target language the model was generated from.</param>
 /// <param name="defaultValue">The default value assigned to this parameter.</param>
 /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
 /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
 /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
 /// <param name="attributes">Attributes assigned to this model.</param>
 /// <param name="lookupPath">The fully qualified path of the model that is stored in the model store.</param>
 /// <param name="name">The name of the parameter.</param>
 /// <param name="isOut">Parameter is assigned the out keyword.</param>
 /// <param name="isRef">Parameter is assigned the ref keyword.</param>
 /// <param name="isParams">Parameter supports a parameter array.</param>
 /// <param name="isOptional">Parameter is optional.</param>
 /// <param name="isGenericParameter">Is a generic parameter.</param>
 /// <param name="hasDefaultValue">Parameter has an assigned default value.</param>
 /// <param name="parentPath">The fully qualified path name for the parent model to this model.</param>
 /// <param name="parameterType">The type that this parameter supports.</param>
 protected CsParameter(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCodeType language,
                       IReadOnlyList <CsAttribute> attributes, string lookupPath, string name, bool isOut, bool isRef, bool isParams,
                       bool isOptional, bool isGenericParameter, bool hasDefaultValue, string parentPath, CsType parameterType,
                       CsParameterDefaultValue defaultValue, string sourceDocument = null, ModelStore <ICsModel> modelStore = null,
                       IReadOnlyList <ModelLoadException> modelErrors = null)
     : base(isLoaded, hasErrors, loadedFromSource, language, CsModelType.Parameter, sourceDocument, modelStore, modelErrors)
 {
     _attributes         = attributes ?? ImmutableList <CsAttribute> .Empty;
     _lookupPath         = lookupPath;
     _name               = name;
     _isOut              = isOut;
     _isRef              = isRef;
     _isParams           = isParams;
     _isOptional         = isOptional;
     _isGenericParameter = isGenericParameter;
     _hasDefaultValue    = hasDefaultValue;
     _parentPath         = parentPath;
     _parameterType      = parameterType;
     _defaultValue       = defaultValue;
 }
Beispiel #8
0
 /// <summary>
 /// Constructor for the <see cref="CsMethod"/>
 /// </summary>
 /// <param name="isLoaded">Flag that determines if the model was loaded.</param>
 /// <param name="hasErrors">Flag that determine if errors were found creating the model.</param>
 /// <param name="loadedFromSource">Flag that determines if the model was loaded from source code or from an existing library.</param>
 /// <param name="language">The target language the model was generated from.</param>
 /// <param name="parameters">The parameters assigned to the method.</param>
 /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
 /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
 /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
 /// <param name="attributes">List of the attributes assigned to this model.</param>
 /// <param name="sourceFiles">List of the fully qualified paths to the source code files this member is defined in.</param>
 /// <param name="hasDocumentation">Flag that determines if the model has XML documentation assigned to it.</param>
 /// <param name="documentation">The xml documentation assigned to the model.</param>
 /// <param name="lookupPath">The fully qualified model lookup path for this model.</param>
 /// <param name="name">The name of the model.</param>
 /// <param name="parentPath">THe fully qualified lookup path for the parent model to this one.</param>
 /// <param name="security">The security scope assigned to this model.</param>
 /// <param name="isGeneric">Flag that determines if the method is a generic definition.</param>
 /// <param name="hasStrongTypesInGenerics">Flag that determines if the generics use strong type definitions.</param>
 /// <param name="genericParameters">Generic parameters assigned to the method.</param>
 /// <param name="genericTypes">Target types for the generic parameters assigned to the method.</param>
 /// <param name="hasParameters">Flag that determines if the method had parameters.</param>
 /// <param name="isAbstract">Flag that determines if the model is abstract.</param>
 /// <param name="isVirtual">Flag that determines if the model is virtual.</param>
 /// <param name="isSealed">Flag that determines if the model is sealed.</param>
 /// <param name="isOverride">Flag that determines if the model is overridden.</param>
 /// <param name="isStatic">Flag that determines if the model is static.</param>
 /// <param name="isVoid">Flag that determines if the return type is void. </param>
 /// <param name="isAsync">Flag that determines if the method has the async keyword assigned.</param>
 /// <param name="isExtension">Flag that determines if the method is an extension method.</param>
 /// <param name="methodType">The type of method that was implemented.</param>
 /// <param name="returnType">The type definition for the return type.</param>
 protected CsMethod(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCodeType language,
                    IReadOnlyList <CsAttribute> attributes, IReadOnlyList <string> sourceFiles,
                    bool hasDocumentation, string documentation, string lookupPath, string name, string parentPath,
                    CsSecurity security, bool isGeneric, bool hasStrongTypesInGenerics,
                    IReadOnlyList <CsGenericParameter> genericParameters, IReadOnlyList <CsType> genericTypes,
                    bool hasParameters, bool isAbstract, bool isVirtual, bool isSealed, bool isOverride, bool isStatic,
                    bool isVoid, bool isAsync, bool isExtension, CsMethodType methodType, CsType returnType,
                    IReadOnlyList <CsParameter> parameters, string sourceDocument = null,
                    ModelStore <ICsModel> modelStore = null, IReadOnlyList <ModelLoadException> modelErrors = null)
     : base(isLoaded, hasErrors, loadedFromSource, language, CsModelType.Method,
            attributes, sourceFiles, hasDocumentation, documentation, lookupPath, name, parentPath,
            security, CsMemberType.Method, sourceDocument, modelStore, modelErrors)
 {
     _isGeneric = isGeneric;
     _hasStrongTypesInGenerics = hasStrongTypesInGenerics;
     _genericParameters        = genericParameters ?? ImmutableList <CsGenericParameter> .Empty;
     _genericTypes             = genericTypes ?? ImmutableList <CsType> .Empty;
     _hasParameters            = hasParameters;
     _isAbstract  = isAbstract;
     _isVirtual   = isVirtual;
     _isSealed    = isSealed;
     _isOverride  = isOverride;
     _isStatic    = isStatic;
     _isVoid      = isVoid;
     _isAsync     = isAsync;
     _isExtension = isExtension;
     _methodType  = methodType;
     _returnType  = returnType;
     _parameters  = parameters ?? ImmutableList <CsParameter> .Empty;
 }
Beispiel #9
0
 /// <summary>
 /// Constructor for the <see cref="CsGenericParameter"/>
 /// </summary>
 /// <param name="isLoaded">Flag that determines if the model was loaded.</param>
 /// <param name="hasErrors">Flag that determine if errors were found creating the model.</param>
 /// <param name="loadedFromSource">Flag that determines if the model was loaded from source code or from an existing library.</param>
 /// <param name="language">The target language the model was generated from.</param>
 /// <param name="modelType">The type of code model created.</param>
 /// <param name="hasOutKeyword">Flag that determines if parameter has out keyword assigned.</param>
 /// <param name="hasNewConstraint">Flag that determines if generic parameter supports new keyword.</param>
 /// <param name="hasClassConstraint">flag that determines if the generic parameter has a constraint requirement to classes.</param>
 /// <param name="hasStructConstraint">Flag that determines if the generic parameter has a constraint requirement to structures.</param>
 /// <param name="hasConstraintTypes">Flag that determines if the generic parameter has additional type constraints.</param>
 /// <param name="constrainingTypes">List of of additional constraints the generic parameter supports.</param>
 /// <param name="type">The type definition for the generic type</param>
 /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
 /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
 /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
 protected CsGenericParameter(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCodeType language, CsModelType modelType,
                              bool hasOutKeyword, bool hasNewConstraint, bool hasClassConstraint, bool hasStructConstraint,
                              bool hasConstraintTypes, IReadOnlyList <CsType> constrainingTypes, CsType type, string sourceDocument = null, ModelStore <ICsModel> modelStore = null, IReadOnlyList <ModelLoadException> modelErrors = null)
     : base(isLoaded, hasErrors, loadedFromSource, language, modelType, sourceDocument, modelStore, modelErrors)
 {
     _hasOutKeyword       = hasOutKeyword;
     _hasNewConstraint    = hasNewConstraint;
     _hasClassConstraint  = hasClassConstraint;
     _hasStructConstraint = hasStructConstraint;
     _hasConstraintTypes  = hasConstraintTypes;
     _constrainingTypes   = constrainingTypes ?? ImmutableList <CsType> .Empty;
     _type = type;
 }
Beispiel #10
0
 /// <summary>
 /// Constructor for the <see cref="CsAttributeParameterValue"/>
 /// </summary>
 /// <param name="isLoaded">Flag that determines if the model was loaded.</param>
 /// <param name="hasErrors">Flag that determine if errors were found creating the model.</param>
 /// <param name="loadedFromSource">Flag that determines if the model was loaded from source code or from an existing library.</param>
 /// <param name="language">The target language the model was generated from.</param>
 /// <param name="values">The list of values if the parameter has more then one value.</param>
 /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
 /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
 /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
 /// <param name="parameterKind">The kind of attribute parameter.</param>
 /// <param name="value">The value of the attribute parameter.</param>
 /// <param name="enumValue">The value of the enumeration if the parameter is an enumeration.</param>
 /// <param name="typeValue">The type if the parameter is a single value.</param>
 protected CsAttributeParameterValue(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCodeType language,
                                     AttributeParameterKind parameterKind, string value, string enumValue, CsType typeValue,
                                     IReadOnlyList <CsAttributeParameterValue> values, string sourceDocument = null, ModelStore <ICsModel> modelStore = null, IReadOnlyList <ModelLoadException> modelErrors = null)
     : base(isLoaded, hasErrors, loadedFromSource, language, CsModelType.AttributeParameterValue, sourceDocument, modelStore, modelErrors)
 {
     _parameterKind = parameterKind;
     _value         = value;
     _enumValue     = enumValue;
     _typeValue     = typeValue;
     _values        = values ?? ImmutableList <CsAttributeParameterValue> .Empty;
 }