Example #1
0
        /// <summary>
        /// determines the operation name to use in a corba request for a method.
        /// </summary>
        internal static string GetPropertyRequestOperationName(PropertyInfo forProperty, bool forSetter)
        {
            string methodName;

            if (!forSetter)
            {
                methodName = GetRequestMethodNameFromAttr(forProperty.GetGetMethod());
            }
            else
            {
                methodName = GetRequestMethodNameFromAttr(forProperty.GetSetMethod());
            }
            if (methodName == null)
            {
                string mappedPropertyName =
                    IdlNaming.MapClsNameToIdlName(forProperty.Name);
                if (!forSetter)
                {
                    methodName = DetermineGetterTransmissionName(mappedPropertyName);
                }
                else
                {
                    methodName = DetermineSetterTransmissionName(mappedPropertyName);
                }
            }
            return(methodName);
        }
Example #2
0
        public object MapToIdlStruct(Type clsType)
        {
            lock (structTCs)
            {
                StructTC result = structTCs[clsType] as StructTC;
                if (result != null)
                {
                    return(result);
                }

                result = new StructTC();
                RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                               result);

                FieldInfo[]    members       = ReflectionHelper.GetAllDeclaredInstanceFieldsOrdered(clsType);
                StructMember[] structMembers = new StructMember[members.Length];
                for (int i = 0; i < members.Length; i++)
                {
                    omg.org.CORBA.TypeCode memberType =
                        CreateOrGetTypeCodeForType(members[i].FieldType,
                                                   ReflectionHelper.GetCustomAttriutesForField(members[i],
                                                                                               true));
                    structMembers[i] = new StructMember(members[i].Name, memberType);
                }
                result.Initalize(Repository.GetRepositoryID(clsType),
                                 IdlNaming.ReverseIdlToClsNameMapping(clsType.Name),
                                 structMembers);

                structTCs[clsType] = result;

                return(result);
            }
        }
Example #3
0
        public object MapToIdlLocalInterface(Type clsType)
        {
            LocalIfTC result = new LocalIfTC(Repository.GetRepositoryID(clsType),
                                             IdlNaming.ReverseIdlToClsNameMapping(clsType.Name));

            RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                           result);
            return(result);
        }
Example #4
0
 public object MapToIdlConcreteInterface(System.Type dotNetType)
 {
     if (!dotNetType.Equals(ReflectionHelper.MarshalByRefObjectType))
     {
         return(IdlNaming.MapFullTypeNameToIdlScoped(dotNetType));
     }
     else
     {
         return("Object");
     }
 }
Example #5
0
        public object MapToIdlEnum(Type clsType)
        {
            string[] names  = Enum.GetNames(clsType);
            EnumTC   result = new EnumTC(Repository.GetRepositoryID(clsType),
                                         IdlNaming.ReverseIdlToClsNameMapping(clsType.Name),
                                         names);

            RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                           result);
            return(result);
        }
