Exemple #1
0
        /// <summary>
        /// Adds a property type to the cache.
        /// </summary>
        internal void AddPropTypeToCache(int ID, string name, PropDataType propType, PropTypeFlags flags)
        {
            if (ID < 0 || ID > 65536)
            {
                throw new BadIndexesException("Invalid property type ID " + ID);
            }

            lock ( _propTypeCache )
            {
                PropTypeItem propTypeItem = new PropTypeItem(ID, name, propType, flags);
                while (_propTypeCache.Count < ID)
                {
                    _propTypeCache.Add(null);
                }

                if (_propTypeCache.Count == ID)
                {
                    _propTypeCache.Add(propTypeItem);
                }
                else
                {
                    _propTypeCache [ID] = propTypeItem;
                }

                _propTypeNameCache [name] = propTypeItem;
            }
        }
Exemple #2
0
        internal PropTypeCollection(MyPalStorage storage, ITable propTypeTable)
        {
            _storage       = storage;
            _propTypeTable = propTypeTable;

            _pseudoProps [0] = new PropTypeItem(ResourceProps.Id,
                                                "", PropDataType.Int, PropTypeFlags.Normal);
            _pseudoProps [1] = new PropTypeItem(ResourceProps.DisplayName,
                                                "DisplayName", PropDataType.String, PropTypeFlags.Normal);
            _pseudoProps [1].SetDisplayNames("Name", null);
            _pseudoProps [2] = new PropTypeItem(ResourceProps.Type,
                                                "Type", PropDataType.String, PropTypeFlags.Normal);
        }
Exemple #3
0
        private PropTypeItem FindPropTypeItem(int propID)
        {
            if (propID < 0 || propID >= _propTypeCache.Count)
            {
                throw new StorageException("Invalid property type ID " + propID);
            }

            PropTypeItem item = (PropTypeItem)_propTypeCache [propID];

            if (item == null)
            {
                throw new StorageException("Invalid property type ID " + propID);
            }
            return(item);
        }
Exemple #4
0
        /**
         * Returns the display name for a property or link.
         */

        public string GetPropDisplayName(int propId)
        {
            bool reverse      = false;
            bool directedLink = false;

            PropTypeItem ptItem = (PropTypeItem)this [propId];

            if (ptItem.DataType == PropDataType.Link && ptItem.HasFlag(PropTypeFlags.DirectedLink))
            {
                directedLink = true;
                if (propId < 0)
                {
                    propId  = -propId;
                    reverse = true;
                }
            }

            string result;

            if (reverse)
            {
                result = ptItem.ReverseDisplayName;
                if (result == null)
                {
                    result = ptItem.Name + " Target";
                }
            }
            else
            {
                result = ptItem.DisplayName;
                if (result == null)
                {
                    if (directedLink)
                    {
                        result = ptItem.Name + " Source";
                    }
                    else
                    {
                        result = ptItem.Name;
                    }
                }
            }
            return(result);
        }
Exemple #5
0
        /**
         * When a PropType resource is changed, updates the DB data for it.
         */

        internal void UpdatePropType(Resource res)
        {
            string propName = res.GetStringProp("Name");

            if (propName == null)
            {
                MyPalStorage.Storage.OnIndexCorruptionDetected("UpdatePropType: Name property missing on PropType resource");
                return;
            }

            int propId = this [propName].Id;

            UpdatePropTypeRecord(propName, res);

            PropTypeItem propTypeItem = FindPropTypeItem(propId);

            Debug.Assert(propTypeItem.Name == propName);
            propTypeItem.SetFlags((PropTypeFlags)res.GetIntProp("Flags"));
        }
Exemple #6
0
        internal void   UpdatePropTypeFlags(int propId, PropTypeFlags flags)
        {
            PropTypeItem propType = (PropTypeItem)_propTypeCache [propId];

            propType.SetFlags(flags);

            IResource res = _storage.FindUniqueResource("PropType", "ID", propId);

            if (res != null)
            {
                res.SetProp("Flags", (int)flags);

                UpdatePropTypeRecord(propType.Name, res);
            }
            else
            {
                MyPalStorage.Storage.OnIndexCorruptionDetected("Could not find PropType resource with ID " + propId);
            }
        }
