547 lines
13 KiB
C++
547 lines
13 KiB
C++
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|
|
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
|
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|
|
// PARTICULAR PURPOSE.
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved
|
|
|
|
#ifndef UNICODE
|
|
#define UNICODE
|
|
#endif
|
|
#include "WebServices.h"
|
|
#include "process.h"
|
|
#include "stdio.h"
|
|
#include "string.h"
|
|
|
|
// Print out rich error info
|
|
void PrintError(
|
|
_In_ HRESULT errorCode,
|
|
_In_opt_ WS_ERROR* error)
|
|
{
|
|
wprintf(L"Failure: errorCode=0x%lx\n", errorCode);
|
|
|
|
if (errorCode == E_INVALIDARG || errorCode == WS_E_INVALID_OPERATION)
|
|
{
|
|
// Correct use of the APIs should never generate these errors
|
|
wprintf(L"The error was due to an invalid use of an API. This is likely due to a bug in the program.\n");
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
if (error != NULL)
|
|
{
|
|
ULONG errorCount;
|
|
hr = WsGetErrorProperty(error, WS_ERROR_PROPERTY_STRING_COUNT, &errorCount, sizeof(errorCount));
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
for (ULONG i = 0; i < errorCount; i++)
|
|
{
|
|
WS_STRING string;
|
|
hr = WsGetErrorString(error, i, &string);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
wprintf(L"%.*s\n", string.length, string.chars);
|
|
}
|
|
}
|
|
Exit:
|
|
if (FAILED(hr))
|
|
{
|
|
wprintf(L"Could not get error string (errorCode=0x%lx)\n", hr);
|
|
}
|
|
}
|
|
|
|
struct ColorDictionary
|
|
{
|
|
WS_XML_DICTIONARY dictionary;
|
|
WS_XML_STRING red;
|
|
WS_XML_STRING yellow;
|
|
WS_XML_STRING blue;
|
|
WS_XML_STRING green;
|
|
};
|
|
|
|
ColorDictionary colorDictionary =
|
|
{
|
|
{
|
|
{ /* fd7d93f6-a9ec-40a5-a492-8bb45b1e3a5f */
|
|
0xfd7d93f6,
|
|
0xa9ec,
|
|
0x40a5,
|
|
{0xa4, 0x92, 0x8b, 0xb4, 0x5b, 0x1e, 0x3a, 0x5f}
|
|
},
|
|
&colorDictionary.red,
|
|
4,
|
|
TRUE
|
|
},
|
|
WS_XML_STRING_DICTIONARY_VALUE("red", &colorDictionary.dictionary, 0),
|
|
WS_XML_STRING_DICTIONARY_VALUE("yellow", &colorDictionary.dictionary, 1),
|
|
WS_XML_STRING_DICTIONARY_VALUE("blue", &colorDictionary.dictionary, 2),
|
|
WS_XML_STRING_DICTIONARY_VALUE("green", &colorDictionary.dictionary, 3),
|
|
};
|
|
|
|
|
|
struct ShapeDictionary
|
|
{
|
|
WS_XML_DICTIONARY dictionary;
|
|
WS_XML_STRING circle;
|
|
WS_XML_STRING square;
|
|
WS_XML_STRING triangle;
|
|
};
|
|
|
|
ShapeDictionary shapeDictionary =
|
|
{
|
|
{
|
|
{ /* 4eab536f-d3a9-418c-b6d4-26b2b926eafe */
|
|
0x4eab536f,
|
|
0xd3a9,
|
|
0x418c,
|
|
{0xb6, 0xd4, 0x26, 0xb2, 0xb9, 0x26, 0xea, 0xfe}
|
|
},
|
|
&colorDictionary.red,
|
|
3,
|
|
TRUE
|
|
},
|
|
WS_XML_STRING_DICTIONARY_VALUE("circle", &shapeDictionary.dictionary, 0),
|
|
WS_XML_STRING_DICTIONARY_VALUE("square", &shapeDictionary.dictionary, 1),
|
|
WS_XML_STRING_DICTIONARY_VALUE("triangle", &shapeDictionary.dictionary, 2),
|
|
};
|
|
|
|
|
|
struct ObjectsDictionary
|
|
{
|
|
WS_XML_DICTIONARY dictionary;
|
|
WS_XML_STRING objects;
|
|
WS_XML_STRING color;
|
|
WS_XML_STRING ns;
|
|
};
|
|
|
|
ObjectsDictionary objectsDictionary =
|
|
{
|
|
{
|
|
{ /* 34065de6-b672-417f-96dc-c4436a055bf1 */
|
|
0x34065de6,
|
|
0xb672,
|
|
0x417f,
|
|
{0x96, 0xdc, 0xc4, 0x43, 0x6a, 0x05, 0x5b, 0xf1}
|
|
},
|
|
&objectsDictionary.objects,
|
|
3,
|
|
TRUE
|
|
},
|
|
WS_XML_STRING_DICTIONARY_VALUE("objects", &objectsDictionary.dictionary, 0),
|
|
WS_XML_STRING_DICTIONARY_VALUE("color", &objectsDictionary.dictionary, 1),
|
|
WS_XML_STRING_DICTIONARY_VALUE("ns", &objectsDictionary.dictionary, 2),
|
|
};
|
|
|
|
|
|
struct MergedDictionary
|
|
{
|
|
WS_XML_DICTIONARY dictionary;
|
|
WS_XML_STRING strings[32];
|
|
ULONG stringCount;
|
|
};
|
|
|
|
MergedDictionary mergedDictionary =
|
|
{
|
|
{
|
|
{ /* 472007e3-7378-4ac3-846d-bf8c63550a73 */
|
|
0x472007e3,
|
|
0x7378,
|
|
0x4ac3,
|
|
{0x84, 0x6d, 0xbf, 0x8c, 0x63, 0x55, 0x0a, 0x73}
|
|
},
|
|
mergedDictionary.strings,
|
|
0,
|
|
FALSE
|
|
},
|
|
};
|
|
|
|
HRESULT CALLBACK DynamicStringCallback(
|
|
_In_ void* callbackState,
|
|
_In_ const WS_XML_STRING* value,
|
|
_Inout_ BOOL* found,
|
|
_When_(*found, _Out_) ULONG* id,
|
|
_In_opt_ WS_ERROR* error)
|
|
{
|
|
UNREFERENCED_PARAMETER(callbackState);
|
|
UNREFERENCED_PARAMETER(error);
|
|
|
|
// Only merge strings that are const
|
|
if (value->dictionary != NULL && value->dictionary->isConst)
|
|
{
|
|
// See if we've seen this string before
|
|
for (ULONG i = 0; i < mergedDictionary.dictionary.stringCount; i++)
|
|
{
|
|
if (value->length == mergedDictionary.strings[i].length &&
|
|
memcmp(value->bytes, mergedDictionary.strings[i].bytes, value->length) == 0)
|
|
{
|
|
(*found) = TRUE;
|
|
(*id) = mergedDictionary.strings[i].id;
|
|
return S_OK;
|
|
}
|
|
}
|
|
if (mergedDictionary.dictionary.stringCount < WsCountOf(mergedDictionary.strings))
|
|
{
|
|
// Add this string to the merged dictionary
|
|
ULONG index = mergedDictionary.dictionary.stringCount;
|
|
mergedDictionary.strings[index].bytes = value->bytes;
|
|
mergedDictionary.strings[index].length = value->length;
|
|
mergedDictionary.strings[index].dictionary = &mergedDictionary.dictionary;
|
|
mergedDictionary.strings[index].id = index;
|
|
mergedDictionary.dictionary.stringCount++;
|
|
(*id) = index;
|
|
(*found) = TRUE;
|
|
return S_OK;
|
|
}
|
|
}
|
|
(*found) = FALSE;
|
|
return S_OK;
|
|
}
|
|
|
|
// Main entry point
|
|
int __cdecl wmain()
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
WS_ERROR* error = NULL;
|
|
WS_XML_WRITER* writer = NULL;
|
|
WS_XML_READER* reader = NULL;
|
|
WS_HEAP* heap = NULL;
|
|
|
|
// Create an error object for storing rich error information
|
|
hr = WsCreateError(
|
|
NULL,
|
|
0,
|
|
&error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Create a heap to store deserialized data
|
|
hr = WsCreateHeap(
|
|
/*maxSize*/ 2048,
|
|
/*trimSize*/ 512,
|
|
NULL,
|
|
0,
|
|
&heap,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Create an XML writer
|
|
hr = WsCreateWriter(
|
|
NULL,
|
|
0,
|
|
&writer,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Setup the output
|
|
WS_XML_WRITER_BUFFER_OUTPUT bufferOutput;
|
|
ZeroMemory(&bufferOutput, sizeof(bufferOutput));
|
|
bufferOutput.output.outputType = WS_XML_WRITER_OUTPUT_TYPE_BUFFER;
|
|
|
|
// Setup the encoding
|
|
WS_XML_WRITER_BINARY_ENCODING writerEncoding;
|
|
ZeroMemory(&writerEncoding, sizeof(writerEncoding));
|
|
writerEncoding.encoding.encodingType = WS_XML_WRITER_ENCODING_TYPE_BINARY;
|
|
writerEncoding.staticDictionary = &objectsDictionary.dictionary;
|
|
writerEncoding.dynamicStringCallback = DynamicStringCallback;
|
|
writerEncoding.dynamicStringCallbackState = NULL;
|
|
|
|
// Setup the writer
|
|
hr = WsSetOutput(
|
|
writer,
|
|
&writerEncoding.encoding,
|
|
&bufferOutput.output,
|
|
NULL,
|
|
0,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsWriteStartElement(
|
|
writer,
|
|
NULL,
|
|
&objectsDictionary.objects,
|
|
&objectsDictionary.ns,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Write some xml using strings from all the dictionaries
|
|
static const WS_XML_STRING* shapes[3] = { &shapeDictionary.triangle, &shapeDictionary.square, &shapeDictionary.circle };
|
|
static const WS_XML_STRING* colors[3] = { &colorDictionary.green, &colorDictionary.blue, &colorDictionary.red };
|
|
for (ULONG i = 0; i < 3; i++)
|
|
{
|
|
hr = WsWriteStartElement(
|
|
writer,
|
|
NULL,
|
|
shapes[i],
|
|
&objectsDictionary.ns,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsWriteStartAttribute(
|
|
writer,
|
|
NULL,
|
|
&objectsDictionary.color,
|
|
&objectsDictionary.ns,
|
|
FALSE,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsWriteType(
|
|
writer,
|
|
WS_ATTRIBUTE_TYPE_MAPPING,
|
|
WS_XML_STRING_TYPE, NULL,
|
|
WS_WRITE_REQUIRED_VALUE,
|
|
colors[i],
|
|
sizeof(*colors[i]),
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsWriteEndAttribute(
|
|
writer,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsWriteEndElement(
|
|
writer,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
hr = WsWriteEndElement(
|
|
writer,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
WS_BYTES bytes;
|
|
hr = WsGetWriterProperty(
|
|
writer,
|
|
WS_XML_WRITER_PROPERTY_BYTES,
|
|
&bytes,
|
|
sizeof(bytes),
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Create an XML reader
|
|
hr = WsCreateReader(
|
|
NULL,
|
|
0,
|
|
&reader,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Setup the input
|
|
WS_XML_READER_BUFFER_INPUT bufferInput;
|
|
ZeroMemory(&bufferInput, sizeof(bufferInput));
|
|
bufferInput.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER;
|
|
bufferInput.encodedData = bytes.bytes;
|
|
bufferInput.encodedDataSize = bytes.length;
|
|
|
|
// Setup the encoding
|
|
WS_XML_READER_BINARY_ENCODING readerEncoding;
|
|
ZeroMemory(
|
|
&readerEncoding,
|
|
sizeof(readerEncoding));
|
|
|
|
readerEncoding.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_BINARY;
|
|
readerEncoding.staticDictionary = &objectsDictionary.dictionary;
|
|
readerEncoding.dynamicDictionary = &mergedDictionary.dictionary;
|
|
|
|
// Setup the reader
|
|
hr = WsSetInput(
|
|
reader,
|
|
&readerEncoding.encoding,
|
|
&bufferInput.input,
|
|
NULL,
|
|
0,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsReadToStartElement(
|
|
reader,
|
|
&objectsDictionary.objects,
|
|
&objectsDictionary.ns,
|
|
NULL,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
hr = WsReadStartElement(
|
|
reader,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
BOOL found;
|
|
hr = WsReadToStartElement(
|
|
reader,
|
|
NULL,
|
|
NULL,
|
|
&found,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
break;
|
|
}
|
|
|
|
const WS_XML_NODE* node;
|
|
hr = WsGetReaderNode(
|
|
reader,
|
|
&node,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
const WS_XML_ELEMENT_NODE* elementNode = (WS_XML_ELEMENT_NODE*)node;
|
|
printf("%.*s: ", elementNode->localName->length, elementNode->localName->bytes);
|
|
|
|
ULONG index;
|
|
hr = WsFindAttribute(
|
|
reader,
|
|
&objectsDictionary.color,
|
|
&objectsDictionary.ns,
|
|
TRUE,
|
|
&index,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsReadStartAttribute(
|
|
reader,
|
|
index,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
WS_XML_STRING color;
|
|
hr = WsReadType(
|
|
reader,
|
|
WS_ATTRIBUTE_TYPE_MAPPING,
|
|
WS_XML_STRING_TYPE,
|
|
NULL,
|
|
WS_READ_REQUIRED_VALUE,
|
|
heap,
|
|
&color,
|
|
sizeof(color),
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
printf(
|
|
"%.*s\n",
|
|
color.length,
|
|
color.bytes);
|
|
|
|
hr = WsReadEndAttribute(
|
|
reader,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
hr = WsSkipNode(
|
|
reader,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
hr = WsReadEndElement(
|
|
reader,
|
|
error);
|
|
if (FAILED(hr))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
Exit:
|
|
if (FAILED(hr))
|
|
{
|
|
// Print out the error
|
|
PrintError(hr, error);
|
|
}
|
|
|
|
if (writer != NULL)
|
|
{
|
|
WsFreeWriter(writer);
|
|
}
|
|
if (reader != NULL)
|
|
{
|
|
WsFreeReader(reader);
|
|
}
|
|
if (heap != NULL)
|
|
{
|
|
WsFreeHeap(heap);
|
|
}
|
|
if (error != NULL)
|
|
{
|
|
WsFreeError(error);
|
|
}
|
|
fflush(stdout);
|
|
return SUCCEEDED(hr) ? 0 : -1;
|
|
}
|