Example #6
0
        private object MapToIdlBoxedValueType(Type clsType,
                                              bool boxInAny)
        {
            // dotNetType is subclass of BoxedValueBase
            if (!clsType.IsSubclassOf(ReflectionHelper.BoxedValueBaseType))
            {
                // mapper error: MapToIdlBoxedValue found incorrect type
                throw new INTERNAL(1929, CompletionStatus.Completed_MayBe);
            }
            Type boxedType;

            object[] attributesOnBoxed = new object[0];
            try {
                boxedType = (Type)clsType.InvokeMember(BoxedValueBase.GET_BOXED_TYPE_METHOD_NAME,
                                                       BindingFlags.InvokeMethod | BindingFlags.Public |
                                                       BindingFlags.NonPublic | BindingFlags.Static |
                                                       BindingFlags.DeclaredOnly,
                                                       null, null, new object[0]);

                attributesOnBoxed = (object[])clsType.InvokeMember(BoxedValueBase.GET_BOXED_TYPE_ATTRIBUTES_METHOD_NAME,
                                                                   BindingFlags.InvokeMethod | BindingFlags.Public |
                                                                   BindingFlags.NonPublic | BindingFlags.Static |
                                                                   BindingFlags.DeclaredOnly,
                                                                   null, null, new object[0]);
            }
            catch (Exception) {
                // invalid type: clsType
                // static method missing or not callable:
                // BoxedValueBase.GET_BOXED_TYPE_METHOD_NAME
                throw new INTERNAL(1930, CompletionStatus.Completed_MayBe);
            }
            if (boxInAny)
            {
                omg.org.CORBA.TypeCode boxed = CreateOrGetTypeCodeForType(boxedType,
                                                                          AttributeExtCollection.ConvertToAttributeCollection(attributesOnBoxed));

                ValueBoxTC result = new ValueBoxTC(Repository.GetRepositoryID(clsType),
                                                   IdlNaming.ReverseIdlToClsNameMapping(clsType.Name),
                                                   boxed);
                RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection, result);
                return(result);
            }
            else
            {
                // don't use boxed form
                // therefore create a typecode for the type boxed inside
                // e.g. in case of a boxed sequence of int, there will be a idlsequence typecode with int as element type created.
                // e.g. in case, where a sequence of boxed valuetype is boxed, an idl sequence will be created containing a typecode
                // for the boxed type.
                omg.org.CORBA.TypeCodeImpl forBoxed = CreateOrGetTypeCodeForType(boxedType,
                                                                                 AttributeExtCollection.ConvertToAttributeCollection(attributesOnBoxed));
                return(forBoxed);
            }
        }
Example #7
0
 public object MapToIdlSequence(System.Type dotNetType, int bound, AttributeExtCollection allAttributes, AttributeExtCollection elemTypeAttributes)
 {
     if (m_useAnonymousSequences)
     {
         string refToElemType = (string)m_mapper.MapClsType(dotNetType.GetElementType(), elemTypeAttributes, this);
         return("sequence<" + refToElemType + ">");
     }
     else
     {
         // use a typedef for non-anonymous sequence
         return(IdlNaming.GetFullyQualifiedIdlTypeDefAliasForSequenceType(dotNetType, bound, elemTypeAttributes));
     }
 }
Example #8
0
        /// <summary>
        /// creates a CLS type name for a type represented by the IDL-id
        /// </summary>
        /// <param name="idlID"></param>
        /// <param name="assumeMappedFromIdl">should assume, that type represented by idlid is mapped from IDL to CLS</param>
        /// <returns>
        /// The typename for the idlID
        /// </returns>
        private static string CreateTypeNameForIDLId(string idlID, bool assumeMappedFromIdl)
        {
            int colonIndex = idlID.IndexOf(':', 4);

            if (colonIndex < 0)
            {
                // invalid repository id: idlID
                throw new INV_IDENT(9901, CompletionStatus.Completed_MayBe);
            }
            string typeName = idlID.Substring(4, colonIndex - 4);

            typeName = IdlNaming.MapIdlRepIdTypePartToClsName(typeName, assumeMappedFromIdl);
            return(typeName);
        }
Example #9
0
        /// <summary>
        /// determines the operation name to use in a corba request for a method.
        /// </summary>
        internal static string GetMethodRequestOperationName(MethodInfo method, bool isOverloaded)
        {
            string methodName = GetRequestMethodNameFromAttr(method);

            if (methodName == null)
            {
                // determine name for a native .NET method (not mapped from idl)
                // do a CLS to IDL mapping, because .NET server expect this for every client, also for a
                // native .NET client, which uses not CLS -> IDL -> CLS mapping
                methodName = IdlNaming.MapClsMethodNameToIdlName(method,
                                                                 isOverloaded);
                methodName = DetermineOperationTransmissionName(methodName);
            }
            return(methodName);
        }
Example #10
0
        public object MapToIdlConcreteInterface(Type clsType)
        {
            ObjRefTC result;

            if (!clsType.Equals(ReflectionHelper.MarshalByRefObjectType))
            {
                result = new ObjRefTC(Repository.GetRepositoryID(clsType),
                                      IdlNaming.ReverseIdlToClsNameMapping(clsType.Name));
            }
            else
            {
                result = new ObjRefTC(String.Empty, String.Empty);
            }
            RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                           result);
            return(result);
        }
