// *************************************************************************************
public TAGENTRY(Tag.TAGENTRY te)
{
strName = te.strName;
stringSize = te.stringSize;
arrayRows = te.arrayRows;
arrayCols = te.arrayCols;
dataType = te.dataType;
Access = te.Access;
description = te.description;
groupName = te.groupName;
}
//**************************************************************
public DWORD AddTag(Tag.TAGENTRY tTagEntry, DWORD relativeOffset, MemInterface i_face)
{
DWORD readOffset = 0;
DWORD writeOffset = 0;
DWORD nextAvailableDataOffset = 0; // offset for next data block
DWORD nextAvailableTagOffset = 0; // offset for next tag
Tag refTag; //= NULL;
Device refDevice = this;
// Create new Tag
refTag = new Tag(ref refDevice, tTagEntry, relativeOffset, GetSharedMemoryOffset());
if (refTag.Equals(null))
{
Trace.Assert(false);
return (relativeOffset); // re-use this offset for the next tag
}
// Determine register's read offset
if (refTag.IsReadable())
{
readOffset = Register.DATA_MIN_OFFSET;
nextAvailableDataOffset = readOffset + Register.DATA_SIZE_MIN + refTag.GetReadValueExtSize();
// Determine register's write offset
if (refTag.IsWriteable())
{
// read/write
writeOffset = nextAvailableDataOffset;
nextAvailableDataOffset = writeOffset + Register.DATA_SIZE_MIN + refTag.GetWriteValueExtSize();
}
else
{
// read-only
writeOffset = 0;
}
}
else
{
readOffset = 0;
// Determine register's write offset
if (refTag.IsWriteable())
{
// write-only
writeOffset = Register.DATA_MIN_OFFSET;
nextAvailableDataOffset = writeOffset + Register.DATA_SIZE_MIN + refTag.GetWriteValueExtSize();
}
else
{
// neither read or write
Debug.Assert(false);
writeOffset = 0;
}
}
// Prepare the register offset for the next tag (if applicable)
nextAvailableTagOffset = relativeOffset + nextAvailableDataOffset;
string msg = "";
// Check for Shared Memory file overrun
if ((GetSharedMemoryOffset() + nextAvailableTagOffset) > SharedMemServer.MAPSIZE)
{
// Reached the limits of our Shared Memory file
// Don't add tag
msg = string.Format("Tag {0,0:T} could not be added.", refTag.GetName()) +
string.Format("Register {0,0:D} with size ", refTag.GetSharedMemoryOffset()) +
string.Format("{0,0:D} bytes would exceed Shared Memory file size of ", (DWORD)(writeOffset + Register.DATA_SIZE_MIN + refTag.GetExtendedSize())) +
string.Format("{0,0:D}", SharedMemServer.MAPSIZE);
Trace.WriteLine(msg);
return (relativeOffset);
}
int nRC = TagData.SMRC_NO_ERROR;
// Initialize register if we have access to shared memory
if (i_face.memStream != null)
{
Register.SetReadOffset(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), readOffset);
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}" + ": SetReadOffset nRC = " +
"{2,0:D}" +
", dwReadOffset = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, readOffset);
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
Register.SetWriteOffset(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), writeOffset);
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}: SetWriteOffset nRC = " +
"{2,0:D}" +
", dwWriteOffset = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, writeOffset);
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
Register.SetReadValueType(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), refTag.GetReadValueType());
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}: SetReadValueType nRC = " +
"{2,0:D}" +
", ReadValueType = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, refTag.GetReadValueType());
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
if (writeOffset != 0)
{
Register.SetWriteValueType(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), refTag.GetWriteValueType());
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}: SetWriteValueType nRC = " +
"{2,0:D}" +
", WriteValueType = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, refTag.GetWriteValueType());
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
}
Register.SetReadValueExtSize(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), refTag.GetReadValueExtSize());
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}: SetReadValueExtSize nRC = " +
"{2,0:D}" +
", ReadValueExtSize = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, refTag.GetReadValueExtSize());
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
if (writeOffset != 0)
{
Register.SetWriteValueExtSize(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), refTag.GetWriteValueExtSize());
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}: SetWriteValueExtSize nRC = " +
"{2,0:D}" +
", WriteValueExtSize = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, refTag.GetWriteValueExtSize());
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
}
if (refTag.GetDataType() == (ushort)(Value.T_ARRAY | Value.T_STRING))
{
nRC = Register.SetReadValueArrayStringSize(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), refTag.GetReadValueArrayStringSize());
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}: SetReadValueArrayStringSize nRC = " +
"{2,0:D}" +
", ReadValueArrayStringSize = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, refTag.GetReadValueArrayStringSize());
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
if (writeOffset != 0)
{
nRC = Register.SetWriteValueArrayStringSize(i_face.memStream, (long)refTag.GetSharedMemoryOffset(), (WORD)refTag.GetWriteValueArrayStringSize());
#if TRACE_SM_ACCESS
msg = string.Format("{0,8:0D}: Tag " +
"{1,0:T}: SetWriteValueArrayStringSize nRC = " +
"{2,0:D}" +
", WriteValueArrayStringSize = {3,0:D}", GetTickCount(), refTag.GetName(), nRC, refTag.GetWriteValueArrayStringSize());
Trace.WriteLine(msg);
#endif//TRACE_SM_ACCESS
}
}
} // if (pSharedMemoryBaseMem != null)
// Add tag to our tag set
tagSet.Add(refTag);
msg = string.Format("Tag {0,0:T}: assigned to Register " +
"{1,0:D} with size " +
"{2,0:D} bytes. Relative offset = " +
"{3,0:D}", refTag.GetName(), refTag.GetSharedMemoryOffset(),
nextAvailableDataOffset,
refTag.GetRelativeOffset());
Trace.WriteLine(msg);
return (nextAvailableTagOffset);
} // AddTag ()