/// <summary>
 /// Initializes a new instance of the <see cref="ParameterSignature" /> class.
 /// </summary>
 /// <param name="name">The parameter name.</param>
 /// <param name="parameterType">The parameter type.</param>
 /// <param name="isOutParameter">if set to <c>true</c>, this is an out parameter.</param>
 /// <param name="isRefParameter">if set to <c>true</c>, this is a reference parameter.</param>
 public ParameterSignature(string name, TypeSignature parameterType, bool isOutParameter, bool isRefParameter)
 {
     Name = name;
     ParameterType = parameterType;
     IsOutParameter = isOutParameter;
     IsRefParameter = isRefParameter;
 }
Exemple #2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PropertySignature"/> class.
 /// </summary>
 /// <param name="identity">The Identity.</param>
 /// <param name="name">The name of the property.</param>
 /// <param name="declaringType">The declaring type.</param>
 /// <param name="propertyType">The property type.</param>
 public PropertySignature(
     string identity,
     string name,
     TypeSignature declaringType,
     TypeSignature propertyType)
 {
     _identity = identity;
     _name = name;
     _declaringType = declaringType;
     _propertyType = propertyType;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="PropertySignature"/> class.
 /// </summary>
 /// <param name="identity">The Identity.</param>
 /// <param name="name">The name of the property.</param>
 /// <param name="declaringType">The declaring type.</param>
 /// <param name="propertyType">The property type.</param>
 public PropertySignature(
     string identity,
     string name,
     TypeSignature declaringType,
     TypeSignature propertyType)
 {
     Identity = identity;
     Name = name;
     DeclaringType = declaringType;
     PropertyType = propertyType;
 }
        /// <summary>
        /// Gets the type of the dynamic object builder.
        /// </summary>
        /// <param name="properties">The properties.</param>
        /// <returns></returns>
        public static Type GetDynamicObjectBuilderType(IEnumerable<SLDataColumn> properties)
        {
            Type type;
            var signature = new TypeSignature(properties);

            if (!TypesCache.TryGetValue(signature, out type))
            {
                type = CreateDynamicObjectBuilderType(properties);
                TypesCache.Add(signature, type);
            }

            return type;
        } 
 internal static Type GetDynamicObjectBuilderType(ThrowingHashSet<IPropertyInfo> properties)
 {
     lock (SyncRoot)
     {
         TypeSignature signature = new TypeSignature(properties);
         Type type;
         if (!TypesCache.TryGetValue(signature, out type))
         {
             type = CreateDynamicObjectBuilderType(properties);
             TypesCache.Add(signature, type);
         }
         return type;
     }
 }
        private static TagDataEntry GetEntry(TypeSignature type, int idx, ICCHeader header)
        {
            switch (type)
            {
                case TypeSignature.chromaticity:
                    return new chromaticityTagDataEntry(idx);
                case TypeSignature.colorantOrder:
                    return new colorantOrderTagDataEntry(idx);
                case TypeSignature.colorantTable:
                    return new colorantTableTagDataEntry(idx);
                case TypeSignature.curve:
                    return new curveTagDataEntry(idx);
                case TypeSignature.data:
                    return new dataTagDataEntry(idx);
                case TypeSignature.dateTime:
                    return new dateTimeTagDataEntry(idx);
                case TypeSignature.lut16:
                    return new lut16TagDataEntry(idx);
                case TypeSignature.lut8:
                    return new lut8TagDataEntry(idx);
                case TypeSignature.lutAToB:
                    return new lutAToBTagDataEntry(idx);
                case TypeSignature.lutBToA:
                    return new lutBToATagDataEntry(idx);
                case TypeSignature.measurement:
                    return new measurementTagDataEntry(idx);
                case TypeSignature.multiLocalizedUnicode:
                    return new multiLocalizedUnicodeTagDataEntry(idx, false);
                case TypeSignature.multiProcessElements:
                    return new multiProcessElementsTagDataEntry(idx);
                case TypeSignature.namedColor2:
                    return new namedColor2TagDataEntry(idx);
                case TypeSignature.parametricCurve:
                    return new parametricCurveTagDataEntry(idx);
                case TypeSignature.profileSequenceDesc:
                    return new profileSequenceDescTagDataEntry(idx, header);
                case TypeSignature.profileSequenceIdentifier:
                    return new profileSequenceIdentifierTagDataEntry(idx);
                case TypeSignature.responseCurveSet16:
                    return new responseCurveSet16TagDataEntry(idx);
                case TypeSignature.s15Fixed16Array:
                    return new s15Fixed16ArrayTagDataEntry(idx);
                case TypeSignature.signature:
                    return new signatureTagDataEntry(idx);
                case TypeSignature.text:
                    return new textTagDataEntry(idx);
                case TypeSignature.u16Fixed16Array:
                    return new u16Fixed16ArrayTagDataEntry(idx);
                case TypeSignature.uInt16Array:
                    return new uInt16ArrayTagDataEntry(idx);
                case TypeSignature.uInt32Array:
                    return new uInt32ArrayTagDataEntry(idx);
                case TypeSignature.uInt64Array:
                    return new uInt64ArrayTagDataEntry(idx);
                case TypeSignature.uInt8Array:
                    return new uInt8ArrayTagDataEntry(idx);
                case TypeSignature.viewingConditions:
                    return new viewingConditionsTagDataEntry(idx);
                case TypeSignature.XYZ:
                    return new XYZTagDataEntry(idx);

                default:
                    return new TagDataEntry();
            }
        }
Exemple #7
0
        /// <summary>
        /// Creates a new method with argument types given by function arguments.
        /// </summary>
        internal MethodEntity CreateMethod(string name, TypeSignature returnType, IEnumerable<FunctionArgument> args = null, bool isStatic = false, bool isVirtual = false, bool prepare = false)
        {
            var argHash = new HashList<FunctionArgument>();
            if(args != null)
                foreach (var curr in args)
                    argHash.Add(curr.Name, curr);

            var me = createMethodCore(name, isStatic, isVirtual, prepare);
            me.ReturnTypeSignature = returnType;
            me.Arguments = argHash;
            return me;
        }
Exemple #8
0
        /// <summary>
        /// Creates a new method with argument types given by signatures.
        /// </summary>
        internal MethodEntity CreateMethod(string name, TypeSignature returnType, string[] argTypes = null, bool isStatic = false, bool isVirtual = false, bool prepare = false)
        {
            var args = argTypes == null
                ? null
                : argTypes.Select((a, idx) => new FunctionArgument("arg" + idx.ToString(), a)).ToArray();

            return CreateMethod(name, returnType, args, isStatic, isVirtual, prepare);
        }
Exemple #9
0
 /// <summary>
 /// Creates a new field by type signature.
 /// </summary>
 internal FieldEntity CreateField(string name, TypeSignature signature, bool isStatic = false, bool prepare = false)
 {
     var fe = createFieldCore(name, isStatic, prepare);
     fe.TypeSignature = signature;
     return fe;
 }
Exemple #10
0
 /// <summary>
 /// Creates a new field by type signature.
 /// </summary>
 internal FieldEntity CreateField(string name, TypeSignature signature, bool isStatic = false, bool prepare = true)
 {
     return createFieldCore(name, isStatic, prepare, fe => fe.TypeSignature = signature);
 }
Exemple #11
0
 /// <summary>
 /// Creates a new method with argument types given by function arguments.
 /// </summary>
 internal MethodEntity CreateMethod(string name, TypeSignature returnType, IEnumerable<FunctionArgument> args = null, bool isStatic = false, bool isVirtual = false, bool prepare = true)
 {
     return createMethodCore(name, isStatic, isVirtual, prepare, me =>
         {
             me.Arguments = new HashList<FunctionArgument>(args, x => x.Name);
             me.ReturnTypeSignature = returnType;
         }
     );
 }
 internal ParameterSignature(TypeSignature type, bool isByRef)
 {
     Type = type;
     IsByRef = isByRef;
 }
 WildcardTypeSignature(TypeSignatureKind typeSignatureKind, TypeSignature bound)
     : super(typeSignatureKind, "*") {
     : super(typeSignatureKind, "*") {
     this.bound = bound;
 }
Exemple #15
0
 internal static PointerTypeSignature Pointer(TypeSignature pointedAtType)
 {
     return new PointerTypeSignature(pointedAtType);
 }
Exemple #16
0
 internal static ArrayTypeSignature Array(TypeSignature elementType, int rank)
 {
     return new ArrayTypeSignature(elementType, rank);
 }
Exemple #17
0
 internal static QualifiedTypeSignature Qualified(TypeSignature left, string right)
 {
     return new QualifiedTypeSignature(left, right);
 }
 ArrayTypeSignature(TypeSignature elementType)
     : super(TypeSignatureKind.ArrayType, "[" + elementType.Name) {