private void SetupNotifications()
{
if (this.notifications != null)
{
this.notifications.Close();
this.notifications = null;
}
this.notifications = new NotificationHandler(this.gablarski);
var enabledSpeech = new MutableLookup <ITextToSpeech, NotificationType>();
foreach (var enabled in Settings.EnabledNotifications)
{
Type type = Type.GetType(enabled.Key);
if (type == null)
{
LogManager.GetLogger("Notifications").WarnFormat("Notifier {0} not found", enabled.Key);
continue;
}
object n = Activator.CreateInstance(type);
var notifier = n as INotifier;
if (notifier != null)
{
this.notifications.AddNotifier(notifier, enabled);
}
else if (n is ITextToSpeech)
{
enabledSpeech.Add((ITextToSpeech)n, enabled);
}
}
if (enabledSpeech.Count > 0)
{
foreach (var enabled in enabledSpeech)
{
ITextToSpeech tts = enabled.Key;
tts.Media = this.mediaPlayerIntegration;
var format = tts.SupportedFormats.OrderByDescending(af => af.SampleRate).FirstOrDefault();
if (format == null)
{
format = new AudioFormat(WaveFormatEncoding.LPCM, 1, 16, 44100);
}
var source = this.gablarski.Sources.CreateFake("speech", format, (short)(format.SampleRate / 100));
this.speechSources.Add(tts, source);
tts.AudioSource = source;
this.gablarski.Audio.Attach(this.audioPlayback, source, new AudioEnginePlaybackOptions());
this.notifications.AddNotifier(tts, enabled);
}
this.notifications.SpeechReceiver = this.gablarski.Sources;
}
this.notifications.MediaController = this.mediaPlayerIntegration;
}
public async Task InitializeAsync()
{
_logger.LogTrace("Downloading accounts from database.");
using (var c = _context())
{
_securities = await c.Securities
.Select(s => new Security
{
SecurityId = s.SecurityId,
Name = s.Name,
Ticker = s.Ticker,
})
.ToDictionaryAsync(s => s.SecurityId);
_securityValues = (await c.SecurityValues
.Select(sv => new Security
{
SecurityId = sv.SecurityId,
CurrentValueDate = sv.Date,
CurrentValue = sv.Value,
})
.ToListAsync())
.ToMutableLookup(
sv => sv.SecurityId,
sv => sv,
sv => sv.CurrentValueDate);
}
}
public void TestOverallEquivalence([Values(false, true)] bool includeNull)
{
//--Arrange
var collection = BuildSourceCollection(includeNull);
var expected = collection.ToLookup(x => x.key, x => x.element);
//--Act/Assert
var actual = new MutableLookup <long?, Guid>();
foreach (var grouping in expected)
{
CollectionAssert.IsEmpty(actual[grouping.Key]);
actual[grouping.Key] = grouping;
}
//--Assert
Assert.IsFalse(actual.Contains(-1));
CollectionAssert.AreEquivalent(expected.Select(x => x.Key), actual.Select(x => x.Key));
foreach (var expectedGrouping in expected)
{
Assert.IsTrue(actual.Contains(expectedGrouping.Key));
CollectionAssert.AreEquivalent(expectedGrouping, actual[expectedGrouping.Key]);
}
foreach (var(expectedGrouping, actualGrouping) in expected.Zip(actual, (e, a) => (e, a)))
{
Assert.AreEqual(expectedGrouping.Key, actualGrouping.Key);
CollectionAssert.AreEquivalent(expectedGrouping, actualGrouping);
}
}
public void TryGetValuesNullFail()
{
var lookup = new MutableLookup <string, string>();
IEnumerable <string> values;
Assert.IsFalse(lookup.TryGetValues(null, out values));
Assert.IsNull(values);
}
public void DoesNotContainNull()
{
var lookup = new MutableLookup <string, string>();
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsFalse(lookup.Contains(null));
}
public void Add()
{
var lookup = new MutableLookup<string, string>();
lookup.Add ("F", "Foo");
Assert.AreEqual (1, lookup.Count);
Assert.AreEqual ("Foo", lookup["F"].First());
lookup.Add ("F", "Foobar");
Assert.AreEqual (1, lookup.Count);
Assert.AreEqual (2, lookup["F"].Count());
}
public void AddNull()
{
var lookup = new MutableLookup<string, string>();
lookup.Add (null, "Foo");
Assert.AreEqual (1, lookup.Count);
Assert.AreEqual (1, lookup[null].Count());
lookup.Add (null, null);
Assert.AreEqual (1, lookup.Count);
Assert.AreEqual (2, lookup[null].Count());
}
public void AddMultipleNull()
{
var values = new [] { "Foo", "Foobar" };
var lookup = new MutableLookup<string, string>();
lookup.Add (null, values);
Assert.AreEqual (1, lookup.Count);
Assert.IsTrue (values.SequenceEqual (lookup[null]), "S");
Assert.Throws<ArgumentNullException> (() => lookup.Add ("foo", (IEnumerable<string>)null));
}
public void AddMultipleNull()
{
var values = new [] { "Foo", "Foobar" };
var lookup = new MutableLookup <string, string>();
lookup.Add(null, values);
Assert.AreEqual(1, lookup.Count);
Assert.IsTrue(values.SequenceEqual(lookup[null]), "S");
Assert.Throws <ArgumentNullException> (() => lookup.Add("foo", (IEnumerable <string>)null));
}
public void Add()
{
var lookup = new MutableLookup <string, string>();
lookup.Add("F", "Foo");
Assert.AreEqual(1, lookup.Count);
Assert.AreEqual("Foo", lookup["F"].First());
lookup.Add("F", "Foobar");
Assert.AreEqual(1, lookup.Count);
Assert.AreEqual(2, lookup["F"].Count());
}
public void GroupingEnumerator()
{
List <int> ints = new List <int> {
10, 20, 21, 30
};
var lookup = new MutableLookup <int, int>(ints.ToLookup(i => Int32.Parse(i.ToString()[0].ToString())));
Assert.AreEqual(2, lookup[2].Count());
Assert.IsTrue(lookup[2].Any(i => i == 20));
Assert.IsTrue(lookup[2].Any(i => i == 21));
}
public void AddNull()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, "Foo");
Assert.AreEqual(1, lookup.Count);
Assert.AreEqual(1, lookup[null].Count());
lookup.Add(null, (string)null);
Assert.AreEqual(1, lookup.Count);
Assert.AreEqual(2, lookup[null].Count());
}
public override bool Autoload(ref string name, ref string texture)
{
if (Plants == null)
{
Plants = new MutableLookup <int, PlantTile>();
}
foreach (var tileType in GrowthTiles)
{
Plants.Add(tileType, this);
}
return(base.Autoload(ref name, ref texture));
}
public void EnumeratorNotNull()
{
List <string> strings = new List <string> {
"hi", "hai", "bai", "bye"
};
var lookup = new MutableLookup <string, string> (strings.ToLookup(s => s[0].ToString()));
Assert.AreEqual(2, lookup.Count);
Assert.IsTrue(lookup.Any(g => g.Key == "h"));
Assert.IsTrue(lookup.Any(g => g.Key == "b"));
Assert.IsFalse(lookup.Any(g => g.Key == null));
}
public void CtorILookup()
{
List <int> ints = new List <int> {
10, 20, 21, 30
};
var lookup = new MutableLookup <int, int> (ints.ToLookup(i => Int32.Parse(i.ToString()[0].ToString())));
Assert.AreEqual(3, lookup.Count);
Assert.AreEqual(1, lookup[1].Count());
Assert.AreEqual(2, lookup[2].Count());
Assert.AreEqual(1, lookup[3].Count());
}
public void ContainsNull()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsTrue(lookup.Contains(null));
}
public void IndexerNotFound()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.AreEqual(0, lookup["D"].Count());
}
public void Enumerator()
{
List <int> ints = new List <int> {
10, 20, 21, 30
};
var lookup = new MutableLookup <int, int>(ints.ToLookup(i => Int32.Parse(i.ToString()[0].ToString())));
Assert.AreEqual(3, lookup.Count());
Assert.IsTrue(lookup.Any(g => g.Key == 1));
Assert.IsTrue(lookup.Any(g => g.Key == 2));
Assert.IsTrue(lookup.Any(g => g.Key == 3));
}
public void DoesNotContain()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsFalse(lookup.Contains("D"));
}
public MutableLookup <string, string> GetTestLookup()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, (string)null);
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
return(lookup);
}
public void ClearWithNull()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, "blah");
lookup.Add("F", "Foo");
lookup.Clear();
Assert.AreEqual(0, lookup.Count);
Assert.IsFalse(lookup.Contains(null));
Assert.IsFalse(lookup.Contains("F"));
}
public void ClearWithoutNull()
{
var lookup = new MutableLookup <string, string>();
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
lookup.Clear();
Assert.AreEqual(0, lookup.Count);
Assert.IsFalse(lookup.Contains("F"));
Assert.IsFalse(lookup.Contains("B"));
}
public void AddMultiple()
{
var values = new [] { "Foo", "Foobar" };
var lookup = new MutableLookup<string, string>();
lookup.Add ("key", values);
Assert.AreEqual (1, lookup.Count);
Assert.Contains (values[0], lookup["key"].ToList());
Assert.Contains (values[1], lookup["key"].ToList());
lookup.Add ("key2", values);
Assert.AreEqual (2, lookup.Count);
Assert.Contains (values[0], lookup["key2"].ToList());
Assert.Contains (values[1], lookup["key2"].ToList());
}
public void CtorILookupWithNulls()
{
List <string> strs = new List <string> {
"Foo", "Foos", "Foobar", "Monkeys", "Bar", "Ban", "Barfoo"
};
var lookup = new MutableLookup <string, string> (strs.ToLookup(s => (s[0] != 'F' && s[0] != 'B') ? null : s[0].ToString()));
Assert.AreEqual(3, lookup.Count);
Assert.AreEqual(3, lookup["F"].Count());
Assert.AreEqual(3, lookup["B"].Count());
Assert.AreEqual(1, lookup[null].Count());
}
public void UpdateSettings()
{
Settings.EnableNotifications = NotificationsEnabled;
var notifications = new MutableLookup <string, NotificationType>();
foreach (var notifier in Notifiers.Where(vm => vm.IsEnabled))
{
string name = notifier.Notifier.GetType().GetSimpleName();
notifications.Add(name, this.globalNotifications[name].Where(vm => vm.IsEnabled).Select(vm => vm.Type));
}
Settings.EnabledNotifications = notifications;
}
public void AddMultiple()
{
var values = new [] { "Foo", "Foobar" };
var lookup = new MutableLookup <string, string>();
lookup.Add("key", values);
Assert.AreEqual(1, lookup.Count);
Assert.Contains(values[0], lookup["key"].ToList());
Assert.Contains(values[1], lookup["key"].ToList());
lookup.Add("key2", values);
Assert.AreEqual(2, lookup.Count);
Assert.Contains(values[0], lookup["key2"].ToList());
Assert.Contains(values[1], lookup["key2"].ToList());
}
public void EnumeratorNull()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.AreEqual(3, lookup.Count());
Assert.IsTrue(lookup.Any(g => g.Key == null));
Assert.IsTrue(lookup.Any(g => g.Key == "F"));
Assert.IsTrue(lookup.Any(g => g.Key == "B"));
}
public void ClearValueType()
{
var lookup = new MutableLookup<int, int>();
lookup.Add (1, 10);
lookup.Add (1, 12);
lookup.Add (1, 13);
lookup.Add (2, 21);
lookup.Add (2, 22);
lookup.Add (2, 23);
lookup.Clear();
Assert.AreEqual (0, lookup.Count);
Assert.IsFalse (lookup.Contains (1));
Assert.IsFalse (lookup.Contains (2));
}
public void CountValueType()
{
var lookup = new MutableLookup <int, int>();
Assert.AreEqual(0, lookup.Count);
lookup.Add(1, 10);
Assert.AreEqual(1, lookup.Count);
lookup.Add(2, 20);
Assert.AreEqual(2, lookup.Count);
lookup.Add(2, 21);
Assert.AreEqual(2, lookup.Count);
lookup.Remove(1, 10);
Assert.AreEqual(1, lookup.Count);
}
public void CountRefType()
{
var lookup = new MutableLookup <string, string>();
Assert.AreEqual(0, lookup.Count);
lookup.Add(null, "blah");
Assert.AreEqual(1, lookup.Count);
lookup.Add("F", "Foo");
Assert.AreEqual(2, lookup.Count);
lookup.Add("F", "Foobar");
Assert.AreEqual(2, lookup.Count);
lookup.Remove(null, "blah");
Assert.AreEqual(1, lookup.Count);
}
public void ClearValueType()
{
var lookup = new MutableLookup <int, int>();
lookup.Add(1, 10);
lookup.Add(1, 12);
lookup.Add(1, 13);
lookup.Add(2, 21);
lookup.Add(2, 22);
lookup.Add(2, 23);
lookup.Clear();
Assert.AreEqual(0, lookup.Count);
Assert.IsFalse(lookup.Contains(1));
Assert.IsFalse(lookup.Contains(2));
}
public void NullGroupingEnumerator()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, null);
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.AreEqual(3, lookup[null].Count());
Assert.IsTrue(lookup[null].Any(s => s == "blah"));
Assert.IsTrue(lookup[null].Any(s => s == "monkeys"));
Assert.IsTrue(lookup[null].Any(s => s == null));
}
public CommandService()
{
_activations = new ObjectsStorage <object, EventHandlerSubscriptionStorage>(ComponentSubscriptionActivationFactory);
_trackerRegistry = new ObservableCollection <CommandServiceComponent>();
_viewRegistry = new ObservableCollection <CommandServiceComponent>();
_metadata = new MutableLookup <object, ComponentMetadata>();
_componentsTracker = DeepTracker.Setup(_trackerRegistry)
.Subscribe <ObjectAttachmentEventArgs>(OnObjectAttachmentEvent)
.Subscribe <ChangedPropertyEventArgs>(OnChangedPropertyEvent)
.Include <CommandServiceComponent>(instance => instance.Id)
.Include <CommandBundle>(instance => instance.Groups)
.Include <CommandBundle>(instance => instance.Context)
.Include <CommandGroup>(instance => instance.Commands)
.Include <CommandServiceCommand>(instance => instance.Commands)
.Create()
.Activate();
}
public NotificationSettingsViewModel()
{
Notifiers = Modules.Notifiers.Concat (Modules.TextToSpeech.Cast<INamedComponent>())
.Select (n => new NotifierViewModel (n, Settings.EnabledNotifications.Contains (n.GetType().GetSimpleName())))
.ToArray();
NotificationsEnabled = Settings.EnableNotifications;
this.globalNotifications = new MutableLookup<string, NotificationTypeViewModel> ();
foreach (string notifier in Notifiers.Select (n => n.Notifier.GetType().GetSimpleName())) {
this.globalNotifications.Add (notifier,
Enum.GetValues (typeof (NotificationType))
.Cast<NotificationType>()
.Select (t =>
new NotificationTypeViewModel (t, Settings.EnabledNotifications[notifier].Contains (t))));
}
CurrentNotifier = Notifiers.FirstOrDefault();
}
public void RemoveNonExisting()
{
var lookup = new MutableLookup <string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsFalse(lookup.Remove("D"));
Assert.AreEqual(3, lookup.Count);
Assert.IsFalse(lookup.Remove("F", "asdf"));
Assert.AreEqual(3, lookup.Count);
lookup.Remove(null);
Assert.IsFalse(lookup.Remove(null));
Assert.AreEqual(2, lookup.Count);
}
public async Task InitializeAsync()
{
_logger.LogTrace("Downloading transactions from database.");
using (var c = _context())
{
var transactions = await c.Transactions
.LoadWith(t => t.TransactionItems)
.AsQueryable()
.AsAsyncEnumerable()
.Select(t => new Transaction
{
TransactionId = t.TransactionId,
Date = t.Date,
Description = t.Description,
Memo = t.Memo,
TransactionItems = t.TransactionItems
.Select(ti => new TransactionItem
{
TransactionItemId = ti.TransactionItemId,
AccountId = ti.AccountId,
SecurityId = ti.SecurityId,
Shares = ti.Shares,
Amount = ti.Amount,
Memo = ti.Memo,
ClearedStatus = ti.ClearedStatusId,
PlaidTransactionData = ti.PlaidTransactionData,
Account = _accountService.GetAccount(ti.AccountId),
Security = _securityService.GetSecurity(ti.SecurityId),
})
.ToList(),
})
.ToListAsync();
_transactionsById = transactions.ToDictionary(t => t.TransactionId);
_transactionsByAccountId = transactions
.SelectMany(t => t.TransactionItems, (t, ti) => (t, ti.AccountId))
.ToMutableLookup(x => x.AccountId, x => x.t, t => t.Date);
}
}
public void NullGroupingEnumerator()
{
var lookup = new MutableLookup<string, string>();
lookup.Add (null, null);
lookup.Add (null, "blah");
lookup.Add (null, "monkeys");
lookup.Add ("F", "Foo");
lookup.Add ("F", "Foobar");
lookup.Add ("B", "Bar");
Assert.AreEqual (3, lookup[null].Count());
Assert.IsTrue (lookup[null].Any (s => s == "blah"));
Assert.IsTrue (lookup[null].Any (s => s == "monkeys"));
Assert.IsTrue (lookup[null].Any (s => s == null));
}
public void IndexerNull()
{
var lookup = new MutableLookup<string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.AreEqual (2, lookup[null].Count());
}
public void ClearWithoutNull()
{
var lookup = new MutableLookup<string, string>();
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
lookup.Clear();
Assert.AreEqual (0, lookup.Count);
Assert.IsFalse (lookup.Contains ("F"));
Assert.IsFalse (lookup.Contains ("B"));
}
public void ClearWithNull()
{
var lookup = new MutableLookup<string, string>();
lookup.Add (null, "blah");
lookup.Add ("F", "Foo");
lookup.Clear();
Assert.AreEqual (0, lookup.Count);
Assert.IsFalse (lookup.Contains (null));
Assert.IsFalse (lookup.Contains ("F"));
}
internal MutableLookup<string, string> GetTestLookup()
{
var lookup = new MutableLookup<string, string>();
lookup.Add (null, (string)null);
lookup.Add (null, "blah");
lookup.Add (null, "monkeys");
lookup.Add ("F", "Foo");
lookup.Add ("F", "Foobar");
lookup.Add ("B", "Bar");
return lookup;
}
public void CountRefType()
{
var lookup = new MutableLookup<string, string>();
Assert.AreEqual (0, lookup.Count);
lookup.Add (null, "blah");
Assert.AreEqual (1, lookup.Count);
lookup.Add ("F", "Foo");
Assert.AreEqual (2, lookup.Count);
lookup.Add ("F", "Foobar");
Assert.AreEqual (2, lookup.Count);
lookup.Remove (null, "blah");
Assert.AreEqual (1, lookup.Count);
}
public void CtorILookupWithNulls()
{
List<string> strs = new List<string> { "Foo", "Foos", "Foobar", "Monkeys", "Bar", "Ban", "Barfoo" };
var lookup = new MutableLookup<string, string> (strs.ToLookup (s => (s[0] != 'F' && s[0] != 'B') ? null : s[0].ToString()));
Assert.AreEqual (3, lookup.Count);
Assert.AreEqual (3, lookup["F"].Count());
Assert.AreEqual (3, lookup["B"].Count());
Assert.AreEqual (1, lookup[null].Count());
}
public void Update(IEnumerable<IUserInfo> userUpdate)
{
if (userUpdate == null)
throw new ArgumentNullException ("userUpdate");
lock (this.syncRoot)
{
this.ignores = new HashSet<int> (this.ignores.Intersect (userUpdate.Select (u => u.UserId)));
this.users = userUpdate.ToDictionary (u => u.UserId, u => new UserInfo (u));
this.channels =
new MutableLookup<int, UserInfo> (userUpdate.ToLookup (u => u.CurrentChannelId, u => new UserInfo (u)));
}
}
public void DoesNotContainNull()
{
var lookup = new MutableLookup<string, string>();
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsFalse (lookup.Contains (null));
}
public void DoesNotContain()
{
var lookup = new MutableLookup<string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsFalse (lookup.Contains ("D"));
}
public void Enumerator()
{
List<int> ints = new List<int> { 10, 20, 21, 30 };
var lookup = new MutableLookup<int, int>(ints.ToLookup(i => Int32.Parse(i.ToString()[0].ToString())));
Assert.AreEqual (3, lookup.Count());
Assert.IsTrue (lookup.Any (g => g.Key == 1));
Assert.IsTrue (lookup.Any (g => g.Key == 2));
Assert.IsTrue (lookup.Any (g => g.Key == 3));
}
public void EnumeratorNotNull()
{
List<string> strings = new List<string> { "hi", "hai", "bai", "bye" };
var lookup = new MutableLookup<string, string> (strings.ToLookup (s => s[0].ToString()));
Assert.AreEqual (2, lookup.Count);
Assert.IsTrue (lookup.Any (g => g.Key == "h"));
Assert.IsTrue (lookup.Any (g => g.Key == "b"));
Assert.IsFalse (lookup.Any (g => g.Key == null));
}
public void TryGetValuesNullFail()
{
var lookup = new MutableLookup<string,string>();
IEnumerable<string> values;
Assert.IsFalse (lookup.TryGetValues (null, out values));
Assert.IsNull (values);
}
public void EnumeratorNull()
{
var lookup = new MutableLookup<string, string>();
lookup.Add (null, "blah");
lookup.Add (null, "monkeys");
lookup.Add ("F", "Foo");
lookup.Add ("F", "Foobar");
lookup.Add ("B", "Bar");
Assert.AreEqual (3, lookup.Count());
Assert.IsTrue (lookup.Any (g => g.Key == null));
Assert.IsTrue (lookup.Any (g => g.Key == "F"));
Assert.IsTrue (lookup.Any (g => g.Key == "B"));
}
public void CtorILookup()
{
List<int> ints = new List<int> { 10, 20, 21, 30 };
var lookup = new MutableLookup <int, int> (ints.ToLookup (i => Int32.Parse (i.ToString()[0].ToString())));
Assert.AreEqual (3, lookup.Count);
Assert.AreEqual (1, lookup[1].Count());
Assert.AreEqual (2, lookup[2].Count());
Assert.AreEqual (1, lookup[3].Count());
}
public void ContainsNull()
{
var lookup = new MutableLookup<string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsTrue (lookup.Contains (null));
}
public void CountValueType()
{
var lookup = new MutableLookup<int, int>();
Assert.AreEqual (0, lookup.Count);
lookup.Add (1, 10);
Assert.AreEqual (1, lookup.Count);
lookup.Add (2, 20);
Assert.AreEqual (2, lookup.Count);
lookup.Add (2, 21);
Assert.AreEqual (2, lookup.Count);
lookup.Remove (1, 10);
Assert.AreEqual(1, lookup.Count);
}
public void GroupingEnumerator()
{
List<int> ints = new List<int> { 10, 20, 21, 30 };
var lookup = new MutableLookup<int, int>(ints.ToLookup(i => Int32.Parse(i.ToString()[0].ToString())));
Assert.AreEqual (2, lookup[2].Count());
Assert.IsTrue (lookup[2].Any (i => i == 20));
Assert.IsTrue (lookup[2].Any(i => i == 21));
}
private void SetupNotifications ()
{
if (this.notifications != null)
{
this.notifications.Close();
this.notifications = null;
}
this.notifications = new NotificationHandler (this.gablarski);
var enabledSpeech = new MutableLookup<ITextToSpeech, NotificationType>();
foreach (var enabled in Settings.EnabledNotifications) {
Type type = Type.GetType (enabled.Key);
if (type == null) {
LogManager.GetLogger ("Notifications").WarnFormat ("Notifier {0} not found", enabled.Key);
continue;
}
object n = Activator.CreateInstance (type);
var notifier = n as INotifier;
if (notifier != null)
this.notifications.AddNotifier (notifier, enabled);
else if (n is ITextToSpeech)
enabledSpeech.Add ((ITextToSpeech) n, enabled);
}
if (enabledSpeech.Count > 0) {
foreach (var enabled in enabledSpeech) {
ITextToSpeech tts = enabled.Key;
tts.Media = this.mediaPlayerIntegration;
var format = tts.SupportedFormats.OrderByDescending (af => af.SampleRate).FirstOrDefault();
if (format == null)
format = new AudioFormat (WaveFormatEncoding.LPCM, 1, 16, 44100);
var source = this.gablarski.Sources.CreateFake ("speech", format, (short)(format.SampleRate / 100));
this.speechSources.Add (tts, source);
tts.AudioSource = source;
this.gablarski.Audio.Attach (this.audioPlayback, source, new AudioEnginePlaybackOptions());
this.notifications.AddNotifier (tts, enabled);
}
this.notifications.SpeechReceiver = this.gablarski.Sources;
}
this.notifications.MediaController = this.mediaPlayerIntegration;
}
public void RemoveNonExisting()
{
var lookup = new MutableLookup<string, string>();
lookup.Add(null, "blah");
lookup.Add(null, "monkeys");
lookup.Add("F", "Foo");
lookup.Add("F", "Foobar");
lookup.Add("B", "Bar");
Assert.IsFalse (lookup.Remove ("D"));
Assert.AreEqual(3, lookup.Count);
Assert.IsFalse (lookup.Remove ("F", "asdf"));
Assert.AreEqual(3, lookup.Count);
lookup.Remove (null);
Assert.IsFalse (lookup.Remove (null));
Assert.AreEqual (2, lookup.Count);
}
public void UpdateSettings()
{
Settings.EnableNotifications = NotificationsEnabled;
var notifications = new MutableLookup<string, NotificationType>();
foreach (var notifier in Notifiers.Where (vm => vm.IsEnabled))
{
string name = notifier.Notifier.GetType().GetSimpleName();
notifications.Add (name, this.globalNotifications[name].Where (vm => vm.IsEnabled).Select (vm => vm.Type));
}
Settings.EnabledNotifications = notifications;
}
