public Error_CouldNotRemoveSetting(ADBSettingsBase mySetting, TypesSettingScope myScope, GraphDBType myType = null, TypeAttribute myAttribute = null)
{
Setting = mySetting;
Scope = myScope;
Type = myType;
Attribute = myAttribute;
}
public ADBSettingsBase(ADBSettingsBase myCopy)
{
Name = myCopy.Name;
Description = myCopy.Description;
OwnerID = myCopy.OwnerID;
Type = myCopy.Type;
Default = myCopy.Default;
_Value = myCopy._Value;
}
protected ADBBaseObject GetValueForSetting(ADBSettingsBase mySetting, String myValue)
{
var _TypeUUID = mySetting.Type;
if (myValue != "DEFAULT")
return GraphDBTypeMapper.GetADBBaseObjectFromUUID(_TypeUUID, myValue);
else
return GraphDBTypeMapper.GetADBBaseObjectFromUUID(_TypeUUID, mySetting.Default.Value);
}
protected Dictionary<String, Object> MakeOutputForAttribs(ADBSettingsBase mySetting)
{
var settingList = new Dictionary<String, Object>();
settingList.Add("Name", mySetting.Name);
settingList.Add("ID", mySetting.ID);
settingList.Add("Type", mySetting.Type);
settingList.Add("Value", mySetting.Value);
settingList.Add("Default", mySetting.Default);
return settingList;
}
private byte[] Serialize(ref SerializationWriter mySerializationWriter, ADBSettingsBase myValue)
{
#region Write Basics
try
{
if (myValue != null)
{
mySerializationWriter.WriteString(myValue.Name);
mySerializationWriter.WriteString(myValue.Description);
mySerializationWriter.WriteObject(myValue.OwnerID);
myValue.Type.Serialize(ref mySerializationWriter);
mySerializationWriter.WriteObject(myValue.Default.Value);
mySerializationWriter.WriteObject(myValue._Value.Value);
_isDirty = false;
}
else
{
mySerializationWriter.WriteString(Name);
mySerializationWriter.WriteString(Description);
mySerializationWriter.WriteObject(myValue.OwnerID);
myValue.Type.Serialize(ref mySerializationWriter);
mySerializationWriter.WriteObject(Default.Value);
mySerializationWriter.WriteObject(_Value.Value);
}
}
catch (SerializationException e)
{
throw new SerializationException(e.Message);
}
#endregion
return mySerializationWriter.ToArray();
}
private object Deserialize(ref SerializationReader mySerializationReader, ADBSettingsBase myValue)
{
#region Read Basics
try
{
if (myValue != null)
{
myValue.Name = mySerializationReader.ReadString();
myValue.Description = mySerializationReader.ReadString();
myValue.OwnerID = (EntityUUID)mySerializationReader.ReadObject();
myValue.Type = new TypeUUID(mySerializationReader.ReadByteArray());
myValue.Default.SetValue(mySerializationReader.ReadObject());
myValue._Value.SetValue(mySerializationReader.ReadObject());
}
else
{
Name = mySerializationReader.ReadString();
Description = mySerializationReader.ReadString();
OwnerID = (EntityUUID)mySerializationReader.ReadObject();
Type = new TypeUUID(mySerializationReader.ReadByteArray());
Default.SetValue(mySerializationReader.ReadObject());
_Value.SetValue(mySerializationReader.ReadObject());
}
}
catch (Exception e)
{
throw new GraphFSException_EntityCouldNotBeDeserialized("ADBSetting could not be deserialized!\n\n" + e);
}
#endregion
return myValue;
}
/// <summary>
/// validates two parametersets
/// </summary>
/// <param name="pFunc"></param>
/// <param name="pParam1"></param>
/// <param name="pParam2"></param>
/// <returns></returns>
public Boolean doValidate(ValidateFunc pFunc, ADBSettingsBase pParam1, ADBSettingsBase pParam2)
{
if (pFunc != null)
return pFunc.Invoke(pParam1, pParam2);
return false;
}
/// <summary>
/// Sets the given setting for a given type within this session
/// </summary>
/// <param name="setting">The setting to be set</param>
/// <param name="typeUUID">The name of the type</param>
/// <returns>True for success</returns>
public Exceptional SetTypeSetting(ADBSettingsBase setting, TypeUUID typeUUID)
{
lock (_SessionSettingsType)
{
if (_SessionSettingsType.ContainsKey(typeUUID))
{
if (_SessionSettingsType[typeUUID].ContainsKey(setting.Name))
{
_SessionSettingsType[typeUUID][setting.Name] = setting;
}
else
{
_SessionSettingsType[typeUUID].Add(setting.Name, setting);
}
}
else
{
_SessionSettingsType.Add(typeUUID, new Dictionary<string, ADBSettingsBase>());
_SessionSettingsType[typeUUID].Add(setting.Name, setting);
}
}
return Exceptional.OK;
}
/// <summary>
/// Sets the given setting for this session
/// </summary>
/// <param name="setting">The setting to be set</param>
/// <returns>True for success</returns>
public Exceptional SetSessionSetting(ADBSettingsBase setting)
{
lock (_SessionSettingsSession)
{
if (_SessionSettingsSession.ContainsKey(setting.Name))
{
_SessionSettingsSession[setting.Name] = setting;
}
else
{
_SessionSettingsSession.Add(setting.Name, setting);
}
}
return Exceptional.OK;
}
/// <summary>
/// generate a output result
/// </summary>
/// <param name="mySetting">the setting</param>
/// <param name="myReadOutList">list of dbreadouts</param>
private Vertex GenerateResult(ADBSettingsBase mySetting, DBTypeManager typeManager)
{
var Setting = new Dictionary<String, Object>();
Setting.Add("Name", mySetting.Name);
Setting.Add("ID", mySetting.ID);
Setting.Add("Type", typeManager.GetTypeByUUID(mySetting.Type).Name);
Setting.Add("Desc", mySetting.Description);
Setting.Add("Default", mySetting.Default);
Setting.Add("Value", mySetting.Value);
return new Vertex(Setting);
}
/// <summary>
/// Adds a setting to this type
/// </summary>
/// <param name="myName">The name of the setting</param>
/// <param name="mySetting">The setting itself</param>
/// <param name="myTypeManager">The DB type manager</param>
/// <returns>A Result type</returns>
public Exceptional SetPersistentSetting(string myName, ADBSettingsBase mySetting, DBTypeManager myTypeManager)
{
if (!_TypeSettings.ContainsKey(myName))
{
_TypeSettings.Add(myName, (ADBSettingsBase)mySetting.Clone());
}
else
{
_TypeSettings[myName] = (ADBSettingsBase)mySetting.Clone();
}
var FlushExcept = myTypeManager.FlushType(this);
if (FlushExcept.Failed())
return new Exceptional(FlushExcept);
return Exceptional.OK;
}
public Exceptional SetPersistentDBSetting(DBContext myDBContext, ADBSettingsBase mySetting)
{
#region Verify that DB is not set to readonly
var readWriteCheck = VerifyReadWriteOperationIsValid(myDBContext, mySetting.Name);
if (readWriteCheck.Failed())
{
return new Exceptional(readWriteCheck);
}
#endregion
var _SetMetadatumExceptional = _IGraphFSSession.SetMetadatum<ADBSettingsBase>(_DBSettingsLocation, FSConstants.SETTINGSSTREAM, FSConstants.DefaultEdition, mySetting.Name, mySetting, IndexSetStrategy.REPLACE);
if (_SetMetadatumExceptional != null && _SetMetadatumExceptional.Success())
{
return Exceptional.OK;
}
return _SetMetadatumExceptional.PushIError(new Error_SettingCouldNotBeSet(mySetting.Name));
}
public Exceptional SetPersistentSetting(String mySettingName, ADBSettingsBase myADBSettingsBase, DBTypeManager myDBTypeManager)
{
if (!_Settings.ContainsKey(mySettingName))
{
_Settings.Add(mySettingName, (ADBSettingsBase)myADBSettingsBase.Clone());
}
else
{
_Settings[mySettingName] = (ADBSettingsBase)myADBSettingsBase.Clone();
}
var FlushExcept = myDBTypeManager.FlushType(GetRelatedType(myDBTypeManager));
if (FlushExcept.Failed())
return new Exceptional(FlushExcept);
return Exceptional.OK;
}
