/// <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();
}