Example #11
0
        public object MapToIdlConcreateValueType(Type clsType)
        {
            omg.org.CORBA.TypeCode baseTypeCode;
            if (clsType.BaseType.Equals(ReflectionHelper.ObjectType) ||
                clsType.BaseType.Equals(typeof(System.ComponentModel.MarshalByValueComponent)))
            {
                baseTypeCode = new NullTC();
            }
            else
            {
                baseTypeCode = CreateOrGetTypeCodeForType(clsType.BaseType,
                                                          AttributeExtCollection.EmptyCollection);
            }
            ValueTypeTC result = new ValueTypeTC();

            RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                           result);

            // create the TypeCodes for the members
            FieldInfo[]   members      = ReflectionHelper.GetAllDeclaredInstanceFieldsOrdered(clsType);
            ValueMember[] valueMembers = new ValueMember[members.Length];
            for (int i = 0; i < members.Length; i++)
            {
                omg.org.CORBA.TypeCode memberType = CreateOrGetTypeCodeForType(members[i].FieldType,
                                                                               ReflectionHelper.GetCustomAttriutesForField(members[i],
                                                                                                                           true));
                short visibility;
                if (members[i].IsPrivate)
                {
                    visibility = VISIBILITY_PRIVATE;
                }
                else
                {
                    visibility = VISIBILITY_PUBLIC;
                }
                valueMembers[i] = new ValueMember(members[i].Name, memberType, visibility);
            }
            result.Initalize(Repository.GetRepositoryID(clsType),
                             IdlNaming.ReverseIdlToClsNameMapping(clsType.Name),
                             valueMembers, baseTypeCode, CONCRETE_VALUE_MOD);
            return(result);
        }
Example #12
0
        public object MapException(Type clsType)
        {
            // TODO: check this, generic user exception handling ...
            ExceptTC result = new ExceptTC();

            RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                           result);

            FieldInfo[]    members   = ReflectionHelper.GetAllDeclaredInstanceFieldsOrdered(clsType);
            StructMember[] exMembers = new StructMember[members.Length];
            for (int i = 0; i < members.Length; i++)
            {
                omg.org.CORBA.TypeCode memberType = CreateOrGetTypeCodeForType(members[i].FieldType,
                                                                               ReflectionHelper.GetCustomAttriutesForField(members[i],
                                                                                                                           true));
                exMembers[i] = new StructMember(members[i].Name, memberType);
            }
            result.Initalize(Repository.GetRepositoryID(clsType),
                             IdlNaming.ReverseIdlToClsNameMapping(clsType.Name),
                             exMembers);
            return(result);
        }
        /// <summary>creates the fully qualified type name for the box</summary>
        private string CreateBoxedArrayFullTypeName(Type arrayType)
        {
            Type arrayElemType = DetermineInnermostArrayElemType(arrayType);
            // unqualified name of the innermost element type of the array
            string arrayElemTypeName = IdlNaming.MapShortTypeNameToIdl(arrayElemType); // need the mapped name for identifier

            arrayElemTypeName = arrayElemTypeName.Replace(" ", "_");
            string boxUnqual = "seq" + DetermineArrayRank(arrayType) + "_" + arrayElemTypeName;

            string namespaceBox = arrayElemType.Namespace;

            if ((namespaceBox != null) && (namespaceBox.Length > 0))
            {
                namespaceBox = "org.omg.BoxedArray." + namespaceBox;
            }
            else
            {
                namespaceBox = "org.omg.BoxedArray";
            }

            return(namespaceBox + "." + boxUnqual);
        }
Example #14
0
        public object MapToIdlAbstractValueType(Type clsType)
        {
            omg.org.CORBA.TypeCode baseTypeCode;
            if (clsType.BaseType.Equals(ReflectionHelper.ObjectType) ||
                clsType.BaseType.Equals(typeof(System.ComponentModel.MarshalByValueComponent)))
            {
                baseTypeCode = new NullTC();
            }
            else
            {
                baseTypeCode = CreateOrGetTypeCodeForType(clsType.BaseType,
                                                          AttributeExtCollection.EmptyCollection);
            }
            ValueTypeTC result = new ValueTypeTC();

            RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                           result);
            result.Initalize(Repository.GetRepositoryID(clsType),
                             IdlNaming.ReverseIdlToClsNameMapping(clsType.Name),
                             new ValueMember[0],
                             baseTypeCode, ABSTRACT_VALUE_MOD);
            return(result);
        }
