protected override IEnumerable <Command> OnAlter(IMetadata sourceMetadata, IMetadata targetMetadata, IComparerContext context)
{
var otherRole = FindOtherChecked(targetMetadata.MetadataRoles.Roles, RoleName, "role");
if (EquatableHelper.PropertiesEqual(this, otherRole, EquatableProperties, nameof(RoleFlag), nameof(SystemPrivileges)))
{
if (EquatableHelper.PropertiesEqual(this, otherRole, EquatableProperties, nameof(RoleFlag)))
{
yield return(new Command()
.Append($"ALTER ROLE {RoleName.AsSqlIndentifier()} {(RoleFlag.HasFlag(RoleFlagType.RoleFlagMayTrust) ? "SET" : "DROP")} AUTO ADMIN MAPPING"));
}
if (EquatableHelper.PropertiesEqual(this, otherRole, EquatableProperties, nameof(SystemPrivileges)))
{
var systemPrivileges = SystemPrivileges?.ToPrivileges() ?? Enumerable.Empty <string>();
if (systemPrivileges.Any())
{
yield return(new Command()
.Append($"ALTER ROLE {RoleName.AsSqlIndentifier()} SET SYSTEM PRIVILEGES TO {string.Join(", ", systemPrivileges)}"));
}
else
{
yield return(new Command()
.Append($"ALTER ROLE {RoleName.AsSqlIndentifier()} DROP SYSTEM PRIVILEGES"));
}
}
}
else
{
throw new NotSupportedOnFirebirdException($"Altering role is not supported ({RoleName}).");
}
}
public override bool Equals(object other)
{
if (other == null || GetType() != other.GetType())
{
return(false);
}
return(EquatableHelper.PropertiesEquals(this, other));
}
protected override IEnumerable <Command> OnAlter(IMetadata sourceMetadata, IMetadata targetMetadata, IComparerContext context)
{
var otherRole = FindOtherChecked(targetMetadata.MetadataRoles.Roles, RoleName, "role");
if (EquatableHelper.PropertiesEqual(this, otherRole, EquatableProperties, nameof(RoleFlag)))
{
yield return(new Command()
.Append($"ALTER ROLE {RoleName.AsSqlIndentifier()} {(RoleFlag.HasFlag(RoleFlagType.RoleFlagMayTrust) ? "SET" : "DROP")} AUTO ADMIN MAPPING"));
}
else
{
throw new NotSupportedOnFirebirdException($"Altering role is not supported ({RoleName}).");
}
}
protected override IEnumerable <Command> OnAlter(IMetadata sourceMetadata, IMetadata targetMetadata, IComparerContext context)
{
var otherGenerator = FindOtherChecked(targetMetadata.MetadataGenerators.GeneratorsByName, GeneratorName, "role");
if (EquatableHelper.PropertiesEqual(this, otherGenerator, EquatableProperties, nameof(GeneratorIncrement)))
{
yield return(new Command()
.Append($"ALTER SEQUENCE {GeneratorName.AsSqlIndentifier()} INCREMENT BY {GeneratorIncrement}"));
}
else
{
throw new NotSupportedOnFirebirdException($"Altering sequence is not supported ({GeneratorName}).");
}
}
protected override IEnumerable <Command> OnAlter(IMetadata sourceMetadata, IMetadata targetMetadata, IComparerContext context)
{
var otherCharacterSet = FindOtherChecked(targetMetadata.MetadataCharacterSets.CharacterSetsByName, CharacterSetName, "character set");
if (EquatableHelper.PropertiesEqual(this, otherCharacterSet, EquatableProperties, nameof(DefaultCollateName)))
{
yield return(new Command()
.Append($"ALTER CHARACTER SET {CharacterSetName.AsSqlIndentifier()} SET DEFAULT COLLATION {DefaultCollateName.AsSqlIndentifier()}"));
}
else
{
throw new NotSupportedOnFirebirdException($"Altering charset is not supported ({CharacterSetName}).");
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="ownerComparer">Optional: if null, then reference equality is used.</param>
/// <param name="keyComparer">Optional: if null then the default
/// <see cref="EqualityComparer{T}"/> for the type <typeparamref name="TKey"/>
/// is used.</param>
/// <param name="initialKeyCapacity">Specifies the initial capatity for the entry cache.</param>
/// <param name="entryFactory">Optional delegate can provide the implementation for the
/// protected virtual <see cref="EntryFactory(TKey)"/> method; which constructs
/// all new entries. Can be null if that method is overridden; and can also
/// be null if this <typeparamref name="TEntry"/> Type IS
/// <see cref="OwnerCacheEntry{TKey, TOwner, TValue}"/> (the default).
/// For any custom tyoe you must eother provide this delegate or override
/// the factory method.</param>
public OwnerCache(
IEqualityComparer <TOwner> ownerComparer = null,
IEqualityComparer <TKey> keyComparer = null,
int initialKeyCapacity = 8,
Func <TKey, TEntry> entryFactory = null)
{
OwnerComparer = ownerComparer ?? EquatableHelper.ReferenceEqualityComparer <TOwner>();
KeyComparer = keyComparer ?? EqualityComparer <TKey> .Default;
Entries = new Dictionary <TKey, TEntry>(initialKeyCapacity, KeyComparer);
this.entryFactory = entryFactory;
if ((this.entryFactory == null) &&
(typeof(TEntry) == typeof(OwnerCacheEntry <TKey, TOwner, TValue>)))
{
this.entryFactory = DefaultEntryFactory;
}
private TResult handleMutate <TResult>(
MultiDictionary <CompositionHost, object> exportsList,
Func <List <object>, TResult> mutate,
CompositionHost addUnder)
{
IEqualityComparer <object> referenceEqualityComparer
= EquatableHelper.ReferenceEqualityComparer <object>();
MultiDictionary <CompositionHost, object> currentCopy = exports.CopyCollection(exportsList);
List <object> currentValuesCopy = exportsList.GetAllValues();
List <object> currentValues = exportsList.GetAllValues();
TResult result = mutate(currentValues);
// Removed?
foreach (object currentValueCopy in currentValuesCopy)
{
if (currentValues.Contains(currentValueCopy, referenceEqualityComparer))
{
continue;
}
KeyValuePair <CompositionHost, object> entry
= currentCopy.FirstOrDefault(kv => object.ReferenceEquals(currentValueCopy, kv.Value));
exportsList.Remove(entry);
if (!exportsList.ContainsKey(entry.Key) &&
!object.ReferenceEquals(MefSingletonComposer.unmanagedCompositionHost, entry.Key))
{
entry.Key.Dispose();
}
}
// Added?
foreach (object currentValue in currentValues)
{
if (currentValuesCopy.Contains(currentValue, referenceEqualityComparer))
{
continue;
}
exportsList.AddValue(addUnder, currentValue);
}
return(result);
}
protected override IEnumerable <Command> OnAlter(IMetadata sourceMetadata, IMetadata targetMetadata, IComparerContext context)
{
if (IsLegacy)
{
var otherFunction = FindOtherChecked(targetMetadata.MetadataFunctions.FunctionsByName, FunctionNameKey, "function");
if (EquatableHelper.PropertiesEqual(this, otherFunction, EquatableProperties, new[] { nameof(ModuleName), nameof(EntryPoint) }))
{
yield return(new Command().Append($"ALTER EXTERNAL FUNCTION {FunctionName.AsSqlIndentifier()} ENTRY_POINT '{SqlHelper.DoubleSingleQuotes(EntryPoint)}' MODULE_NAME '{SqlHelper.DoubleSingleQuotes(ModuleName)}'"));
}
else
{
throw new NotSupportedOnFirebirdException($"Altering function is not supported ({FunctionName}).");
}
}
else
{
foreach (var item in OnCreate(sourceMetadata, targetMetadata, context))
{
yield return(item);
}
}
}
/// <summary> /// /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> public static bool operator !=(ChatApiInstanceParameters?left, ChatApiInstanceParameters?right) => !EquatableHelper.IsEquatable(left, right);
/// <summary/> public static bool operator !=(ParticipantRequest?left, ParticipantRequest?right) => !EquatableHelper.IsEquatable(left, right);
/// <summary/> public static bool operator !=(ForwardMessageRequest?left, ForwardMessageRequest?right) => !EquatableHelper.IsEquatable(left, right);
public static bool operator ==(ValueObject x, ValueObject y)
{
return(EquatableHelper.PropertiesEquals(x, y));
}
/// <summary/> public static bool operator !=(AccountStatusData?left, AccountStatusData?right) => !EquatableHelper.IsEquatable(left, right);
/// <summary/> public static bool operator !=(MessagesRequest?left, MessagesRequest?right) => !EquatableHelper.IsEquatable(left, right);
public override bool Equals(object obj) => EquatableHelper.ElementaryEqualsThenEquatableEquals(this, obj);
/// <summary/> public static bool operator ==(TextMessageRequest?left, TextMessageRequest?right) => EquatableHelper.IsEquatable(left, right);
public bool Equals(T x, T y)
{
return(EquatableHelper.ElementaryEquals(x, y) ?? EquatableHelper.PropertiesEqual(x, y, m_EquatableProperties));
}
/// <summary/> public static bool operator ==(Message?left, Message?right) => EquatableHelper.IsEquatable(left, right);
/// <summary/> public static bool operator !=(ContactMessageRequest?left, ContactMessageRequest?right) => !EquatableHelper.IsEquatable(left, right);
public bool CanAlter(Index other) => EquatableHelper.PropertiesEqual(this, other, EquatableProperties, nameof(Inactive));
/// <summary/> public static bool operator !=(ActionQueue?left, ActionQueue?right) => !EquatableHelper.IsEquatable(left, right);
/// <summary/> public static bool operator !=(DeviceCharacteristic?left, DeviceCharacteristic?right) => !EquatableHelper.IsEquatable(left, right);
/// <summary/> public static bool operator !=(Label?left, Label?right) => !EquatableHelper.IsEquatable(left, right);
public bool Equals(DatabaseStringOrdinal other) => EquatableHelper.ElementaryEquals(this, other) ?? CompareImpl(this, other) == 0;
/// <summary/> public static bool operator !=(ClearMessagesQueueResponse?left, ClearMessagesQueueResponse?right) => !EquatableHelper.IsEquatable(left, right);
/// <summary/> public static bool operator !=(BanSettings?left, BanSettings?right) => !EquatableHelper.IsEquatable(left, right);
public int GetHashCode(T obj)
{
return(EquatableHelper.GetHashCode(obj, m_EquatableProperties));
}
public bool Equals(T other)
{
return(EquatableHelper.ElementaryEquals(this, other) ?? EquatableHelper.PropertiesEqual(this, other, EquatableProperties));
}
public override int GetHashCode()
{
return(EquatableHelper.PropertiesGetHashCode(this));
}
/// <summary/> public static bool operator !=(OutputIPAddressResponse?left, OutputIPAddressResponse?right) => !EquatableHelper.IsEquatable(left, right);
