public void Init(
ConfigurationCommonEventTypeMeta.AvroSettingsConfig avroSettings,
ImportService importService)
{
_avroSettings = avroSettings;
if (avroSettings.TypeRepresentationMapperClass != null) {
_optionalTypeMapper = TypeHelper.Instantiate<TypeRepresentationMapper>(
avroSettings.TypeRepresentationMapperClass,
importService.ClassForNameProvider);
}
if (avroSettings.ObjectValueTypeWidenerFactoryClass != null) {
_optionalWidenerFactory = TypeHelper.Instantiate<ObjectValueTypeWidenerFactory>(
avroSettings.ObjectValueTypeWidenerFactoryClass,
importService.ClassForNameProvider);
}
}
public void Init(ConfigurationEngineDefaults.AvroSettings avroSettings, EngineImportService engineImportService)
{
_avroSettings = avroSettings;
if (avroSettings.TypeRepresentationMapperClass != null)
{
_optionalTypeMapper = TypeHelper.Instantiate <TypeRepresentationMapper>(
avroSettings.TypeRepresentationMapperClass,
engineImportService.GetClassForNameProvider());
}
if (avroSettings.ObjectValueTypeWidenerFactoryClass != null)
{
_optionalWidenerFactory = TypeHelper.Instantiate <ObjectValueTypeWidenerFactory>(
avroSettings.ObjectValueTypeWidenerFactoryClass,
engineImportService.GetClassForNameProvider());
}
}
private static Schema AssembleNestedSchema(
MapEventType mapEventType,
ConfigurationEngineDefaults.AvroSettings avroSettings,
Attribute[] annotations,
EventAdapterService eventAdapterService,
string statementName,
string engineURI,
TypeRepresentationMapper optionalMapper)
{
var fields = new JArray();
foreach (var prop in mapEventType.Types)
{
AssembleField(
prop.Key, prop.Value, fields, annotations, avroSettings, eventAdapterService, statementName,
engineURI, optionalMapper);
}
return SchemaBuilder.Record(mapEventType.Name, fields);
}
private static Schema AssembleNestedSchema(
MapEventType mapEventType,
ConfigurationCommonEventTypeMeta.AvroSettingsConfig avroSettings,
Attribute[] annotations,
EventTypeNameResolver eventTypeNameResolver,
string statementName,
TypeRepresentationMapper optionalMapper)
{
var fields = new JArray();
foreach (var prop in mapEventType.Types) {
AssembleField(
prop.Key,
prop.Value,
fields,
annotations,
avroSettings,
eventTypeNameResolver,
statementName,
optionalMapper);
}
return SchemaBuilder.Record(mapEventType.Name, fields);
}
internal static void AssembleField(
string propertyName,
Object propertyType,
JArray assembler,
Attribute[] annotations,
ConfigurationEngineDefaults.AvroSettings avroSettings,
EventAdapterService eventAdapterService,
string statementName,
string engineURI,
TypeRepresentationMapper optionalMapper)
{
if (propertyName.Contains("."))
{
throw new EPException(
"Invalid property name as Avro does not allow dot '.' in field names (property '" + propertyName +
"')");
}
Schema schema = GetAnnotationSchema(propertyName, annotations);
if (schema != null)
{
assembler.Add(TypeBuilder.Field(propertyName, schema));
// assembler.Name(propertyName).Type(schema).NoDefault();
return;
}
if (optionalMapper != null && propertyType is Type)
{
var result = (Schema) optionalMapper.Map(
new TypeRepresentationMapperContext(
(Type) propertyType, propertyName, statementName, engineURI));
if (result != null)
{
assembler.Add(TypeBuilder.Field(propertyName, result));
// assembler.Name(propertyName).Type(result).NoDefault();
return;
}
}
if (propertyType == null)
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Null()));
// assembler.Name(propertyName).Type("null");
}
else if (propertyType is string)
{
string propertyTypeName = propertyType.ToString();
bool isArray = EventTypeUtility.IsPropertyArray(propertyTypeName);
if (isArray)
{
propertyTypeName = EventTypeUtility.GetPropertyRemoveArray(propertyTypeName);
}
// Add EventType itself as a property
EventType eventType = eventAdapterService.GetEventTypeByName(propertyTypeName);
if (!(eventType is AvroEventType))
{
throw new EPException(
"Type definition encountered an unexpected property type name '"
+ propertyType + "' for property '" + propertyName +
"', expected the name of a previously-declared Avro type");
}
schema = ((AvroEventType) eventType).SchemaAvro;
if (!isArray)
{
assembler.Add(TypeBuilder.Field(propertyName, schema));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(schema)));
}
}
else if (propertyType is EventType)
{
var eventType = (EventType) propertyType;
CheckCompatibleType(eventType);
if (eventType is AvroEventType)
{
schema = ((AvroEventType) eventType).SchemaAvro;
assembler.Add(TypeBuilder.Field(propertyName, schema));
}
else if (eventType is MapEventType)
{
var mapEventType = (MapEventType) eventType;
var nestedSchema = AssembleNestedSchema(
mapEventType, avroSettings, annotations, eventAdapterService, statementName, engineURI,
optionalMapper);
assembler.Add(TypeBuilder.Field(propertyName, nestedSchema));
}
else
{
throw new IllegalStateException("Unrecognized event type " + eventType);
}
}
else if (propertyType is EventType[])
{
EventType eventType = ((EventType[]) propertyType)[0];
CheckCompatibleType(eventType);
if (eventType is AvroEventType)
{
schema = ((AvroEventType) eventType).SchemaAvro;
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(schema)));
}
else if (eventType is MapEventType)
{
var mapEventType = (MapEventType) eventType;
var nestedSchema = AssembleNestedSchema(
mapEventType, avroSettings, annotations, eventAdapterService, statementName, engineURI,
optionalMapper);
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(nestedSchema)));
}
else
{
throw new IllegalStateException("Unrecognized event type " + eventType);
}
}
else if (propertyType is Type)
{
var propertyClass = (Type) propertyType;
var propertyClassBoxed = propertyClass.GetBoxedType();
bool nullable = propertyClass == propertyClassBoxed;
bool preferNonNull = avroSettings.IsEnableSchemaDefaultNonNull;
if (propertyClassBoxed == typeof (bool?))
{
AssemblePrimitive(nullable, REQ_BOOLEAN, OPT_BOOLEAN, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (int?) || propertyClassBoxed == typeof (byte?))
{
AssemblePrimitive(nullable, REQ_INT, OPT_INT, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (long?))
{
AssemblePrimitive(nullable, REQ_LONG, OPT_LONG, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (float?))
{
AssemblePrimitive(nullable, REQ_FLOAT, OPT_FLOAT, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (double?))
{
AssemblePrimitive(nullable, REQ_DOUBLE, OPT_DOUBLE, assembler, propertyName, preferNonNull);
}
else if (propertyClass == typeof (string))
{
if (avroSettings.IsEnableNativeString)
{
if (preferNonNull)
{
assembler.Add(
TypeBuilder.Field(propertyName,
TypeBuilder.Primitive("string",
TypeBuilder.Property(AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE))));
}
else
{
assembler.Add(
TypeBuilder.Field(
propertyName,
TypeBuilder.Union(
TypeBuilder.Null(),
TypeBuilder.String(
TypeBuilder.Property(
AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE)))));
}
}
else
{
AssemblePrimitive(nullable, REQ_STRING, OPT_STRING, assembler, propertyName, preferNonNull);
}
}
else if (propertyClass == typeof (byte[]))
{
if (preferNonNull)
{
assembler.Add(TypeBuilder.RequiredBytes(propertyName));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.Null(), TypeBuilder.Bytes())));
}
}
else if (propertyClass.IsArray)
{
var componentType = propertyClass.GetElementType();
var componentTypeBoxed = componentType.GetBoxedType();
var nullableElements = componentType == componentTypeBoxed;
if (componentTypeBoxed == typeof (bool?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_BOOLEAN, ARRAY_OF_OPT_BOOLEAN, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (int?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_INT, ARRAY_OF_OPT_INT, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (long?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_LONG, ARRAY_OF_OPT_LONG, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (float?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_FLOAT, ARRAY_OF_OPT_FLOAT, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof(double?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_DOUBLE, ARRAY_OF_OPT_DOUBLE, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (byte?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_INT, ARRAY_OF_OPT_INT, assembler, propertyName, preferNonNull);
}
else if (propertyClass == typeof (string[]))
{
JObject array;
if (avroSettings.IsEnableNativeString)
{
array = TypeBuilder.Array(TypeBuilder.String(TypeBuilder.Property(
AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE)));
}
else
{
array = TypeBuilder.Array(TypeBuilder.String());
}
if (preferNonNull)
{
assembler.Add(TypeBuilder.Field(propertyName, array));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.Null(), array)));
}
}
else if (propertyClass.CanUnwrap<object>())
{
}
else
{
throw MakeEPException(propertyName, propertyType);
}
}
else if (propertyClass.IsGenericDictionary())
{
JToken value;
if (avroSettings.IsEnableNativeString)
{
value = TypeBuilder.String(
TypeBuilder.Property(AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE));
}
else
{
value = TypeBuilder.String();
}
if (preferNonNull)
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Map(value)));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.Null(), TypeBuilder.Map(value))));
}
}
else if (propertyClass.IsGenericCollection())
{
AssembleFieldForCollection(propertyName, propertyType, assembler, avroSettings, propertyClass, preferNonNull);
}
else
{
throw MakeEPException(propertyName, propertyType);
}
}
else
{
throw MakeEPException(propertyName, propertyType);
}
}
