public void ExactNameAndExplicitConversionTypeMatching() { var source = new A() { Double = 11 }; var mapper = new Mapper(cfg => { var matching = new MatchingRules(); cfg.Conventions.GetOrAdd <DefaultConvention>(convention => { convention.MatchingRules.GetOrAdd <ExactNameMatching>() .GetOrAdd <TypeMatchingRule>(ruleCfg => ruleCfg.AllowExplicitConversions = false); }); }); var result = mapper.Map <B>(source); Assert.IsTrue(result.Double == 0); var mapper2 = new Mapper(cfg => { cfg.Conventions.GetOrAdd <DefaultConvention>(convention => { convention.MatchingRules.GetOrAdd <ExactNameMatching>() .GetOrAdd <TypeMatchingRule>(ruleCfg => ruleCfg.AllowExplicitConversions = true); }); }); result = mapper2.Map <B>(source); Assert.IsTrue(result.Double == 11); }
internal void SetEmptyValuesToNull() { ProviderStates = ProviderStates?.FirstOrDefault() != null ? ProviderStates : null; if (MatchingRules != null) { MatchingRules.SetEmptyValuesToNull(); } }
protected MatchingRules FindRulesThatCanFire(Tag tagToMatch, Namespace data) { var result = new MatchingRules(); var rulesForTag = rules.GetRules(tagToMatch); if (rulesForTag != null) { int lastMatchingPriority = int.MinValue; foreach (RuleBase rule in rulesForTag) { // Rules should be stored in decreasing priority, so as soon as we find a priority lower than // a valid match, we know to stop looking. if (rule.Priority < lastMatchingPriority) { break; } // If the tag has no hashtags, it doesn't care, if it does, at least one must be present. if (tagToMatch.HashTags.Count > 0 && !tagToMatch.HashTags.Overlaps(rule.HashTags)) { continue; } // The rule can have arbitrary additional requirements (like if-clauses). if (!rule.CanFire(tagToMatch, data)) { continue; } result.Add(rule); result.totalFrequency += rule.Frequency; // Only increase the matched priority. if (rule.MinPriority > lastMatchingPriority) { lastMatchingPriority = rule.MinPriority; } } } return(result); }
public string Run(TagBase tag, Namespace data = null) { if (!tag.IsRecursive) { return(RunNonRecursiveTag(tag as NonRecursiveTag, data)); } else { Tag tagToReplace = tag as Tag; MatchingRules matchingRules = FindRulesThatCanFire(tagToReplace, data); if (matchingRules.Count == 0) { return(tagToReplace.ToString()); } else { RuleBase ruleToFire = matchingRules.ChooseRuleToFire(random); return(FireRuleOnTag(ruleToFire, tagToReplace, data)); } } }
public void SuffixMatching() { //Property -> DtoProperty var source2 = new TestClass() { Property = 11 }; var mapper2 = new Mapper(cfg => { var matching = new MatchingRules(); cfg.Conventions.GetOrAdd <DefaultConvention>(convention => { convention.MatchingRules.GetOrAdd <SuffixMatching>(); }); }); var result2 = mapper2.Map <SuffixTestClass>(source2); Assert.IsTrue(source2.Property == result2.PropertyDto); //DtoProperty -> Property var source = new SuffixTestClass() { PropertyDto = 11 }; var mapper = new Mapper(cfg => { var matching = new MatchingRules(); cfg.Conventions.GetOrAdd <DefaultConvention>(convention => { convention.MatchingRules.GetOrAdd <SuffixMatching>(); }); }); var result = mapper.Map <TestClass>(source); Assert.IsTrue(source.PropertyDto == result.Property); }