berkus
/
Dryad
mirror of https://github.com/MicrosoftResearch/Dryad.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Dryad/DryadVertex/VertexHost/system/classlib/include/DrPropertyDumper.h

713 lines
24 KiB
C++
Raw Blame History

/*
Copyright (c) Microsoft Corporation
All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License
at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF
TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions and
limitations under the License.
*/
#pragma once
#include "DrList.h"
#pragma warning(push)
#pragma warning(disable:4995)
// A structure that defines a mapping between a particular bit range within a UInt32 and a readable name
typedef struct {
const char *fieldName; // The name of the bit field
UInt32 bitMask; // The bits that relate to this mask
const char **prgValueNames; // An array of enum names for the field (of length 2**n-1, where n is the number of bits including
// the least significant and most significant 1 bit in bitMask. If an entry is NULL,
// the bitmask value will not be displayed. If prgValueNames is NULL, all values will
// be displayed as a UInt.
} DrBitFieldMap;
// A structure that defines a mapping between a UInt32 and a set of bit fields
typedef struct {
int numFields; // The number of fields
const DrBitFieldMap *prgFields; // The array of bit field mappiings
} DrBitMaskMap;
/* JC
class DrPropertyDumper
{
private:
typedef enum {
// We are at the beginning of a property id
DrPropertyDumper_StartOfTag = 0,
// we have read the first byte of the property ID and are waiting for the second byte
DrPropertyDumper_ReadingPropertyId,
// We have read the property ID, but are waiting on 1-4 remaining length bytes (1 byte for a shortatom, 4 bytes for a longatom)
DrPropertyDumper_ReadingLength,
// We have read the property ID and the length, , but are waiting on the remaining data
DrPropertyDumper_ReadingData
} DrPropertyDumperState;
public:
public:
// The default maximum size that will be dumped for blob properties, unknown properties, and partial/malformed properties. Blob properties
// that exceed this length will be truncated in the dump with an "...(n bytes remaining)" annotation.
static const size_t k_nbDefaultMaxBlobSize = 512;
// The default maximum size that will be dumped for
static const size_t k_nbDefaultMaxPayloadSize = 64;
static const int k_nDefaultIndentSpacesPerLevel = 2;
private:
void Construct(size_t maxBlobSize, bool fIncludeComments, int nIndentSpacesPerLevel)
{
m_state = DrPropertyDumper_StartOfTag;
m_partialPropertyId = 0;
m_partialPropertyTotalLength = 0;
m_pReader = NULL;
m_pWriter = NULL;
m_fDeleteReader = false;
m_fDeleteWriter = false;
m_indent = 0;
m_fAtBol = true;
m_fOutputCrlf = true;
m_nbMaxBlobSize = maxBlobSize;
m_nbMaxPayloadSize = k_nbDefaultMaxPayloadSize;
if (m_nbMaxPayloadSize > m_nbMaxBlobSize) {
m_nbMaxPayloadSize = m_nbMaxBlobSize;
}
m_nIndentSpacesPerLevel = nIndentSpacesPerLevel;
m_fIncludeComments = fIncludeComments;
}
public:
DrPropertyDumper()
{
Construct(k_nbDefaultMaxBlobSize, true, k_nDefaultIndentSpacesPerLevel);
}
DrPropertyDumper(bool fFullContent, bool fIncludeComments = true, int nIndentSpacesPerLevel = k_nDefaultIndentSpacesPerLevel)
{
Construct(fFullContent ? MAX_SIZE_T : k_nbDefaultMaxBlobSize, fIncludeComments, nIndentSpacesPerLevel);
}
DrPropertyDumper(size_t maxBlobSize, bool fIncludeComments = true, int nIndentSpacesPerLevel = k_nDefaultIndentSpacesPerLevel)
{
Construct(maxBlobSize, fIncludeComments, nIndentSpacesPerLevel);
}
__declspec(deprecated) void SetReader(DrMemoryReader *pReader, bool fDelete = false)
{
if (m_pReader != NULL && m_fDeleteReader) {
delete m_pReader;
}
m_pReader = pReader;
m_fDeleteReader = fDelete;
}
// If true, then the full content of the property set (including large blobs) will be encoded rather than summarized
// If false, then blobs will be limited to the first k_nbDefaultMaxBlobSize bytes.
void SetFullContent(bool fFullContent=true)
{
m_nbMaxBlobSize = fFullContent ? MAX_SIZE_T : k_nbDefaultMaxBlobSize;
}
// If parameter is true, causes bare '\n' to terminate lines, rather than "\r\n"
void SetSuppressOutputCr(bool fSuppressOutputCr = true)
{
m_fOutputCrlf = !fSuppressOutputCr;
}
// Will lower, but not raise the max payload size
void SetMaxBlobSize(size_t nbMaxBlobSize)
{
m_nbMaxBlobSize = nbMaxBlobSize;
if (m_nbMaxPayloadSize > m_nbMaxBlobSize) {
m_nbMaxPayloadSize = m_nbMaxBlobSize;
}
}
// Will not raise the max payload size
void SetUnlimitedBlobSize()
{
SetMaxBlobSize(MAX_SIZE_T);
}
size_t GetMaxBlobSize()
{
return m_nbMaxBlobSize;
}
void SetIncludeComments(bool fIncludeComments = true)
{
m_fIncludeComments = fIncludeComments;
}
bool ShouldIncludeComments()
{
return m_fIncludeComments;
}
// Does not affect the limits for non-payload blobs
void SetMaxPayloadSize(size_t nbMaxPayloadSize)
{
m_nbMaxPayloadSize = nbMaxPayloadSize;
}
// Does not affect the limits for non-payload blobs
void SetUnlimitedPayloadSize()
{
SetMaxPayloadSize(MAX_SIZE_T);
}
size_t GetMaxPayloadSize()
{
return m_nbMaxPayloadSize;
}
DrMemoryReader *GetReader()
{
return m_pReader;
}
void SetWriter(DrMemoryWriter *pWriter, bool fDelete = false)
{
if (m_pWriter != NULL && m_fDeleteWriter) {
delete m_pWriter;
}
m_pWriter = pWriter;
m_fDeleteWriter = fDelete;
}
DrMemoryWriter *GetWriter()
{
return m_pWriter;
}
void SetNumIndentSpacesPerLevel(int n)
{
m_nIndentSpacesPerLevel = n;
}
int GetNumIndentSpacesPerLevel()
{
return m_nIndentSpacesPerLevel;
}
void SetIndent(int n)
{
m_indent = n;
}
int GetIndent()
{
return m_indent;
}
void Indent()
{
m_indent += m_nIndentSpacesPerLevel;
}
void Unindent()
{
m_indent -= m_nIndentSpacesPerLevel;
if (m_indent < 0) {
m_indent = 0;
}
}
DrError WriteF(const char *pszFormat, ...);
DrError VWriteF(const char *pszFormat, va_list args);
// Writes an XML start tag. Does NOT affect the DrTag Nesting level
DrError WriteStartTag(const char *pszTagName, Size_t length, bool fIncludeLength, bool fNewlineAfter)
{
DrError err;
if (fIncludeLength) {
err = WriteF("<%s length=\"%Iu\"%s", pszTagName, length, (fNewlineAfter ? ">\n" : ">"));
} else {
err = WriteF("<%s%s", pszTagName, (fNewlineAfter ? ">\n" : ">"));
m_fAtBol = fNewlineAfter;
}
Indent();
return err;
}
DrError WriteSimpleStartTag(const char *pszTagName, bool fNewlineAfter)
{
DrError err;
err = WriteF("<%s%s", pszTagName, (fNewlineAfter ? ">\n" : ">"));
m_fAtBol = fNewlineAfter;
Indent();
return err;
}
DrError FlushFileWriter()
{
}
DrError WriteXmlFileHeader()
{
return PutStr("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
}
// Writes an XML start tag. Does NOT affect the DrTag Nesting level
// pszAttributes is an optional XML attributes string in the form:
// attrib1="value" attrib2="value"
//
DrError WriteStartTagWithAttributes(__in const char *pszTagName, __in_opt const char *pszAttributes, bool fNewlineAfter)
{
DrError err;
if (pszAttributes == NULL) {
pszAttributes = "";
} else {
while(pszAttributes[0] == ' ') {
pszAttributes++;
}
}
err = WriteF("<%s%s%s%s", pszTagName, (pszAttributes[0] == '\0') ? "" : " ", pszAttributes, (fNewlineAfter ? ">\n" : ">"));
m_fAtBol = fNewlineAfter;
Indent();
return err;
}
DrError WriteStartTagWithLengthAndAttributes(__in const char *pszTagName, Size_t length, __in_opt const char *pszAttributes, bool fNewlineAfter)
{
DrError err;
if (pszAttributes == NULL) {
pszAttributes = "";
} else {
while(pszAttributes[0] == ' ') {
pszAttributes++;
}
}
err = WriteF("<%s length=\"%Iu\"%s%s%s", pszTagName, length, (pszAttributes[0] == '\0') ? "" : " ", pszAttributes, (fNewlineAfter ? ">\n" : ">"));
m_fAtBol = fNewlineAfter;
Indent();
return err;
}
// Writes an XML end tag. DOes NOT affect the DrTag Nesting level
DrError WriteEndTag(const char *pszTagName, bool fNewlineBefore)
{
Unindent();
DrError err = WriteF("%s/%s>\n", (fNewlineBefore ? "\n<" : "<"), pszTagName);
return err;
}
// The string generated by pszFormat must be XML-encoded or contain no XML delimiters
DrError VWriteSimpleTagValue(
const char *pszTagName,
UInt32 length,
bool fIncludeLength,
bool fSeperateLine,
const char *pszFormat,
va_list args)
{
DrError err;
WriteStartTag(pszTagName, length, fIncludeLength, fSeperateLine);
VWriteF(pszFormat, args);
err = WriteEndTag(pszTagName, fSeperateLine);
return err;
}
// The string generated by pszFormat must be XML-encoded or contain no XML delimiters
DrError WriteSimpleTagValue(
const char *pszTagName,
UInt32 length,
bool fIncludeLength,
bool fSeperateLine,
const char *pszFormat,
...)
{
va_list args;
va_start(args, pszFormat);
return VWriteSimpleTagValue(pszTagName, length, fIncludeLength, fSeperateLine, pszFormat, args);
}
// The string generated by pszFormat must be XML-encoded or contain no XML delimiters
DrError WriteSimpleTagValue(
const char *pszTagName,
const char *pszFormat,
...)
{
va_list args;
va_start(args, pszFormat);
return VWriteSimpleTagValue(pszTagName, 0, false, false, pszFormat, args);
}
// The string generated by pszFormat must be XML-encoded or contain no XML delimiters
DrError WriteSimpleTagValue(
const char *pszTagName,
UInt32 length,
const char *pszFormat,
...)
{
va_list args;
va_start(args, pszFormat);
return VWriteSimpleTagValue(pszTagName, length, true, false, pszFormat, args);
}
// Puts a string to output, indenting lines as appropriate
// Must obey XML conventions
DrError PutStr(const char *psz, int len = -1);
DrError PutBolLeader()
{
if (m_indent > 0) {
m_fAtBol = false;
for (int i = 0; i < m_indent; i++) {
m_pWriter->WriteChar(' ');
}
}
return m_pWriter->GetStatus();
}
DrError PutUInt64TagValue(const char *pszTagName, UInt64 val, bool fHex = false)
{
const char *pszFormat = (fHex ? "0x%016I64x" : "%I64u");
return WriteSimpleTagValue(pszTagName, pszFormat, val);
}
DrError PutUInt32TagValue(const char *pszTagName, UInt32 val, bool fHex = false)
{
const char *pszFormat = (fHex ? "0x%08x" : "%u");
return WriteSimpleTagValue(pszTagName, pszFormat, val);
}
DrError PutDoubleTagValue(const char *pszTagName, double val)
{
const char *pszFormat = "%lf";
return WriteSimpleTagValue(pszTagName, pszFormat, val);
}
DrError PutUInt32BitMaskValue(const char *pszTagName, UInt32 val, const DrBitMaskMap *pMap);
DrError PutUInt16TagValue(const char *pszTagName, UInt16 val, bool fHex = false)
{
const char *pszFormat = (fHex ? "0x%04x" : "%u");
return WriteSimpleTagValue(pszTagName, pszFormat, (UInt32)val);
}
DrError PutTagIdTagValue(const char *pszTagName, UInt16 val)
{
const char *pszTagIdName = GetTagName(val);
if (pszTagIdName == NULL) {
return WriteSimpleTagValue(pszTagName, "0x%04x", (UInt32)val);
} else {
return WriteSimpleTagValue(pszTagName, "0x%04x <!-- %s -->", (UInt32)val, pszTagIdName);
}
}
DrError PutInt64TagValue(const char *pszTagName, Int64 val, bool fHex = false)
{
const char *pszFormat = (fHex ? "0x%016I64x" : "%I64d");
return WriteSimpleTagValue(pszTagName, pszFormat, val);
}
DrError PutInt32TagValue(const char *pszTagName, Int32 val, bool fHex = false)
{
const char *pszFormat = (fHex ? "0x%08x" : "%d");
return WriteSimpleTagValue(pszTagName, pszFormat, val);
}
DrError PutInt16TagValue(const char *pszTagName, Int16 val, bool fHex = false)
{
const char *pszFormat = (fHex ? "0x%04x" : "%d");
return WriteSimpleTagValue(pszTagName, pszFormat, (Int32)val);
}
DrError PutBooleanTagValue(const char *pszTagName, bool val)
{
return WriteSimpleTagValue(pszTagName, "%s", (val ? "true" : "false"));
}
// safely XML-encodes the string
DrError PutStringTagValue(const char *pszTagName, const char *val, int len = -1)
{
if (val == NULL) {
return WriteSimpleTagValue(pszTagName, "%s", "<!-- null string -->");
} else {
if (len < 0) {
len = (int)strlen(val);
}
DrStr512 strXml;
strXml.AppendXmlEncodedString(val, (Size_t)len, true);
return WriteSimpleTagValue(pszTagName, "%s", strXml.GetString());
}
}
DrError PutGuidTagValue(const char *pszTagName, const DrGuid& val)
{
char buff[40];
return WriteSimpleTagValue(pszTagName, "%s", val.ToString(buff, false));
}
DrError PutTimeStampTagValue(const char *pszTagName, DrTimeStamp val)
{
char buff[64];
DrError err;
if (val == DrTimeStamp_Never) {
err = WriteSimpleTagValue(pszTagName, "never", (UInt64)val, buff);
} else if (val == DrTimeStamp_LongAgo) {
err = WriteSimpleTagValue(pszTagName, "long ago", (UInt64)val, buff);
} else {
err = DrTimeStampToString(val, buff, sizeof(buff), false);
if (err == DrError_OK) {
err = WriteSimpleTagValue(pszTagName, "%I64u<!-- %s -->", (UInt64)val, buff);
} else {
m_pWriter->SetStatus(err);
}
}
return err;
}
DrError PutNodeAddressTagValue(const char *pszTagName, const DrNodeAddress& val)
{
char buff[64];
DrError err = val.ToAddressPortString(buff, sizeof(buff));
if (err == DrError_OK) {
err = WriteSimpleTagValue(pszTagName, "%s", buff);
} else {
m_pWriter->SetStatus(err);
}
return err;
}
DrError PutTimeIntervalTagValue(const char *pszTagName, DrTimeInterval val)
{
DrError err;
char buff[k_DrTimeIntervalStringBufferSize];
err = DrTimeIntervalToString(val, buff, sizeof(buff));
LogAssert(err == DrError_OK);
err = WriteSimpleTagValue(pszTagName, "%I64d<!-- %s -->", (Int64)val, buff);
return err;
}
DrError PutDrErrorTagValue(const char *pszTagName, DrError val)
{
char buff[1024];
const char *pszErr = DrGetErrorDescription(val, buff, sizeof(buff));
// Assumes error code descriptions are XML-friendly
DrError err = WriteSimpleTagValue(pszTagName, "0x%08x<!-- %s -->", (UInt32)val, pszErr);
return err;
}
DrError PutDrExitCodeTagValue(const char *pszTagName, DrExitCode val)
{
// Assumes exit code descriptions are XML-friendly
DrError err = WriteSimpleTagValue(pszTagName, "0x%08x<!-- %s -->", (UInt32)val, DREXITCODESTRING(val));
return err;
}
DrError PutBlobTagValue(const char *pszTagName, DrMemoryReader *pReader, Size_t length, Size_t maxShowLength, const char *pszExtraAttributes = NULL);
DrError PutEnvironmentBlockTagValue(const char *pszTagName, const DrEnvironmentStrings& envBlock);
static const char *GetPropertyName(UInt16 enumId);
static const char *GetTagName(UInt16 tagId);
// Returns the number of nested DrTag begintags that are currently in effect. 0 means we are not inside a begin tag
UInt32 GetCurrentTagLevel()
{
return m_beginTagStack.NumEntries();
}
// returns DrTag_InvalidTag if we are at level 0
UInt16 GetCurrentNestedTagId()
{
if (m_beginTagStack.NumEntries() == 0) {
return DrTag_InvalidTag;
} else {
return m_beginTagStack.TopOfStack();
}
}
// returns NULL if the current nested DrTag tag name is not known
const char *GetCurrentNestedTagName()
{
const char * pszTagName = GetTagName(GetCurrentNestedTagId());
return pszTagName;
}
// Returns the DrTag tag level below which we are not allowed to pop, due to a balanced block being in effect
UInt32 GetCurrentMinimumTagLevel()
{
if (m_balancedBlockStack.NumEntries() == 0) {
return 0;
} else {
return m_balancedBlockStack.TopOfStack();
}
}
// returns true if there is a partially written DrProperty waiting to be completed before it is dumped
bool PartialPropertyIsPending()
{
return (m_state != DrPropertyDumper_StartOfTag);
}
// Begins a section where begin/end DrTags must be balanced and there must not be be a partial property at the beginning or end
// On entry, any partially written property is written out as a specially tagged "incomplete" property
void BeginBalancedBlock();
// If there is a partially written property pending, it is written out as a specially tagged "incomplete" property.
// This resets the parser to expect a property ID next.
// Also, if there are outstanding open begin-DrTag beyond the currend balanced block level, writes end DrTags for them (with XML comments
// describing them as missing).
// After this call, the current DrTag level will be equal to the current balanced block level.
DrError SynchronizeToBalancedBlock();
// endss a section where begin/end DrTags must be balanced.
// If there is a partially written property pending, it is written out as a specially tagged "incomplete" property.
// This resets the parser to expect a property ID next.
// Also, if there are outstanding open begin-DrTag beyond the currend balanced block level, writes end DrTags for them (with XML comments
// describing them as missing).
// After this call, the current DrTag level will be equal to the current balanced block level.
DrError EndBalancedBlock()
{
LogAssert(m_balancedBlockStack.NumEntries() != 0);
SynchronizeToBalancedBlock();
LogAssert(GetCurrentTagLevel() == GetCurrentMinimumTagLevel());
m_balancedBlockStack.Pop();
return m_pWriter->GetStatus();
}
// writes an XML equivalent to a DrTag "begin tag", and pushes a level
DrError WriteAndPushDrBeginTag(UInt16 tagId);
// writes an XML equivalent to a DrTag "end tag", and pops a level
DrError WriteAndPopDrEndTag(UInt16 tagId);
// If there is a partially written property pending, it is written out as a specially tagged "incomplete" property.
// This resets the parser to expect a property ID next.
DrError WritePartialProperty();
// Final flush of the dumper. must be called from balanced block level 0
DrError WriteIncompleteEndTagsAndFlushWriter()
{
LogAssert(m_balancedBlockStack.NumEntries() == 0);
SynchronizeToBalancedBlock();
return m_pWriter->FlushMemoryWriter();
}
// reads all remaining bytes from the reader and generates XML output as appropriate
// The content of the reader does not need to be balanced or complete, and it need not begin or end at a property boundary; you may call this multiple times to
// represent a coherent property stream
// If you want to enforce tag balancing accross a section, call BeginBalancedBlock before calling this, and EndBalancedBlock after calling this.
// if maxLength is specified, the function will return after reading maxLength bytes even if end of stream is not reached
DrError ParseAndWriteFromReader(DrMemoryReader *pReader, Size_t maxLength=MAX_SIZE_T);
DrError ParseAndWriteFromBuffer(DrMemoryBuffer *pBuffer, Size_t initialOffset=0, Size_t maxLength = MAX_SIZE_T)
{
DrMemoryBufferReader reader(pBuffer);
if (initialOffset != 0) {
reader.SetBufferOffset(initialOffset);
}
return ParseAndWriteFromReader(&reader, maxLength);
}
DrError ParseAndWriteFromSingleBlock(const void *pData, Size_t length)
{
DrSingleBlockReader reader(pData, length);
return ParseAndWriteFromReader(&reader, length);
}
// reads the next single tag&value and outputs it. Does not reads aggregates--begintag and endtag are
// trated as independent values; however, it does increment indentation in begintag, and decrement it on endtag.
__declspec(deprecated) DrError PutNextPropertyTagValue()
{
return PutNextPropertyTagValue(m_pReader);
}
DrError PutNextPropertyTagValue(DrMemoryReader *pReader);
// Reads the remainder of the input stream (Until DrError_EndOfStream is returned) as a sequential list
// of 0 or more properties and/or aggregates, and outputs them accordingly. Does not return until the entire stream has been read.
// Will always write a balanced set even if the input is unbalanced (will add missing end tags, etc., as necessary).
// returns the writer status
__declspec(deprecated) DrError PutNestedPropertyList()
{
return PutNestedPropertyList(m_pReader);
}
DrError PutNestedPropertyList(DrMemoryReader *pReader)
{
BeginBalancedBlock();
ParseAndWriteFromReader(pReader);
return EndBalancedBlock();
}
bool IsAtBeginningOfLine()
{
return m_fAtBol;
}
private:
DrMemoryReader *m_pReader;
bool m_fDeleteReader;
DrMemoryWriter *m_pWriter;
bool m_fDeleteWriter;
int m_indent;
int m_nIndentSpacesPerLevel;
bool m_fAtBol; // Beginning-of-line flag
bool m_fOutputCrlf; // True if '\r' should precede each '\n' on output.
size_t m_nbMaxBlobSize;
size_t m_nbMaxPayloadSize;
bool m_fIncludeComments;
DrPropertyDumperState m_state;
// A stack of unmatched begintag tagids. The top of stack is the end tag we are currently looking for.
// The number of entries in this list is the current tag "level"
DrValList<UInt16> m_beginTagStack;
// A stack of pushed "BeginBalancedBlock" "level" parameters.
// The top of the stack is the current balanced block level -- the parser will not allow end tags to pop the beginTagStack
// above this level.
DrValList<UInt32> m_balancedBlockStack;
// buffer to store an incomplete property we are parsing
// Includes property tag
DrRef<DrSimpleHeapBuffer> m_pPartialPropertyBuffer;
UInt16 m_partialPropertyId;
Size_t m_partialPropertyTotalLength;
};
*/
extern void DrInitPropertyTable();
extern void DrInitTagTable();
/* JC
typedef DrError (*DrPropertyConverter)(DrPropertyDumper *pDumper, UInt16 enumId, const char *propertyName);
// returns ERROR_ALREADY_ASSIGNED if the property has already been defined
extern DrError DrAddPropertyToDumper(UInt16 prop, const char *pszDescription, DrPropertyConverter pConverter);
// returns ERROR_ALREADY_ASSIGNED if the tag has already been defined
extern DrError DrAddTagToDumper(UInt16 tag, const char *pszDescription);
*/
#pragma warning(pop)
Reference in New Issue View Git Blame Copy Permalink