public void TestHashSetEqualityComparer()
{
var data = new[] { "foo", "bar", "foobar" };
var set1 = new HashSet <string>(data, StringComparer.Ordinal);
var set2 = new HashSet <string>(data, StringComparer.OrdinalIgnoreCase);
var comparer = HashSetEx <string> .CreateSetComparer();
Assert.IsTrue(comparer.Equals(set1, set1));
Assert.IsTrue(comparer.Equals(set1, set2));
Assert.AreEqual(comparer.GetHashCode(set1), comparer.GetHashCode(set2));
var set3 = new HashSet <string>(new[] { "foobar", "foo", "bar" });
Assert.IsTrue(comparer.Equals(set1, set3));
Assert.AreEqual(comparer.GetHashCode(set1), comparer.GetHashCode(set3));
var set4 = new HashSet <string>(new[] { "oh", "hai", "folks" });
Assert.IsFalse(comparer.Equals(set2, set4));
Assert.AreNotEqual(comparer.GetHashCode(set2), comparer.GetHashCode(set4));
Assert.IsTrue(comparer.Equals(null, null));
// ReSharper disable once AssignNullToNotNullAttribute
Assert.AreEqual(0, comparer.GetHashCode(null));
Assert.IsFalse(comparer.Equals(set1, null));
}
private string GetMemberName(HashSetEx <string> members, string name, string altnamebase)
{
name = name.Replace(" ", "_");
if (altnamebase != null)
{
altnamebase = altnamebase.Replace(" ", "_");
}
if (!members.Contains(name))
{
members.Add(name);
return(name);
}
if (altnamebase != null && altnamebase.EndsWith("_ID") && !members.Contains(altnamebase.Substring(0, altnamebase.Length - 2)))
{
string n = altnamebase.Substring(0, altnamebase.Length - 2);
members.Add(n);
return(n);
}
string name0 = name;
int idx = 1;
while (members.Contains(name))
{
name = name0 + idx.ToString();
idx++;
}
members.Add(name);
return(name);
}
private void ReloadStyleNames()
{
if (m_enumNamedStyles == null)
{
return;
}
try
{
m_loadingData++;
var names = new HashSetEx <string>();
foreach (var es in m_enumNamedStyles(null))
{
if (!es.StyleName.IsEmpty())
{
names.Add(es.StyleName);
}
}
string text = cbxExisting.Text;
int pos = cbxExisting.SelectionStart;
cbxExisting.Items.Clear();
foreach (string name in names)
{
cbxExisting.Items.Add(name);
}
cbxExisting.Text = text;
cbxExisting.SelectionStart = pos;
}
finally
{
m_loadingData--;
}
}
private void codeEditorQuery_Leave(object sender, EventArgs e)
{
try
{
SaveSource(false);
}
catch (Exception err)
{
CurCache.TargetChanged = false;
CurCache.SourceModel = null;
StdDialog.ShowError(Errors.ExtractImportantException(err).Message);
}
if (CurCache.SourceModel != null)
{
var cols = new HashSetEx <string>();
foreach (var col in CurCache.SourceModel.Columns)
{
if (cols.Contains(col.ColumnName))
{
CurCache.TargetChanged = false;
CurCache.SourceModel = null;
StdDialog.ShowError(Texts.Get("s_datasynerr_duplicate$column", "column", col.ColumnName));
break;
}
cols.Add(col.ColumnName);
}
}
}
private bool HasNewFavNote(List <FavoriteNoteEntity> fNotes)
{
bool rt = false;
fNotes = fNotes ?? new List <FavoriteNoteEntity>();
var notes = HashSetEx.Create <string>(fNotes.Select(k => k.Note));
if (_preFavoriteNoteSet == null || notes.Count != _preFavoriteNoteSet.Count)
{
rt = true;
}
else
{
foreach (string nt in notes)
{
if (!_preFavoriteNoteSet.Contains(nt))
{
rt = true;
break;
}
}
}
_preFavoriteNoteSet = notes;
return(rt);
}
private List <IAbstractObjectStructure> GetEqualObjs()
{
var grps = new HashSetEx <string>();
var objs = new List <IAbstractObjectStructure>();
foreach (var elem in m_diff.Actions.Elements)
{
grps.Add(elem.GroupId);
}
foreach (var obj in m_src.Tables)
{
if (grps.Contains(obj.GroupId))
{
continue;
}
objs.Add(obj);
}
foreach (var spec in m_src.GetAllSpecificObjects())
{
if (grps.Contains(spec.GroupId))
{
continue;
}
objs.Add(spec);
}
return(objs);
}
public async Task SchedulingSimpleTest()
{
const int TasksCount = 5000;
var threadIds = new HashSetEx <int>();
var priorities = new HashSetEx <ThreadPriority>();
var taskWasNotContinuedInline = false;
var tasks = new Task[TasksCount];
var rnd = new Random(0);
for (int i = 0; i < TasksCount; i++)
{
tasks[i] = HeavyComputationTaskScheduler.Run(
async() =>
{
lock (threadIds)
{
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
priorities.Add(Thread.CurrentThread.Priority);
}
Thread.SpinWait(100_000 * rnd.Next(3, 6));
await Task.Yield();
lock (threadIds)
{
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
priorities.Add(Thread.CurrentThread.Priority);
}
await Task.Delay(1);
var tid = Thread.CurrentThread.ManagedThreadId;
await Task.CompletedTask;
if (tid != Thread.CurrentThread.ManagedThreadId)
{
taskWasNotContinuedInline = true;
}
lock (threadIds)
{
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
priorities.Add(Thread.CurrentThread.Priority);
}
Thread.SpinWait(100_000 * rnd.Next(3, 6));
});
}
await Task.WhenAll(tasks);
//// threadIds.Count.Should().Be(Environment.ProcessorCount);
priorities.Count.Should().Be(1);
priorities.Single().Should().Be(ThreadPriority.BelowNormal);
taskWasNotContinuedInline.Should().BeFalse();
}
public static HashSet <string> GetSuperAccounts(string mainNick)
{
Util.Assert(TbNickHelper.IsMainAccount(mainNick));
var subAccs = Params.Auth.GetSuperAccounts(mainNick) ?? new HashSet <string>();
var superAccs = HashSetEx.Create <string>(subAccs.Select(k => mainNick + ":" + k));
superAccs.Add(mainNick);
return(superAccs);
}
public override HashSetEx <string> GetSupportedKeys()
{
var res = new HashSetEx <string>();
res.Add("Encoding");
res.Add("EncodingStyle");
res.Add("Url");
res.Add("HttpLogin");
res.Add("HttpPassword");
return(res);
}
protected virtual HashSetEx<string> LoadKeywords()
{
var res = new HashSetEx<string>();
res.Add("SELECT"); res.Add("CREATE"); res.Add("UPDATE"); res.Add("DELETE");
res.Add("DROP"); res.Add("ALTER"); res.Add("TABLE"); res.Add("VIEW");
res.Add("FROM"); res.Add("WHERE"); res.Add("GROUP"); res.Add("ORDER"); res.Add("BY");
res.Add("ASC"); res.Add("DESC"); res.Add("HAVING"); res.Add("INTO"); res.Add("ASC");
res.Add("LEFT"); res.Add("RIGHT"); res.Add("INNER"); res.Add("OUTER");
res.Add("CROSS"); res.Add("NATURAL"); res.Add("JOIN"); res.Add("ON");
res.Add("DISTINCT"); res.Add("ALL"); res.Add("ANY");
return res;
}
//public virtual DbTypeBase CreateCommonType(ColumnInfo column)
//{
// return new DbTypeString();
//}
protected virtual HashSetEx <string> LoadKeywords()
{
var res = new HashSetEx <string>();
res.Add("SELECT"); res.Add("CREATE"); res.Add("UPDATE"); res.Add("DELETE");
res.Add("DROP"); res.Add("ALTER"); res.Add("TABLE"); res.Add("VIEW");
res.Add("FROM"); res.Add("WHERE"); res.Add("GROUP"); res.Add("ORDER"); res.Add("BY");
res.Add("ASC"); res.Add("DESC"); res.Add("HAVING"); res.Add("INTO"); res.Add("ASC");
res.Add("LEFT"); res.Add("RIGHT"); res.Add("INNER"); res.Add("OUTER");
res.Add("CROSS"); res.Add("NATURAL"); res.Add("JOIN"); res.Add("ON");
res.Add("DISTINCT"); res.Add("ALL"); res.Add("ANY");
return(res);
}
// Returns a list of data source names from the local machine.
public static List <string> GetAllDataSourceNames()
{
// Get the list of user DSN's first.
var dsnList = GetUserDataSourceNames();
// Get list of System DSN's and add them to the first list.
var systemDsnList = GetSystemDataSourceNames();
var res = new HashSetEx <string>();
res.AddRange(dsnList);
res.AddRange(systemDsnList);
return(new List <string>(res));
}
public string[] Complement(List <string> cols)
{
var incols = new HashSetEx <string>(cols);
var res = new List <string>();
foreach (var item in Columns)
{
if (!incols.Contains(item.Target))
{
res.Add(item.Target);
}
}
return(res.ToArray());
}
public void TryGetValue()
{
var actual = new object();
var check = new object();
var equalityComparer = new CustomEqualityComparer <object>(FuncHelper.GetTautologyFunc <object, object>(), _ => 0);
var hashSet = new HashSetEx <object>(equalityComparer)
{
actual
};
var test = hashSet.TryGetValue(check, out var found);
Assert.IsTrue(test);
Assert.AreSame(actual, found);
Assert.AreNotSame(check, found);
}
public static string[] GetLatest5SecDetectedNicksNotNull()
{
string[] nicks = null;
try
{
var set = HashSetEx.Create <string>(_sellerHistory.Where(kv => kv.Value.xElapse().TotalSeconds < 5.0).Select(kv => kv.Key));
set.xAddRange(GetSellers());
nicks = (set.ToArray <string>() ?? new string[0]);
}
catch (Exception e)
{
Log.Exception(e);
}
return(nicks);
}
public ObjectGridOverview(IList data)
{
m_data = new List <object>(data.Count);
foreach (var obj in data)
{
m_data.Add(obj);
var type = obj.GetType();
if (m_types.ContainsKey(type))
{
continue;
}
m_types[type] = GetProperties(type);
}
var cols = new HashSetEx <string>();
foreach (var lst in m_types.Values)
{
foreach (var def in lst)
{
cols.Add(def.DisplayName);
}
}
m_columns = new List <string>(cols);
m_columns.Sort(CompareCols);
foreach (var tp in m_types.Keys)
{
m_colDefs[tp] = new List <ObjectGridPropertyDef>();
foreach (string col in m_columns)
{
ObjectGridPropertyDef def = null;
foreach (var d in m_types[tp])
{
if (d.DisplayName == col)
{
def = d;
break;
}
}
m_colDefs[tp].Add(def);
}
}
}
private static string AllocName(HashSetEx <string> usedNames, ref int lastIndex, string preffered, string prefix)
{
string name;
if (preffered != null)
{
name = preffered;
int idx = 1;
while (usedNames.Contains(name))
{
name = String.Format("{0}{1}", name, idx++);
}
}
else
{
name = String.Format("{0}_{1}", prefix, ++lastIndex);
}
usedNames.Add(name);
return(name);
}
private List <DbDiffAction> GetColumnActions()
{
var res = new List <DbDiffAction>();
if (m_shownAction == null)
{
return(res);
}
if (!(m_shownAction.SourceObject is ITableStructure) || !(m_shownAction.TargetObject is ITableStructure))
{
return(res);
}
var grps = new HashSetEx <string>();
foreach (var elem in m_shownAction.Elements)
{
if (!(elem.AnyObject is IColumnStructure))
{
continue;
}
res.Add(elem);
grps.Add(elem.GroupId);
}
foreach (var scol in ((ITableStructure)m_shownAction.SourceObject).Columns)
{
if (grps.Contains(scol.GroupId))
{
continue;
}
grps.Add(scol.GroupId);
res.Add(new DbDiffAction(m_diff)
{
GroupId = scol.GroupId
});
}
res.Sort((a, b) => ((IColumnStructure)a.AnyObject).ColumnOrder - ((IColumnStructure)b.AnyObject).ColumnOrder);
return(res);
}
// [Require(typeof(IClusterNode))]
private LoggerWebApp(
IIxResolver resolver,
IWebHostBuilder webHostBuilder,
IJsonLogger logger,
ILogReader logReader,
LoggerWebAppConfig config)
{
Log = new ClassJsonLogger <LoggerWebApp>(logger);
Log.Info(_ => _("Starting Asp.Net core..."));
_webHost = webHostBuilder
// Should be removed after adoption IndirectX to Asp.Net core.
.ConfigureServices(
x => x
.AddHttpRequestScopeService()
.AddScopedHttpContextAccessor()
.AddSingleton(new Tuple <IJsonLogger, IIxResolver>(Log, resolver))
.AddSingleton <ILogReader>(logReader)
.AddSingleton(config))
.UseStartup <LoggerWebAppStartup>()
.ConfigureJsonFormatters(JsonDefaults.RestRpcSerializerSource.Settings)
.Build();
_webHost.Start();
var addressesFeature = _webHost.ServerFeatures.Get <IServerAddressesFeature>();
var addresses = new HashSetEx <string>();
foreach (string addressesFeatureAddress in addressesFeature.Addresses)
{
addresses.Add(addressesFeatureAddress);
Log.Info(
addressesFeatureAddress,
(_, addr) => _($"Now listening on: {addr}").Data(new { ListenAddress = addr }));
}
HostingUrls = addresses;
}
public void HashSetEqualsTest()
{
HashSetEx.HashSetEquals <int>(null, null).ShouldBe(true);
var set1 = new HashSet <int>()
{
1, 10, 20
};
var set2 = new HashSet <int>()
{
10, 1, 20
};
set1.HashSetEquals(set2).ShouldBe(true);
set1.HashSetEquals(null).ShouldBe(false);
var set3 = new HashSet <int>()
{
10, 1, 20, 30
};
set1.HashSetEquals(set3).ShouldBe(false);
}
public static void SaveLines(string path, HashSetEx<string> lines)
{
using (var sw = new StreamWriter(path))
{
foreach (string line in lines)
{
sw.WriteLine(line);
}
}
}
public override void WriteStructureAfterData(IDatabaseStructure db)
{
HashSetEx <string> usedTypes = new HashSetEx <string> {
"String", "Int", "DateTime"
};
Dictionary <NameWithSchema, string> tableTypes = new Dictionary <NameWithSchema, string>();
foreach (var tbl in db.Tables)
{
tableTypes[tbl.FullName] = GetMemberName(usedTypes, tbl.FullName.Name, null);
}
ISqlDialect dialect = m_dialect;
using (XmlWriter xw = XmlWriter.Create(GetWorkingFileName(), new XmlWriterSettings {
Indent = true
}))
{
string XMLNS = "http://schemas.microsoft.com/linqtosql/dbml/2007";
xw.WriteStartDocument();
xw.WriteStartElement("Database", XMLNS);
xw.WriteAttributeString("xmlns", XMLNS);
xw.WriteAttributeString("Name", DatabaseName);
xw.WriteAttributeString("Class", ClassName);
xw.WriteAttributeString("ContextNamespace", ContextNamespace);
xw.WriteAttributeString("EntityNamespace", EntityNamespace);
foreach (var tbl in db.Tables)
{
HashSetEx <string> tblmembers = new HashSetEx <string>();
string tblmember = tbl.FullName.Name;
tblmembers.Add(tblmember);
xw.WriteStartElement("Table");
xw.WriteAttributeString("Name", tbl.FullName.ToString());
xw.WriteAttributeString("Member", tblmember);
xw.WriteStartElement("Type");
xw.WriteAttributeString("Name", tableTypes[tbl.FullName]);
IPrimaryKey pk = tbl.FindConstraint <IPrimaryKey>();
foreach (var col in tbl.Columns)
{
string colmember = GetMemberName(tblmembers, col.ColumnName, null);
tblmembers.Add(colmember);
xw.WriteStartElement("Column");
if (col.ColumnName != colmember)
{
xw.WriteAttributeString("Member", colmember);
}
if (pk != null && pk.Columns.Any(c => c.ColumnName == col.ColumnName))
{
xw.WriteAttributeString("IsPrimaryKey", "true");
}
xw.WriteAttributeString("Name", col.ColumnName);
xw.WriteAttributeString("CanBeNull", col.IsNullable ? "true" : "false");
xw.WriteAttributeString("Type", GetLinqType(col.DataType));
xw.WriteAttributeString("DbType", dialect.GenericTypeToSpecific(col.DataType).ToString());
if (col.DataType.IsAutoIncrement())
{
xw.WriteAttributeString("IsDbGenerated", "true");
}
xw.WriteEndElement(); // Column
}
foreach (var fk in tbl.GetConstraints <IForeignKey>())
{
if (fk.Columns.Count != 1)
{
continue;
}
xw.WriteStartElement("Association");
xw.WriteAttributeString("Name", fk.Name);
xw.WriteAttributeString("Member", GetMemberName(tblmembers, fk.PrimaryKeyTable.Name, fk.Columns[0].ColumnName));
xw.WriteAttributeString("Type", tableTypes[fk.PrimaryKeyTable]);
xw.WriteAttributeString("ThisKey", fk.Columns[0].ColumnName);
xw.WriteAttributeString("OtherKey", fk.PrimaryKeyColumns[0].ColumnName);
xw.WriteAttributeString("IsForeignKey", "true");
xw.WriteEndElement(); // Association
}
xw.WriteEndElement(); // Type
xw.WriteEndElement(); // Table
}
xw.WriteEndElement(); // Database
xw.WriteEndDocument();
}
}