Example #15
0
        /// <summary>
        /// returns the repository id to use for type. In the repIdForType the string identifying the
        /// type is returned. The result and the repIdForType can be different (e.g. SupportedInterface)
        /// </summary>
        private string GetRepositoryIDFromType(Type type, out string repIdForType)
        {
            string result;

            object[] attr = type.GetCustomAttributes(ReflectionHelper.RepositoryIDAttributeType, false);
            if (attr != null && attr.Length > 0)
            {
                RepositoryIDAttribute repIDAttr = (RepositoryIDAttribute)attr[0];
                result = repIDAttr.Id;
            }
            else
            {
                result = IdlNaming.MapFullTypeNameToIdlRepId(type);
            }
            repIdForType = result;
            if (type.IsMarshalByRef)
            {
                attr = type.GetCustomAttributes(ReflectionHelper.SupportedInterfaceAttributeType, true);
                if (attr != null && attr.Length > 0)
                {
                    SupportedInterfaceAttribute repIDFrom = (SupportedInterfaceAttribute)attr[0];
                    Type fromType = repIDFrom.FromType;
                    if (fromType.Equals(type))
                    {
                        throw new INTERNAL(1701, CompletionStatus.Completed_MayBe);
                    }
                    string repIdForInterface;
                    result = GetRepositoryIDFromType(fromType, out repIdForInterface); // repository ID to use when serialising such a type
                }
            }
            if (IsValueTypeImplClass(type))
            {
                string repIdForValType;
                result = GetRepositoryIDFromType(type.BaseType, out repIdForValType); // repository ID to use when serialising such a type
            }
            return(result);
        }
Example #16
0
 public object MapToIdlBoxedValueType(System.Type dotNetType, System.Type needsBoxingFrom)
 {
     // the dotNetType is a subclass of BoxedValueBase representing the boxed value type
     return(IdlNaming.MapFullTypeNameToIdlScoped(dotNetType));
 }
        /// <summary>
        /// returns the repository id, which will be assigned to a boxed value type generated at runtime
        /// for a .NET array type.
        /// </summary>
        internal string GetRepositoryIDForBoxedArrayType(Type arrayType)
        {
            string typeName = CreateBoxedArrayFullTypeName(arrayType);

            return(IdlNaming.MapFullTypeNameToIdlRepId(typeName));
        }
Example #18
0
        /// <param name="elemNamespace">the namespace of the elementType</param>
        /// <returns> the unqualified elem-type name </returns>
        private static string ParseRMIArrayElemType(string rmiElemType, out string elemNamespace)
        {
            elemNamespace = string.Empty; // for primitve types, this is the correct namespace
            // first character in elemType determines what kind of type
            switch (rmiElemType[0])
            {
            case 'I':
                return("long");

            case 'Z':
                return("boolean");

            case 'B':
                return("octet");

            case 'C':
                return("wchar");

            case 'D':
                return("double");

            case 'F':
                return("float");

            case 'J':
                return("long_long");

            case 'S':
                return("short");

            case 'L':
                if (rmiElemType.Length <= 1)
                {
                    // invalid element type in RMI array repository id"
                    throw new INV_IDENT(10004, CompletionStatus.Completed_MayBe);
                }
                string elemTypeName = rmiElemType.Substring(1, rmiElemType.Length - 1 - (rmiElemType[rmiElemType.Length - 1] == ';' ? 1 : 0));
                string unqualName   = string.Empty;
                int    lastPIndex   = elemTypeName.LastIndexOf('.');
                if (lastPIndex < 0)
                {
                    elemNamespace = string.Empty;
                    unqualName    = elemTypeName;
                }
                else
                {
                    if (string.Compare(elemTypeName, 0, "java.lang", 0, lastPIndex) == 0 &&
                        string.Compare(elemTypeName, lastPIndex + 1, "String", 0, elemTypeName.Length - lastPIndex - 1) == 0)
                    {
                        // special case: map to CORBA.WStringValue
                        elemNamespace = "CORBA";
                        unqualName    = "WStringValue";
                    }
                    else
                    {
                        elemNamespace = elemTypeName.Substring(0, lastPIndex);
                        unqualName    = elemTypeName.Substring(lastPIndex + 1);
                        // map rmi name to cls name, handle e.g. clashes with cls keywords
                        if (unqualName.StartsWith("_"))
                        {
                            unqualName = "J" + unqualName;     // rmi mapping adds a J before a class name starting with _
                        }
                        unqualName    = IdlNaming.MapRmiNameToClsName(unqualName);
                        elemNamespace = IdlNaming.MapRmiNameToClsName(elemNamespace);
                        if (unqualName.StartsWith("_"))
                        {
                            // remove _ added by IDL to CLS mapping, because class name follows a seq<n>_, therefore _ not added
                            // in IDL to CLS mapping
                            unqualName = unqualName.Substring(1);
                        }
                    }
                }
                return(unqualName);

            default:
                // invalid element type identifier in RMI array repository id: firstChar
                throw new INV_IDENT(10003, CompletionStatus.Completed_MayBe);
            }
        }
