public object this[object o, INamedVersionedUniqueId p, string k] { get { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } if (k == null) { throw new ArgumentNullException("k"); } SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k); SharedDictionaryEntry result; return(_values.TryGetValue(e, out result) ? result.Value : null); } set { Set(o, p, k, value); } }
public T GetOrSet <T>(object o, INamedVersionedUniqueId p, string k, Func <T> value) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } if (k == null) { throw new ArgumentNullException("k"); } SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k); SharedDictionaryEntry result; if (_values.TryGetValue(e, out result)) { return((T)result.Value); } T val = value == null ? default(T) : value(); e.Value = val; Add(e); return(val); }
public ChangeStatus Set(object o, INamedVersionedUniqueId p, string k, object value) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } if (k == null) { throw new ArgumentNullException("k"); } SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k); SharedDictionaryEntry result; if (_values.TryGetValue(e, out result)) { if (!Equals(result.Value, value)) { result.Value = value; if (Changed != null) { Changed(this, new ConfigChangedEventArgs(result, result, ChangeStatus.Update)); } return(ChangeStatus.Update); } return(ChangeStatus.None); } e.Value = value; Add(e); return(ChangeStatus.Add); }
internal void ForEach(object o, INamedVersionedUniqueId p, Action <SharedDictionaryEntry> a) { PluginConfigByObject co; if (_byObject.TryGetValue(o, out co) && co.Count > 0) { if (co.Count < 10) { co.ForEach(p, a); } else { PluginConfigByPlugin cp; if (_byPlugin.TryGetValue(p.UniqueId, out cp) && cp.PluginId == p && cp.Count > 0) { if (cp.Count < co.Count) { cp.ForEach(o, a); } else { co.ForEach(p, a); } } } } }
public bool Remove(object o, INamedVersionedUniqueId p, string k) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } if (k == null) { throw new ArgumentNullException("k"); } SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k); SharedDictionaryEntry result; if (_values.TryGetValue(e, out result)) { PluginConfigByObject co = _byObject[e.Obj]; co.Remove(result); PluginConfigByPlugin cp = _byPlugin[e.PluginId.UniqueId]; cp.Remove(result); _finalDictionary[e].Count--; _values.Remove(result); result.Value = null; if (Changed != null) { Changed(this, new ConfigChangedEventArgs(e, e, ChangeStatus.Delete)); } return(true); } return(false); }
public void CreateSkippedFragments() { INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0]; INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1]; // Creates a dummy dictionnary and writes it. SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2); string path = TestBase.GetTestFilePath("SharedDic", "SkippedFragments"); SharedDicTestContext.Write("Test", path, dic, this); Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty."); Assert.That(dic.Fragments.Count, Is.EqualTo(0), "There is no skipped fragments for this dic."); // Creates a second dictionnary to load previous data (with skippedFragments) IList <ReadElementObjectInfo> errors; SharedDictionaryImpl dic2 = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors); dic2.Ensure(uid1); Assert.That(errors.Count, Is.EqualTo(0)); Assert.That(dic2.Fragments.Count, Is.EqualTo(1)); Assert.That(dic2[this, uid2, "key1"], Is.Null); Assert.That(dic2[this, uid2, "key2"], Is.Null); }
public SharedDictionaryEntry(object o, INamedVersionedUniqueId p, string k) { Debug.Assert(o != null && p != null); _obj = o; _pluginId = p; _key = k; }
public void ReloadSkippedFragments() { INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0]; INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1]; // Creates a dummy dictionnary and writes it. SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2); // Creates a second dictionnary to load previous data (with skippedFragments) string path = TestBase.GetTestFilePath("SharedDic", "ReloadSkippedFragments"); SharedDicTestContext.Write("Test", path, dic, this); IList <ReadElementObjectInfo> errors; ISharedDictionary dic2 = SharedDicTestContext.Read("Test", path, this, d => d.Ensure(uid1), out errors); SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2; Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty."); Assert.That(errors.Count, Is.EqualTo(0)); Assert.That(implDic2.Fragments.Count, Is.EqualTo(1)); Assert.That(dic2[this, uid2, "key1"], Is.Null); Assert.That(dic2[this, uid2, "key2"], Is.Null); // Now we have skippedFragments. Let's try to reload it. dic2.Ensure(uid2); Assert.That(dic2[this, uid2, "key1"], Is.EqualTo("value1")); Assert.That(dic2[this, uid2, "key2"], Is.EqualTo("value2")); Assert.That(implDic2.Fragments.Count, Is.EqualTo(0)); }
PluginConfigAccessor GetConfigAccessor(INamedVersionedUniqueId idEdited) { Debug.Assert(idEdited != null); Debug.Assert(_contextObject != null); // Switch from whatever INamedVersionedUniqueId is to IPluginProxy... if it is loaded. IPluginProxy p = idEdited as IPluginProxy; if (p == null) { p = (IPluginProxy)_host.FindLoadedPlugin(idEdited.UniqueId, true); if (p == null) { _configAccessors.Remove(idEdited); return(null); } } PluginConfigAccessor result; if (!_configAccessors.TryGetValue(p, out result)) { result = new PluginConfigAccessor(p, _config.Extended, _contextObject); _configAccessors.Add(p, result); } return(result); }
public SharedDictionaryEntry( object o, INamedVersionedUniqueId p, string k ) { Debug.Assert( o != null && p != null ); _obj = o; _pluginId = p; _key = k; }
public void Destroy(INamedVersionedUniqueId p) { if (p == null) { throw new ArgumentNullException("p"); } DoRemove(p, true); }
public void Clear(INamedVersionedUniqueId p) { if (p == null) { throw new ArgumentNullException("p"); } DoRemove(p, false); }
public bool Contains(INamedVersionedUniqueId p) { if (p == null) { throw new ArgumentNullException("p"); } PluginConfigByPlugin cp; return(_byPlugin.TryGetValue(p.UniqueId, out cp) && cp.PluginId == p); }
internal void ForEach(INamedVersionedUniqueId p, Action <SharedDictionaryEntry> a) { for (int i = 0; i < Count; ++i) { SharedDictionaryEntry e = this[i]; if (e.PluginId == p) { a(e); } } }
internal PluginConfigAccessor(INamedVersionedUniqueId idEdited, IConfigManagerExtended cfg, object contextObject) { Debug.Assert(cfg != null); _idEdited = idEdited; _configContainer = cfg.Container; _system = _configContainer.GetObjectPluginConfig(cfg.ConfigManager.SystemConfiguration, _idEdited); _user = _configContainer.GetObjectPluginConfig(cfg.ConfigManager.UserConfiguration, _idEdited); _context = _configContainer.GetObjectPluginConfig(contextObject, _idEdited); }
internal bool TryRestore(SharedDictionaryImpl dic, MergeMode mergeMode) { INamedVersionedUniqueId uid = dic.FindPlugin(PluginId); if (uid != null) { Restore(dic, mergeMode); return(true); } return(false); }
public bool Contains(object o, INamedVersionedUniqueId p) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } return(_finalDictionary.ContainsKey(new SharedDictionaryEntry(o, p, null))); }
IObjectPluginConfig IConfigContainer.GetObjectPluginConfig(object o, INamedVersionedUniqueId p, bool ensure) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } return(GetFinalDictionary(new SharedDictionaryEntry(o, p, null), ensure)); }
public PluginUpdateViewModel( INamedVersionedUniqueId pluginId, System.Action<IDownloadResult> InstallAction ) { PluginId = pluginId; InstallCommand = new VMCommand( () => { State = PluginUpdateState.Installing; InstallAction( DownloadResult ); }, ( o ) => { return State == PluginUpdateState.WaitingForInstall; } ); }
public int Count(object o, INamedVersionedUniqueId p) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } FinalDictionary d; return(_finalDictionary.TryGetValue(new SharedDictionaryEntry(o, p, null), out d) ? d.Count : 0); }
public INamedVersionedUniqueId Ensure(INamedVersionedUniqueId p) { if (p == null) { throw new ArgumentNullException("p"); } PluginConfigByPlugin cp; if (!_byPlugin.TryGetValue(p.UniqueId, out cp)) { cp = CreatePluginConfigByPlugin(p); } return(cp.PluginId); }
public SharedDictionaryTester(string testName, string path, object o, INamedVersionedUniqueId uid1, INamedVersionedUniqueId uid2, Action <ISharedDictionary, object, INamedVersionedUniqueId> f) { _errors = new List <ReadElementObjectInfo>(); _testName = testName; _path = path; _seed = Environment.TickCount; _o = o; _uid1 = uid1; _uid2 = uid2; _dic = SharedDictionary.Create(null); _seed2 = GenerateRandomProperties(_dic, _o, _uid1, 10, _seed); f(_dic, _o, _uid1); _seed3 = GenerateRandomProperties(_dic, _o, _uid1, 10, _seed2); GenerateRandomProperties(_dic, _o, _uid2, 20, _seed3); }
public void BugBinarySizeDiffer() { INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0]; INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1]; string path = TestBase.GetTestFilePath("SharedDic", "BugBinarySizeDiffer"); SharedDictionaryTester checker = new SharedDictionaryTester("BugBinarySizeDiffer", path, this, uid1, uid2, (d, o, id) => d[o, id, "Obj"] = new SerializableObject()); checker.WriteAndReadWithTests( d => d.SelectSingleNode(@"CK-Structured/BugBinarySizeDiffer/p/data[@key=""Obj""]").Attributes["size"].Value = "1", dic => { dic.Ensure(uid1); dic.Ensure(uid2); }); Assert.That(checker.Errors.Count, Is.EqualTo(1)); Assert.That(checker.Errors[0].HasError, Is.True); }
public void Add(object o, INamedVersionedUniqueId p, string k, object value) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } if (k == null) { throw new ArgumentNullException("k"); } Add(new SharedDictionaryEntry(o, p, k, value)); }
private int GenerateRandomProperties(ISharedDictionary dic, object o, INamedVersionedUniqueId g, int count, int seed) { Random r = new Random(seed); StringBuilder b = new StringBuilder(10); while (--count > 0) { b.Length = 0; for (int j = 0; j < 10; ++j) { b.Append((char)(r.Next(26) + 'A')); } dic[o, g, b.ToString()] = count; } return(r.Next()); }
private ISharedDictionary BuggyReader <T>(int expectedErrorCount) where T : BuggyObjectBase, new() { INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0]; INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1]; string path = TestBase.GetTestFilePath("SharedDic", typeof(T).Name); SharedDictionaryTester checker = new SharedDictionaryTester(typeof(T).Name, path, this, uid1, uid2, (d, o, id) => { Assert.That(id == uid1); d[o, id, "AnotherValue"] = 13; d[o, id, "Obj"] = new T() { Name = "No Bug for this one!" }; d[o, id, "Obj2"] = new T() { BugWhileReading = BugRead.SkipTag, Name = "This name will not be read back. (But the object exists.)" }; d[o, id, "Obj3"] = new T() { BugWhileReading = BugRead.MoveToEndTag, Name = "This name will not be read back. (But the object exists.)" }; d[o, id, "Obj4"] = new T() { BugWhileReading = BugRead.Throw, Name = "This object should not exist at all..." }; d[o, id, "YetAnotherValue"] = 87; }); ISharedDictionary d2 = checker.WriteAndReadWithTests(null, dic => { dic.Ensure(uid1); dic.Ensure(uid2); }); TestBase.DumpFileToConsole(path); Assert.That(checker.Errors.Count, Is.EqualTo(expectedErrorCount)); Assert.That(checker.Errors.All(e => e.HasError)); Assert.That(d2[this, uid1, "AnotherValue"], Is.EqualTo(13)); Assert.That(((BuggyObjectBase)d2[this, uid1, "Obj"]).Name, Is.EqualTo("No Bug for this one!")); Assert.That(((BuggyObjectBase)d2[this, uid1, "Obj2"]).Name, Is.EqualTo("Default Name")); Assert.That(((BuggyObjectBase)d2[this, uid1, "Obj3"]).Name, Is.EqualTo("Default Name")); Assert.That(d2[this, uid1, "Obj4"], Is.Null); return(d2); }
void DoRemove(INamedVersionedUniqueId p, bool definitive) { PluginConfigByPlugin cp; if (_byPlugin.TryGetValue(p.UniqueId, out cp) && cp.PluginId == p) { if (cp.Count > 0) { HashSet <object> objectsTouched = new HashSet <object>(); foreach (SharedDictionaryEntry e in cp) { _values.Remove(e); PluginConfigByObject co = _byObject[e.Obj]; co.Remove(e); _finalDictionary.Remove(e); objectsTouched.Add(e.Obj); } cp.Clear(); if (Changed != null) { bool allObjectsConcerned = objectsTouched.Count == _byObject.Count; ChangeStatus changeStatus; if (definitive) { changeStatus = ChangeStatus.ContainerDestroy; } else { changeStatus = ChangeStatus.ContainerClear; } Changed(this, new ConfigChangedEventArgs(new ReadOnlyCollectionOnISet <object>(objectsTouched), allObjectsConcerned, p, changeStatus)); } } if (definitive) { _byPlugin.Remove(p.UniqueId); } } // Clears fragment in any case (the plugin beeing known or not). ClearFragments(p); }
public T GetOrSet <T>(object o, INamedVersionedUniqueId p, string k, Func <T> value, Func <object, T> converter) { if (o == null) { throw new ArgumentNullException("o"); } if (p == null) { throw new ArgumentNullException("p"); } if (k == null) { throw new ArgumentNullException("k"); } if (converter == null) { throw new ArgumentNullException("converter"); } SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k); SharedDictionaryEntry result; if (_values.TryGetValue(e, out result)) { if (result.Value is T) { return((T)result.Value); } T valT = converter(result.Value); result.Value = valT; if (Changed != null) { Changed(this, new ConfigChangedEventArgs(result, result, ChangeStatus.Update)); } return(valT); } T val = value == null ? default(T) : value(); e.Value = val; Add(e); return(val); }
public void ImportReloadedSkippedFragments() { INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0]; INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1]; string path = TestBase.GetTestFilePath("SharedDic", "ImportReloadedSkippedFragments"); #region Creates actual fragments // Creates a dummy dictionnary and writes it. SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2); SharedDicTestContext.Write("Test", path, dic, this); // Creates a second dictionnary to load previous data (with skippedFragments). IList <ReadElementObjectInfo> errors; SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors); Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty."); Assert.That(errors.Count, Is.EqualTo(0)); Assert.That(dicFrag.GetSkippedFragments(this).Count == 2); Assert.That(dicFrag[this, uid1, "key1"], Is.Null); Assert.That(dicFrag[this, uid2, "key2"], Is.Null); #endregion ISharedDictionary dic2 = SharedDictionary.Create(SharedDicTestContext.ServiceProvider); dic2[this, uid1, "key1"] = "value1"; dic2[this, uid1, "key2"] = "value2"; Assert.That(dic2[this, uid2, "key1"], Is.Null); Assert.That(dic2[this, uid2, "key2"], Is.Null); dic2.Ensure(uid2); SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2; implDic2.ImportFragments(dicFrag.Fragments, MergeMode.None); Assert.That(implDic2.GetSkippedFragments(this) == null); Assert.That(dic2[this, uid2, "key1"], Is.EqualTo("value1")); Assert.That(dic2[this, uid2, "key2"], Is.EqualTo("value2")); }
public void BugBinaryBadContent() { INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0]; INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1]; string path = TestBase.GetTestFilePath("SharedDic", "BugBinaryBadContent"); SharedDictionaryTester checker = new SharedDictionaryTester("BugBinaryBadContent", path, this, uid1, uid2, (d, o, id) => d[o, id, "Obj"] = new SerializableObject()); Assert.Throws <XmlException>(() => { checker.WriteAndReadWithTests ( d => { XmlNode n = d.SelectSingleNode(@"CK-Structured/BugBinaryBadContent/p/data[@key=""Obj""]"); n.InnerText = n.InnerText.Insert(n.InnerText.Length / 2, "*bug*"); }, dic => { dic.Ensure(uid1); dic.Ensure(uid2); } ); }); }
/// <summary> /// Throws an ArgumentException if the Guid is already associated to /// another IVersionedUniqueId. /// </summary> private PluginConfigByPlugin CreatePluginConfigByPlugin(INamedVersionedUniqueId p) { PluginConfigByPlugin cp = new PluginConfigByPlugin(p); _byPlugin.Add(p.UniqueId, cp); var entriesToRemove = ClearFragments(_fragments.ToReadOnlyCollection(), f => { if (f.PluginId == p.UniqueId) { f.Restore(this, MergeMode.ErrorOnDuplicate); return(true); } return(false); }); foreach (object entry in entriesToRemove) { _fragments.Remove(entry); } return(cp); }
public void MergeFragments_PreserveExisting() { INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0]; INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1]; INamedVersionedUniqueId uid3 = SharedDicTestContext.Plugins[2]; SharedDictionaryImpl dic = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider); dic[this, uid1, "key1"] = "value1"; dic[this, uid1, "key2"] = "value2"; dic[this, uid2, "key1"] = "value1"; dic[this, uid2, "key2"] = "value2"; dic[this, uid3, "key1"] = "value1"; dic[this, uid3, "key2"] = "value2"; string path = TestBase.GetTestFilePath("SharedDic", "MergeFragments"); SharedDicTestContext.Write("Test", path, dic, this); IList <ReadElementObjectInfo> errors; SharedDictionaryImpl dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors); Assert.That(errors.Count == 0); Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3); SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, d => { d.Ensure(uid1); d.Ensure(uid2); }, out errors); Assert.That(errors.Count == 0); Assert.That(dicFrag.GetSkippedFragments(this).Count == 1); int hashCode = dicFrag.GetSkippedFragments(this)[0].GetHashCode(); dicFrag.ImportFragments(dicFullFrag.Fragments, MergeMode.PreserveExisting); Assert.That(dicFrag.GetSkippedFragments(this) != null); Assert.That(dicFrag.GetSkippedFragments(this).Count == 1); Assert.That(dicFrag.GetSkippedFragments(this)[0].GetHashCode() == hashCode); }
PluginConfigAccessor GetConfigAccessor( INamedVersionedUniqueId idEdited ) { Debug.Assert( idEdited != null ); Debug.Assert( _contextObject != null ); // Switch from whatever INamedVersionedUniqueId is to IPluginProxy... if it is loaded. IPluginProxy p = idEdited as IPluginProxy; if( p == null ) { p = (IPluginProxy)_host.FindLoadedPlugin( idEdited.UniqueId, true ); if( p == null ) { _configAccessors.Remove( idEdited ); return null; } } PluginConfigAccessor result; if( !_configAccessors.TryGetValue( p, out result ) ) { result = new PluginConfigAccessor( p, _config.Extended, _contextObject ); _configAccessors.Add( p, result ); } return result; }
public ConfigChangedEventArgs( object obj, INamedVersionedUniqueId pluginId, ChangeStatus status ) : this( obj, new ReadOnlyListMono<object>( obj ), new ReadOnlyListMono<INamedVersionedUniqueId>( pluginId ), null, null, status ) { }
public ConfigChangedEventArgs( IReadOnlyCollection<object> multiObj, bool allObjectsConcerned, INamedVersionedUniqueId pluginId, ChangeStatus status ) : this( null, multiObj, new ReadOnlyListMono<INamedVersionedUniqueId>( pluginId ), null, null, status ) { IsAllObjectsConcerned = allObjectsConcerned; }
public HelpUpdateDownloadedEventArgs( INamedVersionedUniqueId plugin, IDownloadResult downloadResult ) : base(plugin) { DownloadResult = downloadResult; }
/// <summary> /// Gets (creates it if needed) an easy to use <see cref="IObjectPluginConfig"/> that acts as a standard name-value dictionary. /// </summary> /// <param name="c">This <see cref="IConfigContainer"/> object.</param> /// <param name="o">Object that carries the properties.</param> /// <param name="p">Plugin identifier.</param> /// <returns>>An easy accessor for the object/plugin couple.</returns> public static IObjectPluginConfig GetObjectPluginConfig( this IConfigContainer c, object o, INamedVersionedUniqueId p ) { return c.GetObjectPluginConfig( o, p, true ); }
Action<IDownloadResult> CreateInstallActionFor( INamedVersionedUniqueId pluginId ) { return d => _manualInstaller( pluginId, d ); }
PluginUpdateViewModel FindOrCreateVm( INamedVersionedUniqueId pluginId ) { var plugin = PluginUpdates.FirstOrDefault( p => p.PluginId == pluginId ); if( plugin == null ) { plugin = new PluginUpdateViewModel( pluginId, CreateInstallActionFor( pluginId ) ); PluginUpdates.Add( plugin ); } return plugin; }
public HelpUpdateEventArgs( INamedVersionedUniqueId plugin ) { Plugin = plugin; }
internal void ClearFragments( INamedVersionedUniqueId id ) { ClearFragments( f => f.PluginId == id.UniqueId ); }