private void AddOrMergeIndexedArgumentValues(int key, ValueHolder newValue)
{
ValueHolder currentValue;
IMergable mergable = newValue.Value as IMergable;
if (_indexedArgumentValues.TryGetValue(key, out currentValue) && mergable != null)
{
if (mergable.MergeEnabled)
{
newValue.Value = mergable.Merge(currentValue.Value);
}
}
_indexedArgumentValues[key] = newValue;
}
/// <summary>
/// Merges the value of the supplied 'new' <see cref="PropertyValue"/> with that of
/// the current <see cref="PropertyValue"/> if merging is supported and enabled.
/// </summary>
/// <see cref="IMergable"/>
/// <param name="newPv">The new pv.</param>
/// <param name="currentPv">The current pv.</param>
/// <returns>The possibly merged PropertyValue</returns>
private PropertyValue MergeIfRequired(PropertyValue newPv, PropertyValue currentPv)
{
object val = newPv.Value;
IMergable mergable = val as IMergable;
if (mergable != null)
{
if (mergable.MergeEnabled)
{
object merged = mergable.Merge(currentPv.Value);
return(new PropertyValue(newPv.Name, merged));
}
}
return(newPv);
}
void Microsoft.Samples.WindowsAzure.ServiceManagement.IMergable <T> .Merge(T other)
{
object obj = null;
Mergable <T> mergable = other;
foreach (KeyValuePair <string, object> propertyStore in mergable.PropertyStore)
{
if (this.PropertyStore.TryGetValue(propertyStore.Key, out obj))
{
IMergable mergable1 = obj as IMergable;
if (mergable1 != null)
{
mergable1.Merge(propertyStore.Value);
continue;
}
}
this.PropertyStore[propertyStore.Key] = propertyStore.Value;
}
}
/// <summary>
/// Merges <paramref name="right"/> with current dictionary, appending all lists and merging dictionaries.
/// </summary>
/// <param name="left">The object that will accept all merges.</param>
/// <param name="right">The dictionary to take data from.</param>
/// <param name="preference">See the enum values docs.</param>
public static void Merge(IMergable left, object right, MergePrefer preference)
{
merging_core(left, right, preference);
}
private static object merging_core_imerger(IMergable left, object right, MergePrefer preference)
{
//handle nulls
if (left == null && right != null)
{
return(right);
}
if (right == null)
{
return(left);
}
if (ReferenceEquals(left, right))
{
return(left);
}
//handle kv pairs
if (right is IEnumerable <KeyValuePair <string, object> > rightenumerable && !(right is IDictionary))
{
right = new Dict(rightenumerable);
}
//handle dict
if (right is IDictionary rightdict)
{
//handle empty, fixed or readonly
if (rightdict.Count == 0)
{
return(left);
}
if (!left.IsExpandable)
{
foreach (var leftkey in left.Keys)
{
if (rightdict.Contains(leftkey))
{
left.Set(leftkey, rightdict[leftkey]);
}
}
}
else
{
//get keys to process
var mainkeys = left.Keys.Cast <object>().ToList();
var otherkeys = rightdict.Keys.Cast <object>().ToList();
var sharedkeys = mainkeys.Intersect(otherkeys); //keys both share
var missingkeys = otherkeys.Except(mainkeys); //keys only otherdict has
object current_key = null; //for exception handling
try {
//handle merging of shared keys
foreach (var key in sharedkeys)
{
current_key = key;
var leftkey = (key as string) ?? key.ToString();
try {
left.Set(leftkey, merging_core(left.Get(leftkey), rightdict[key], preference)); //try to merge both values before returning.
} catch (KeyNotFoundException) { } //has no setter.
}
//handle settings of missing keys in sharedkeys
foreach (var key in missingkeys)
{
current_key = key;
try {
left.Set(
(key as string) ?? throw new InvalidOperationException("A key for IMergable must be a string."),
_trycopy(rightdict[key])
); //try to merge both values before returning.
} catch (KeyNotFoundException) { } //has no setter.
}
} catch (Exception e) {
throw new DictMergingException($"Merging failed during merge of key '{current_key}', see inner exception.", e);
}
}
return(left);
}
//handle dict
if (right is IMergable rightmergable)
{
//handle empty, fixed or readonly
if (rightmergable.Count == 0)
{
return(left);
}
var rightkeys = rightmergable.Keys.ToArray();
if (!left.IsExpandable)
{
if (preference == MergePrefer.New)
{
foreach (var leftkey in left.Keys)
{
if (rightkeys.Contains(leftkey))
{
left.Set(leftkey, rightmergable.Get(leftkey));
}
}
}
}
else
{
//get keys to process
var mainkeys = left.Keys.Cast <object>().ToList();
var otherkeys = rightkeys.Cast <object>().ToList();
var sharedkeys = mainkeys.Intersect(otherkeys); //keys both share
var missingkeys = otherkeys.Except(mainkeys); //keys only otherdict has
string current_key = null; //for exception handling
try {
//handle merging of shared keys
foreach (var key in sharedkeys)
{
var leftkey = current_key = (string)key;
try {
left.Set(leftkey, merging_core(left.Get(leftkey), rightmergable.Get(leftkey), preference)); //try to merge both values before returning.
} catch (KeyNotFoundException) { } //has no setter.
}
//handle settings of missing keys in sharedkeys
foreach (var o_key in missingkeys)
{
var key = current_key = (string)o_key;
try {
left.Set(key, _trycopy(rightmergable.Get(current_key))); //try to merge both values before returning.
} catch (KeyNotFoundException) { } //has no setter.
}
} catch (Exception e) {
throw new DictMergingException($"Merging failed during merge of key '{current_key}', see inner exception.", e);
}
}
return(left);
}
return(preference == MergePrefer.Old ? left : right);
}
