public static void BatchMessage(ushort idMessage, byte[] message, uint len, CUQueue q)
{
if (message == null)
{
message = new byte[0];
len = 0;
}
else if (len > message.Length)
{
len = (uint)message.Length;
}
if (q.GetSize() == 0)
{
uint count = 1;
q.Save(count);
}
else
{
unsafe
{
fixed (byte* p = q.IntenalBuffer)
{
uint* pN = (uint*)p;
*pN += 1;
}
}
}
q.Save(idMessage).Save(len);
q.Push(message, len);
}
public void SaveTo(CUQueue UQueue)
{
UQueue.Save(Count);
foreach (long n in this)
{
UQueue.Save(n);
}
}
private static bool Publish(object Message, params uint[] Groups)
{
uint len;
if (Groups == null)
{
len = 0;
}
else
{
len = (uint)Groups.Length;
}
using (CScopeUQueue su = new CScopeUQueue())
{
CUQueue q = su.UQueue;
q.Save(Message);
unsafe
{
fixed(byte *buffer = q.m_bytes)
{
fixed(uint *p = Groups)
{
return(SpeakPush(buffer, q.GetSize(), p, len));
}
}
}
}
}
public static void BatchMessage<T0, T1, T2, T3, T4, T5>(ushort idMessage, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, CUQueue q)
{
CUQueue b = CScopeUQueue.Lock();
b.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5);
BatchMessage(idMessage, b.IntenalBuffer, b.Size, q);
CScopeUQueue.Unlock(b);
}
public static void BatchMessage<T0, T1>(ushort idMessage, T0 t0, T1 t1, CUQueue q)
{
CUQueue b = CScopeUQueue.Lock();
b.Save(t0).Save(t1);
BatchMessage(idMessage, b.IntenalBuffer, b.Size, q);
CScopeUQueue.Unlock(b);
}
public bool Publish(object Message, uint[] Groups)
{
uint len;
if (Groups == null)
{
len = 0;
}
else
{
len = (uint)Groups.Length;
}
using (CScopeUQueue su = new CScopeUQueue())
{
CUQueue q = su.UQueue;
q.Save(Message);
unsafe
{
fixed(byte *buffer = q.m_bytes)
{
fixed(uint *p = Groups)
{
return(ServerCoreLoader.Speak(m_sp.Handle, buffer, q.GetSize(), p, len));
}
}
}
}
}
public static void BatchMessage<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(ushort idMessage, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, CUQueue q)
{
CUQueue b = CScopeUQueue.Lock();
b.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5).Save(t6).Save(t7).Save(t8).Save(t9);
BatchMessage(idMessage, b.IntenalBuffer, b.Size, q);
CScopeUQueue.Unlock(b);
}
/// <summary>
/// Dequeue messages from a persistent message queue file at server side in batch
/// </summary>
/// <param name="key">An ASCII string for identifying a queue at server side</param>
/// <param name="d">A callback for tracking data like remaining message count within a server queue file, queue file size in bytes, message dequeued within this batch and bytes dequeued within this batch</param>
/// <param name="timeout">A time-out number in milliseconds</param>
/// <param name="discarded">a callback for tracking cancel or socket closed event</param>
/// <returns>true for sending the request successfully, and false for failure</returns>
public virtual bool Dequeue(byte[] key, DDequeue d, uint timeout, DDiscarded discarded)
{
DAsyncResultHandler rh = null;
lock (m_csQ)
{
m_keyDequeue = key;
if (d != null)
{
rh = (ar) =>
{
ulong messageCount, fileSize, ret;
ar.UQueue.Load(out messageCount).Load(out fileSize).Load(out ret);
uint messages = (uint)ret;
uint bytes = (uint)(ret >> 32);
d((CAsyncQueue)ar.AsyncServiceHandler, messageCount, fileSize, messages, bytes);
};
m_dDequeue = d;
}
else
{
m_dDequeue = null;
}
}
using (CScopeUQueue sb = new CScopeUQueue())
{
CUQueue q = sb.UQueue;
q.Save(key).Save(timeout);
return(SendRequest(idDequeue, q, rh, discarded, (DOnExceptionFromServer)null));
}
}
public void SaveTo(CUQueue UQueue)
{
UQueue.Save(rental_id);
if (Rental == null || Rental.Ticks == 0)
{
UQueue.Save(ZERO_TICK);
}
else
{
UQueue.Save(Rental);
}
if (Return == null || Return.Ticks == 0)
{
UQueue.Save(ZERO_TICK);
}
else
{
UQueue.Save(Return);
}
if (LastUpdate == null || LastUpdate.Ticks == 0)
{
UQueue.Save(ZERO_TICK);
}
else
{
UQueue.Save(LastUpdate);
}
}
public Task <CScopeUQueue> sendRequest <T0, T1, T2, T3>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3)
{
using (CScopeUQueue sb = new CScopeUQueue())
{
CUQueue b = sb.UQueue;
b.Save(t0).Save(t1).Save(t2).Save(t3);
return(sendRequest(reqId, b.IntenalBuffer, b.GetSize()));
}
}
public Task <CScopeUQueue> sendRequest <T0>(ushort reqId, T0 t0)
{
using (CScopeUQueue sb = new CScopeUQueue())
{
CUQueue b = sb.UQueue;
b.Save(t0);
return(sendRequest(reqId, b.IntenalBuffer, b.GetSize()));
}
}
public Task <CScopeUQueue> sendRequest <T0, T1, T2, T3, T4, T5, T6, T7>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
{
using (CScopeUQueue sb = new CScopeUQueue())
{
CUQueue b = sb.UQueue;
b.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5).Save(t6).Save(t7);
return(sendRequest(reqId, b.IntenalBuffer, b.GetSize()));
}
}
protected bool SendRouteeResult <T0, T1>(T0 t0, T1 t1, ushort reqId)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1);
bool ok = SendRouteeResult(su, reqId);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool SendRequest <T0, T1, T2, T3, T4, T5, T6, T7, T8>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, DAsyncResultHandler ash)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5).Save(t6).Save(t7).Save(t8);
bool ok = SendRequest(reqId, su, ash);
CScopeUQueue.Unlock(su);
return(ok);
}
protected bool SendRouteeResult <T0, T1, T2, T3, T4>(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, ushort reqId)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4);
bool ok = SendRouteeResult(su, reqId);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool SendRequest <T0, T1, T2, T3>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, DAsyncResultHandler ash, DDiscarded discarded, DOnExceptionFromServer exception)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3);
bool ok = SendRequest(reqId, su, ash, discarded, exception);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool SendRequest <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, DAsyncResultHandler ash, DDiscarded discarded, DOnExceptionFromServer exception)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5).Save(t6).Save(t7).Save(t8).Save(t9);
bool ok = SendRequest(reqId, su, ash, discarded, exception);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool SendRequest <T0>(ushort reqId, T0 t0, DAsyncResultHandler ash)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0);
bool ok = SendRequest(reqId, su, ash);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool SendRequest <T0, T1, T2, T3, T4>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, DAsyncResultHandler ash)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4);
bool ok = SendRequest(reqId, su, ash);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool Send <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5).Save(t6).Save(t7).Save(t8).Save(t9);
bool ok = Send(reqId, su);
CScopeUQueue.Unlock(su);
return(ok);
}
public ulong Enqueue <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5).Save(t6).Save(t7).Save(t8).Save(t9);
ulong index = Enqueue(reqId, su);
CScopeUQueue.Unlock(su);
return(index);
}
public ulong Enqueue <T0, T1, T2, T3, T4, T5>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5);
ulong index = Enqueue(reqId, su);
CScopeUQueue.Unlock(su);
return(index);
}
public virtual bool Enqueue(byte[] key, ushort idMessage, byte[] bytes, DEnqueue e, DDiscarded discarded)
{
CUQueue sb = CScopeUQueue.Lock();
sb.Save(key).Save(idMessage).Push(bytes);
bool ok = SendRequest(idEnqueue, sb, GetRH(e), discarded, (DOnExceptionFromServer)null);
CScopeUQueue.Unlock(sb);
return(ok);
}
public ulong Enqueue <T0, T1, T2>(ushort reqId, T0 t0, T1 t1, T2 t2)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2);
ulong index = Enqueue(reqId, su);
CScopeUQueue.Unlock(su);
return(index);
}
public bool Enqueue<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(byte[] key, ushort idMessage, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, DEnqueue e)
{
if (key == null)
key = new byte[0];
CUQueue sb = CScopeUQueue.Lock();
sb.Save(key).Save(idMessage).Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5).Save(t6).Save(t7).Save(t8).Save(t9);
bool ok = SendRequest(idEnqueue, sb, GetRH(e));
CScopeUQueue.Unlock(sb);
return ok;
}
public bool Send <T0, T1, T2>(ushort reqId, T0 t0, T1 t1, T2 t2)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2);
bool ok = Send(reqId, su);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool Enqueue<T0>(byte[] key, ushort idMessage, T0 t0, DEnqueue e)
{
if (key == null)
key = new byte[0];
CUQueue sb = CScopeUQueue.Lock();
sb.Save(key).Save(idMessage).Save(t0);
bool ok = SendRequest(idEnqueue, sb, GetRH(e));
CScopeUQueue.Unlock(sb);
return ok;
}
public bool Enqueue<T0, T1, T2, T3, T4>(byte[] key, ushort idMessage, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, DEnqueue e)
{
if (key == null)
key = new byte[0];
CUQueue sb = CScopeUQueue.Lock();
sb.Save(key).Save(idMessage).Save(t0).Save(t1).Save(t2).Save(t3).Save(t4);
bool ok = SendRequest(idEnqueue, sb, GetRH(e));
CScopeUQueue.Unlock(sb);
return ok;
}
public bool Send <T0, T1, T2, T3, T4, T5>(ushort reqId, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0).Save(t1).Save(t2).Save(t3).Save(t4).Save(t5);
bool ok = Send(reqId, su);
CScopeUQueue.Unlock(su);
return(ok);
}
public bool Send <T0>(ushort reqId, T0 t0)
{
CUQueue su = CScopeUQueue.Lock();
su.Save(t0);
bool ok = Send(reqId, su);
CScopeUQueue.Unlock(su);
return(ok);
}
//make sure both serialization and de-serialization match against each other.
public void SaveTo(CUQueue UQueue)
{
UQueue.Save(NullString) //4 bytes for length
.Save(ObjectNull) //2 bytes for data type
.Save(ADateTime) //8 bytes for double, and all micro/nano seconds are lost
.Save(ADouble) //8 bytes
.Save(ABool) //1 byte
.Save(UnicodeString) //4 bytes for string length + (length * 2) bytes for string data -- UTF16-lowendian
.Save(AsciiString) //4 bytes for ASCII string length + length bytes for string data
.Save(ObjBool) //2 bytes for data type + 2 bytes for variant bool
.Save(ObjString) //2 bytes for data type + 4 bytes for string length + (length * 2) bytes for string data -- UTF16-lowendian
.Save(objArrString) //2 bytes for data type + 4 bytes for array size + (string length + (length * 2) bytes for string data) * arraysize -- UTF16-lowendian
.Save(objArrInt) //2 bytes for data type + 4 bytes for array size + arraysize * 4 bytes for int data
;
}
private void PushTableColNamesOnly(CUQueue UQueue, DataColumn[] dcs)
{
UQueue.Save(dcs.Length);
foreach (DataColumn dc in dcs)
{
UQueue.Save(dc.Table.TableName);
UQueue.Save(dc.Ordinal);
}
}
private void Push(CUQueue UQueue, DataColumn dc)
{
bool bNull = (dc == null);
UQueue.Save(bNull);
if (bNull)
return;
byte bData = 0;
if (dc.AllowDBNull)
bData += (byte)tagColumnBit.cbAllowDBNull;
if (dc.AutoIncrement)
bData += (byte)tagColumnBit.cbIsAutoIncrement;
if (dc.ReadOnly)
bData += (byte)tagColumnBit.cbIsReadOnly;
if (dc.Unique)
bData += (byte)tagColumnBit.cbIsUnique;
UQueue.Save(bData);
UQueue.Save(dc.AutoIncrementSeed);
UQueue.Save(dc.AutoIncrementStep);
UQueue.Save(dc.Caption);
UQueue.Save((byte)dc.ColumnMapping);
UQueue.Save(dc.ColumnName);
UQueue.Save((short)GetDT(dc.DataType.FullName));
// UQueue.Push((byte)dc.DateTimeMode);
UQueue.Save(dc.DefaultValue, false, false);
UQueue.Save(dc.Expression);
//dc.ExtendedProperties ignored. If needed, write your own code
UQueue.Save(dc.MaxLength);
UQueue.Save(dc.Namespace);
UQueue.Save(dc.Prefix);
}
private void Push(CUQueue UQueue, DataColumnCollection Cols)
{
bool bNull = (Cols == null);
UQueue.Save(bNull);
if (!bNull)
{
int n;
int nLen = 0;
if (Cols != null && Cols.Count > 0)
nLen = Cols.Count;
UQueue.Save(nLen);
for (n = 0; n < nLen; n++)
{
Push(UQueue, Cols[n]);
}
}
}
private void Push(CUQueue UQueue, DataColumn[] dcs)
{
if (dcs == null)
{
UQueue.Save((int)-1);
}
else
{
UQueue.Save(dcs.Length);
foreach (DataColumn dc in dcs)
{
Push(UQueue, dc);
}
}
}
internal void PushHeader(CUQueue UQueue, DataTable dt, bool bNeedParentRelations, bool bNeedChildRelations)
{
int n;
int nSize;
if (dt == null)
return;
UQueue.SetSize(0);
m_dts = new tagDataTypeSupported[dt.Columns.Count];
UQueue.Save(dt.Rows.Count);
byte bData = 0;
/* if (dt.RemotingFormat == SerializationFormat.Xml)
bData += 1;*/
if (bNeedParentRelations)
bData += 2;
if (bNeedChildRelations)
bData += 4;
UQueue.Save(bData);
UQueue.Save(dt.TableName);
Push(UQueue, dt.Columns);
for (n = 0; n < dt.Columns.Count; n++)
{
m_dts[n] = GetDT(dt.Columns[n].DataType.FullName);
}
UQueue.Save(dt.DisplayExpression);
UQueue.Save(dt.MinimumCapacity);
UQueue.Save(dt.Namespace);
UQueue.Save(dt.Prefix);
nSize = dt.PrimaryKey.Length;
UQueue.Save(nSize);
for (n = 0; n < nSize; n++)
{
UQueue.Save(dt.PrimaryKey[n].Ordinal);
}
if (bNeedParentRelations)
{
Push(UQueue, dt.ParentRelations);
}
if (bNeedChildRelations)
{
Push(UQueue, dt.ChildRelations);
}
}
internal void Push(CUQueue UQueue, DataRow dr)
{
int n;
bool bNull;
if (dr == null)
throw new ArgumentNullException("Datarow object can't be null");
if (m_dts == null)
throw new ArgumentNullException("DataTable header is not serialized yet");
if (m_dts.Length != dr.ItemArray.Length)
throw new InvalidOperationException("The size of the input data type array does not match the size of data row");
byte b = 0;
byte bOne = 1;
m_qBit.SetSize(0);
m_qTemp.SetSize(0);
bool bDelete = (dr.RowState == DataRowState.Deleted);
if (bDelete)
dr.RejectChanges();
object[] data = dr.ItemArray;
int nLen = m_dts.Length;
for (n = 0; n < nLen; n++)
{
object myData = data[n];
bNull = (myData == null || myData.Equals(DBNull.Value));
if (bNull)
{
b += (byte)(bOne << (byte)(n % 8));
}
if ((n % 8) == 7)
{
m_qBit.Save(b);
b = 0;
}
if (bNull)
continue;
switch (m_dts[n])
{
case tagDataTypeSupported.dtBoolean:
m_qTemp.Save((bool)myData);
break;
case tagDataTypeSupported.dtByte:
m_qTemp.Save((byte)myData);
break;
case tagDataTypeSupported.dtChar:
m_qTemp.Save((char)myData);
break;
case tagDataTypeSupported.dtDateTime:
m_qTemp.Save((DateTime)myData);
break;
case tagDataTypeSupported.dtDecimal:
m_qTemp.Save((decimal)myData);
break;
case tagDataTypeSupported.dtDouble:
m_qTemp.Save((double)myData);
break;
case tagDataTypeSupported.dtFloat:
m_qTemp.Save((float)myData);
break;
case tagDataTypeSupported.dtGuid:
m_qTemp.Save((Guid)myData);
break;
case tagDataTypeSupported.dtUInt16:
m_qTemp.Save((ushort)myData);
break;
case tagDataTypeSupported.dtUInt32:
m_qTemp.Save((uint)myData);
break;
case tagDataTypeSupported.dtUInt64:
m_qTemp.Save((ulong)myData);
break;
case tagDataTypeSupported.dtInt16:
m_qTemp.Save((short)myData);
break;
case tagDataTypeSupported.dtInt32:
m_qTemp.Save((int)myData);
break;
case tagDataTypeSupported.dtInt64:
m_qTemp.Save((long)myData);
break;
case tagDataTypeSupported.dtString:
m_qTemp.Save((string)myData);
break;
case tagDataTypeSupported.dtValue:
case tagDataTypeSupported.dtValues:
case tagDataTypeSupported.dtChars:
case tagDataTypeSupported.dtBytes:
case tagDataTypeSupported.dtTimeSpan:
m_qTemp.Save(myData, false, false);
break;
case tagDataTypeSupported.dtUDT:
m_qTemp.Save(myData.ToString());
break;
default:
throw new InvalidOperationException("Unsupported data type for serialization");
}
}
if ((n % 8) != 0)
m_qBit.Save(b);
UQueue.Push(m_qBit.m_bytes, m_qBit.GetSize());
UQueue.Push(m_qTemp.m_bytes, m_qTemp.GetSize());
if (bDelete)
dr.Delete();
UQueue.Save((byte)dr.RowState);
UQueue.Save(dr.HasErrors);
if (dr.HasErrors)
UQueue.Save(dr.RowError);
}
internal void Push(CUQueue UQueue, DataRelationCollection drc)
{
UQueue.Save(drc.Count);
foreach (DataRelation dr in drc)
{
PushTableColNamesOnly(UQueue, dr.ChildColumns);
UQueue.Save(dr.Nested);
UQueue.Save(dr.RelationName);
PushTableColNamesOnly(UQueue, dr.ParentColumns);
}
}
private void Push(CUQueue UQueue, UniqueConstraint uc)
{
bool bNull = (uc == null);
UQueue.Save(bNull);
if (!bNull)
{
Push(UQueue, uc.Columns);
UQueue.Save(uc.ConstraintName);
UQueue.Save(uc.IsPrimaryKey);
}
}
private void Push(CUQueue UQueue, ForeignKeyConstraint fkc)
{
bool bNull = (fkc == null);
UQueue.Save(bNull);
if (!bNull)
{
Push(UQueue, fkc.Columns);
Push(UQueue, fkc.RelatedColumns);
UQueue.Save(fkc.ConstraintName);
UQueue.Save((byte)fkc.DeleteRule);
UQueue.Save((byte)fkc.AcceptRejectRule);
UQueue.Save((byte)fkc.UpdateRule);
}
}
internal void PushHeader(CUQueue UQueue, DataSet ds)
{
byte bData = 0;
UQueue.SetSize(0);
/* if (ds.RemotingFormat == SerializationFormat.Xml)
bData += 1;*/
if (ds.CaseSensitive)
bData += 2;
if (ds.EnforceConstraints)
bData += 4;
UQueue.Save(ds.Tables.Count);
UQueue.Save(bData);
UQueue.Save(ds.DataSetName);
UQueue.Save(ds.Namespace);
UQueue.Save(ds.Prefix);
}
internal void PushHeader(CUQueue UQueue, IDataReader dr)
{
int n;
int nCount;
if (dr == null)
throw new ArgumentNullException("Must pass in a valid data reader object");
ArrayList al = new ArrayList();
UQueue.SetSize(0);
UQueue.Save(dr.FieldCount);
UQueue.Save(dr.RecordsAffected);
DataTable dtSchema = dr.GetSchemaTable();
int nColumnName = dtSchema.Columns.IndexOf("ColumnName");
int nColumnSize = dtSchema.Columns.IndexOf("ColumnSize");
int nDataType = dtSchema.Columns.IndexOf("DataType");
int nIsLong = dtSchema.Columns.IndexOf("IsLong");
int nAllowDBNull = dtSchema.Columns.IndexOf("AllowDBNull");
int nIsReadOnly = dtSchema.Columns.IndexOf("IsReadOnly");
int nIsRowVersion = dtSchema.Columns.IndexOf("IsRowVersion");
int nIsUnique = dtSchema.Columns.IndexOf("IsUnique");
int nIsKey = dtSchema.Columns.IndexOf("IsKey");
int nIsAutoIncrement = dtSchema.Columns.IndexOf("IsAutoIncrement");
m_dts = new tagDataTypeSupported[dr.FieldCount];
for (n = 0; n < dr.FieldCount; n++)
{
tagDataTypeSupported dts = GetDT(dr.GetFieldType(n));
m_dts[n] = dts;
UQueue.Save((short)dts);
}
foreach (DataRow row in dtSchema.Rows)
{
int nData = 0;
string str = null;
if (nIsAutoIncrement != -1)
{
if (row[nIsAutoIncrement].Equals(true))
nData |= (int)tagColumnBit.cbIsAutoIncrement;
}
if (nIsKey != -1)
{
if (row[nIsKey].Equals(true))
nData |= (int)tagColumnBit.cbIsKey;
}
if (nAllowDBNull != -1)
{
if (row[nAllowDBNull].Equals(true))
nData |= (int)tagColumnBit.cbAllowDBNull;
}
if (nIsReadOnly != -1)
{
if (row[nIsReadOnly].Equals(true))
nData |= (int)tagColumnBit.cbIsReadOnly;
}
if (nIsRowVersion != -1)
{
if (row[nIsRowVersion].Equals(true))
nData |= (int)tagColumnBit.cbIsRowVersion;
}
if (nIsUnique != -1)
{
if (row[nIsUnique].Equals(true))
nData |= (int)tagColumnBit.cbIsUnique;
}
if (nIsLong != -1)
{
if (row[nIsLong].Equals(true))
nData |= (int)tagColumnBit.cbIsLong;
}
UQueue.Save(nData);
nData = 0;
if (nColumnSize != -1)
{
nData = (int)row[nColumnSize];
}
UQueue.Save(nData);
if (nColumnName != -1)
{
str = (string)row[nColumnName];
nCount = CountNames(al, str);
if (nCount > 0)
str += nCount.ToString();
al.Add(str);
}
UQueue.Save(str);
}
}
