public virtual void AddSourceTargetSet(Transliterator transliterator, UnicodeSet inputFilter, UnicodeSet sourceSet,
UnicodeSet targetSet)
{
#pragma warning disable 612, 618
UnicodeSet myFilter = transliterator.GetFilterAsUnicodeSet(inputFilter);
#pragma warning restore 612, 618
UnicodeSet affectedCharacters = new UnicodeSet(sourceCache).RetainAll(myFilter);
sourceSet.AddAll(affectedCharacters);
foreach (string s in affectedCharacters)
{
targetSet.AddAll(transform.Transform(s));
}
foreach (string s in sourceStrings)
{
if (myFilter.ContainsAll(s))
{
string t = transform.Transform(s);
if (!s.Equals(t))
{
targetSet.AddAll(t);
sourceSet.AddAll(s);
}
}
}
}
public void Apply(IDocumentSession session, EventStream[] streams)
{
streams
.SelectMany(x => x.Events)
.OfType <Event <TEvent> >()
.Select(x => _transform.Transform(x))
.Each(x => session.Store(x));
}
public void A_string_scanner_with_a_transformer()
{
transformer = Substitute.For<ITransform>();
transformer.Transform('t').Returns('1');
transformer.Transform('h').Returns('2');
transformer.Transform('i').Returns('3');
subject = new ScanStrings(Input) {Transform = transformer};
}
public void Apply(IDocumentSession session)
{
session
.PendingChanges.AllChangedFor <EventStream>()
.SelectMany(x => x.Events)
.OfType <Event <TEvent> >()
.Select(x => _transform.Transform(x))
.Each(x => session.Store(x));
}
/// <summary>
/// Instantiates the object under test and then executes its transform function.
/// </summary>
/// <param name="element">The XElement to transform</param>
/// <returns>The transformed version of <paramref name="element"/></returns>
public XElement Transform(XElement element)
{
ITransform transform = Activator.CreateInstance(this._type) as ITransform;
XElement transformedElement = transform.Transform(element);
return(transformedElement);
}
/// <summary>
/// Runs the transform against the list of elements.
/// </summary>
/// <param name="elements">The elements to transform.</param>
/// <param name="transform">The transform containing the <see cref="ITransform.Transform"/>.</param>
/// <returns>The list of transformed nodes.</returns>
public static IEnumerable <XElement> RunTransform(IEnumerable <XElement> elements, ITransform transform)
{
foreach (var e in elements)
{
yield return(transform.Transform(new XElement(e)));
}
}
public RejectionMessageAndSuccess Transform([NotNull] IPolicy policy)
{
if (policy == null)
{
throw new ArgumentNullException(nameof(policy));
}
var policyDrivers = policy.Drivers.ToArray();
var policyStartDate = policy.StartDate;
var rejectionMessageAndSuccessBasedOnPolicyStartDate = _rejectionMessageAndSuccessBasedOnPolicyStartDateTransform.Transform(policyStartDate);
if (!rejectionMessageAndSuccessBasedOnPolicyStartDate.Success)
{
return(rejectionMessageAndSuccessBasedOnPolicyStartDate);
}
foreach (var driverBasedRejectionMessagesAndSuccessTransform in _driverBasedRejectionMessagesAndSuccessTransforms)
{
var rejectionMessageAndSuccess = driverBasedRejectionMessagesAndSuccessTransform.Transform(policyDrivers);
if (!rejectionMessageAndSuccess.Success)
{
return(rejectionMessageAndSuccess);
}
}
return(new RejectionMessageAndSuccess(string.Empty, true));
}
private static Stream TransformStream(Stream stream, string mapName, bool validate, ref string messageType, ref string targetDocumentSpecName)
{
Type type = Type.GetType(mapName);
if (null == type)
{
throw new Exception("Invalid MapType" + mapName);
}
TransformMetaData transformMetaData = TransformMetaData.For(type);
SchemaMetadata sourceSchemaMetadata = transformMetaData.SourceSchemas[0];
string schemaName = sourceSchemaMetadata.SchemaName;
SchemaMetadata targetSchemaMetadata = transformMetaData.TargetSchemas[0];
if (validate && string.Compare(messageType, schemaName, false, CultureInfo.CurrentCulture) != 0)
{
throw new Exception("Source Document Mismatch. MessageType: " + messageType + " Schema Name: " + schemaName);
}
messageType = targetSchemaMetadata.SchemaName;
targetDocumentSpecName = targetSchemaMetadata.SchemaBase.GetType().AssemblyQualifiedName;
XmlReader reader = XmlReader.Create(stream);
XPathDocument input = new XPathDocument(reader);
ITransform transform = transformMetaData.Transform;
Stream outStream = new MemoryStream();
transform.Transform(input, transformMetaData.ArgumentList, outStream, new XmlUrlResolver());
outStream.Flush();
outStream.Seek(0L, SeekOrigin.Begin);
return(outStream);
}
public Dictionary <string, Dictionary <string, string> > Parse(List <List <String> > lines)
{
List <List <String> > pages = _headerSkipers.Chain(lines);
// WARNING: To find values from header, the parsers are only applied
// on the first page, if a page number isn't specified
foreach (var page in pages.Select((Content, Number) => new { Number, Content }))
{
var parsers = FindPasersForPage(_headerParsers, page.Number, lines.Count);
if (parsers.Any())
{
ParseOnceInPage(parsers, page.Content);
}
}
if (_detailParsers != null && _detailParsers.Any())
{
// WARNING: Remove from the equation wrapping lines from page to the next
List <String> details = (_transform != null)
? _transform.Transform(pages)
: pages.SelectMany(t => t).ToList();
ParseInEveryLine(_detailParsers, details);
}
return(_output);
}
public string Transform(IPolicy policy)
{
if (policy == null)
{
throw new ArgumentNullException(nameof(policy));
}
var policyDrivers = policy.Drivers.ToArray();
var rejectionMessageAndSuccess = _policyToRejectionMessageAndSuccess.Transform(policy);
if (!rejectionMessageAndSuccess.Success)
{
return(rejectionMessageAndSuccess.RejectionMessage);
}
var premium = 0.00;
foreach (var policyDriver in policyDrivers)
{
var premiumUpdatedBasedOnOccupation = _driversAndPremiumToUpdatedPremiumBasedOnOccupationTransform.Transform(new DriverAndPremium(policyDriver, _startingPremium));
var premiumUpdatedBasedOnAge = _driversAndPremiumToUpdatedPremiumBasedOnAgeTransform.Transform(new DriverAndPremium(policyDriver, premiumUpdatedBasedOnOccupation));
var premiumBasedOnDriverClaims = _driversAndPremiumToUpdatedPremiumBasedOnDriverClaimsTransform.Transform(new DriverAndPremium(policyDriver, premiumUpdatedBasedOnAge));
premium += premiumBasedOnDriverClaims;
}
return($"Premium quotation is {premium}");
}
public void ApplyTransform(ITransform transform)
{
for (int i = 0; i < points.Count; i++)
{
points[i] = transform.Transform(points[i]);
}
}
/// <summary>
/// Transform all figures.
/// </summary>
/// <param name="circle"> Circle </param>
/// <param name="cube"> Cube </param>
/// <param name="pyramid"> Pyramid </param>
private static void TransformAllFigures(ITransform circle,
ITransform cube, ITransform pyramid)
{
circle.Transform(GetRandomNumber());
cube.Transform(GetRandomNumber());
pyramid.Transform(GetRandomNumber());
}
public void Transform(JObject input, ref JObject output)
{
foreach (var map in _mapping.Mappings)
{
ITransform trasns = TranformationFactory.GetTransforamtion(map.Type, map);
trasns.Transform(input, ref output);
}
}
public void Apply(IDocumentSession session, EventStream[] streams)
{
foreach (var stream in streams)
{
foreach (var @event in stream.Events.OfType <Event <TEvent> >())
{
session.Store(_transform.Transform(stream, @event));
}
}
}
public double ModelError(KeyValuePair <KeyPoint, KeyPoint> pair, Matrix <double> model)
{
KeyPoint pointA = pair.Key;
KeyPoint pointB = pair.Value;
KeyPoint transformedPoint = _transform.Transform(pointA, model);
return(Math.Sqrt((transformedPoint.CoordY - pointB.CoordY) * (transformedPoint.CoordY - pointB.CoordY)
+ (transformedPoint.CoordX - pointB.CoordX) * (transformedPoint.CoordX - pointB.CoordX)));
}
public async Task <ChuckNorrisFactViewModel> GetOneFactAsync()
{
var fact = await _service.GetOneFactAsync();
if (fact == null)
{
throw new NullFactsException("Something went wrong while gathering a fact. Fact is null");
}
return(_transformer.Transform(fact));
}
public Expression Transform(Expression E)
{
Expression TE;
if (cache.TryGetValue(E, out TE))
{
return(TE);
}
TE = transform.Transform(E);
cache[E] = TE;
return(TE);
}
public double Transform([NotNull] DriverAndPremium driverAndPremium)
{
if (driverAndPremium == null)
{
throw new ArgumentNullException(nameof(driverAndPremium));
}
var driver = driverAndPremium.Driver;
var potentiallyIncreasedPremium = _driversAndPremiumToIncreasedPremiumBasedOnOccupationTransform.Transform(driverAndPremium);
return(_driversAndPremiumToDecreasedPremiumBasedOnOccupationTransform.Transform(new DriverAndPremium(driver, potentiallyIncreasedPremium)));
}
public double Transform([NotNull] DriverAndPremium driverAndPremium)
{
if (driverAndPremium == null)
{
throw new ArgumentNullException(nameof(driverAndPremium));
}
var driver = driverAndPremium.Driver;
var updatedPremiumWhenDriversAreYoung = _driversAndPremiumToUpdatedPremiumForYoungDrivers.Transform(driverAndPremium);
var driversWithUpdatePremium = new DriverAndPremium(driver, updatedPremiumWhenDriversAreYoung);
var updatedPremiumWhenDriversAreAdults = _driversAndPremiumToUpdatedPremiumForAdultDrivers.Transform(driversWithUpdatePremium);
return(updatedPremiumWhenDriversAreAdults);
}
/// <summary>
/// Publishes a list of events to all registered network endpoints after
/// applying the required event format transforms. Stored events will be
/// deleted if publishing was successful for all registered endpoints.
/// This method should NOT be called from the main thread.
/// </summary>
/// <param name="events"></param>
/// <returns></returns>
public async Task PublishEventsAsync(List <InstrumentationEvent> events)
{
if (events == null || events.Count == 0)
{
return;
}
var eventIds = new List <string>();
var success = true;
var remoteKeySet = remotes.Keys;
foreach (var key in remoteKeySet)
{
ITransform transformer = key;
var eventsArray = new JArray();
if (transformer != null)
{
foreach (var instrumentationEvent in events)
{
eventIds.Add(instrumentationEvent.EventId);
var eventJson = transformer.Transform(instrumentationEvent);
if (eventJson != null)
{
eventsArray.Add(eventJson);
}
}
}
var networkPublisher = remotes[key];
if (networkPublisher != null)
{
var networkSuccess = await networkPublisher.PublishAsync(eventsArray);
/*
* Updates the success flag only if all previous requests have been
* successful. This ensures that the operation is marked success only
* if all publishers are successful.
*/
if (success)
{
success = networkSuccess;
}
}
}
if (success)
{
await eventStoreManager.DeleteEventsAsync(eventIds);
}
}
/*
* Menu handler for the transform menu items.
* Apply the corresponding Transformation on the selected types.
*/
void TransformSelection(object o, EventArgs args)
{
ITransform transformation = (o as ToolStripMenuItem).Tag as ITransform;
List <FieldInfo> newTypes = new List <FieldInfo> ();
List <FieldInfo> transformed = transformation.Transform(SelectedTypes);
bool added = false;
for (int i = 0; i < FieldTypes.Count; i++)
{
if (!typeList.SelectedIndices.Contains(i))
{
newTypes.Add(FieldTypes [i]);
}
else if (!added)
{
newTypes.AddRange(transformed);
added = true;
}
}
FieldTypes = newTypes;
}
public string Transform(string data)
{
return(tranform.Transform(data));
}
//Implementations
public object Execute(string json, object objectName)
{
return(_transform.Transform(json, objectName));
}
public SourceTargetUtility(ITransform <string, string> transform, Normalizer2 normalizer)
{
this.transform = transform;
if (normalizer != null)
{
// synchronized (SourceTargetUtility.class) {
// if (NFC == null) {
// NFC = Normalizer2.getInstance(null, "nfc", Mode.COMPOSE);
// for (int i = 0; i <= 0x10FFFF; ++i) {
// String d = NFC.getDecomposition(i);
// if (d == null) {
// continue;
// }
// String s = NFC.normalize(d);
// if (!CharSequences.equals(i, s)) {
// continue;
// }
// // composes
// boolean first = false;
// for (int trailing : CharSequences.codePoints(d)) {
// if (first) {
// first = false;
// } else {
// TRAILING_COMBINING.add(trailing);
// }
// }
// }
// }
// }
sourceCache = new UnicodeSet("[:^ccc=0:]");
}
else
{
sourceCache = new UnicodeSet();
}
sourceStrings = new HashSet <string>();
for (int i = 0; i <= 0x10FFFF; ++i)
{
string s = transform.Transform(UTF16.ValueOf(i));
bool added = false;
if (!CharSequences.Equals(i, s))
{
sourceCache.Add(i);
added = true;
}
if (normalizer == null)
{
continue;
}
string d = NFC.GetDecomposition(i);
if (d == null)
{
continue;
}
s = transform.Transform(d);
if (!d.Equals(s))
{
sourceStrings.Add(d);
}
if (added)
{
continue;
}
if (!normalizer.IsInert(i))
{
sourceCache.Add(i);
continue;
}
// see if any of the non-starters change s; if so, add i
// for (String ns : TRAILING_COMBINING) {
// String s2 = transform.transform(s + ns);
// if (!s2.startsWith(s)) {
// sourceCache.add(i);
// break;
// }
// }
// int endOfFirst = CharSequences.onCharacterBoundary(d, 1) ? 1 : 2;
// if (endOfFirst >= d.length()) {
// continue;
// }
// // now add all initial substrings
// for (int j = 1; j < d.length(); ++j) {
// if (!CharSequences.onCharacterBoundary(d, j)) {
// continue;
// }
// String dd = d.substring(0,j);
// s = transform.transform(dd);
// if (!dd.equals(s)) {
// sourceStrings.add(dd);
// }
// }
}
sourceCache.Freeze();
}
/// <summary>
/// Samples a new value within the specified parameter bounds.
/// </summary>
/// <param name="sampler"></param>
/// <returns></returns>
public double SampleValue(IParameterSampler sampler)
{
return(m_transform.Transform(Min, Max, m_parameterType, sampler));
}
/// <summary>
/// Runs the transform against the list of elements.
/// </summary>
/// <param name="elements">The elements to transform.</param>
/// <param name="transform">The transform containing the <see cref="ITransform.Transform"/>.</param>
/// <returns>The list of transformed nodes.</returns>
public static IEnumerable<XElement> RunTransform(IEnumerable<XElement> elements, ITransform transform)
{
foreach (var e in elements)
yield return transform.Transform(new XElement(e));
}
//Implementations
public object Execute(string xml, object objectName)
{
return(_transform.Transform(xml, objectName));
}
public void Apply(ITransform transforms)
{
m_dateTimes = transforms.Transform(this).DateTimes;
}
public override IRow Transform(IRow row)
{
return(Context.Transform.ShouldRun(row) ? _transform.Transform(row) : row);
}
/// <summary> /// Change size of figure. /// </summary> /// <param name="figure"> Figure </param> /// <param name="coefficient"> Coefficient </param> /// <returns> Figure with modified size </returns> private static void Mapping(ITransform figure, double coefficient) => figure.Transform(coefficient);
public JToken Transform(JToken input, JObject context)
{
return(_transform.Transform(input));
}
public static ITransform Mapping(ITransform g, double d)
{
g.Transform(d);
return(g);
}
