/// <summary>
/// Maps the specified arguments to parameters.
/// </summary>
/// <param name="arguments">The arguments.</param>
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
public MappingResult Map(IEnumerable <KeyValuePair <string, object> > arguments, IEnumerable <ArgumentInfo> parameters)
{
// Prepare
var result = new MappingResult();
if (arguments == null)
{
arguments = new List <KeyValuePair <string, object> >();
}
if (parameters == null)
{
parameters = new List <ArgumentInfo>();
}
// Map
var mapped = parameters.GroupJoin(arguments.DefaultIfEmpty(), x => x.Name, x => x.Key, (x, y) => new Tuple <ArgumentInfo, object>(x, y.ToList().FirstOrDefault().Value)).ToList();
var missing = mapped.Where(x => x.Item1.DefaultValue == null && x.Item2 == null).ToList();
var defaultMissing = mapped.Where(x => x.Item1.DefaultValue != null && x.Item2 == null).ToList();
result.MissingDefaultArguments = defaultMissing.Select(x => x.Item1).ToList();
// Has missing
if (missing.Any())
{
result.State = ResultState.MissingArguments;
result.MissingArguments = missing.Select(x => x.Item1).ToList();
return(result);
}
// Result
result.State = ResultState.Success;
result.ResultArguments = mapped.Select(x => DataCastUtil.Convert(x.Item2?.ToString() ?? x.Item1.DefaultValue?.ToString(), x.Item1.Type)).ToList();
return(result);
}
protected override ISourceInfo ResolveSourceValue(MappingMemberInfo memberInfo)
{
var sourceValue = memberInfo.SourceInstance;
var srcPropMap =
memberInfo.Attributes.FirstOrDefault(x => x is MapSourcePropertyAttribute) as MapSourcePropertyAttribute;
object propValue = null;
MappingResult result = MappingResult.NotResolved;
if (srcPropMap.Name != null && srcPropMap.Path != null)
{
throw new PropertyMappingException(memberInfo.Type.FullName, memberInfo.Name,
"Either Name or Path in the MapSourcePropertyAttribute should be set.");
}
if (!string.IsNullOrWhiteSpace(srcPropMap.Name))
{
return(GetPropertyByName(memberInfo, srcPropMap, sourceValue));
}
if (!string.IsNullOrWhiteSpace(srcPropMap.Path))
{
return(GetProperyByPath(srcPropMap, sourceValue));
}
return(null);
}
/// <summary>
/// Emit the constuctor code.
/// </summary>
void EmitConstructor(TypeBuilder type, MappingResult result)
{
ConstructorBuilder constructor =
type.DefineConstructor(MethodAttributes.Public |
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName,
CallingConventions.Standard, Type.EmptyTypes);
// Calls the constructor of the base class DataReaderMapper
ConstructorInfo data_reader_mapper_ctor = typeof(DataReaderMapper <T>)
.GetConstructor(
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance,
null, Type.EmptyTypes, null);
ILGenerator il = constructor.GetILGenerator();
il.Emit(OpCodes.Ldarg_0); // load "this" pointer
il.Emit(OpCodes.Call, data_reader_mapper_ctor); // call default ctor
// Create the array that will store the column ordinals.
result.OrdinalsField = type
.DefineField("ordinals_", typeof(int[]), FieldAttributes.Private);
result.LoaderField = typeof(DataReaderMapper <T>)
.GetField("loader_", BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance);
// return from the constructor
il.Emit(OpCodes.Ret);
}
public TenantContext(TTenant tenant, ResolutionResult resolutionResult, MappingResult mappingResult, ResolutionType resolvedType)
{
Tenant = tenant;
ResolutionResult = resolutionResult;
MappingResult = mappingResult;
ResolutionType = resolvedType;
}
OrdinalMap[] EmitOrdinals(ILGenerator il, MappingResult result)
{
ValueMap[] fields = result.ValueMappings;
OrdinalMap[] ordinals_mapping = new OrdinalMap[fields.Length];
if (fields.Length > 0)
{
MethodInfo get_ordinal_method =
Dynamics_.GetDataReaderMethod("GetOrdinal");
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldc_I4, fields.Length);
il.Emit(OpCodes.Newarr, typeof(int));
il.Emit(OpCodes.Stfld, result.OrdinalsField);
for (int i = 0, j = fields.Length; i < j; i++)
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, result.OrdinalsField);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldstr, fields[i].Key);
il.Emit(OpCodes.Callvirt, get_ordinal_method);
il.Emit(OpCodes.Stelem_I4);
ordinals_mapping[i] =
new OrdinalMap(i, fields[i].Value, fields[i].RawType)
{
Conversor = fields[i].Conversor
};
}
}
return(ordinals_mapping);
}
private void LogError(string message, ODM2ConverterSourceLocation location)
{
var resultLevel = ResultLevel.ERROR;
var result = new MappingResult(resultLevel, message, location);
_iResults.Add(result);
}
protected void Configure(PatcheetahConfig config)
{
config.EnableNestedPatching();
config.EnableAttributes();
config.SetPrePatchProcessingFunction(context =>
{
if (context.NewValue is int age && age == 0)
{
return(18);
}
return(context.NewValue);
});
config
.ConfigureEntity <User>()
.UseMapping(x => x.Username, x =>
{
if (x == "convertme")
{
return(MappingResult.MapTo($"{x}_1"));
}
return(MappingResult.Skip(x));
})
// .Required(x => x.LastSeenFrom) -> we don't need this anymore. Instead of method setup, we'll install it from attribute
// .IgnoreOnPatching(x => x.Username) -> Same situation, let's install it from attribute
.SetKey(x => x.Username); // Set login as key but replace it by id from attributes
}
public static void WriteJson(this MappingResult value, Utf8JsonWriter writer)
{
switch (value)
{
case MappingResult.NotParsable: JsonSerializer.Serialize(writer, "notParsable"); break;
case MappingResult.Success: JsonSerializer.Serialize(writer, "success"); break;
case MappingResult.TitleNotFound: JsonSerializer.Serialize(writer, "titleNotFound"); break;
}
}
private static MappingResult FindProp(Dictionary <string, MappingResult> map, string propName)
{
MappingResult retVal = null;
foreach (string name in map.Keys)
{
if (name.Equals(propName, StringComparison.InvariantCultureIgnoreCase))
{
retVal = map[name];
break;
}
}
return(retVal);
}
private static void RegisterMapProp <T>(string entityName, MappingResult iCalName)
{
List <Dictionary <string, MappingResult> > map;
if (!_mappingDef.TryGetValue(typeof(T), out map))
{
map = new List <Dictionary <string, MappingResult> >();
map.Add(new Dictionary <string, MappingResult>());
map.Add(new Dictionary <string, MappingResult>());
_mappingDef.Add(typeof(T), map);
}
Dictionary <string, MappingResult> entity2iCal = map[0];
Dictionary <string, MappingResult> iCal2Entity = map[1];
entity2iCal.Add(entityName, iCalName);
iCal2Entity.Add(iCalName.Name, new MappingResult(entityName, iCalName.ValueType));
}
void GetMappings(PropertyInfo[] properties, MappingResult result)
{
List <ValueMap> value_mappings =
new List <ValueMap>(properties.Length);
List <ConstantMap> const_mappings =
new List <ConstantMap>(properties.Length);
for (int i = 0, j = properties.Length; i < j; i++)
{
PropertyInfo property = properties[i];
ITypeMap mapping;
// If a custom map was not defined, maps to the name of the property
// if auto map is enabled, ignoring if not.
if (!mappings_.TryGetValue(property.Name, out mapping))
{
mapping = auto_map_
? (ITypeMap) new StringTypeMap(property.Name)
: new IgnoreMapType(property.Name);
}
if (mapping.MapType == TypeMapType.Ignore || IsReferenceType(property))
{
mapping = new IgnoreMapType(GetDefaultValue(property.PropertyType));
const_mappings.Add(new ConstantMap(mapping, property));
}
else if (mapping.MapType == TypeMapType.String)
{
var map = mapping as StringTypeMap;
value_mappings.Add(
new ValueMap((string)map.Value, property, map.RawType)
{
Conversor = map.Conversor
});
}
else
{
const_mappings.Add(new ConstantMap(mapping, property));
}
}
result.ValueMappings = value_mappings.ToArray();
result.ConstantMappings = const_mappings.ToArray();
}
/// <summary>
/// Generates the dynamic type for <typeparamref source="T"/>.
/// </summary>
/// <returns>
/// The dynamic type for <typeparamref source="T"/>.
/// </returns>
/// <remarks>
/// The type is dynamically created and added to the current
/// <see cref="AppDomain"/>.
/// </remarks>
Type MakeDynamicType(string dynamic_type_name)
{
TypeBuilder builder;
try {
builder = Dynamics_.ModuleBuilder.DefineType(
dynamic_type_name,
TypeAttributes.Public |
TypeAttributes.Class |
TypeAttributes.AutoClass |
TypeAttributes.AutoLayout,
typeof(DataReaderMapper <T>),
new Type[] {
typeof(IDataReaderMapper <T>)
});
} catch (ArgumentException) {
// Check if the type was created by another thread.
Type type = Dynamics_.ModuleBuilder.GetType(dynamic_type_name);
if (type == null)
{
throw;
}
return(type);
}
PropertyInfo[] properties = GetProperties();
MappingResult result = new MappingResult();
// Get the mappings for the properties that return value types.
GetMappings(properties, result);
EmitConstructor(builder, result);
EmitGetOrdinals(builder, result);
//EmitConversors(builder, result);
EmitNewT(builder);
EmitMapMethod(builder, result);
OnPreCreateType(builder);
return(builder.CreateType());
}
public MappingResult <MappedPart> MapItem(LddPart source)
{
var result = new MappingResult <MappedPart>();
var mapped = new MappedPart();
var itemDetails = GetPart(source);
if (itemDetails == null)
{
result.WasSuccessful = false;
result.Message = string.Format("Unable to locate part mapping.");
return(result);
}
mapped.ItemId = itemDetails.ItemId;
var colorId = GetColorId(source);
if (!colorId.HasValue)
{
result.WasSuccessful = false;
result.Message = string.Format("Unable to locate color mapping.");
return(result);
}
mapped.ColorId = colorId.Value;
if (!string.IsNullOrWhiteSpace(source.Decoration) && source.Decoration != "0")
{
result.WasSuccessful = false;
result.Message = string.Format("Decorated elements are not currently supported.");
return(result);
}
result.Mapped = mapped;
result.WasSuccessful = true;
return(result);
}
public void Setup()
{
ParseMovieTitle();
_pass1 = new Mock <IDecisionEngineSpecification>();
_pass2 = new Mock <IDecisionEngineSpecification>();
_pass3 = new Mock <IDecisionEngineSpecification>();
_fail1 = new Mock <IDecisionEngineSpecification>();
_fail2 = new Mock <IDecisionEngineSpecification>();
_fail3 = new Mock <IDecisionEngineSpecification>();
_pass1.Setup(c => c.IsSatisfiedBy(It.IsAny <RemoteMovie>(), null)).Returns(Decision.Accept);
_pass2.Setup(c => c.IsSatisfiedBy(It.IsAny <RemoteMovie>(), null)).Returns(Decision.Accept);
_pass3.Setup(c => c.IsSatisfiedBy(It.IsAny <RemoteMovie>(), null)).Returns(Decision.Accept);
_fail1.Setup(c => c.IsSatisfiedBy(It.IsAny <RemoteMovie>(), null)).Returns(Decision.Reject("fail1"));
_fail2.Setup(c => c.IsSatisfiedBy(It.IsAny <RemoteMovie>(), null)).Returns(Decision.Reject("fail2"));
_fail3.Setup(c => c.IsSatisfiedBy(It.IsAny <RemoteMovie>(), null)).Returns(Decision.Reject("fail3"));
_reports = new List <ReleaseInfo> {
new ReleaseInfo {
Title = "Trolls.2016.720p.WEB-DL.DD5.1.H264-FGT"
}
};
_remoteEpisode = new RemoteMovie
{
Movie = new Movie(),
ParsedMovieInfo = new ParsedMovieInfo()
};
_mappingResult = new MappingResult {
Movie = new Movie(), MappingResultType = MappingResultType.Success
};
_mappingResult.RemoteMovie = _remoteEpisode;
Mocker.GetMock <IParsingService>()
.Setup(c => c.Map(It.IsAny <ParsedMovieInfo>(), It.IsAny <string>(), It.IsAny <SearchCriteriaBase>())).Returns(_mappingResult);
}
private TenantMapResult(MappingResult mappingResult)
{
MappingResult = mappingResult;
Value = default;
ErrorMessage = "";
}
public async Task Invoke(HttpContext httpContext, ITenantResolverService tenantResolverService, ITenantMapperService <TTenantMapping> tenantMapperService,
ITenantInfoService <TTenant> tenantInfoService)
{
TenantContext <TTenant> _tenantContext = null;
TenantResolveResult _tenantResolveResult = null;
TenantMapResult <TTenantMapping> _tenantMapResult = null;
TTenant _tenant = default;
TTenantMapping _tenantMapping = default;
ResolutionResult _resolutionResult = ResolutionResult.NotFound;
MappingResult _mappingResult = MappingResult.NotFound;
ResolutionType _resolutionType = ResolutionType.Nothing;
string _tenantResolvedData = "";
_tenantResolveResult = await tenantResolverService.ResolveTenantAsync(httpContext);
_resolutionResult = _tenantResolveResult.ResolutionResult;
switch (_resolutionResult)
{
case ResolutionResult.Success:
_resolutionType = _tenantResolveResult.ResolutionType;
_tenantResolvedData = _tenantResolveResult.Value;
switch (_resolutionType)
{
case ResolutionType.TenantId:
_mappingResult = MappingResult.NotApply;
break;
case ResolutionType.TenantName:
_mappingResult = MappingResult.Success;
break;
}
break;
case ResolutionResult.NotApply:
_mappingResult = MappingResult.NotApply;
_tenantResolvedData = "";
break;
case ResolutionResult.NotFound:
_mappingResult = MappingResult.NotFound;
_tenantResolvedData = "";
break;
case ResolutionResult.Error:
_mappingResult = MappingResult.Error;
_tenantResolvedData = "";
break;
}
if (_resolutionResult == ResolutionResult.Success)
{
if (_mappingResult != MappingResult.NotApply) //if applies mapping call mapping service
{
_tenantMapResult = await tenantMapperService.MapTenantAsync(_tenantResolveResult.Value);
_mappingResult = _tenantMapResult.MappingResult;
switch (_mappingResult)
{
case MappingResult.Success:
_tenantMapping = _tenantMapResult.Value;
_tenantResolvedData = _tenantMapping.TenantId;
break;
case MappingResult.NotFound:
_tenantResolvedData = "";
_resolutionResult = ResolutionResult.NotFound;
_resolutionType = ResolutionType.Nothing;
break;
case MappingResult.Error:
_tenantResolvedData = "";
_resolutionResult = ResolutionResult.Error;
_resolutionType = ResolutionType.Nothing;
break;
}
}
//at this point it must be the id
if (!string.IsNullOrWhiteSpace(_tenantResolvedData))
{
_tenant = await tenantInfoService.GetTenantInfoAsync(_tenantResolvedData);
}
}
_tenantContext = new TenantContext <TTenant>(_tenant, _resolutionResult, _mappingResult, _resolutionType);
httpContext.SetTenantContext(_tenantContext);
await _next(httpContext);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="offset">Offset</param>
/// <param name="mapping">Mapping flags</param>
public ILFrameIP(uint offset, MappingResult mapping)
{
this.offset = offset;
this.mapping = mapping;
}
private IEnumerable <DownloadDecision> GetMovieDecisions(List <ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
{
if (reports.Any())
{
_logger.ProgressInfo("Processing {0} releases", reports.Count);
}
else
{
_logger.ProgressInfo("No results found");
}
var reportNumber = 1;
foreach (var report in reports)
{
DownloadDecision decision = null;
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
try
{
var parsedMovieInfo = _parsingService.ParseMovieInfo(report.Title, new List <object> {
report
});
MappingResult result = null;
if (parsedMovieInfo == null || parsedMovieInfo.MovieTitle.IsNullOrWhiteSpace())
{
_logger.Debug("{0} could not be parsed :(.", report.Title);
parsedMovieInfo = new ParsedMovieInfo
{
MovieTitle = report.Title,
Year = 1290,
Languages = new List <Language> {
Language.Unknown
},
Quality = new QualityModel(),
};
if (_configService.ParsingLeniency == ParsingLeniencyType.MappingLenient)
{
result = _parsingService.Map(parsedMovieInfo, report.ImdbId.ToString(), searchCriteria);
}
if (result == null || result.MappingResultType != MappingResultType.SuccessLenientMapping)
{
result = new MappingResult {
MappingResultType = MappingResultType.NotParsable
};
result.Movie = null; //To ensure we have a remote movie, else null exception on next line!
result.RemoteMovie.ParsedMovieInfo = parsedMovieInfo;
}
else
{
//Enhance Parsed Movie Info!
result.RemoteMovie.ParsedMovieInfo = Parser.Parser.ParseMinimalMovieTitle(parsedMovieInfo.MovieTitle,
result.RemoteMovie.Movie.Title, parsedMovieInfo.Year);
}
}
else
{
result = _parsingService.Map(parsedMovieInfo, report.ImdbId.ToString(), searchCriteria);
}
result.ReleaseName = report.Title;
var remoteMovie = result.RemoteMovie;
remoteMovie.Release = report;
remoteMovie.MappingResult = result.MappingResultType;
if (result.MappingResultType != MappingResultType.Success && result.MappingResultType != MappingResultType.SuccessLenientMapping)
{
var rejection = result.ToRejection();
decision = new DownloadDecision(remoteMovie, rejection);
}
else
{
if (parsedMovieInfo.Quality.HardcodedSubs.IsNotNullOrWhiteSpace())
{
//remoteMovie.DownloadAllowed = true;
if (_configService.AllowHardcodedSubs)
{
decision = GetDecisionForReport(remoteMovie, searchCriteria);
}
else
{
var whitelisted = _configService.WhitelistedHardcodedSubs.Split(',');
_logger.Debug("Testing: {0}", whitelisted);
if (whitelisted != null && whitelisted.Any(t => (parsedMovieInfo.Quality.HardcodedSubs.ToLower().Contains(t.ToLower()) && t.IsNotNullOrWhiteSpace())))
{
decision = GetDecisionForReport(remoteMovie, searchCriteria);
}
else
{
decision = new DownloadDecision(remoteMovie, new Rejection("Hardcoded subs found: " + parsedMovieInfo.Quality.HardcodedSubs));
}
}
}
else
{
//remoteMovie.DownloadAllowed = true;
decision = GetDecisionForReport(remoteMovie, searchCriteria);
}
}
}
catch (Exception e)
{
_logger.Error(e, "Couldn't process release.");
var remoteMovie = new RemoteMovie {
Release = report
};
decision = new DownloadDecision(remoteMovie, new Rejection("Unexpected error processing release"));
}
reportNumber++;
if (decision != null)
{
if (decision.Rejections.Any())
{
_logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections));
}
else
{
_logger.Debug("Release accepted");
}
yield return(decision);
}
}
}
void EmitGetOrdinals(TypeBuilder type, MappingResult result)
{
MethodBuilder builder = type
.DefineMethod("GetOrdinals",
MethodAttributes.Assembly | MethodAttributes.HideBySig |
MethodAttributes.Virtual, typeof(void),
new Type[] { typeof(IDataReader) });
ILGenerator il = builder.GetILGenerator();
// If there is nothing to be mapped, map nothing.
if (result.ValueMappings.Length == 0)
{
// Create an empty array to prevent the NoResultException to be throw
// by the Map method.
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Newarr, typeof(int));
il.Emit(OpCodes.Stfld, result.OrdinalsField);
result.OrdinalsMapping = new OrdinalMap[0];
}
else
{
// check if the ordinals is not already got.
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, result.OrdinalsField);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ceq);
Label label = il.DefineLabel();
il.Emit(OpCodes.Brtrue_S, label);
il.Emit(OpCodes.Ret);
il.MarkLabel(label);
// get the columns ordinals, using a try/catch block to prevent a
// InvalidOperationException to be throw when no recordset is returned.
il.BeginExceptionBlock();
result.OrdinalsMapping = EmitOrdinals(il, result);
//il.Emit(OpCodes.Leave, exit_try_label);
il.BeginCatchBlock(typeof(InvalidOperationException));
// remove the exception from the stack
il.Emit(OpCodes.Pop);
// set [ordinals_] to null
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Stfld, result.OrdinalsField);
il.EndExceptionBlock();
}
/*MethodInfo method_info =
* typeof (DataReaderMapper<T>).GetMethod("Initialize",
* BindingFlags.NonPublic | BindingFlags.Public |
* BindingFlags.Instance,
* null, new Type[] {typeof (IDataReader)}, null);*/
il.Emit(OpCodes.Ret);
}
void EmitMapMethod(TypeBuilder type, MappingResult result)
{
MethodBuilder builder = type
.DefineMethod("MapInternal",
MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.Virtual, typeof(T),
new Type[] { typeof(IDataReader) });
// define that the method is allowed to acess non-public members.
/*Type permission = typeof(ReflectionPermissionAttribute);
* ConstructorInfo ctor =
* permission
* .GetConstructor(new[] { typeof(SecurityAction) });
* PropertyInfo access = permission.GetProperty("Flags");
* var reflection_permission_attribute =
* new CustomAttributeBuilder(ctor, new object[] { SecurityAction.Demand },
* new[] { access },
* new object[] {
* ReflectionPermissionFlag.MemberAccess |
* ReflectionPermissionFlag.RestrictedMemberAccess
* });
*
* builder.SetCustomAttribute(reflection_permission_attribute);*/
ILGenerator il = builder.GetILGenerator();
// Create a new instance of the T using the associated class loader and
// stores in a local variable.
il.DeclareLocal(type_t_);
MethodInfo callable = typeof(CallableDelegate <T>).GetMethod("Invoke");
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, result.LoaderField);
il.Emit(OpCodes.Callvirt, callable);
il.Emit(OpCodes.Stloc_0);
// Set the value of the properties of the newly created T object.
OrdinalMap[] fields = result.OrdinalsMapping;
for (int i = 0, j = fields.Length; i < j; i++)
{
OrdinalMap field = fields[i];
int ordinal = field.Key;
PropertyInfo property = field.Value;
MethodInfo get_x_method =
Dynamics_.GetDataReaderMethod(
Dynamics_.GetDataReaderMethodName(field.RawType ??
property.PropertyType), data_reader_type_);
// Get the set method of the current property. If the property does
// not have a set method ignores it.
MethodInfo set_x_property = property.GetSetMethod(true);
if (set_x_property == null)
{
throw new ArgumentException(
"The property {0} does not have a set method.".Fmt(property.Name));
}
// loaded the "data transfer object"
il.Emit(OpCodes.Ldloc_0);
// if the conversor method is defined we need to load the
// "this" pointer onto the stack before the data reader, so we can
// chain the conversion method call after the value is retrieved
// from the data reader.
MethodInfo conversor = null;
if (field.Conversor != null)
{
conversor = (field.Conversor.Body as MethodCallExpression).Method;
if (!conversor.IsStatic || !conversor.IsPublic)
{
throw new ArgumentException(
"The \"conversor\" method of the property {0} is not static or public"
.Fmt(property.Name));
}
}
// loads the data reader
il.Emit(OpCodes.Ldarg_1);
// load the ordinals_ array
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, result.OrdinalsField);
// load the element of the array at |ordinal| position
EmitLoad(il, ordinal);
il.Emit(OpCodes.Ldelem_I4);
// call the "get...(int i)" method of the datareader
// -> i will be equals to the element loaded from the
// array at positiom "ordinal"
il.Emit(OpCodes.Callvirt, get_x_method);
// the stack now contains the returned value of "get...(int i)"
// method.
// convert the result of get method and...
if (conversor != null)
{
il.Emit(OpCodes.Call, conversor);
}
// store it on the loaded field.
il.Emit(OpCodes.Callvirt, set_x_property);
}
ConstantMap[] constant_maps = result.ConstantMappings;
for (int i = 0, j = constant_maps.Length; i < j; i++)
{
ITypeMap map = constant_maps[i].Key;
PropertyInfo property = constant_maps[i].Value;
if (map.MapType != TypeMapType.Ignore)
{
// Get the set method of the current property. If the property does
// not have a set method ignores it.
MethodInfo set_x_property = property.GetSetMethod(true);
if (set_x_property == null)
{
continue;
}
il.Emit(OpCodes.Ldloc_0);
EmitLoad(il, map);
il.Emit(OpCodes.Callvirt, set_x_property);
}
}
// load the local T and return.
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ret);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="offset">Offset</param>
/// <param name="mapping">Mapping flags</param>
public ILFrameIP(uint offset, MappingResult mapping)
{
this.Offset = offset;
this.Mapping = mapping;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="offset">Offset</param>
/// <param name="mapping">Mapping flags</param>
public ILFrameIP(uint offset, MappingResult mapping) {
Offset = offset;
Mapping = mapping;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="offset">Offset</param>
/// <param name="mapping">Mapping flags</param>
public ILFrameIP(uint offset, MappingResult mapping)
{
Offset = offset;
Mapping = mapping;
}
