private void UpdateSyncFlagBit(SyncFlags bit1, bool value1, SyncFlags bit2, bool value2, SQLiteConnectionUser cn, DbTransaction txn = null)
{
if (value1)
{
Synced |= (int)bit1;
}
else
{
Synced &= ~(int)bit1;
}
if (value2)
{
Synced |= (int)bit2;
}
else
{
Synced &= ~(int)bit2;
}
using (DbCommand cmd = cn.CreateCommand("Update JournalEntries set Synced = @sync where ID=@journalid", txn))
{
cmd.AddParameterWithValue("@journalid", Id);
cmd.AddParameterWithValue("@sync", Synced);
//System.Diagnostics.Trace.WriteLine(string.Format("Update sync flag ID {0} with {1}", Id, Synced));
cmd.ExecuteNonQuery();
}
}
public static void UpdateSyncFlagBit(long journalid, SyncFlags bit, bool value)
{
using (SQLiteConnectionUser cn = new SQLiteConnectionUser(utc: true))
{
JournalEntry je = Get(journalid, cn);
if (je != null)
{
if (value)
{
je.Synced |= (int)bit;
}
else
{
je.Synced &= ~(int)bit;
}
using (DbCommand cmd = cn.CreateCommand("Update JournalEntries set Synced = @sync where ID=@journalid"))
{
cmd.AddParameterWithValue("@journalid", journalid);
cmd.AddParameterWithValue("@sync", je.Synced);
System.Diagnostics.Trace.WriteLine(string.Format("Update sync flag ID {0} with {1}", journalid, je.Synced));
SQLiteDBClass.SQLNonQueryText(cn, cmd);
}
}
}
}
internal GenerateSelectIDSql(string idFieldName, string dbAdapterName, string fieldsSql, string dbTableName, SyncFlags flags)
{
_IDFieldName = idFieldName;
_DBAdapterName = dbAdapterName;
_FieldSql = fieldsSql;
_DBTableName = dbTableName;
_Flags = flags;
}
internal FieldDescriptor GetFieldDescriptor(PropertyInfo propertyInfo, SyncFlags syncFlags)
{
return(new FieldDescriptor(
GenerateFieldFactoryByType(propertyInfo.PropertyType, syncFlags),
DelegateGenerator.GenerateGetter(propertyInfo),
DelegateGenerator.GenerateSetter(propertyInfo)
));
}
internal FieldDescriptor GetFieldDescriptor(FieldInfo fieldInfo, SyncFlags syncFlags)
{
return(new FieldDescriptor(
GenerateFieldFactoryByType(fieldInfo.FieldType, syncFlags),
DelegateGenerator.GenerateGetter(fieldInfo),
DelegateGenerator.GenerateSetter(fieldInfo)
));
}
/// <summary>
/// Do synchronize
/// </summary>
/// <param name="step"></param>
/// <param name="option">optimize option</param>
/// <param name="fastestMode">if fastest mode. read data from db without log</param>
/// <param name="flags">flags</param>
public void Synchronize(int step, OptimizationOption option, bool fastestMode, SyncFlags flags)
{
if (SyncThread != null)
{
return;
}
if (!_Table.TableSynchronization && (flags & SyncFlags.Rebuild) == 0)
{
throw new DataException("Can't do synchronization. You must set the TableSynchronization to true!");
}
if (!_Table.IndexOnly && (flags & SyncFlags.Rebuild) == 0)
{
throw new DataException("Can't do synchronization in non-indexonly mode");
}
if (SyncThread != null)
{
Hubble.Core.Global.Report.WriteAppLog(string.Format("Table:{0} is synchronizing now.", _Table.Name));
return;
}
SetException(null);
_Step = step;
if (_Step <= 0)
{
_Step = 1;
}
else if (_Step > MaxStep)
{
_Step = MaxStep;
}
_OptimizeOption = option;
_FastestMode = fastestMode;
_Flags = flags;
SetProgress(0);
SyncThread = new Thread(DoSynchronize);
SyncThread.IsBackground = true;
SyncThread.Start();
}
public void UpdateSyncFlagBit(SyncFlags bit1, bool value1, SyncFlags bit2, bool value2, SQLiteConnectionUser cn = null, DbTransaction txn = null)
{
bool closeConn = false;
try
{
if (cn == null)
{
closeConn = true;
cn = new SQLiteConnectionUser(utc: true);
}
if (value1)
{
Synced |= (int)bit1;
}
else
{
Synced &= ~(int)bit1;
}
if (value2)
{
Synced |= (int)bit2;
}
else
{
Synced &= ~(int)bit2;
}
using (DbCommand cmd = cn.CreateCommand("Update JournalEntries set Synced = @sync where ID=@journalid", txn))
{
cmd.AddParameterWithValue("@journalid", Id);
cmd.AddParameterWithValue("@sync", Synced);
System.Diagnostics.Trace.WriteLine(string.Format("Update sync flag ID {0} with {1}", Id, Synced));
SQLiteDBClass.SQLNonQueryText(cn, cmd);
}
}
finally
{
if (closeConn && cn != null)
{
cn.Dispose();
}
}
}
public void SyncTable(Type type, SyncFlags flags = SyncFlags.None)
{
string tableName = type.Name;
if (TableExists(tableName))
{
if (TableHasRows(tableName))
{
if (!CompareFlag(flags, SyncFlags.ForceDrop))
{
// TODO Try Update table
return;
}
DeleteRecords(tableName);
}
DropTable(tableName);
}
CreateTable(type);
}
private static void RegisterFieldType(Type syncFieldType, Type fieldType, SyncFlags syncFlags = SyncFlags.None)
{
if (!syncFieldType.IsSubclassOf(typeof(SynchronisableValue)))
{
throw new NetcodeGenerationException(string.Format(
"{0} must inherit from {1}.",
syncFieldType.FullName, typeof(SynchronisableValue).Name
));
}
RuntimeTypeHandle fieldTypeHandle = fieldType.TypeHandle;
Dictionary <RuntimeTypeHandle, SynchroniserFactory> lookup = ((syncFlags & SyncFlags.HalfPrecision) != 0)
? HalfFieldFactoryLookup : FieldFactoryLookup;
if (lookup.ContainsKey(fieldTypeHandle))
{
throw new NetcodeGenerationException(string.Format(
"A {0} has already been registered against {1} with flags {2}",
typeof(SynchronisableValue).Name, fieldType.FullName, syncFlags
));
}
lookup[fieldTypeHandle] = new SyncValueFactory(syncFieldType);;
}
public static string GetDescription(this SyncFlags value)
{
string result = string.Empty;
if (value.HasFlag(SyncFlags.UnorderedAccessViewGlobal))
{
result += "_uglobal";
}
if (value.HasFlag(SyncFlags.UnorderedAccessViewGroup))
{
result += "_ugroup";
}
if (value.HasFlag(SyncFlags.SharedMemory))
{
result += "_g";
}
if (value.HasFlag(SyncFlags.ThreadsInGroup))
{
result += "_t";
}
return(result);
}
public override string ToString()
{
string result = TypeDescription;
if (Header.OpcodeType == OpcodeType.Sync)
{
result += SyncFlags.GetDescription();
}
if (ExtendedTypes.Contains(InstructionTokenExtendedType.SampleControls))
{
result += "_aoffimmi";
}
if (ExtendedTypes.Contains(InstructionTokenExtendedType.ResourceDim))
{
result += "_indexable";
}
if (ExtendedTypes.Contains(InstructionTokenExtendedType.SampleControls))
{
result += string.Format("({0},{1},{2})", SampleOffsets[0], SampleOffsets[1], SampleOffsets[2]);
}
if (ExtendedTypes.Contains(InstructionTokenExtendedType.ResourceDim))
{
result += string.Format("({0}", ResourceTarget.GetDescription());
if (ResourceStride != 0)
{
result += string.Format(", stride={0}", ResourceStride);
}
result += ")";
}
if (ExtendedTypes.Contains(InstructionTokenExtendedType.ResourceReturnType))
{
result += string.Format("({0},{1},{2},{3})",
ResourceReturnTypes[0].GetDescription(),
ResourceReturnTypes[1].GetDescription(),
ResourceReturnTypes[2].GetDescription(),
ResourceReturnTypes[3].GetDescription());
}
if (Header.OpcodeType == OpcodeType.Resinfo && ResInfoReturnType != ResInfoReturnType.Float)
{
result += string.Format("_{0}", ResInfoReturnType.GetDescription().ToLower());
}
if (Header.OpcodeType.IsConditionalInstruction())
{
result += "_" + TestBoolean.GetDescription();
}
if (Saturate)
{
result += "_sat";
}
result += " ";
if (Header.OpcodeType == OpcodeType.InterfaceCall)
{
result += string.Format("fp{0}[{1}][{2}]",
Operands[0].Indices[0].Value,
Operands[0].Indices[1],
FunctionIndex);
}
else
{
for (int i = 0; i < Operands.Count; i++)
{
var operandString = Operands[i].ToString();
if (i > 0 && !string.IsNullOrEmpty(operandString))
{
result += ", ";
}
result += operandString;
}
}
return(result);
}
public void SetPeerInformation(PlayerInformation playerInformation, out int asyncHandle, SyncFlags flags)
{
throw new NotImplementedException();
}
public int ChannelSetSync(IBassAudioChannel channel, SyncFlags type, long parameter, SyncProcedure procedure, IntPtr user = default) => BassMix.ChannelSetSync(channel.Handle, type, parameter, procedure, user);
public void SyncTable <T>(SyncFlags flags = SyncFlags.None) => SyncTable(typeof(T), flags);
/// <summary>
/// block and wait for a sync object to become signaled
/// </summary>
/// <param name="Sync">The sync object whose status to wait on.</param>
/// <param name="flags">A bitfield controlling the command flushing behavior. flags may be GL_SYNC_FLUSH_COMMANDS_BIT.</param>
/// <param name="timeout_ns">The timeout, specified in nanoseconds, for which the implementation should wait for sync to become signaled.</param>
/// <returns>
/// <list type="bullet">
/// <listheader>The return value is one of four status values:</listheader>
/// <item>GL_ALREADY_SIGNALED indicates that sync was signaled at the time that glClientWaitSync was called.</item>
/// <item>GL_TIMEOUT_EXPIRED indicates that at least timeout nanoseconds passed and sync did not become signaled.</item>
/// <item>GL_CONDITION_SATISFIED indicates that sync was signaled before the timeout expired.</item>
/// <item>GL_WAIT_FAILED indicates that an error occurred. Additionally, an OpenGL error will be generated.</item>
/// </list>
/// </returns>
/// <remarks>
/// glClientWaitSync causes the client to block and wait for the sync object specified by sync to become signaled. If sync is signaled when glClientWaitSync is called, glClientWaitSync returns immediately, otherwise it will block and wait for up to timeout nanoseconds for sync to become signaled.
/// </remarks>
public static ClientWaitSyncStatus ClientWaitSync(IntPtr Sync, SyncFlags flags, ulong timeout_ns)
{
return(Delegates.glClientWaitSync(Sync, flags, timeout_ns));
}
private bool CompareFlag(SyncFlags flag, SyncFlags compare) => (flag & compare) == compare;
public static extern int ChannelSetSync(int Handle, SyncFlags Type, long Param, SyncProcedure Procedure, IntPtr User = default(IntPtr));
public void SetPeerInformation(PlayerInformation playerInformation, SyncFlags flags, object asyncContext)
{
throw new NotImplementedException();
}
public void SetClientInformation(PlayerInformation playerInformation, SyncFlags flags)
{
throw new NotImplementedException();
}
/// <summary>
/// instruct the GL server to block until the specified sync object becomes signaled
/// </summary>
/// <param name="Sync">Specifies the sync object whose status to wait on.</param>
/// <param name="flags">A bitfield controlling the command flushing behavior. flags may be zero.</param>
/// <param name="timeout">Specifies the timeout that the server should wait before continuing. timeout must be GL_TIMEOUT_IGNORED.</param>
/// <remarks>
/// glWaitSync causes the GL server to block and wait until sync becomes signaled. sync is the name of an existing sync object upon which to wait. flags and timeout are currently not used and must be set to zero and the special value GL_TIMEOUT_IGNORED, respectively[1]. glWaitSync will always wait no longer than an implementation-dependent timeout. The duration of this timeout in nanoseconds may be queried by calling glGet with the parameter GL_MAX_SERVER_WAIT_TIMEOUT. There is currently no way to determine whether glWaitSync unblocked because the timeout expired or because the sync object being waited on was signaled.
/// If an error occurs, glWaitSync does not cause the GL server to block.
/// </remarks>
public static void WaitSync(IntPtr Sync, SyncFlags flags = SyncFlags.Zero, ulong timeout = TIMEOUT_IGNORED)
{
Delegates.glWaitSync(Sync, flags, timeout);
}
public void AddPlayerToGroup(int groupID, int clientID, SyncFlags flags)
{
throw new NotImplementedException();
}
/// <summary>
/// instruct the GL server to block until the specified sync object becomes signaled
/// </summary>
/// <param name="Sync">Specifies the sync object whose status to wait on.</param>
/// <param name="flags">A bitfield controlling the command flushing behavior. flags may be zero.</param>
/// <param name="timeout">Specifies the timeout that the server should wait before continuing. timeout must be GL_TIMEOUT_IGNORED.</param>
/// <remarks>
/// glWaitSync causes the GL server to block and wait until sync becomes signaled. sync is the name of an existing sync object upon which to wait. flags and timeout are currently not used and must be set to zero and the special value GL_TIMEOUT_IGNORED, respectively[1]. glWaitSync will always wait no longer than an implementation-dependent timeout. The duration of this timeout in nanoseconds may be queried by calling glGet with the parameter GL_MAX_SERVER_WAIT_TIMEOUT. There is currently no way to determine whether glWaitSync unblocked because the timeout expired or because the sync object being waited on was signaled.
/// If an error occurs, glWaitSync does not cause the GL server to block.
/// </remarks>
public static void WaitSync(IntPtr Sync, SyncFlags flags = SyncFlags.Zero, ulong timeout = TIMEOUT_IGNORED)
{
Delegates.glWaitSync(Sync, flags, timeout);
}
/// <summary>
/// block and wait for a sync object to become signaled
/// </summary>
/// <param name="Sync">The sync object whose status to wait on.</param>
/// <param name="flags">A bitfield controlling the command flushing behavior. flags may be GL_SYNC_FLUSH_COMMANDS_BIT.</param>
/// <param name="timeout_ns">The timeout, specified in nanoseconds, for which the implementation should wait for sync to become signaled.</param>
/// <returns>
/// <list type="bullet">
/// <listheader>The return value is one of four status values:</listheader>
/// <item>GL_ALREADY_SIGNALED indicates that sync was signaled at the time that glClientWaitSync was called.</item>
/// <item>GL_TIMEOUT_EXPIRED indicates that at least timeout nanoseconds passed and sync did not become signaled.</item>
/// <item>GL_CONDITION_SATISFIED indicates that sync was signaled before the timeout expired.</item>
/// <item>GL_WAIT_FAILED indicates that an error occurred. Additionally, an OpenGL error will be generated.</item>
/// </list>
/// </returns>
/// <remarks>
/// glClientWaitSync causes the client to block and wait for the sync object specified by sync to become signaled. If sync is signaled when glClientWaitSync is called, glClientWaitSync returns immediately, otherwise it will block and wait for up to timeout nanoseconds for sync to become signaled.
/// </remarks>
public static ClientWaitSyncStatus ClientWaitSync(IntPtr Sync, SyncFlags flags, ulong timeout_ns)
{
return Delegates.glClientWaitSync(Sync, flags, timeout_ns);
}
public EnumerateSyncValueAttribute(Type fieldType, SyncFlags flags = SyncFlags.None)
{
Flags = flags;
FieldType = fieldType;
}
public void RemovePlayerFromGroup(int groupID, int clientID, out int asyncHandle, SyncFlags flags)
{
throw new NotImplementedException();
}
public void SetGroupInformation(int groupID, GroupInformation groupInformation, out int asyncHandle, SyncFlags flags, object asyncContext)
{
throw new NotImplementedException();
}
public void RemovePlayerFromGroup(int groupID, int clientID, SyncFlags flags, object asyncContext)
{
throw new NotImplementedException();
}
public SyncContainerArrayFactory(SynchroniserFactory elementFactory, SyncFlags flags)
{
DeltaEncoding = (flags & SyncFlags.NoDeltas) == 0;
ElementFactory = elementFactory;
}
private SynchroniserFactory GenerateFieldFactoryByType(Type type, SyncFlags flags)
{
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>))
{
// Recursively get the factory used to create generate the element.
Type elementType = type.GetGenericArguments()[0];
SynchroniserFactory elementFactory = GenerateFieldFactoryByType(elementType, flags);
// Generate the generic factory and create an instance
Type syncFactoryType = typeof(SyncContainerListFactory <>).MakeGenericType(new Type[] { elementType });
// SyncFieldLists take a SyncFieldFactory as an argument.
ConstructorInfo constructor = syncFactoryType.GetConstructor(new Type[] { typeof(SynchroniserFactory), typeof(SyncFlags) });
return((SynchroniserFactory)constructor.Invoke(new object[] { elementFactory, flags }));
}
else if (type.IsArray)
{
// Recursively get the factory used to create generate the element.
Type elementType = type.GetElementType();
SynchroniserFactory elementFactory = GenerateFieldFactoryByType(elementType, flags);
// Generate the generic factory and create an instance
Type syncFactoryType = typeof(SyncContainerArrayFactory <>).MakeGenericType(new Type[] { elementType });
// SyncFieldArrays take a SyncFieldFactory as an argument.
ConstructorInfo constructor = syncFactoryType.GetConstructor(new Type[] { typeof(SynchroniserFactory), typeof(SyncFlags) });
return((SynchroniserFactory)constructor.Invoke(new object[] { elementFactory, flags }));
}
else if ((flags & SyncFlags.Entity) != 0)
{
if (type.IsValueType)
{
throw new NetcodeGenerationException(string.Format("{0}.{1} can not be used on ValueType", typeof(SyncFlags).Name, SyncFlags.Entity));
}
if ((flags & SyncFlags.Dynamic) != 0)
{
return(DynamicEntityFactory);
}
return(EntityCache.GetEntityFactory(type.TypeHandle));
}
else if ((flags & SyncFlags.Reference) != 0)
{
if (type.IsValueType)
{
throw new NetcodeGenerationException(string.Format("{0}.{1} can not be used on ValueType", typeof(SyncFlags).Name, SyncFlags.Reference));
}
return(new SyncReferenceFactory(type, flags));
}
else if ((flags & SyncFlags.Timestamp) != 0)
{
if (type == typeof(long))
{
return(TimestampLongFactory);
}
else if (type == typeof(int))
{
return(TimestampIntFactory);
}
throw new NetcodeGenerationException(string.Format("{0}.{1} must be used on type long or int", typeof(SyncFlags).Name, SyncFlags.Timestamp));
}
RuntimeTypeHandle typeHandle = (type.IsEnum)
? typeof(System.Enum).TypeHandle // Enums all inherit from System.Enum, but have distint typehandles otherwise.
: type.TypeHandle;
if ((flags & SyncFlags.HalfPrecision) != 0)
{
if (HalfFieldFactoryLookup.Keys.Contains(typeHandle))
{
return(HalfFieldFactoryLookup[typeHandle]);
}
else
{
throw new NetcodeGenerationException(string.Format(
"No SyncField registered for type {0} with {1}.{2}",
type.FullName, typeof(SyncFlags).Name, SyncFlags.HalfPrecision
));
}
}
else
{
if (FieldFactoryLookup.Keys.Contains(typeHandle))
{
return(FieldFactoryLookup[typeHandle]);
}
else
{
throw new NetcodeGenerationException(string.Format("No {0} registered for type {1}", typeof(SynchronisableValue).Name, type.FullName));
}
}
}
public SyncReferenceFactory(Type refType, SyncFlags flags)
{
Linked = (flags & SyncFlags.Linked) != 0;
ReferenceType = refType;
}
public void SetClientInformation(PlayerInformation playerInformation, out int asyncHandle, SyncFlags flags, object asyncContext)
{
throw new NotImplementedException();
}
public void SetGroupInformation(int groupID, GroupInformation groupInformation, SyncFlags flags)
{
throw new NotImplementedException();
}
