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);
}
}
public object MapToIdlLocalInterface(Type clsType)
{
LocalIfTC result = new LocalIfTC(Repository.GetRepositoryID(clsType),
IdlNaming.ReverseIdlToClsNameMapping(clsType.Name));
RegisterCreatedTypeCodeForType(clsType, AttributeExtCollection.EmptyCollection,
result);
return(result);
}
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);
}
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);
}
}
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);
}
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);
}
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);
}
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);
}
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);
}
