/// <summary>
/// Tries to map the given instance into generic destination type using an specific key service.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="source">The source.</param>
/// <param name="keyService">The key service.</param>
/// <returns></returns>
public TDestination TryToMap <TSource, TDestination>(TSource source, object keyService)
{
object src = source;
if (src == null)
{
return(default(TDestination));
}
var serviceMapper =
this.mapperResolver.FirstOrDefault(
transformer => transformer.Match(keyService, typeof(TSource), typeof(TDestination)));
if (serviceMapper == null)
{
return(default(TDestination));
}
ISimpleMapper <TSource, TDestination> mapper = serviceMapper.ServiceAs <ISimpleMapper <TSource, TDestination> >();
if (mapper != null)
{
return(mapper.Map(source));
}
ISourceMapper mp = serviceMapper.ServiceAs <ISourceMapper>();
if (mp == null)
{
return(default(TDestination));
}
return((TDestination)mp.Map(source));
}
public void Test()
{
ISourceMapper <Student, Person> mapper1 = FactoryMapper.DynamicResolutionMapper <Student, Person>();
ISourceMapper mapper2 = FactoryMapper.DynamicResolutionMapper(typeof(PersonaGiuridica), typeof(PersonDetails));
ISourceMapper mapper3 = FactoryMapper.DynamicResolutionMapper(typeof(IPersonHeader), typeof(PersonDetails));
IList <IPropertyMapper <Student, Person> > propMappers = new List <IPropertyMapper <Student, Person> >
{
new PropertyMapper <Student, Person>((student, person) => person.Name = student.Name, "Name", "Name")
, new PropertyMapper <Student, Person>((student, person) => person.AnnoNascita = student.AnnoNascita)
, new PropertyMapper <Student, Person>((student, person) => person.Parent = student.Father)
};
SourceMapper <Student, Person> mapper4 = new SourceMapper <Student, Person>(propMappers, null, null);
StudentDetails example = new StudentDetails();
ServiceTransformer <ISourceMapper <Student, Person> > srv1 = new ServiceTransformer <ISourceMapper <Student, Person> >("default", mapper4);
var res1 = srv1.Match <ISourceMapper <Student, Person> >("default");
var res2 = srv1.Match <SourceMapper <Student, Person> >("default");
var res3 = srv1.Match <ISourceMapper <Student, Person> >("ss");
var res4 = srv1.Match <SourceMapper <Student, Person> >("ss");
var res5 = srv1.Match("default", example.GetType(), typeof(Person));
Assert.IsTrue(res1);
Assert.IsFalse(res2);
Assert.IsFalse(res3);
Assert.IsFalse(res4);
Assert.IsTrue(res5);
}
public VBScriptStringContentProvider(string code, ISourceMapper mapper)
{
ContractUtils.RequiresNotNull(code, "code");
_code = code;
_mapper = mapper;
}
//[Test]
public void TestReflection()
{
TransformerObserver a = new TransformerObserver();
ITransformerResolver aa = a;
ISourceMapper <Person, PersonaGiuridica> mapper0 = FactoryMapper.DynamicResolutionMapper <Person, PersonaGiuridica>();
SourceMapper <Person, PersonaGiuridica> mapper = new SourceMapper <Person, PersonaGiuridica>(new List <IPropertyMapper <Person, PersonaGiuridica> >(), null, null);
//aa.Register<ISourceMapper<Person, PersonaGiuridica>>(mapper);
//aa.Register(mapper0);
object obj1 = new Person();
object obj2 = new Person();
Type t1 = typeof(IPersonHeader);
Type t2 = typeof(Person);
try
{
object instance = 5.5;
//int i = (int) instance;
byte bb = Convert.ToByte(instance);
byte b = (byte)instance;
double d = (double)instance;
}
catch (Exception)
{
Assert.IsFalse(true, "Cast invalid");
}
Compare <IPersonHeader>(obj1, obj2);
//Compare<long>(1, 10);
}
public override ScriptCode CompileSourceCode(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink)
{
using (var reader = sourceUnit.GetReader()) {
try
{
switch (sourceUnit.Kind)
{
case SourceCodeKind.SingleStatement:
case SourceCodeKind.Expression:
case SourceCodeKind.AutoDetect:
case SourceCodeKind.InteractiveCode:
return(new VBScriptCode(
_vbscript, _vbscript.ParseExprToLambda(reader),
sourceUnit));
case SourceCodeKind.Statements:
case SourceCodeKind.File:
return(new VBScriptCode(
_vbscript,
_vbscript.ParseFileToLambda(sourceUnit.Path, reader),
sourceUnit));
default:
throw Assert.Unreachable;
}
}
catch (VBScriptCompilerException ex)
{
VBScriptSourceCodeReader vbscriptReader = reader as VBScriptSourceCodeReader;
if (vbscriptReader != null)
{
ISourceMapper mapper = vbscriptReader.SourceMapper;
if (mapper != null)
{
foreach (VBScriptSyntaxError error in ex.SyntaxErrors)
{
DocSpan docSpan = mapper.Map(error.Span);
error.FileName = docSpan.Uri;
error.Span = docSpan.Span;
}
}
}
throw ex;
}
catch (Exception e)
{
// Real language implementation would have a specific type
// of exception. Also, they would pass errorSink down into
// the parser and add messages while doing tighter error
// recovery and continuing to parse.
errorSink.Add(sourceUnit, e.Message, SourceSpan.None, 0,
Severity.FatalError);
return(null);
}
}
}
public void TestNonGenericMapper1()
{
ISourceMapper mapper = FactoryMapper.DynamicResolutionMapper(typeof(PersonaGiuridica), typeof(PersonDetails));
PersonaGiuridica person = new PersonaGiuridica
{
Code = "150",
Name = "Sergio",
Surname = "Hill",
AnnoNascita = 1980,
Parent = new Person {
Name = "fatherName", Surname = "fatherSurname", AnnoNascita = 1950
}
};
var result = mapper.Map(person);
Assert.IsNotNull(result);
}
public void TestMapperNonPublicMembers()
{
ISourceMapper <PersonaGiuridica, PersonDetails> mapper = FactoryMapper.DynamicResolutionMapper <PersonaGiuridica, PersonDetails>();
PersonaGiuridica person = new PersonaGiuridica
{
Code = "150",
Name = "Sergio",
Surname = "Hill",
AnnoNascita = 1980,
Parent = new Person {
Name = "fatherName", Surname = "fatherSurname", AnnoNascita = 1950
}
};
var result = mapper.Map(person);
Assert.IsNotNull(result);
}
public void TestMapper()
{
TransformerObserver observer = new TransformerObserver();
ISourceMapper <Student, Person> mapper1 = FactoryMapper.DynamicResolutionMapper <Student, Person>();
observer.RegisterMapper(mapper1);
Student st = new Student {
Name = "mario", Surname = "monti", AnnoNascita = 19
};
var res = observer.TryToMap <Student, Person>(st);
Assert.IsNotNull(res);
Assert.AreEqual(st.Name, res.Name);
Assert.AreEqual(st.Surname, res.Surname);
Assert.IsNull(st.Father);
Assert.IsNull(res.Parent);
}
/// <summary>
/// Tries to map the given instance into destination type using an specific key service.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destinationType">Type of the destination.</param>
/// <param name="keyService">The key service.</param>
/// <returns></returns>
public object TryToMap(object source, Type destinationType, object keyService)
{
if (source == null)
{
return(null);
}
var serviceMapper = this.mapperResolver.FirstOrDefault(
transformer => transformer.Match(keyService, source.GetType(), destinationType));
if (serviceMapper == null)
{
return(null);
}
ISourceMapper mapper = serviceMapper.ServiceAs <ISourceMapper>();
return(mapper.Map(source));
}
ParseExprToLambda(TextReader reader)
{
var scanner = new VB.Scanner(reader);
var errorTable = new List <VB.SyntaxError>();
var ast = new VB.Parser().ParseScriptFile(scanner, errorTable);
VBScriptSourceCodeReader sourceReader = reader as VBScriptSourceCodeReader;
ISourceMapper mapper = null;
if (sourceReader != null)
{
mapper = sourceReader.SourceMapper;
}
var scope = new AnalysisScope(
null,
"__snippet__",
this,
Expression.Parameter(typeof(VBScript), "vbscriptRuntime"),
Expression.Parameter(typeof(IDynamicMetaObjectProvider), "fileModule"),
mapper
);
List <Expression> body = new List <Expression>();
body.Add(Expression.Convert(VBScriptGenerator.GenerateExpr(ast, scope), typeof(object)));
if (scope.Errors.Count > 0)
{
throw new VBScriptCompilerException(scope.Errors);
}
var moduleFun = Expression.Lambda <Action <VBScript, IDynamicMetaObjectProvider> >(
Expression.Block(body),
scope.RuntimeExpr,
scope.ModuleExpr
);
return(moduleFun.Compile());
}
public AnalysisScope(AnalysisScope parent,
string name,
VBScript runtime,
ParameterExpression runtimeParam,
ParameterExpression moduleParam,
ISourceMapper mapper)
{
_parent = parent;
_name = name;
_runtime = runtime;
_runtimeParam = runtimeParam;
_moduleParam = moduleParam;
_mapper = mapper;
if (_moduleParam != null)
{
_functionTable = new Set <string>(StringComparer.InvariantCultureIgnoreCase);
_errors = new List <VBScriptSyntaxError>();
_docInfos = new Dictionary <string, SymbolDocumentInfo>();
}
_names = new Dictionary <string, ParameterExpression>();
}
ParseFileToLambda(string filename, TextReader reader)
{
var scanner = new VB.Scanner(reader);
var errorTable = new List <VB.SyntaxError>();
var block = new VB.Parser().ParseScriptFile(scanner, errorTable);
if (errorTable.Count > 0)
{
List <VBScriptSyntaxError> errors = new List <VBScriptSyntaxError>();
foreach (VB.SyntaxError error in errorTable)
{
errors.Add(new VBScriptSyntaxError(
filename,
SourceUtil.ConvertSpan(error.Span),
(int)error.Type,
error.Type.ToString())
);
}
throw new VBScriptCompilerException(errors);
}
VBScriptSourceCodeReader sourceReader = reader as VBScriptSourceCodeReader;
ISourceMapper mapper = null;
if (sourceReader != null)
{
mapper = sourceReader.SourceMapper;
}
var scope = new AnalysisScope(
null,
filename,
this,
Expression.Parameter(typeof(VBScript), "vbscriptRuntime"),
Expression.Parameter(typeof(IDynamicMetaObjectProvider), "fileModule"),
mapper);
//Generate function table
List <Expression> body = new List <Expression>();
//Add the built in globals
ParameterExpression err = Expression.Parameter(typeof(ErrObject), ERR_PARAMETER);
scope.Names.Add(ERR_PARAMETER, err);
body.Add(
Expression.Assign(
err,
Expression.New(typeof(ErrObject))
)
);
if (Trace)
{
ParameterExpression trace = Expression.Parameter(typeof(ITrace), TRACE_PARAMETER);
scope.Names.Add(TRACE_PARAMETER, trace);
body.Add(
Expression.Assign(
trace,
Expression.Convert(
Expression.Dynamic(
scope.GetRuntime().GetGetMemberBinder(TRACE_PARAMETER),
typeof(object),
scope.GetModuleExpr()
),
typeof(ITrace)
)
)
);
}
//Put module variables and functions into the scope
VBScriptAnalyzer.AnalyzeFile(block, scope);
//Generate the module level code other than the methods:
if (block.Statements != null)
{
foreach (var s in block.Statements)
{
if (s is VB.MethodDeclaration)
{
//Make sure methods are created first before being executed
body.Insert(0, VBScriptGenerator.GenerateExpr(s, scope));
}
else
{
Expression stmt = VBScriptGenerator.GenerateExpr(s, scope);
if (scope.VariableScope.IsOnErrorResumeNextOn)
{
stmt = VBScriptGenerator.WrapTryCatchExpression(stmt, scope);
}
Expression debugInfo = null;
Expression clearDebugInfo = null;
if (Trace && s is VB.Statement && !(s is VB.BlockStatement))
{
debugInfo = VBScriptGenerator.GenerateDebugInfo(s, scope, out clearDebugInfo);
body.Add(debugInfo);
}
body.Add(stmt);
if (clearDebugInfo != null)
{
body.Add(clearDebugInfo);
}
}
}
}
body.Add(Expression.Constant(null)); //Stop anything from returning
if (scope.Errors.Count > 0)
{
throw new VBScriptCompilerException(scope.Errors);
}
//if (Debug)
//{
// Expression registerRuntimeVariables = VBScriptGenerator.GenerateRuntimeVariablesExpression(scope);
// body.Insert(0, registerRuntimeVariables);
//}
var moduleFun = Expression.Lambda <Action <VBScript, IDynamicMetaObjectProvider> >(
Expression.Block(
scope.Names.Values,
body),
scope.RuntimeExpr,
scope.ModuleExpr);
//if (!Debug)
//{
return(moduleFun.Compile());
//}
//else
//{
// Expression<Action<VBScript, IDynamicMetaObjectProvider>> lambda = (Expression<Action<VBScript, IDynamicMetaObjectProvider>>)DebugContext.TransformLambda(moduleFun);
// return lambda.Compile();
//}
}
public VBScriptSourceCodeReader(TextReader textReader, Encoding encoding, ISourceMapper mapper)
: base(textReader, encoding)
{
_mapper = mapper;
}
