/// <inheritdoc />
public override IASSourceMapper GetASSourceMapper(ASSourceMappingDescriptor descriptor)
{
foreach (PrimitiveMapper mapper in mappers)
if (mapper.SupportsSourceMapping(descriptor))
return mapper;
return null;
}
/// <inheritdoc />
public override IASSourceMapper GetASSourceMapper(ASSourceMappingDescriptor descriptor)
{
if (descriptor.SourceKind == ASTypeKind.Object)
{
ActionScriptClassMapping classMapping = mappingTable.GetClassMappingByAlias(descriptor.SourceClassAlias);
if (classMapping != null && descriptor.TargetNativeType.IsAssignableFrom(classMapping.NativeType))
{
return new ObjectMapper(classMapping);
}
}
return null;
}
/// <summary>
/// Gets an ActionScript source mapper that satisfies the specified descriptor.
/// </summary>
/// <param name="descriptor">The source mapping descriptor</param>
/// <returns>The ActionScript target mapper, or null if no compatible mapper can be obtained by any registered factory</returns>
public IASSourceMapper GetASSourceMapper(ASSourceMappingDescriptor descriptor)
{
lock (syncRoot)
{
IASSourceMapper mapper;
if (!sourceMapperCache.TryGetValue(descriptor, out mapper))
{
foreach (IASMapperFactory factory in mapperFactories)
{
mapper = factory.GetASSourceMapper(descriptor);
if (mapper != null)
break;
}
sourceMapperCache.Add(descriptor, mapper);
}
return mapper;
}
}
private object UncachedToNative(IASValue asValue, Type nativeType)
{
ASTypeKind kind = asValue.Kind;
ASClass asClass = asValue.Class;
string classAlias = asClass != null ? asClass.ClassAlias : "";
ASValueContentFlags contentFlags = asValue.ContentFlags;
Type defaultNativeType = mappingTable.GetDefaultNativeType(kind, classAlias, contentFlags);
// If the requested native type is not as precise as the default native type,
// then use the default native type instead. This rule is intended to avoid
// the ambiguities that occur if we try to map to type "object" or some other
// type that is too general.
if (nativeType == null || nativeType.IsAssignableFrom(defaultNativeType))
{
nativeType = defaultNativeType;
}
// Quick short circuit if the desired type is a subtype of IASValue so mapping won't help.
if (!typeof(IASValue).IsAssignableFrom(nativeType))
{
// Note: This will handle uninitialized values by returning null if no trivial
// conversion is possible without complete initialization.
object value = asValue.GetNativeValue(nativeType);
if (value != null)
{
return(value);
}
// If the value isn't initialized then give up because we might have to do mapping.
if (!asValue.IsInitialized)
{
throw new ActionScriptException(String.Format(CultureInfo.CurrentCulture,
"The ActionScript value cannot be mapped to type '{0}' because it is not completely initialized.",
nativeType != null ? nativeType.FullName : "<default>"));
}
// Use mappers.
// FIXME: This won't work if mapping ends up being recursive!
ASSourceMappingDescriptor descriptor = new ASSourceMappingDescriptor(kind, classAlias, contentFlags, nativeType);
IASSourceMapper mapper = mappingTable.GetASSourceMapper(descriptor);
if (mapper != null)
{
return(mapper.ToNative(this, asValue, nativeType));
}
}
// Apply default handling for null references.
if (asValue == ASNull.Value && !nativeType.IsValueType)
{
return(null);
}
// As a last resort, if we can assign the AS value to the original type requested then
// do so. We generally prefer mappings over returning IASValue instances, but if there
// is no other choice...
if (nativeType.IsInstanceOfType(asValue))
{
return(asValue);
}
// Give up!
throw new ActionScriptException(String.Format(CultureInfo.CurrentCulture,
"Cannot find a suitable mapper for mapping an ActionScript value of kind '{0}' with class alias '{1}' to an instance of type '{2}'.",
asValue.Kind, classAlias, nativeType != null ? nativeType.FullName : "<default>"));
}
/// <summary>
/// Gets an ActionScript source mapper that satisfies the specified descriptor.
/// </summary>
/// <param name="descriptor">The source mapping descriptor</param>
/// <returns>The ActionScript target mapper, or null if no compatible mapper can be obtained by this factory</returns>
public virtual IASSourceMapper GetASSourceMapper(ASSourceMappingDescriptor descriptor)
{
return null;
}
public override bool SupportsSourceMapping(ASSourceMappingDescriptor descriptor)
{
ASTypeKind sourceKind = descriptor.SourceKind;
return descriptor.TargetNativeType.IsEnum
&& (sourceKind == ASTypeKind.Int29 || sourceKind == ASTypeKind.Number || sourceKind == ASTypeKind.String);
}
public virtual bool SupportsSourceMapping(ASSourceMappingDescriptor descriptor)
{
// Note: Use strict equality here because we don't want to use
// most primitive mappings if the result type is underspecified.
// How would we know whether to map to "int" or "long"? The mapping
// would be ambiguous! Instead we handle this case with default native type
// mappings elsewhere.
if (descriptor.TargetNativeType == type)
{
foreach (ASTypeKind kind in kinds)
if (descriptor.SourceKind == kind)
return true;
}
return false;
}
