/// <summary>
/// Marks this Object to be inserted upon next flush
/// </summary>
public void Insert(IDataHolder obj)
{
lock (m_toInsert)
{
m_toInsert.Add(obj);
}
}
private void Flush(List <IDataHolder> list, Action <IDataHolder> callback)
{
lock (list)
{
int count = 0;
try
{
for (; count < list.Count; ++count)
{
IDataHolder dataHolder = list[count];
callback(dataHolder);
}
}
finally
{
if (count < list.Count)
{
list.RemoveRange(0, count);
}
else
{
list.Clear();
}
}
}
}
/// <summary>
/// Marks this Object to be deleted upon next flush
/// </summary>
public void Delete(IDataHolder obj)
{
lock (m_toDelete)
{
m_toDelete.Add(obj);
}
}
List <T> GetKeyValuePairs <T>(IDataHolder obj, Func <TableDefinition, T> listCreator)
where T : KeyValueListBase
{
var dataHolderDef = m_mapping.GetDataHolderDefinition(obj.GetType());
var lists = new List <T>(m_mapping.TableDefinitions.Length);
for (var i = 0; i < m_mapping.TableDefinitions.Length; i++)
{
var table = m_mapping.TableDefinitions[i];
for (var j = 0; j < table.ColumnDefinitions.Length; j++)
{
var col = table.ColumnDefinitions[j];
for (var k = 0; k < col.FieldList.Count; k++)
{
var field = col.FieldList[k];
var def = field.DataHolderDefinition;
if (def == dataHolderDef)
{
var list = lists.FirstOrDefault(l => l.TableName == table.Name);
if (list == null)
{
lists.Add(list = listCreator(table));
}
var value = field.Get(obj);
list.AddPair(col.ColumnName, value.ToString());
}
}
}
}
return(lists);
}
public void SetSingleValue(object value, IDataHolder holder)
{
for (int index = 0; index < FieldList.Count; ++index)
{
FieldList[index].Set(holder, value);
}
}
public IDataHolder Read(BinaryReader reader)
{
object firstValue = this.m_persistors[0].Read(reader);
IDataHolder holder = (IDataHolder)this.m_Def.CreateHolder(firstValue);
this.m_fields[0].Accessor.Set((object)holder, firstValue);
for (int index = 1; index < this.m_persistors.Length; ++index)
{
IBinaryPersistor persistor = this.m_persistors[index];
try
{
object obj = persistor.Read(reader);
this.m_fields[index].Accessor.Set((object)holder, obj);
}
catch (Exception ex)
{
throw new DataHolderException(ex,
"Failed to read DataHolder \"{0}\" (Persistor #{1} {2} for: {3}).", new object[4]
{
(object)holder,
(object)index,
(object)persistor,
(object)this.m_fields[index]
});
}
}
return(holder);
}
public static void CallShowData(object sender, IDataHolder data)
{
if (ShowData != null)
{
ShowData(sender, data);
}
}
public void Start()
{
//provider = new FileDatabase();
//provider = new MysqlDatabase.Database();
provider = new Unturned.RemoteDatabase();
provider.Init();
connectionGuard = new GameObject();
UnityEngine.Object.DontDestroyOnLoad(Database.connectionGuard);
connectionGuard.name = "Connection Guard";
connectionGuard.AddComponent <ConnectionGuard>();
if (!Database.welcomed)
{
StartCoroutine(fixFrameRate());
Database.welcomed = true;
PlayerSettings.id = "Server";
PlayerSettings.status = 21;
if (Epoch.serverTime == -1)
{
Epoch.serverTime = (int)(GetServerTime() - 1401854099);
}
ServerSettings.cycle = (int)(GetServerTime() - 1401854099);
ServerSettings.offset = 0f;
ServerSettings.time = (int)((float)ServerSettings.cycle % Sun.COURSE);
Sun.tick = 0f;
Sun.lastTick = Time.realtimeSinceStartup;
Sun.tool.cycle();
}
}
private List <T> GetKeyValuePairs <T>(IDataHolder obj, Func <TableDefinition, T> listCreator)
where T : KeyValueListBase
{
DataHolderDefinition holderDefinition = this.m_mapping.GetDataHolderDefinition(obj.GetType());
List <T> source = new List <T>(this.m_mapping.TableDefinitions.Length);
for (int index1 = 0; index1 < this.m_mapping.TableDefinitions.Length; ++index1)
{
TableDefinition table = this.m_mapping.TableDefinitions[index1];
for (int index2 = 0; index2 < table.ColumnDefinitions.Length; ++index2)
{
SimpleDataColumn columnDefinition = table.ColumnDefinitions[index2];
for (int index3 = 0; index3 < columnDefinition.FieldList.Count; ++index3)
{
IFlatDataFieldAccessor field = columnDefinition.FieldList[index3];
if (field.DataHolderDefinition == holderDefinition)
{
T obj1 = source.FirstOrDefault <T>((Func <T, bool>)(l => l.TableName == table.Name));
if ((object)obj1 == null)
{
source.Add(obj1 = listCreator(table));
}
object obj2 = field.Get(obj);
obj1.AddPair(columnDefinition.ColumnName, (object)obj2.ToString());
}
}
}
}
return(source);
}
/// <summary>
/// Marks this Object to be updated upon next flush
/// </summary>
public void Update(IDataHolder obj)
{
lock (m_toUpdate)
{
m_toUpdate.Add(obj);
}
}
void HCellData_InvalidateData(object sender)
{
if (Sender == sender)
{
Data = null;
Sender = null;
}
}
public override int SupportLevel(IDataHolder data, IBedValueReader holder)
{
if (holder.GetFieldType().IsDateRelated())
{
return(10);
}
return(0);
}
public object Get(IDataHolder obj)
{
if (Field == null)
{
return(null);
}
return(Field.Accessor.Get(obj));
}
public override int SupportLevel(IDataHolder data, IBedValueReader holder)
{
if (data.LookupInfo != null)
{
return(10);
}
return(0);
}
private static IEncoder <string> CreateHeaderBasedStringEncoder(
Stream dataStream,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new HeaderBasedStringEncoder(
CreateHeaderUsageProvider(dataStream, cachedHeaderHolder)));
}
public object Get(IDataHolder obj)
{
if (this.Field == null)
{
return((object)null);
}
return(this.Field.Accessor.Get((object)obj));
}
void HCellData_ShowData(object sender, IDataHolder data)
{
m_data = data;
m_sender = sender;
if (m_visible)
{
m_frame.Data = data;
}
}
public void SetSingleValue(object value, IDataHolder holder)
{
for (var i = 0; i < FieldList.Count; i++)
{
var dataField = FieldList[i];
// set value
dataField.Set(holder, value);
}
}
public void SetSingleValue(object value, IDataHolder holder)
{
for (var i = 0; i < FieldList.Count; i++)
{
var dataField = FieldList[i];
// set value
dataField.Set(holder, value);
}
}
public HeaderUsageProvider(
IDataReader dataReader,
IDecoder <Header> headerDecoder,
IDataHolder <Header> cachedHeaderHolder)
{
this.dataReader = dataReader;
this.headerDecoder = headerDecoder;
this.cachedHeaderHolder = cachedHeaderHolder;
}
private static IHeaderUsageProvider CreateHeaderUsageProvider(
Stream dataStream,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new HeaderUsageProvider(
new DataReader(dataStream),
CreateHeaderDecoder(),
cachedHeaderHolder));
}
private static IRawDataAllocator CreateRawDataAllocator(
Stream dataStream,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new RawDataAllocator(
CreateAllocationFinder(dataStream),
CreateAMapBasedStreamExtender(dataStream, cachedHeaderHolder),
CreateAMapBasedAllocationReserver(dataStream, cachedHeaderHolder)));
}
internal void LoadAll(BinaryReader reader, List <Action> initors)
{
int num = reader.ReadInt32();
for (int index = 0; index < num; ++index)
{
IDataHolder dataHolder = this.Read(reader);
initors.Add(new Action(dataHolder.FinalizeDataHolder));
}
}
private static IDataBlockReader CreateDataBlockReader(
Stream dataReader,
ICache <BID, BTPage> cachedBTPages,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new BlockIdBasedDataBlockReader(
new DataReader(dataReader),
CreateHeaderUsageProvider(dataReader, cachedHeaderHolder),
CreateBlockBTreeEntryFinder(dataReader, cachedBTPages)));
}
private static IPropertyNameToIdMap CreatePropertyIdToNameMap(
Stream dataStream,
ICache <BID, BTPage> cachedBTPages,
ICache <BID, SubnodeBlock> cachedSubnodeBlocks,
ICache <BID, InternalDataBlock> cachedInternalDataBlocks,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new PropertyNameToIdMap(
CreatePropertyContextBasedPropertyReader(dataStream, cachedBTPages, cachedSubnodeBlocks, cachedInternalDataBlocks, cachedHeaderHolder)));
}
private static IEncoding CreateBlockEncoding(
Stream dataStream,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new EncodingThatDetectsTypeFromTheHeader(
CreateHeaderUsageProvider(dataStream, cachedHeaderHolder),
new PermutativeEncoding(),
new CyclicEncoding(),
new NoEncoding()));
}
private static IDataTreeAllocator CreateDataTreeAllocator(
Stream dataStream,
List <LBBTEntry> allocatedBlockBTreeEntries,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new DataTreeAllocator(
CreateExternalDataBlockAllocator(dataStream, allocatedBlockBTreeEntries, cachedHeaderHolder),
CreateInternalDataBlockAllocator(dataStream, allocatedBlockBTreeEntries, cachedHeaderHolder, internalBlockLevel: 0x01),
CreateInternalDataBlockAllocator(dataStream, allocatedBlockBTreeEntries, cachedHeaderHolder, internalBlockLevel: 0x02)));
}
private static IBTreeOnHeapReader <PropertyId> CreatePropertyIdBasedBTreeOnHeapReader(
Stream dataStream,
ICache <BID, BTPage> cachedBBTNodes,
ICache <BID, SubnodeBlock> cachedSubnodeBlocks,
ICache <BID, InternalDataBlock> cachedInternalDataBlocks,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new BTreeOnHeapReader <PropertyId>(
new PropertyIdDecoder(),
CreateHeapOnNodeReader(dataStream, cachedBBTNodes, cachedSubnodeBlocks, cachedInternalDataBlocks, cachedHeaderHolder)));
}
private static IBTreeOnHeapReader <int> CreateInt32BasedBTreeOnHeapReader(
Stream dataStream,
ICache <BID, BTPage> cachedBBTNodes,
ICache <BID, SubnodeBlock> cachedSubnodeBlocks,
ICache <BID, InternalDataBlock> cachedInternalDataBlocks,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new BTreeOnHeapReader <int>(
new FuncBasedDecoder <int>(d => BitConverter.ToInt32(d.Value, 0)),
CreateHeapOnNodeReader(dataStream, cachedBBTNodes, cachedSubnodeBlocks, cachedInternalDataBlocks, cachedHeaderHolder)));
}
private static INodeEntryFinder CreateNodeEntryFinder(
Stream dataStream,
ICache <BID, BTPage> cachedBTPages,
ICache <BID, SubnodeBlock> cachedSubnodeBlocks,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new NodeEntryFinder(
CreateHeaderUsageProvider(dataStream, cachedHeaderHolder),
CreateNodeBTreeEntryFinder(dataStream, cachedBTPages),
CreateSubNodesEnumerator(dataStream, cachedBTPages, cachedSubnodeBlocks, cachedHeaderHolder)));
}
private static IHeapOnNodeReader CreateHeapOnNodeReader(
Stream dataStream,
ICache <BID, BTPage> cachedBBTNodes,
ICache <BID, SubnodeBlock> cachedSubnodeBlocks,
ICache <BID, InternalDataBlock> cachedInternalDataBlocks,
IDataHolder <Header> cachedHeaderHolder)
{
return
(new HeapOnNodeReader(
new HeapOnNodeItemsLoader(),
CreateDataTreeReader(dataStream, cachedBBTNodes, cachedInternalDataBlocks, cachedSubnodeBlocks, cachedHeaderHolder)));
}
public InputDataInTables(IDataHolder dataHolder)
{
InitializeComponent();
var varNamelst = new List<string>();
for (int i = 0; i < dataHolder.AllVariables.Length; i++)
{
varNamelst.Add("Переменная " + (i + 1));
}
gridViewVariables.DataSource = dataHolder.AllVariables.GetDataTableFromMatrix(varNamelst.ToArray());
var funcNamelst = new List<string>();
for (int i = 0; i < dataHolder.Y.Length; i++)
{
funcNamelst.Add("Функция " + (i + 1));
}
gridViewFunctions.DataSource =
dataHolder.Y.GetDataTableFromMatrix(funcNamelst.ToArray());
}
void Write(BinaryWriter writer, IDataHolder holder)
{
for (var i = 0; i < m_persistors.Length; i++)
{
var persistor = m_persistors[i];
try
{
var val = m_fields[i].Accessor.Get(holder);
persistor.Write(writer, val);
}
catch (Exception e)
{
throw new DataHolderException(e, "Failed to write DataHolder \"{0}\" (Persistor #{1} {2} for: {3}).",
holder, i, persistor, m_fields[i]);
}
}
}
public void Set(IDataHolder obj, object value)
{
//throw new DataHolderException("Proxy field is not settable.");
}
public object Get(IDataHolder obj)
{
return Field.Accessor.Get(obj);
}
/// <summary>
///
/// </summary>
/// <param name="rootObject"></param>
/// <returns></returns>
public object GetTargetObject(IDataHolder rootObject)
{
if (m_parent == null)
{
return rootObject;
}
var targetObj = m_parent.GetTargetObject(rootObject);
var obj = m_parent.Accessor.Get(targetObj);
if (obj == null)
{
obj = m_parent.Producer.Produce();
m_parent.Accessor.Set(rootObject, obj);
}
return obj;
}
public object Get(IDataHolder obj)
{
var targetObj = m_ArrayField.GetTargetObject(obj);
return m_ArrayField.Get(targetObj, m_Index);
}
public void Set(IDataHolder obj, object value)
{
var targetObj = m_ArrayField.GetTargetObject(obj);
m_ArrayField.Set(targetObj, m_Index, value);
}
public object Get(IDataHolder obj)
{
var targetObj = GetTargetObject(obj);
return m_accessor.Get(targetObj);
}
public void Set(IDataHolder obj, object value)
{
var targetObj = GetTargetObject(obj);
m_accessor.Set(targetObj, value);
if (targetObj.GetType().IsValueType)
{
var parent = m_parent;
object parentTarget;
while (parent != null)
{
parentTarget = parent.GetTargetObject(obj);
parent.Accessor.Set(parentTarget, targetObj);
targetObj = parentTarget;
parent = parent.Parent;
if (!parentTarget.GetType().IsValueType)
{
break;
}
}
}
}
public object GetTargetObject(IDataHolder rootObject)
{
return m_ArrayField.GetTargetObject(rootObject);
}
// TODO: Fix up default values
internal void SetDefaults(object id, IDataHolder holder)
{
if (id is object[])
{
var ids = (object[])id;
for (var i = 0; i < PrimaryColumns.Length; i++)
{
var col = PrimaryColumns[i].DataColumn;
col.SetSingleValue(ids[i], holder);
}
}
else
{
PrimaryColumns[0].DataColumn.SetSingleValue(id, holder);
}
}
