/// <summary>
        ///     Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2" />.
        /// </summary>
        /// <param name="key">The object to use as the key of the element to add.</param>
        /// <param name="value">The object to use as the value of the element to add.</param>
        public void Add(RelationshipEntryKey key, RelationshipEntry value)
        {
            if (key.Cardinality != null && (key.Cardinality == CardinalityEnum_Enumeration.ManyToOne || key.Cardinality == CardinalityEnum_Enumeration.OneToOne))
            {
                var cardinalityKey = new RelationshipEntryCardinalityKey(key.TypeId, key.FromId);

                _toOne.Add(cardinalityKey, value);
            }

            if (key.Cardinality != null && (key.Cardinality == CardinalityEnum_Enumeration.OneToMany || key.Cardinality == CardinalityEnum_Enumeration.OneToOne))
            {
                var cardinalityKey = new RelationshipEntryCardinalityKey(key.TypeId, key.ToId);

                _fromOne.Add(cardinalityKey, value);
            }

            _dictionary.Add(key, value);
        }
        /// <summary>
        ///     Gets the value associated with the specified key.
        /// </summary>
        /// <param name="key">The key whose value to get.</param>
        /// <param name="value">
        ///     When this method returns, the value associated with the specified key, if the key is found;
        ///     otherwise, the default value for the type of the <paramref name="value" /> parameter. This parameter is passed
        ///     uninitialized.
        /// </param>
        /// <returns>
        ///     true if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2" /> contains an element
        ///     with the specified key; otherwise, false.
        /// </returns>
        /// <exception cref="NotImplementedException"></exception>
        public bool TryGetValue(RelationshipEntryKey key, out RelationshipEntry value)
        {
            if (key.Cardinality != null && (key.Cardinality == CardinalityEnum_Enumeration.ManyToOne || key.Cardinality == CardinalityEnum_Enumeration.OneToOne))
            {
                var cardinalityKey = new RelationshipEntryCardinalityKey(key.TypeId, key.FromId);

                if (_toOne.TryGetValue(cardinalityKey, out value))
                {
                    return(true);
                }
            }

            if (key.Cardinality != null && (key.Cardinality == CardinalityEnum_Enumeration.OneToMany || key.Cardinality == CardinalityEnum_Enumeration.OneToOne))
            {
                var cardinalityKey = new RelationshipEntryCardinalityKey(key.TypeId, key.ToId);

                if (_fromOne.TryGetValue(cardinalityKey, out value))
                {
                    return(true);
                }
            }

            return(_dictionary.TryGetValue(key, out value));
        }
        /// <summary>
        ///     Determines whether the <see cref="T:System.Collections.Generic.IDictionary`2" /> contains an element with the
        ///     specified key.
        /// </summary>
        /// <param name="key">The key to locate in the <see cref="T:System.Collections.Generic.IDictionary`2" />.</param>
        /// <returns>
        ///     true if the <see cref="T:System.Collections.Generic.IDictionary`2" /> contains an element with the key; otherwise,
        ///     false.
        /// </returns>
        /// <exception cref="NotImplementedException"></exception>
        public bool ContainsKey(RelationshipEntryKey key)
        {
            if (key.Cardinality != null && (key.Cardinality == CardinalityEnum_Enumeration.ManyToOne || key.Cardinality == CardinalityEnum_Enumeration.OneToOne))
            {
                var cardinalityKey = new RelationshipEntryCardinalityKey(key.TypeId, key.FromId);

                if (_toOne.ContainsKey(cardinalityKey))
                {
                    return(true);
                }
            }

            if (key.Cardinality != null && (key.Cardinality == CardinalityEnum_Enumeration.OneToMany || key.Cardinality == CardinalityEnum_Enumeration.OneToOne))
            {
                var cardinalityKey = new RelationshipEntryCardinalityKey(key.TypeId, key.ToId);

                if (_fromOne.ContainsKey(cardinalityKey))
                {
                    return(true);
                }
            }

            return(_dictionary.ContainsKey(key));
        }
