/// <summary>
/// Initializes a new instance of the <see cref="BuildCapability" /> class.
/// </summary>
/// <param name="generator">The generator that provides the build functions.</param>
/// <exception cref="ArgumentNullException">The <paramref name="generator" /> parameter is <c>null</c>.</exception>
public BuildCapability(IValueGenerator generator)
{
generator = generator ?? throw new ArgumentNullException(nameof(generator));
ImplementedByType = generator.GetType();
SupportsCreate = true;
_createType = (strategy, type, args) => generator.Generate(strategy, type);
_createProperty = (strategy, propertyInfo, args) => generator.Generate(strategy, propertyInfo);
_createParameter = (strategy, parameterInfo, args) => generator.Generate(strategy, parameterInfo);
_populate = (strategy, instance) =>
throw new NotSupportedException(
$"{nameof(IValueGenerator)} types do not support populating an instance.");
}
public object Create(Type type)
{
if (CircleDepend.Where(CircleType => CircleType == type).Count() >= 5)
{
Console.WriteLine("Circular Dependency");
return(GetDefaultValue(type));
}
CircleDepend.Push(type);
Faker faker = new Faker(Configuration);
int seed = (int)DateTime.Now.Ticks & 0x0000FFFF;
GeneratorContext Context = new GeneratorContext(new Random(seed), type, faker);
IValueGenerator generator = FindGenerator(type);
if (generator != null)
{
CircleDepend.Pop();
return(generator.Generate(Context));
}
var obj = CreateObject(type);
obj = FillObject(obj);
CircleDepend.Pop();
return(obj);
}
private List <Vector2> GenerateInnerPoints(List <Vector2> initialPoints)
{
var points = new List <Vector2>(initialPoints);
var sa = _prng.Generate() * 2 * Mathf.PI;
int citySize = CityLayer.CitySize;
var pointAmount = _parameters.CellDensity + (2 * citySize) + (int)((1 + _prng.Generate() * 3) * 2f);
int cnt = 0;
for (int i = 0; i < pointAmount * 10; i++)
{
var a = sa + Mathf.Sqrt(i) * 5;
var progress = (float)cnt / (pointAmount - initialPoints.Count);
var evaluatedVal = 1 + _parameters.PointDistribution.Evaluate(progress);
var radius = (evaluatedVal + citySize) * _prng.Generate();
var xr = radius * Mathf.Cos(a);
var yr = radius * Mathf.Sin(a);
var p = new Vector2(xr + points[0].x, yr + points[0].y);
EvaluatePoint(p);
if (points.Count >= pointAmount)
{
break;
}
}
return(MapPointsToBoundingBox(points));
void EvaluatePoint(Vector2 p)
{
// Check min neighbor point distance
var closest = p.FindClosestIn(points);
if (closest.HasValue && Vector2.Distance(closest.Value, p) >= _parameters.MinPointDistance)
{
points.Add(p);
cnt++;
}
}
}
private static List <T> CreateOriginalList <T>(IValueGenerator <int> countGenerator, IValueGenerator <T> valueGenerator)
{
var count = countGenerator.Generate();
var result = new List <T>();
for (int i = 0; i < count; i++)
{
result.Add(valueGenerator.Generate());
}
return(result);
}
private void ClearTest <T>(int testsCount, IValueGenerator <int> countGenerator, IValueGenerator <T> valueGenerator)
{
for (int iTest = 0; iTest < testsCount; iTest++)
{
var testList = new CommandedList <T>(CreateCommandDispatcher());
var count = countGenerator.Generate();
for (int i = 0; i < count; i++)
{
testList.Add(valueGenerator.Generate());
}
testList.Clear();
Assert.IsFalse(testList.Any());
}
}
private void AddTest <T>(int testsCount, IValueGenerator <int> countGenerator, IValueGenerator <T> valueGenerator)
{
for (int iTest = 0; iTest < testsCount; iTest++)
{
var originalList = new List <T>();
var testList = new CommandedList <T>(CreateCommandDispatcher());
var count = countGenerator.Generate();
for (int i = 0; i < count; i++)
{
var value = valueGenerator.Generate();
originalList.Add(value);
testList.Add(value);
Assert.IsTrue(originalList.SequenceEqual(testList));
}
}
}
// Генерация значения. Если нет подходящего генератора, то генерируется дефолтное значение (0 или null)
public object GenerateValue(GeneratorContext context)
{
IValueGenerator generator = GetGenerator(context.TargetType);
object value;
if (generator != null)
{
value = generator.Generate(context);
}
else
{
value = GetDefaultValue(context.TargetType);
Console.WriteLine("Dont have generator for " + context.TargetType.Name);
}
return(value);
}
/// <summary>
/// <para>Заполнить массив значениями</para>
/// </summary>
/// <typeparam name="T">Тип элементов массива</typeparam>
/// <param name="array">Заполняемый массив</param>
/// <param name="generator">Генератор значений</param>
/// <param name="start">Первый элемент массива, с которого начинается заполнение</param>
/// <param name="count">Количество элементов массива, заменяемых новым значением</param>
/// <remarks>v.2021.04.18</remarks>
public static void Fill <T>(this T[] array, IValueGenerator <T> generator, long start = 0, long count = 0)
{
#region Check arguments
#if CHECK_ARGS
_ = array ?? throw new ArgumentNullException(nameof(array));
_ = generator ?? throw new ArgumentNullException(nameof(generator));
if ((count < 0) || (count > array.Length))
{
throw new ArgumentOutOfRangeException(nameof(count));
}
if ((start < 0) || ((start + count) > array.Length))
{
throw new ArgumentOutOfRangeException(nameof(start));
}
/*
#else
*
* if ((array is null) ||
* (generator is null) ||
* (count < 0) || (count > array.Length) ||
* (start < 0) || ((start + count) > array.Length))
* {
* Debug.WriteLine("incorrect call {0}<{1}>(array:{2},generator:{3},start:{4},count:{5})",
* "Darkangel.Arrays.ArrayHelper.Fill",
* typeof(T).FullName,
* (array is null) ? "null" : array.Length.ToString(),
* generator.GetType().FullName,
* start,
* count
* );
* return;
* }
*/
#endif
#endregion Check arguments
var end = (count == 0) ? (array.Length) : (start + count);
for (var i = start; i < end; i++)
{
array[i] = generator.Generate(i);
}
}
private void ContainsTest <T>(int testsCount, IValueGenerator <int> countGenerator, IValueGenerator <T> valueGenerator)
{
for (int iTest = 0; iTest < testsCount; iTest++)
{
var originalList = CreateOriginalList(countGenerator, valueGenerator);
var testList = CreateTestListByOriginal(originalList);
foreach (var item in originalList)
{
Assert.IsTrue(originalList.Contains(item) == testList.Contains(item));
}
var count = countGenerator.Generate();
for (int i = 0; i < count; i++)
{
var value = valueGenerator.Generate();
Assert.IsTrue(originalList.Contains(value) == testList.Contains(value));
}
}
}