Example #19
0
        /// <summary>
        /// create a CLS type name for a type represented by the RMI-id
        /// </summary>
        /// <param name="rmiID"></param>
        /// <returns></returns>
        private static string CreateTypeNameForRMIId(string rmiID)
        {
            string typeName;
            int    colonIndex = rmiID.IndexOf(':', 4);

            if (colonIndex >= 0)
            {
                typeName = rmiID.Substring(4, colonIndex - 4);
            }
            else
            {
                typeName = rmiID.Substring(4);
            }
            // check for array type
            if (typeName.StartsWith("["))
            {
                if (typeName.Length == 1)
                {
                    // invalid rmi-repository-id: typeName
                    throw new INV_IDENT(10002, CompletionStatus.Completed_MayBe);
                }
                string elemType  = typeName.TrimStart('[');
                int    arrayRank = typeName.Length - elemType.Length; // array rank = number of [ - characters
                // parse the elem-type, which is in RMI-ID format
                string elemNameSpace;
                string unqualElemType = ParseRMIArrayElemType(elemType, out elemNameSpace);
                if (elemNameSpace.Length > 0)
                {
                    elemNameSpace = "." + elemNameSpace;
                }
                unqualElemType = ResolveRmiInnerTypeMapping(unqualElemType);
                // determine name of boxed value type
                typeName = "org.omg.boxedRMI" + elemNameSpace + ".seq" + arrayRank + "_" + unqualElemType;
                Debug.WriteLine("mapped rmi id to boxed value type name:" + typeName);
            }
            else
            {
                int lastPIndex = typeName.LastIndexOf(".");
                if (lastPIndex >= 0)
                {
                    string elemNamespace = typeName.Substring(0, lastPIndex);
                    string unqualName    = typeName.Substring(lastPIndex + 1);
                    if (unqualName.StartsWith("_"))
                    {
                        // rmi mapping adds a J before a class name starting with _
                        typeName = elemNamespace + ".J" + unqualName;
                    }
                }
                else
                {
                    if (typeName.StartsWith("_"))
                    {
                        // rmi mapping adds a J before a class name starting with _
                        typeName = "J" + typeName;
                    }
                }
                typeName = ResolveRmiInnerTypeMapping(typeName);

                // do name mapping (e.g. resolve clashes with CLS keywords)
                typeName = IdlNaming.MapRmiNameToClsName(typeName);
            }

            return(typeName);
        }
Example #20
0
 public object MapToIdlLocalInterface(System.Type dotNetType)
 {
     return(IdlNaming.MapFullTypeNameToIdlScoped(dotNetType));
 }
Example #21
0
 public object MapToIdlAbstractValueType(System.Type dotNetType)
 {
     return(IdlNaming.MapFullTypeNameToIdlScoped(dotNetType));
 }
Example #22
0
 public object MapToIdlEnum(System.Type dotNetType)
 {
     return(IdlNaming.MapFullTypeNameToIdlScoped(dotNetType));
 }
Example #23
0
 public object MapToIdlArray(System.Type dotNetType, int[] dimensions, AttributeExtCollection allAttributes, AttributeExtCollection elemTypeAttributes)
 {
     // use a typedef for arrays, because dimension is part of the name of the thing, the type is an array
     return(IdlNaming.GetFullyQualifiedIdlTypeDefAliasForArrayType(dotNetType, dimensions, elemTypeAttributes));
 }