Пример #4
0
        /// <summary>
        /// Reads the relationships.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="reader">The reader.</param>
        /// <param name="cardinality">The cardinality.</param>
        /// <param name="dict">The dictionary.</param>
        /// <param name="toOne">To one.</param>
        /// <param name="fromOne">From one.</param>
        /// <param name="droppedRelationships">if set to <c>true</c> [dropped relationships].</param>
        private void ReadRelationships(IProcessingContext context, IDataReader reader, Dictionary <long, CardinalityEnum_Enumeration> cardinality, Dictionary <RelationshipEntryKey, RelationshipEntry> dict, Dictionary <RelationshipEntryCardinalityKey, RelationshipEntry> toOne, Dictionary <RelationshipEntryCardinalityKey, RelationshipEntry> fromOne, bool droppedRelationships)
        {
            while (reader.Read( ))
            {
                if (reader.IsDBNull(0))
                {
                    context?.WriteWarning("Unexpected null UpgradeId in Entity.");

                    continue;
                }

                Guid typeId = reader.GetGuid(0);
                Guid fromId = reader.GetGuid(1);
                Guid toId   = reader.GetGuid(2);

                CardinalityEnum_Enumeration?card = null;

                if (reader.FieldCount > 3 && !reader.IsDBNull(3))
                {
                    CardinalityEnum_Enumeration cardValue;

                    if (cardinality.TryGetValue(reader.GetInt64(3), out cardValue))
                    {
                        card = cardValue;
                    }
                }

                RelationshipEntry entry = card == null ? new RelationshipEntry(typeId, fromId, toId) : new RelationshipEntry(typeId, fromId, toId, card.Value);

                if (RelationshipRestrictions != null)
                {
                    if (RelationshipRestrictions.Any(restriction => !restriction.IsAllowed(entry)))
                    {
                        continue;
                    }
                }

                var key = entry.GetKey( );

                RelationshipEntry value;

                bool violation = false;

                Action addFrom = null;
                Action addTo   = null;

                if (entry.Cardinality != null && (entry.Cardinality == CardinalityEnum_Enumeration.ManyToOne || entry.Cardinality == CardinalityEnum_Enumeration.OneToOne))
                {
                    var cardinalityKey = new RelationshipEntryCardinalityKey(entry.TypeId, entry.FromId);

                    if (toOne.TryGetValue(cardinalityKey, out value))
                    {
                        if (entry.TypeId != value.TypeId || entry.FromId != value.FromId || entry.ToId != value.ToId)
                        {
                            /////
                            // Cardinality violation.
                            /////
                            EventLog.Application.WriteWarning(string.Format("Detected cardinality violation {7}({0}).\n\nExisting Type: {1}\nExisting From: {2}\nExisting To: {3}\n\nDropped Type: {4}\nDropped From: {5}\nDropped To: {6}\n",
                                                                            entry.Cardinality,
                                                                            value.TypeId.ToString("B"),
                                                                            value.FromId.ToString("B"),
                                                                            value.ToId.ToString("B"),
                                                                            entry.TypeId.ToString("B"),
                                                                            entry.FromId.ToString("B"),
                                                                            entry.ToId.ToString("B"),
                                                                            droppedRelationships ? "processing previously dropped relationship " : ""));
                        }

                        violation = true;
                    }
                    else
                    {
                        RelationshipEntry relationshipEntry = entry;
                        addFrom = () => toOne.Add(cardinalityKey, relationshipEntry);
                    }
                }

                if (!violation && entry.Cardinality != null && (entry.Cardinality == CardinalityEnum_Enumeration.OneToMany || entry.Cardinality == CardinalityEnum_Enumeration.OneToOne))
                {
                    var cardinalityKey = new RelationshipEntryCardinalityKey(entry.TypeId, entry.ToId);

                    if (fromOne.TryGetValue(cardinalityKey, out value))
                    {
                        if (entry.TypeId != value.TypeId || entry.FromId != value.FromId || entry.ToId != value.ToId)
                        {
                            /////
                            // Cardinality violation.
                            /////
                            EventLog.Application.WriteWarning(string.Format("Detected cardinality violation {7}({0}).\n\nExisting Type: {1}\nExisting From: {2}\nExisting To: {3}\n\nDropped Type: {4}\nDropped From: {5}\nDropped To: {6}\n",
                                                                            entry.Cardinality,
                                                                            value.TypeId.ToString("B"),
                                                                            value.FromId.ToString("B"),
                                                                            value.ToId.ToString("B"),
                                                                            entry.TypeId.ToString("B"),
                                                                            entry.FromId.ToString("B"),
                                                                            entry.ToId.ToString("B"),
                                                                            droppedRelationships ? "processing previously dropped relationship " : ""));
                        }

                        violation = true;
                    }
                    else
                    {
                        RelationshipEntry relationshipEntry = entry;
                        addTo = () => fromOne.Add(cardinalityKey, relationshipEntry);
                    }
                }

                if (violation)
                {
                    continue;
                }

                addFrom?.Invoke( );

                addTo?.Invoke( );

                if (!dict.TryGetValue(key, out value))
                {
                    dict.Add(key, entry);
                }
                else
                {
                    if (entry.Cardinality != CardinalityEnum_Enumeration.ManyToMany)
                    {
                        if (entry.TypeId != value.TypeId || entry.FromId != value.FromId || entry.ToId != value.ToId)
                        {
                            /////
                            // Cardinality violation.
                            /////
                            EventLog.Application.WriteWarning(string.Format("Detected cardinality violation {7}({0}).\n\nExisting Type: {1}\nExisting From: {2}\nExisting To: {3}\n\nDropped Type: {4}\nDropped From: {5}\nDropped To: {6}\n",
                                                                            entry.Cardinality,
                                                                            value.TypeId.ToString("B"),
                                                                            value.FromId.ToString("B"),
                                                                            value.ToId.ToString("B"),
                                                                            entry.TypeId.ToString("B"),
                                                                            entry.FromId.ToString("B"),
                                                                            entry.ToId.ToString("B"),
                                                                            droppedRelationships ? "processing previously dropped relationship " : ""));
                        }
                    }
                }
            }
        }