public static Value Group(INSGenerator generator, Arguments arguments)
{
var count = arguments[0].Int;
if (count > 0)
{
var iterator = new NSIterator(generator);
var array = new Array();
iterator.Reset();
var value = iterator.Next();
for (var i = 0; i < MAX_ARRAY && !value.IsNil; i += count)
{
var subArray = new Array();
for (var j = 0; j < count && !value.IsNil; j++)
{
subArray.Add(value);
value = iterator.Next();
}
array.Add(value);
value = iterator.Next();
}
return(array);
}
using (var assistant = new ParameterAssistant(arguments))
{
var block = assistant.Block();
if (block == null)
{
return(ToArray(generator));
}
var hash = new AutoHash <string, List <Value> >
{
Default = DefaultType.Lambda,
DefaultLambda = k => new List <Value>(),
AutoAddDefault = true
};
assistant.IteratorParameter();
var iterator = new NSIterator(generator);
iterator.Reset();
foreach (var item in iterator)
{
assistant.SetIteratorParameter(item);
var key = block.Evaluate().Text;
hash[key].Add(item);
}
var array = new Array();
foreach (var item in hash)
{
array[item.Key] = new Array(item.Value);
}
return(array);
}
}
public VariableNames(string[] variableNames)
{
hash = new AutoHash <int, string>("");
for (var i = 0; i < variableNames.Length; i++)
{
hash[i] = variableNames[i];
}
}
static ImportPackage()
{
assemblyCache = new AutoHash <string, Assembly>(packageName =>
{
var fullPath = System.IO.Path.Combine(Machine.Current.PackageFolder, $"Kagami.{packageName}.dll");
var assembly = Assembly.LoadFile(fullPath);
return(assembly);
}, true);
}
public void AutoHashTest()
{
test(new AutoHash <string, int>(k => - 1), "No auto-add", k => - 2);
test(new AutoHash <string, int>(k => - 1, true), "Auto-add", k => - 2);
var autoHash = new AutoHash <string, int>(k => k.Length);
autoHash.AddKeys(new List <string> {
"alpha", "bravo"
});
test(autoHash, "AddKeys", k => - k.Length);
}
protected static void test(AutoHash <string, int> autoHash, string message, Func <string, int> newLambda)
{
var keys = array("alpha", "bravo", "charlie");
Console.WriteLine("-".Repeat(80));
Console.WriteLine(message.LeftJustify(80, '-'));
foreach (var key in keys)
{
Console.WriteLine($"{key}: {autoHash[key]}");
}
autoHash.DefaultLambda = newLambda;
Console.WriteLine("-".Repeat(80));
foreach (var key in keys)
{
Console.WriteLine($"{key}: {autoHash[key]}");
}
}
public virtual IObject GroupBy(Lambda lambda)
{
var hash = new AutoHash <IObject, List <IObject> >(_ => new List <IObject>())
{
AutoAddDefault = true
};
foreach (var item in List().ToList())
{
var key = lambda.Invoke(item);
hash[key].Add(item);
}
var result = new Hash <IObject, IObject>();
foreach (var key in hash.KeyArray())
{
result[key] = collectionClass.Revert(hash[key]);
}
return(new Dictionary(result));
}
public static bool MatchObjects(Object obj1, Object obj2, bool required, bool assigning)
{
var chains = new Hash <string, MessagePath>();
var bindings = new AutoHash <string, Value>
{
Default = DefaultType.Value,
DefaultValue = ""
};
var repeating = false;
int comparison;
while (true)
{
comparison = obj1.Compare(obj2, chains, new MessagePath(), bindings, ref repeating);
if (comparison == 0)
{
foreach (var item in chains)
{
Regions.SetBinding(item.Key, item.Value.Invoke(obj1).Resolve(), assigning);
}
foreach (var item in bindings)
{
Regions.SetBinding(item.Key, item.Value.Resolve(), assigning);
}
return(returnMatched(comparison == 0, required, null));
}
if (!repeating)
{
break;
}
}
return(comparison == 0);
}
public InternalList(AutoHash <string, Value> fields) => this.fields = fields;
static Block()
{
results = new AutoHash <int, string>(_ => "");
}
