/// <summary> /// Adds a new ResourceTypeItem to the resource type cache. /// </summary> private void AddResourceTypeToCache(int ID, string name, string displayNameTemplate, ResourceTypeFlags flags) { if (ID < 0 || ID > 65536) { throw new BadIndexesException("Invalid resource type ID " + ID); } lock ( _resourceTypeCache ) { ResourceTypeItem item = new ResourceTypeItem(ID, name, displayNameTemplate, flags); while (_resourceTypeCache.Count < ID) { _resourceTypeCache.Add(null); } if (_resourceTypeCache.Count == ID) { _resourceTypeCache.Add(item); } else { _resourceTypeCache [ID] = item; } _resourceTypeNameCache [name] = item; } }
internal void UpdateResourceType(string name, string displayNameTemplate, ResourceTypeFlags flags, string propDisplayName) { ICountedResultSet rs = _resourceTypeTable.CreateModifiableResultSet(1, name); try { if (rs.Count > 0) { IRecord rec = rs [0]; if (rec.GetStringValue(2) != displayNameTemplate) { rec.SetValue(2, displayNameTemplate); _storage.SafeCommitRecord(rec, "ResourceTypeCollection.UpdateResourceType"); } int resID = rec.GetIntValue(0); UpdateResourceTypeCache(resID, displayNameTemplate, flags); ResourceTypeItem item = (ResourceTypeItem)this [resID]; item.SetDisplayName(propDisplayName); } } finally { rs.Dispose(); } }
internal void UpdateResourceTypeCache(int resTypeID, string displayNameMask, ResourceTypeFlags flags) { ResourceTypeItem item = (ResourceTypeItem)_resourceTypeCache [resTypeID]; Debug.Assert(item != null); Debug.Assert(item.Id == resTypeID); item.SetDisplayNameTemplate(displayNameMask, true); item.SetFlags(flags); }
internal ResourceTypeItem(int ID, string name, string displayNameTemplate, ResourceTypeFlags flags) { _id = ID; _name = name; _displayName = name; _displayNameTemplate = new DisplayNameMask(displayNameTemplate, true); _flags = flags; _ownerPluginLoaded = true; }
/** * Registering of file resource type with corresponding list of extensions */ public void RegisterFileResourceType(string fileResType, string displayName, string resourceDisplayNameTemplate, ResourceTypeFlags flags, IPlugin ownerPlugin, params string[] exts) { _store.ResourceTypes.Register(fileResType, displayName, resourceDisplayNameTemplate, flags | ResourceTypeFlags.FileFormat, ownerPlugin); RegisterFileResourceTypeImpl(fileResType, exts); }
private bool IsFeasibleRT(IResourceType rt, ArrayList validNames, ResourceTypeFlags checkFlag) { // 1. Plugin must be loaded which is responsible for that res type // 2. If there is no restriction on particular res types // (validNames.Count == 0) then allow those which are indexable and // with nonempty name. // 3. If there is restriction on the particular res types, then only // those res types are allowed. return(rt.OwnerPluginLoaded && ((!rt.HasFlag(checkFlag) && (rt.DisplayName != null) && (validNames.Count == 0)) || (validNames.IndexOf(rt.Name) != -1))); }
private ResourceTypeFlags GetFlagsFromResource(IResource res) { ResourceTypeFlags flags = ResourceTypeFlags.Normal; foreach (ResourceTypeFlagMapping flagMapping in _flagMap) { if (flagMapping.Value.Equals(res.GetProp(flagMapping.Prop))) { flags |= flagMapping.Flag; } } return(flags); }
internal void SetResourceTypeFlags(IResource res, ResourceTypeFlags flags) { foreach (ResourceTypeFlagMapping flagMapping in _flagMap) { if ((flags & flagMapping.Flag) != 0) { res.SetProp(flagMapping.Prop, flagMapping.Value); } else { res.DeleteProp(flagMapping.Prop); } } }
internal void CreateOrUpdateResourceTypeResource(string name, string displayName, string resourceDisplayNameTemplate, ResourceTypeFlags flags, IPlugin ownerPlugin, int ID, bool newType) { ResourceTypeFlags oldFlags = ResourceTypeFlags.Normal; IResource res; if (newType) { try { res = CreateResourceTypeResource(ID, name, resourceDisplayNameTemplate); } catch (ResourceRestrictionException ex) { MyPalStorage.Storage.OnIndexCorruptionDetected("ResourceRestrictionException when creating PropType resource: " + ex.Message); return; } } else { res = _storage.FindUniqueResource("ResourceType", _storage.Props.Name, name); oldFlags = this [name].Flags; } if (res == null) { MyPalStorage.Storage.OnIndexCorruptionDetected("Could not find ResourceType resource with name " + name); } else { SetResourceTypeFlags(res, flags); res.SetProp(_storage.Props.PropDisplayName, displayName); _storage.SetOwnerPlugin(res, ownerPlugin); } UpdateResourceTypeCache(ID, resourceDisplayNameTemplate, flags | oldFlags); if (newType) { _storage.CacheResourceTypePredicate((ResourceTypeItem)_resourceTypeCache [ID]); } }
public int Register(string name, string displayName, string resourceDisplayNameTemplate, ResourceTypeFlags flags, IPlugin ownerPlugin) { if (resourceDisplayNameTemplate == null) { resourceDisplayNameTemplate = ""; } // creating the mask instance validates it, and we don't want to get exceptions // after some of the data has been created new DisplayNameMask(resourceDisplayNameTemplate, true); bool newType = false; int ID = RegisterResourceTypeInternal(name, resourceDisplayNameTemplate, flags, false, out newType); CreateOrUpdateResourceTypeResource(name, displayName, resourceDisplayNameTemplate, flags, ownerPlugin, ID, newType); return(ID); }
/** * Adds a record for the specified resource type to the DB. */ internal int RegisterResourceTypeInternal(string name, string displayNameTemplate, ResourceTypeFlags flags, bool skipChecks, out bool newType) { _storage.CheckOwnerThread(); IRecord rec = _resourceTypeTable.GetRecordByEqual(1, name); if (rec != null) { if (!_resourceTypeNameCache.ContainsKey(name)) { throw new BadIndexesException("Resource type " + name + " found in ResourceTypes table but missing in name cache"); } string oldDisplayNameTemplate = rec.GetStringValue(2); if (!skipChecks && String.Compare(oldDisplayNameTemplate, displayNameTemplate, true, CultureInfo.InvariantCulture) != 0) { if (oldDisplayNameTemplate.Length == 0) { rec.SetValue(2, displayNameTemplate); _storage.SafeCommitRecord(rec, "ResourceTypeCollection.RegisterResourceTypeInternal"); } else { throw new StorageException("Inconsistent display name template for resource type " + name + "\nOld: " + oldDisplayNameTemplate + " New: " + displayNameTemplate); } } newType = false; return(rec.GetIntValue(0)); } int ID; lock ( _resourceTypeTable ) { IRecord resourceType = _resourceTypeTable.NewRecord(); resourceType.SetValue(1, name); resourceType.SetValue(2, displayNameTemplate); _storage.SafeCommitRecord(resourceType, "ResourceTypeCollection.RegisterResourceTypeInternal"); ID = resourceType.GetID(); if (ID > 65536) { MyPalStorage.Storage.OnIndexCorruptionDetected("Invalid next ID in property type table"); } } AddResourceTypeToCache(ID, name, displayNameTemplate, flags); newType = true; return(ID); }
/** * Registers a new resource type, or returns the ID of the existing type if * it has already been registered. */ public int Register(string name, string displayName, string resourceDisplayNameTemplate, ResourceTypeFlags flags) { return(Register(name, displayName, resourceDisplayNameTemplate, flags, null)); }
public ResourceTypeFlagMapping(ResourceTypeFlags flag, string prop, object value) { Flag = flag; Prop = prop; Value = value; }
internal void SetFlags(ResourceTypeFlags flags) { _flags = flags; }
public bool HasFlag(ResourceTypeFlags flag) { return((_flags & flag) != 0); }
public int Register(string name, string displayName, string resourceDisplayNameTemplate, ResourceTypeFlags flags, IPlugin ownerPlugin) { throw new NotImplementedException(); }