public void TestNamedCollection()
{
INamedList <int> l1 = new NamedList <int>("l1", 11);
INamedCollection <int> nc1 = new NamedCollection <int>("NamedCollection 1 ", l1);
nc1.OnNameChanged += Nc1_OnNameChanged;
l1.OnNameChanged += Nc1_OnNameChanged;
Console.WriteLine(nc1);
Console.WriteLine(l1);
l1.Name = "Named List #1";
for (int i = 0; i < 11; i++)
{
nc1.Add(i);
}
nc1.Name = "NamedCollection 1";
nc1.Name = "Collection 1, which is named.";
Console.WriteLine(nc1);
Console.WriteLine(l1);
}
private void TypeToArguments(NamedCollection <IArgumentInstance> arguments, NamedCollection <IArgumentDeclaration> declarations, ILocalIdentifierScope identifiers, ArgumentSide side, Type type, FieldToInstance fields)
{
if (type == null)
{
return;
}
foreach (var field in type.GetRuntimeFields())
{
var argumentDecl = new ArgumentDeclaration {
IsUnrolled = field.GetCustomAttributes(typeof(ArgumentUnrolled)).Any(),
IsAssignable = field.GetCustomAttributes(typeof(ArgumentAssignable)).Any(),
Name = field.Name,
Type = NetTypeToRebuildType(field.FieldType)
//Value = field.V
};
var argument = new ArgumentInstance {
Argument = argumentDecl,
Side = side
};
declarations.Add(argumentDecl);
identifiers.Add(argument);
arguments.Add(argument);
fields.Add(field, argument);
}
}
private static void LoadParameters(NamedCollection <Code.Parameter> parameters, Procedure procedure)
{
string parameterName;
var procedureParameters = procedure.Parameters;
foreach (var parameter in procedureParameters)
{
parameterName = provider.GetParameterName(parameter.Name);
parameters.Add(
new Code.Parameter()
{
Name = parameterName.ToPascalCase(),
CamelCaseName = parameterName.ToCamelCase(),
SqlName = parameter.Name,
DbType = parameter.DbType,
Type = MappingHelper.GetCommonTypeString(parameter.DbType.ToCommonType()),
EnumType = DiscoverEnumType(parameter.DbType.ToCommonType(), parameterName),
Direction = parameter.Direction,
Size = parameter.Size,
Description = parameter.Description
});
}
}
public void Initialize()
{
_list = new List <Person>(new Person[]
{
new Person()
{
Name = "Unnamed",
},
new Customer()
{
Name = "Customer#1",
},
new Employee()
{
Name = "Employee#1",
},
new Employee()
{
Name = "Employee#2",
},
new Customer()
{
Name = "Customer#2",
},
new Customer()
{
Name = "Customer#3",
},
});
_customers = new NamedCollection <Customer>(_list, p => p.Name, item => item != null && item.GetType() == typeof(Customer));
_employees = new NamedCollection <Employee>(_list, p => p.Name, item => item != null && item.GetType() == typeof(Employee));
}
static void DeclareArguments(IFunctionDeclaration function, NamedCollection <IArgumentDeclaration> arguments, ICppScope scope, string kind)
{
if (arguments.IsEmpty())
{
return;
}
var typeName = GetFunctionTypeName(function.Name, kind);
scope.Declaration.AddLine($"struct {typeName} {{");
scope.WithDeclarationIndented(
innerScope => {
foreach (var argument in arguments)
{
var argTypeName = GetArgumentTypeName(argument.Type);
var argName = CppEscape(argument.Name);
if (argument.IsAssignable && kind != "Result")
{
innerScope.Declaration.AddLine($"{argTypeName}* {argName};");
if (arguments.Count == 1)
{
innerScope.Declaration.AddLine($"operator {argTypeName}() const {{ return *{argName}; }}");
}
}
else
{
innerScope.Declaration.AddLine($"{argTypeName} {argName};");
if (arguments.Count == 1)
{
innerScope.Declaration.AddLine($"operator {argTypeName}() const {{ return {argName}; }}");
}
}
}
});
scope.Declaration.AddLine(line: "};");
}
private IReadOnlyNamedCollection <DataEntityPropertyToken> CreateTokens(Type type)
{
var collection = new NamedCollection <DataEntityPropertyToken>(m => m.Property.Name);
if (type == null || type == typeof(object) || Zongsoft.Common.TypeExtension.IsDictionary(type))
{
foreach (var property in _entity.Properties)
{
collection.Add(new DataEntityPropertyToken(property, null));
}
}
else
{
foreach (var property in _entity.Properties)
{
var member = this.FindMember(type, property.Name);
if (member != null)
{
collection.Add(new DataEntityPropertyToken(property, member));
}
}
}
return(collection);
}
public void Initialize()
{
_list = new List<Person>(new Person[]
{
new Person()
{
Name = "Unnamed",
},
new Customer()
{
Name = "Customer#1",
},
new Employee()
{
Name = "Employee#1",
},
new Employee()
{
Name = "Employee#2",
},
new Customer()
{
Name = "Customer#2",
},
new Customer()
{
Name = "Customer#3",
},
});
_customers = new NamedCollection<Customer>(_list, p => p.Name, item => item != null && item.GetType() == typeof(Customer));
_employees = new NamedCollection<Employee>(_list, p => p.Name, item => item != null && item.GetType() == typeof(Employee));
}
private void InitCreateStoredProcedure(ISchema table, NamedCollection <Column> columns)
{
foreach (var column in columns)
{
checkedListBoxForCreate.Items.Add(column.Name, string.IsNullOrEmpty(column.Default));
}
}
/// <inheritdoc/>
protected override void Execute()
{
Nodes = new NamedCollection <CacheNode>();
_feeds = _feedCache.GetAll();
foreach (var feed in _feeds)
{
Add(GetFeedNode(feed));
}
foreach (var digest in _implementationStore.ListAll())
{
var node = GetImplementationNode(digest);
if (node != null)
{
TotalSize += node.Size;
Add(node);
}
}
foreach (string path in _implementationStore.ListAllTemp())
{
Add(GetTempNode(path));
}
}
static string BuildArgumentValues(
IFunctionInstance function,
NamedCollection <IArgumentDeclaration> arguments,
INamedExpressionTuple expressions,
ICppScope scope,
string kind)
{
if (arguments.IsEmpty())
{
return(string.Empty);
}
var name = scope.MakeLocalName();
var typeName = GetFunctionTypeName(function.Name, kind);
scope.Runtime.AddLine($"{typeName} {name};");
var argN = 0;
foreach (var expression in expressions.Tuple)
{
var argument = arguments[argN];
argN++;
var value = Dynamic((dynamic)expression.Expression, scope);
if (argument.IsAssignable)
{
scope.Runtime.AddLine($"{name}.{CppEscape(argument.Name)} = &{value};");
}
else
{
scope.Runtime.AddLine($"{name}.{CppEscape(argument.Name)} = {value};");
}
}
return(name);
}
public void ConstructorSetsStringComparerToOrdinalIgnoreCaseWhenNotSpecified()
{
var values = new[] { new Foo("bar") };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.StringComparer.Should().BeSameAs(StringComparer.OrdinalIgnoreCase);
}
public void ConstructorSetsStringComparer()
{
var values = new[] { new Foo("bar") };
var collection = new NamedCollection <Foo>(values, f => f.Name, StringComparer.InvariantCulture);
collection.StringComparer.Should().BeSameAs(StringComparer.InvariantCulture);
}
public void ConstructorSetsDefaultNameToDefaultWhenNotSpecified()
{
var values = new[] { new Foo("bar") };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.DefaultName.Should().Be("default");
}
void AssertArguments(NamedCollection <IArgumentDeclaration> expected, NamedCollection <IArgumentDeclaration> actual, string name)
{
Assert.AreEqual(expected.Count, actual.Count, $"{name}Arguments.Count");
for (var i = 0; i < expected.Count; i++)
{
AssertArgument(expected[i], actual[i], name: $"{name}Arguments[{i}]");
}
}
public void DefaultValuePropertyIsNullWhenNoValueHasADefaultName()
{
var values = new[] { new Foo("bar") };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.DefaultValue.Should().BeNull();
}
/// <summary>
/// Default constructor for ViewBase
/// </summary>
public ViewBase()
{
Inputs = new NamedCollection <IInput>();
Outputs = new NamedCollection <IOutput>();
BackColor = SystemColors.ControlLight;
BorderStyle = BorderStyle.FixedSingle;
}
// Fills in the ProcessStartInfo object that belongs to this node using the Variables collection.
public ProcessStartInfo GetPsi(NamedCollection Variables)
{
ProcessStartInfo ret = this.Psi;
ret.FileName = this.BuildCommandString(Variables);
ret.Arguments = this.BuildArgumentsString(Variables);
return(ret);
}
public void DefaultValuePropertyIsTheValueWithANameEqualToDefaultNameProperty()
{
var defaultFoo = new Foo("default");
var values = new[] { new Foo("bar"), defaultFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.DefaultValue.Should().BeSameAs(defaultFoo);
}
public void NamedValuesPropertyContainsTheValuesWithANonDefaultName()
{
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { barFoo, bazFoo, new Foo("default") };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.NamedValues.Should().BeEquivalentTo(new[] { barFoo, bazFoo });
}
public void ContainsMethodReturnsTrueWhenGivenADefaultNameAndThereIsADefaultValue(string name)
{
var defaultFoo = new Foo("default");
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { defaultFoo, barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.Contains(name).Should().Be(true);
}
public static i32 Main(String[] args)
{
// Default argument values.
// NB: these are strings ONLY, conversion to appropriate types is done ad hoc.
var dic = new Dictionary <String, String> {
["target"] = null,
["filename"] = "makefile.xml",
["redirect"] = "false",
["cancel-on-error"] = "true",
["var-str"] = ""
};
if (args.Length == 1 && args[0].Equals("love"))
{
Program.WriteLine("Not war");
}
Program.ParseArguments(args, dic);
String filename = dic["filename"];
if (!File.Exists(filename))
{
return(Program.ExitMessage(1, "ERROR - file not found: {0}", filename));
}
String target = dic["target"];
// Prepare XBOSS for Makefile type and its dependencies.
Array <Node <String> > .RegisterType();
NamedCollection.RegisterType();
Makefile.RegisterType();
// Parse the file
Document d = Document.FromFile(filename);
var file = (Makefile)d.Root;
file.AddVariables(Program.ToNamedCollection(dic["var-str"]));
if (String.IsNullOrWhiteSpace(target))
{
target = file.DefaultTarget;
Program.WriteLine($"No target specified; defaulting to {target}");
} // if
if (!file.Commands.ContainsKey(target))
{
return(Program.ExitMessage(2, "ERROR - command not found: {0}", target));
}
Program.CacheDirectory = Program.FindCacheDirectory();
bool redirect = dic["redirect"].Equals("true");
//bool cancel_on_error = dic["cancel-on-error"].Equals("true");
(ProcessStartInfo, bool)[] res = file.MakeCommands(target);
public void ContainsMethodReturnsFalseWhenGivenANonDefaultNameThatIsNotFound()
{
var defaultFoo = new Foo("default");
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { defaultFoo, barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.Contains("qux").Should().Be(false);
}
public void TryGetValueMethodRetrievesTheDefaultValueWhenGivenADefaultName(string name)
{
var defaultFoo = new Foo("default");
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { defaultFoo, barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.TryGetValue(name, out var value).Should().Be(true);
value.Should().BeSameAs(defaultFoo);
}
public void ContainsMethodReturnsTrueWhenGivenAMatchingName()
{
var defaultFoo = new Foo("default");
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { defaultFoo, barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
collection.Contains("bar").Should().Be(true);
collection.Contains("baz").Should().Be(true);
}
public void IndexerRetrievesTheDefaultValueWhenGivenADefaultName(string name)
{
var defaultFoo = new Foo("default");
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { defaultFoo, barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
var value = collection[name];
value.Should().BeSameAs(defaultFoo);
}
public void ContainsMethodReturnsFalseWhenGivenADefaultNameAndThereIsNoDefaultValue()
{
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
foreach (var defaultName in new[] { "default", null, "" })
{
collection.Contains(defaultName).Should().Be(false);
}
}
private static void LoadEnumMembers(NamedCollection <EnumMember> members, Enumeration enumeration)
{
foreach (var enumerationMember in enumeration.Members)
{
members.Add(
new EnumMember
{
Name = enumerationMember.Name,
Value = enumerationMember.Value,
Description = enumerationMember.Description
});
}
}
private static void LoadResults(NamedCollection <Result> results, string modelName, Method method, StoredProcedure procedure)
{
Match matchResults = regexResults.Match(procedure.Definition);
int length = matchResults.Groups["Name"].Captures.Count;
if (length == 0 && method.MethodType == MethodType.ExecuteReader)
{
string typePostfix = regexGetList.IsMatch(method.Name) ? "Collection" : "Item";
string modelNameWithSchema = GetModelForMethod(procedure.Schema, modelName);
// TODO: Conflict Names.
results.Add(
new Result
{
Name = modelName + typePostfix,
CommonType = modelNameWithSchema + typePostfix,
Description = string.Empty,
IsOutputParameter = false
});
}
else
{
for (int i = 0; i < length; i++)
{
results.Add(
new Result
{
Name = MappingHelper.GetPascalCase(matchResults.Groups["Name"].Captures[i].Value),
CommonType = matchResults.Groups["Type"].Captures[i].Value,
Description = string.Empty,
IsOutputParameter = false
});
}
}
foreach (var parameter in method.Parameters)
{
if (parameter.Direction != ParameterDirection.Input)
{
results.Add(
new Result
{
Name = parameter.Name,
CommonType = parameter.Name == "ReturnResult" ? "ReturnResult" : MappingHelper.GetCommonTypeString(parameter.Type),
Description = parameter.Description,
IsOutputParameter = true
});
}
}
}
/// <summary>
/// Creates <see cref="TrustNode"/> representations for all entries in a <see cref="TrustDB"/>.
/// </summary>
public static NamedCollection<TrustNode> ToNodes([NotNull] this TrustDB trustDB)
{
#region Sanity checks
if (trustDB == null) throw new ArgumentNullException("trustDB");
#endregion
var nodes = new NamedCollection<TrustNode>();
foreach (var key in trustDB.Keys)
{
foreach (var domain in key.Domains)
nodes.Add(new TrustNode(key.Fingerprint, domain));
}
return nodes;
}
static INamedExpressionTuple AssignArguments(NamedCollection <IArgumentInstance> instances, INamedExpressionTuple arguments)
{
var result = new NamedExpressionTuple();
var o = arguments.Tuple.Count - instances.Count;
foreach (var instance in instances)
{
// TODO: check that conversion exists
result.Tuple.Add(arguments.Tuple[o]);
arguments.Tuple.RemoveAt(o);
}
// TODO: check that enough arguments are given
return(result);
}
public void IndexerThrowsWhenGivenANonDefaultNameThatIsNotFound()
{
var defaultFoo = new Foo("default");
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { defaultFoo, barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
Action action = () => { var dummy = collection["qux"]; };
action.Should().ThrowExactly <KeyNotFoundException>()
.WithMessage("The given name was not present in the named collection: qux.");
}
/// <inheritdoc/>
protected override void Execute()
{
Nodes = new NamedCollection<CacheNode>();
_feeds = _feedCache.GetAll();
foreach (var feed in _feeds)
{
feed.Normalize(feed.Uri);
Add(feed);
}
foreach (var digest in _store.ListAll()) Add(digest);
foreach (string path in _store.ListAllTemp()) Add(path);
State = TaskState.Complete;
}
public void IndexerThrowsWhenGivenADefaultNameAndThereIsNoDefaultValue()
{
var barFoo = new Foo("bar");
var bazFoo = new Foo("baz");
var values = new[] { barFoo, bazFoo };
var collection = new NamedCollection <Foo>(values, f => f.Name);
foreach (var defaultName in new[] { "default", null, "" })
{
Action action = () => { var dummy = collection[defaultName]; };
action.Should().ThrowExactly <KeyNotFoundException>()
.WithMessage("The named collection does not have a default value.");
}
}
/// <summary>
/// Adds a specific file to the <paramref name="files"/> list.
/// </summary>
/// <param name="files">The collection to add the file to.</param>
/// <param name="type">The type-subdirectory the file belongs to.</param>
/// <param name="name">The file name to be added to the list.</param>
/// <param name="flagAsMod">Set to <c>true</c> when handling mod files to detect added and changed files.</param>
private static void AddFileToList(NamedCollection<FileEntry> files, string type, string name, bool flagAsMod)
{
if (flagAsMod)
{
// Detect whether this is a new file or a replacement for an existing one
if (files.Contains(name))
{
var previousEntry = files[name];
// Only mark as modified if the pre-existing file isn't already a mod file itself
if (previousEntry.EntryType == FileEntryType.Normal)
{
files.Remove(previousEntry);
files.Add(new FileEntry(type, name, FileEntryType.Modified));
}
}
else files.Add(new FileEntry(type, name, FileEntryType.Added));
}
else
{
// Prevent duplicate entries
if (!files.Contains(name)) files.Add(new FileEntry(type, name));
}
}
/// <summary>
/// Recursively finds all files in <paramref name="directory"/> ending with <paramref name="extension"/> and adds them to the <paramref name="files"/> list.
/// </summary>
/// <param name="files">The collection to add the found files to.</param>
/// <param name="type">The type-subdirectory the files belong to.</param>
/// <param name="extension">The file extension to look for.</param>
/// <param name="directory">The directory to look in.</param>
/// <param name="prefix">A prefix to add before the file name in the list (used to indicate current sub-directory).</param>
/// <param name="flagAsMod">Set to <c>true</c> when handling mod files to detect added and changed files.</param>
private static void AddDirectoryToList(NamedCollection<FileEntry> files, string type, string extension, DirectoryInfo directory, string prefix, bool flagAsMod)
{
// Add the files in this directory to the list
foreach (FileInfo file in directory.GetFiles("*" + extension))
AddFileToList(files, type, prefix + file.Name, flagAsMod);
// Recursively call this method for all sub-directories
foreach (DirectoryInfo subDir in directory.GetDirectories()
// Don't add dot directories (e.g. .svn)
.Where(subDir => !subDir.Name.StartsWith(".")))
AddDirectoryToList(files, type, extension, subDir, prefix + subDir.Name + Path.DirectorySeparatorChar, flagAsMod);
}
/// <summary>
/// Finds all files in <paramref name="archiveData"/> ending with <paramref name="extension"/> and adds them to the <paramref name="files"/> collection
/// </summary>
/// <param name="files">The collection to add the found files to.</param>
/// <param name="extension">The file extension to look for.</param>
/// <param name="type">The type-subdirectory to look in.</param>
/// <param name="archiveData">The archive data list to look in.</param>
/// <param name="flagAsMod">Set to <c>true</c> when handling mod files to detect added and changed files.</param>
private static void AddArchivesToList(NamedCollection<FileEntry> files, string type, string extension, IEnumerable<KeyValuePair<string, ContentArchiveEntry>> archiveData, bool flagAsMod)
{
foreach (var pair in archiveData
.Where(pair => pair.Key.StartsWith(type, StringComparison.OrdinalIgnoreCase) &&
pair.Key.EndsWith(extension, StringComparison.OrdinalIgnoreCase)))
{
// Cut away the type part of the path
AddFileToList(files, type, pair.Key.Substring(type.Length + 1), flagAsMod);
}
}
/// <summary>
/// Gets a list of all files of a certain type
/// </summary>
/// <param name="type">The type of files you want (e.g. Textures, Sounds, ...)</param>
/// <param name="extension">The file extension to so search for</param>
/// <returns>An collection of strings with file IDs</returns>
public static NamedCollection<FileEntry> GetFileList([NotNull, Localizable(false)] string type, [NotNull, Localizable(false)] string extension)
{
#region Sanity checks
if (string.IsNullOrEmpty(type)) throw new ArgumentNullException(nameof(type));
if (string.IsNullOrEmpty(extension)) throw new ArgumentNullException(nameof(extension));
#endregion
type = FileUtils.UnifySlashes(type);
// Create an alphabetical list of files without duplicates
var files = new NamedCollection<FileEntry>();
#region Find all base files
// Find real files
if (Directory.Exists(Path.Combine(BaseDir.FullName, type)))
{
AddDirectoryToList(files, type, extension,
new DirectoryInfo(Path.Combine(BaseDir.FullName, type)), "", false);
}
// Find files in archives
AddArchivesToList(files, type, extension, _baseArchiveEntries, false);
#endregion
if (ModDir != null)
{
#region Find all mod files
// Find real files
if (Directory.Exists(Path.Combine(ModDir.FullName, type)))
{
AddDirectoryToList(files, type, extension,
new DirectoryInfo(Path.Combine(ModDir.FullName, type)), "", true);
}
// Find files in archives
AddArchivesToList(files, type, extension, _modArchiveEntries, true);
#endregion
}
return files;
}
