private void ResetValueEnter()
{
EditedTag = null;
ValueEnterMode = false;
SelectedComparator = Comparators.First();
EnteredValue = string.Empty;
}
public WBQueryClause(WBColumn column, Comparators comparator, Object value)
{
Column = column;
Comparator = comparator;
Value = value;
switch (Comparator)
{
case Comparators.Equals: { break; }
case Comparators.NotEquals: { break; }
case Comparators.LessThan: { break; }
case Comparators.LessThanEquals: { break; }
case Comparators.GreaterThan: { break; }
case Comparators.GreaterThanEquals: { break; }
case Comparators.IsNull: { break; }
case Comparators.IsNotNull: { break; }
default: throw new NotImplementedException("The selected comparator has not been implemented yet.");
}
UseDescendants = false;
}
public void TestExtractSingleLongTerm()
{
var nounPhrases = nounPhraseExtractor.Extract("The lovely red ironed rectangular Swiss flag.");
Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >();
Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases));
}
public void TestExtractSingleShortWord()
{
var nounPhrases = nounPhraseExtractor.Extract("There is a P.");
Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >();
Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases));
}
public void ShouldReturnTrueIfYearOldIsGreaterOrEqual18YearOld()
{
DateTime yerToCompare = DateTime.Now.AddYears(-18);
var result = Comparators.IsYearOldIsGreaterOrEqual18YearOld(yerToCompare);
Assert.IsTrue(result);
}
public Email(string address)
{
Address = address;
if (!Comparators.IsValidEmail(Address))
{
AddNotification("E-mail", $"O e-mail {Address} não possui um formato válido");
}
}
public Document(string number)
{
Number = number;
if (!Comparators.IsLengthEqualThan(number, Constraints.LengthDocument))
{
AddNotification(nameof(Number), $"O número do documento possui {number.Length}. Ele precisa ter o tamanho igual a {Constraints.LengthDocument}");
}
}
private void _validations()
{
if (Comparators.IsLengthLessThan(Street, Constraints.MinimumLengthStreet))
{
AddNotification(nameof(Street), $"O rua {Street} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthStreet}");
}
else if (Comparators.IsLengthGranThan(Street, Constraints.MaximumLengthStreet))
{
AddNotification(nameof(Street), $"O rua {Street} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthStreet}");
}
if (Comparators.IsLengthLessThan(Number, Constraints.MinimumLengthNumber))
{
AddNotification(nameof(Number), $"O número {Number} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthNumber}");
}
else if (Comparators.IsLengthGranThan(Number, Constraints.MaximumLengthNumber))
{
AddNotification(nameof(Number), $"O número {Number} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthNumber}");
}
if (Comparators.IsLengthLessThan(District, Constraints.MinimumLengthDistrict))
{
AddNotification(nameof(District), $"O Distrito {District} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthDistrict}");
}
else if (Comparators.IsLengthGranThan(District, Constraints.MaximumLengthDistrict))
{
AddNotification(nameof(District), $"O Distrito {District} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthDistrict}");
}
if (Comparators.IsLengthLessThan(City, Constraints.MinimumLengthCity))
{
AddNotification(nameof(City), $"A Cidade {City} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthCity}");
}
else if (Comparators.IsLengthGranThan(City, Constraints.MaximumLengthCity))
{
AddNotification(nameof(City), $"A Cidade {City} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthCity}");
}
if (Comparators.IsLengthLessThan(Country, Constraints.MinimumLengthCountry))
{
AddNotification(nameof(Country), $"O Pais {Country} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthCountry}");
}
else if (Comparators.IsLengthGranThan(Country, Constraints.MaximumLengthCountry))
{
AddNotification(nameof(Country), $"O Pais {Country} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthCountry}");
}
if (Comparators.IsLengthLessThan(ZipCode, Constraints.MinimumLengthZipCode))
{
AddNotification(nameof(ZipCode), $"O Código Postal {ZipCode} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthZipCode}");
}
else if (Comparators.IsLengthGranThan(ZipCode, Constraints.MaximumLengthZipCode))
{
AddNotification(nameof(ZipCode), $"O Código Postal {ZipCode} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthZipCode}");
}
}
public void TestExtractSingle()
{
var nounPhrases = nounPhraseExtractor.Extract("A large red flag fluttered.");
Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >();
ISet <string> variants = new HashSet <string>();
variants.Add("large red flag");
expectedNounPhrases.Add("large red flag", variants);
Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases));
}
public Phone(string phoneNumber)
{
PhoneNumber = phoneNumber;
if (Comparators.IsLengthLessThan(phoneNumber, Constraints.MinimumLengthNumber))
{
AddNotification(nameof(PhoneNumber), $"O número do telefone {phoneNumber} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthNumber}");
}
else if (Comparators.IsLengthGranThan(phoneNumber, Constraints.MaximumLengthNumber))
{
AddNotification(nameof(PhoneNumber), $"O número do telefone {phoneNumber} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthNumber}");
}
}
internal static ScoreDocComparator GetCachedComparator(IndexReader reader, System.String field, int type, System.Globalization.CultureInfo locale, SortComparatorSource factory)
{
if (type == SortField.DOC)
{
return(Lucene.Net.Search.ScoreDocComparator_Fields.INDEXORDER);
}
if (type == SortField.SCORE)
{
return(Lucene.Net.Search.ScoreDocComparator_Fields.RELEVANCE);
}
FieldCacheImpl.Entry entry = (factory != null) ? new FieldCacheImpl.Entry(field, factory) : new FieldCacheImpl.Entry(field, type, locale);
return((ScoreDocComparator)Comparators.Get(reader, entry));
}
public void TestExtractMultipleVariantsNumber()
{
var nounPhrases = nounPhraseExtractor.Extract("There are 12 dogs. A dog can't be seen.");
Comparators.PrintDictionaryOfSets(nounPhrases);
Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >();
ISet <string> variants = new HashSet <string>();
// NOTE there is a TODO in the code to fix this problem
//variants.Add("dogs");
variants.Add("dog");
expectedNounPhrases.Add("dog", variants);
Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases));
}
public void TestExtractMultipleVariants()
{
var nounPhrases = nounPhraseExtractor.Extract("Dogs are looking at dogs but not at a dog.");
Comparators.PrintDictionaryOfSets(nounPhrases);
Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >();
ISet <string> variants = new HashSet <string>();
variants.Add("Dogs");
variants.Add("dogs");
variants.Add("dog");
expectedNounPhrases.Add("dog", variants);
Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases));
}
static void Main()
{
IEqualityComparer cmpId = Comparators.Comparer(typeof(Point), "id");
IEqualityComparer cmpCoords = Comparators.Comparer(typeof(Point), "X", "Y");
IEqualityComparer cmpModule = Comparators.Comparer(typeof(Point), "GetModule");
Point p1 = new Point(54132, 5, 7);
Point p2 = new Point(980, 5, 7);
Point p3 = new Point(65465, 7, 5);
Console.WriteLine(cmpId.Equals(p1, p2)); // false
Console.WriteLine(cmpCoords.Equals(p1, p2)); // true
Console.WriteLine(cmpCoords.Equals(p2, p3)); // false
Console.WriteLine(cmpModule.Equals(p2, p3)); // true
}
internal static void Close(IndexReader reader)
{
lock (Comparators.SyncRoot)
{
System.Collections.Hashtable readerCache = (System.Collections.Hashtable)Comparators[reader];
if (readerCache != null)
{
readerCache.Clear();
readerCache = null;
}
Comparators.Remove(reader);
}
}
public void TestExtractMultipleVariantsIrregular()
{
var nounPhrases = nounPhraseExtractor.Extract("Wolves are looking at wolves but not at a wolf.");
Comparators.PrintDictionaryOfSets(nounPhrases);
Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >();
ISet <string> variants = new HashSet <string>();
// NOTE there is a TODO in the code to fix this problem
//variants.Add("Wolves");
//variants.Add("wolves");
variants.Add("wolf");
expectedNounPhrases.Add("wolf", variants);
Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases));
}
/// <summary>
/// Gets a functional values in defined y position.
/// </summary>
/// <param name="start">The start point of the segment.</param>
/// <param name="y">The y position.</param>
/// <param name="global">True, if y and returned x value is are global space, false, if y and x are related to the start point.</param>
/// <param name="tolerance">Tolerance</param>
/// <returns>A values related to the y position.</returns>
public override double[] GetValueByY(ref Point start, double y, bool global, double tolerance = 0)
{
Refresh(ref start);
if (!global)
{
y += start.Y;
}
if (Comparators.InIntervalBoth(start.Y, EndPoint.Y, y, tolerance))
{
// y = ax^2 + bx + c
// ax^2 + bx + (c - y) = 0;
var cc = c - y;
var discr = (b * b) - 4 * a * cc;
if (discr.IsGreater(0, 1e-5) && !a.IsZero())
{
var x1 = (-b + Math.Sqrt(discr)) / (2 * a);
var x2 = (-b - Math.Sqrt(discr)) / (2 * a);
if (Comparators.InIntervalBoth(start.X, EndPoint.X, x1, tolerance) && Comparators.InIntervalBoth(start.X, EndPoint.X, x2, tolerance))
{
return(new double[]
{
global?x1 : x1 - start.X,
global ? x2 : x2 - start.X,
});
}
else if (Comparators.InIntervalBoth(start.X, EndPoint.X, x1, tolerance))
{
return(new double[]
{
global?x1 : x1 - start.X
});
}
else if (Comparators.InIntervalBoth(start.X, EndPoint.X, x2, tolerance))
{
return(new double[]
{
global?x2 : x2 - start.X
});
}
}
}
return(new double[0]);
}
public bool Evaluate()
{
Object source;
if (TestObject.Find(Source) != null)
{
source = TestObject.Find(Source);
}
else if (KodiObject.Find(Source) != null)
{
source = KodiObject.Find(Source);
}
else if (WeatherObject.Find(Source) != null)
{
source = WeatherObject.Find(Source);
}
else if (GenericInfoObject.Find(Source) != null)
{
source = GenericInfoObject.Find(Source);
}
else
{
Console.WriteLine("Source not found"); return(false);
}
string attribute = source.GetType().GetMethod("AGet" + Attribute).Invoke(source, null).ToString();
Comparators comparator = (Comparators)Enum.Parse(typeof(Comparators), Comparator.ToUpper());
if (comparator.Equals(Comparators.EQUALS))
{
return(attribute.Equals(Threshold));
}
else if (comparator.Equals(Comparators.MORE))
{
try { return(Double.Parse(attribute) > Double.Parse(Threshold)); } catch (Exception) { Console.WriteLine("Cannot cast inputs"); return(false); }
}
else if (comparator.Equals(Comparators.LESS))
{
try { return(Double.Parse(attribute) < Double.Parse(Threshold)); } catch (Exception) { Console.WriteLine("Cannot cast inputs"); return(false); }
}
else
{
return(false);
}
}
public override Rect GetBounds(ref Point start)
{
var centre = GetCentre(ref start);
var angle = GetAngle(ref start);
if (Comparators.InIntervalDown(start.X, EndPoint.X, centre.X) &&
Comparators.InIntervalDown(start.Y, EndPoint.Y, centre.Y))
{
if (angle < 180)
{
return(new Rect(start, EndPoint));
}
////else
////{
//// var r = GetRadius(ref start);
//// return new Rect(centre.X - r, centre.Y - r, 2 * r, 2 * r);
////}
}
var min = new Point(double.PositiveInfinity, double.PositiveInfinity);
var max = new Point(double.NegativeInfinity, double.NegativeInfinity);
CheckMinMax(ref start, ref min, ref max);
Point ep = EndPoint;
CheckMinMax(ref ep, ref min, ref max);
double a = 5;
angle = Math.Abs(angle);
if (a < angle)
{
int numberOfTiles = (int)Math.Ceiling(angle / a);
double rel = a / angle;
for (int i = 1; i < numberOfTiles; ++i)
{
var pt = GetPointOnSegment(ref start, i * rel);
CheckMinMax(ref pt, ref min, ref max);
}
}
return(new Rect(min, max));
}
/// <summary>
/// Gets a functional values in defined y position.
/// </summary>
/// <param name="start">The start point of the segment.</param>
/// <param name="y">The y position.</param>
/// <param name="global">True, if y and returned x value is are global space, false, if y and x are related to the start point.</param>
/// <param name="tolerance">Tolerance</param>
/// <returns>A values related to the y position.</returns>
public override double[] GetValueByY(ref Point start, double y, bool global, double tolerance = 0)
{
if (!global)
{
y += start.Y;
}
var bounds = GetBounds(ref start);
if (Comparators.InIntervalBoth(bounds.Top, bounds.Bottom, y, tolerance))
{
var radius = GetRadius(ref start);
var centre = GetCentre(ref start);
y -= centre.Y;
var x = Math.Sqrt(radius * radius - y * y);
var c1 = Comparators.InIntervalBoth(bounds.Left, bounds.Right, centre.X + x, tolerance);
var c2 = Comparators.InIntervalBoth(bounds.Left, bounds.Right, centre.X - x, tolerance);
if (c1 && c2)
{
return(new double[]
{
global?centre.X + x : centre.X + x - start.X,
global ? centre.X - x : centre.X - x - start.X,
});
}
else if (c1)
{
return(new double[]
{
global?centre.X + x : centre.X + x - start.X
});
}
else if (c2)
{
return(new double[]
{
global?centre.X - x : centre.X - x - start.X
});
}
}
return(new double[0]);
}
/// <summary>
/// Gets a functional values in defined x position of the CircularArcSegment.
/// </summary>
/// <param name="start">The start point of the circular arc segment.</param>
/// <param name="x">The x position.</param>
/// <param name="global">True, if x and returned y value is are global space, false, if x and y are related to the start point.</param>
/// <param name="tolerance">Tolerance</param>
/// <returns>A values related to the x position.</returns>
public override double[] GetValueByX(ref Point start, double x, bool global, double tolerance = 0)
{
if (!global)
{
x += start.X;
}
var bounds = GetBounds(ref start);
if (Comparators.InIntervalBoth(bounds.Left, bounds.Right, x, tolerance))
{
var radius = GetRadius(ref start);
var centre = GetCentre(ref start);
x -= centre.X;
var y = Math.Sqrt(radius * radius - x * x);
var c1 = Comparators.InIntervalBoth(bounds.Top, bounds.Bottom, centre.Y + y, tolerance);
var c2 = Comparators.InIntervalBoth(bounds.Top, bounds.Bottom, centre.Y - y, tolerance);
if (c1 && c2)
{
return(new double[]
{
global?centre.Y + y : centre.Y + y - start.Y,
global ? centre.Y - y : centre.Y - y - start.Y,
});
}
else if (c1)
{
return(new double[]
{
global?centre.Y + y : centre.Y + y - start.Y,
});
}
else if (c2)
{
return(new double[]
{
global?centre.Y - y : centre.Y - y - start.Y,
});
}
}
return(new double[0]);
}
public Collaborator(
Name name,
Document document,
Email email,
Phone phone,
Address address,
decimal salary,
string projectName,
DateTime birthDate,
string jobTitle)
{
Name = name;
Document = document;
Email = email;
Phone = phone;
Address = address;
IdAddress = address.Id;
Salary = salary;
ProjectName = projectName;
BirthDate = birthDate;
JobTitle = jobTitle;
CreateDate = DateTime.UtcNow.AddHours(_TIME_ZONE);
if (Comparators.IsLengthLessThan(projectName, Constraints.MinimumLengthProjectName))
{
AddNotification(nameof(ProjectName), $"O nome do projeto {projectName} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthProjectName}");
}
else if (Comparators.IsLengthGranThan(projectName, Constraints.MaximumLengthProjectName))
{
AddNotification(nameof(ProjectName), $"O nome do projeto {projectName} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthProjectName}");
}
if (Comparators.IsLessThan(Salary, Constraints.BaseSalary))
{
AddNotification(nameof(Salary), $"O salário {Salary} é inválido. Ele é menor do que o piso salarial {Constraints.BaseSalary}");
}
if (!Comparators.IsYearOldIsGreaterOrEqual18YearOld(BirthDate))
{
AddNotification(nameof(BirthDate), $"O colaborador não poderá ser cadastrado, pois ele possui menos de 18 anos de idade");
}
}
public Name(string firstname, string lastName)
{
FirstName = firstname;
LastName = lastName;
if (Comparators.IsLengthGranThan(FirstName, Constraints.MaxLengthFirstName))
{
AddNotification(nameof(FirstName), $"O primeiro nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho menor do que {Constraints.MaxLengthFirstName}");
}
else if (Comparators.IsLengthLessThan(FirstName, Constraints.MinLengthFirstName))
{
AddNotification(nameof(FirstName), $"O primeiro nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho maior do que {Constraints.MinLengthFirstName}");
}
if (Comparators.IsLengthGranThan(LastName, Constraints.MaxLengthLastName))
{
AddNotification(nameof(LastName), $"O último nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho menor do que {Constraints.MaxLengthFirstName}");
}
else if (Comparators.IsLengthLessThan(LastName, Constraints.MinLengthLastName))
{
AddNotification(nameof(LastName), $"O último nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho maior do que {Constraints.MinLengthFirstName}");
}
}
/// <summary>
/// Gets a functional values in defined x position of the ParabolicArcSegment.
/// </summary>
/// <param name="start">The start point of the parabolic arc segment.</param>
/// <param name="x">The x position.</param>
/// <param name="global">True, if x and returned y value is are global space, false, if x and y are related to the start point.</param>
/// <param name="tolerance">Tolerance</param>
/// <returns>A values related to the x position.</returns>
public override double[] GetValueByX(ref Point start, double x, bool global, double tolerance = 0)
{
Refresh(ref start);
if (!global)
{
x += start.X;
}
if (Comparators.InIntervalBoth(start.X, EndPoint.X, x, tolerance))
{
// y = ax^2 + bx + c
var y = a * x * x + b * x + c;
if (!global)
{
y -= start.Y;
}
return(new double[] { y });
}
return(new double[0]);
}
/// <summary>
/// Calculates relative position on segment by given x position.
/// </summary>
/// <param name="start">The start point of the segment.</param>
/// <param name="x">The x position.</param>
/// <param name="global">True, if x and returned y value is are global space, false, if x and y are related to the start point.</param>
/// <returns>The relative position.</returns>
public override double[] GetRelativePosition(ref Point start, double x, bool global, double tolerance = 0)
{
if (!global)
{
x += start.X;
}
var radius = GetRadius(ref start);
var centre = GetCentre(ref start);
if (Comparators.InIntervalBoth(centre.X - radius, centre.X + radius, x, tolerance))
{
var xx = x - centre.X;
var y = (radius * radius - xx * xx).IsZero() ? 0 : Math.Sqrt(radius * radius - xx * xx);
var cc = IsCounterClockwise(ref start);
var angle = GetAngle(ref start);
Func <Point, Point, double> getAngle = (s, p) =>
{
var u1 = Point.Subtract(s, centre);
var u2 = Point.Subtract(p, centre);
var a = Vector.AngleBetween(u1, u2) * cc;
if (a.IsZero())
{
return(0);
}
return(a < 0 ? 360 + a : a);
};
var px = new Point(x, centre.Y + y);
var angle1 = getAngle(start, px);
px.Y = centre.Y - y;
var angle2 = getAngle(start, px);
return(new double[] { angle1 / angle, angle2 / angle });
}
return(new double[0]);
}
public void TestExtractWithConjunction()
{
var nounPhrases = nounPhraseExtractor.Extract("The red and flat flag.");
Comparators.PrintDictionaryOfSets(nounPhrases);
Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >();
ISet <string> variants = new HashSet <string>();
variants.Add("red");
expectedNounPhrases.Add("red", variants);
ISet <string> variants2 = new HashSet <string>();
variants2.Add("flat flag");
expectedNounPhrases.Add("flat flag", variants2);
ISet <string> variants3 = new HashSet <string>();
variants3.Add("red and flat flag");
expectedNounPhrases.Add("red and flat flag", variants3);
Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases));
}
public void ShouldReturntrueWhenEmailIsValid(string email)
{
bool result = Comparators.IsValidEmail(email);
Assert.AreEqual(result, true);
}
public void ShouldReturnTrueWhenValueToCompareLengthIsGreaterValueComparator(string valueToCompare, int ValueComparator)
{
bool result = Comparators.IsLengthGranThan(valueToCompare, ValueComparator);
Assert.AreEqual(result, true);
}
public void ShouldReturnFalseWhenValueToCompareLengthIsLessValueComparator(string valueToCompare, int ValueComparator)
{
bool result = Comparators.IsLengthGranThan(valueToCompare, ValueComparator);
Assert.AreEqual(result, false);
}
public void ShouldReturnTrueWhenValueToCompareIsEqualValueComparator(int valueToCompare, int ValueComparator)
{
bool result = Comparators.IsEqual(valueToCompare, ValueComparator);
Assert.AreEqual(result, true);
}