Example #24
0
        public object MapToIdlUnion(Type clsType)
        {
            UnionTC result = new UnionTC();

            RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
                                           result);

            // first get discriminator type
            FieldInfo discriminator = clsType.GetField(UnionGenerationHelper.DISCR_FIELD_NAME,
                                                       BindingFlags.Instance |
                                                       BindingFlags.DeclaredOnly |
                                                       BindingFlags.NonPublic);

            omg.org.CORBA.TypeCode discrTypeCode =
                CreateOrGetTypeCodeForType(discriminator.FieldType,
                                           ReflectionHelper.GetCustomAttriutesForField(discriminator,
                                                                                       true));
            // get the methods used for typecode creation
            MethodInfo getCoveredDiscrMethod = clsType.GetMethod(UnionGenerationHelper.GET_COVERED_DISCR_VALUES,
                                                                 BindingFlags.Static | BindingFlags.NonPublic |
                                                                 BindingFlags.DeclaredOnly);
            MethodInfo getDefaultFieldMethod = clsType.GetMethod(UnionGenerationHelper.GET_DEFAULT_FIELD,
                                                                 BindingFlags.Static | BindingFlags.NonPublic |
                                                                 BindingFlags.DeclaredOnly);
            MethodInfo getFieldForDiscrVal = clsType.GetMethod(UnionGenerationHelper.GET_FIELD_FOR_DISCR_METHOD,
                                                               BindingFlags.Static | BindingFlags.NonPublic |
                                                               BindingFlags.DeclaredOnly);

            // get all discriminator values used in switch-cases
            object[] coveredDiscrs = (object[])getCoveredDiscrMethod.Invoke(null, new object[0]);
            if (coveredDiscrs == null)
            {
                throw new INTERNAL(898, CompletionStatus.Completed_MayBe);
            }

            FieldInfo defaultField = (FieldInfo)getDefaultFieldMethod.Invoke(null, new object[0]);

            UnionSwitchCase[] cases = null;
            int defaultCaseNumber   = -1; // no default case

            if (defaultField != null)
            {
                cases = new UnionSwitchCase[coveredDiscrs.Length + 1];
                omg.org.CORBA.TypeCode elemType =
                    CreateOrGetTypeCodeForType(defaultField.FieldType,
                                               ReflectionHelper.GetCustomAttriutesForField(defaultField,
                                                                                           true));
                // create a default value of type discriminiator type, because of possible discriminator types, this
                // is possible with Activator.CreateInstance ...
                object dummyValue = null;
                try {
                    dummyValue = Activator.CreateInstance(discriminator.FieldType);
                } catch (Exception) {
                    throw new MARSHAL(881, CompletionStatus.Completed_MayBe);
                }
                cases[coveredDiscrs.Length] = new UnionSwitchCase(dummyValue, defaultField.Name.Substring(2),
                                                                  elemType);
                defaultCaseNumber = coveredDiscrs.Length;
            }
            else
            {
                cases = new UnionSwitchCase[coveredDiscrs.Length];
            }

            // add a UnionSwitchCase to typecode for every discriminator value used
            for (int i = 0; i < coveredDiscrs.Length; i++)
            {
                FieldInfo caseField = (FieldInfo)getFieldForDiscrVal.Invoke(null, new object[] { coveredDiscrs[i] });
                if (caseField == null)
                {
                    throw new INTERNAL(898, CompletionStatus.Completed_MayBe);
                }
                omg.org.CORBA.TypeCode elemType =
                    CreateOrGetTypeCodeForType(caseField.FieldType,
                                               ReflectionHelper.GetCustomAttriutesForField(caseField, true));
                // extract name of element field: strip m_
                UnionSwitchCase switchCase = new UnionSwitchCase(coveredDiscrs[i], caseField.Name.Substring(2),
                                                                 elemType);
                cases[i] = switchCase;
            }
            result.Initalize(Repository.GetRepositoryID(clsType),
                             IdlNaming.ReverseIdlToClsNameMapping(clsType.Name),
                             discrTypeCode, defaultCaseNumber, cases);
            return(result);
        }