Exemple #7
0
        /**
         * Unregisters the specified property type and deletes all properties
         * of that type.
         */

        public void Delete(int id)
        {
            PropTypeItem item = FindPropTypeItem(id);

            if (item.DataType == PropDataType.Link)
            {
                _storage.DeleteLinksOfType(id);
            }
            else
            {
                _storage.DeletePropsOfType(id);
            }
            ResourceRestrictions.DeletePropRestrictions(id);

            IResultSet rs = _propTypeTable.CreateModifiableResultSet(0, id);

            try
            {
                SafeRecordEnumerator enumerator = new SafeRecordEnumerator(rs, "PropTypes.Delete");
                using ( enumerator )
                {
                    if (!enumerator.MoveNext())
                    {
                        MyPalStorage.Storage.OnIndexCorruptionDetected("PropTypeCollection.Delete: Attempt to delete non-existing property type " + id);
                    }
                    else
                    {
                        IRecord rec = enumerator.Current;
                        _storage.SafeDeleteRecord(rec, "PropTypes.Delete");
                    }
                }
            }
            finally
            {
                rs.Dispose();
            }

            IResource propTypeRes = _storage.FindUniqueResource("PropType", "ID", id);

            Debug.Assert(propTypeRes != null);
            propTypeRes.Delete();
        }
Exemple #8
0
        public IPropType this [int propID]
        {
            get
            {
                if (propID < 0)
                {
                    PropTypeItem revItem = FindPropTypeItem(-propID);
                    if (revItem.HasFlag(PropTypeFlags.DirectedLink))
                    {
                        return(revItem);
                    }
                    throw new StorageException("Invalid property type ID " + propID);
                }
                if (propID >= ResourceProps.Id)
                {
                    return(_pseudoProps [propID - ResourceProps.Id]);
                }

                return(FindPropTypeItem(propID));
            }
        }
Exemple #9
0
        internal void RegisterPropDisplayNameInternal(int propID, string fromDisplayName, string toDisplayName)
        {
            PropTypeItem propTypeItem = (PropTypeItem)_propTypeCache [propID];

            IResource propTypeRes = _storage.FindUniqueResource("PropType", "ID", propID);

            if (propTypeRes == null)
            {
                MyPalStorage.Storage.OnIndexCorruptionDetected("Property type not found in RegisterPropDisplayNameInternal");
                return;
            }
            propTypeRes.SetProp("PropDisplayName", fromDisplayName);
            if (toDisplayName == null)
            {
                propTypeRes.DeleteProp("ReverseDisplayName");
            }
            else
            {
                propTypeRes.SetProp("ReverseDisplayName", toDisplayName);
            }

            propTypeItem.SetDisplayNames(fromDisplayName, toDisplayName);
        }
Exemple #10
0
        /**
         * Adds a record for the specified prop type to the DB.
         */

        internal int RegisterPropTypeInternal(string name, PropDataType propType, PropTypeFlags flags,
                                              bool forceType, out bool newPropType)
        {
            _storage.CheckOwnerThread();
            IRecord rec = _propTypeTable.GetRecordByEqual(1, name);

            if (rec != null)
            {
                if (!_propTypeNameCache.ContainsKey(name))
                {
                    throw new BadIndexesException("Property type " + name + " found in PropTypes table but missing in name cache");
                }

                bool recordChanged = false;
                if (rec.GetIntValue(2) != (int)propType)
                {
                    if (forceType)
                    {
                        rec.SetValue(2, IntInternalizer.Intern((int)propType));
                        ((PropTypeItem)this[name]).SetDataType(propType);
                        recordChanged = true;
                    }
                    else
                    {
                        throw new StorageException("Inconsistent registration for property type " + name +
                                                   ": old type " + (PropDataType)rec.GetIntValue(2) + ", new type " + propType);
                    }
                }
                int           propId   = rec.GetIntValue(0);
                PropTypeFlags newFlags = flags | this [propId].Flags;
                if (rec.GetIntValue(3) != (int)newFlags)
                {
                    rec.SetValue(3, (int)newFlags);
                    recordChanged = true;
                }
                if (recordChanged)
                {
                    rec.Commit();
                }

                newPropType = false;
                PropTypeItem propTypeItem = (PropTypeItem)_propTypeCache [propId];
                propTypeItem.SetFlags(newFlags);
                return(propId);
            }

            if ((flags & (PropTypeFlags.DirectedLink | PropTypeFlags.CountUnread)) != 0 &&
                propType != PropDataType.Link)
            {
                throw new StorageException("DirectedLink and CountUnread flags can be used only on Link properties");
            }

            int ID;

            lock ( _propTypeTable )
            {
                IRecord propertyType = _propTypeTable.NewRecord();
                propertyType.SetValue(1, name);
                propertyType.SetValue(2, IntInternalizer.Intern((int)propType));
                propertyType.SetValue(3, (int)flags);
                _storage.SafeCommitRecord(propertyType, "PropTypeCollection.RegisterPropTypeInternal");
                ID = propertyType.GetID();
                if (ID > 65536)
                {
                    MyPalStorage.Storage.OnIndexCorruptionDetected("Invalid next ID in property type table");
                }
            }

            AddPropTypeToCache(ID, name, propType, flags);

            newPropType = true;
            return(ID);
        }