Home | History | Annotate | Download | only in vkjson 
      1 ///////////////////////////////////////////////////////////////////////////////
      2 //
      3 // Copyright (c) 2015-2016 The Khronos Group Inc.
      4 // Copyright (c) 2015-2016 Valve Corporation
      5 // Copyright (c) 2015-2016 LunarG, Inc.
      6 // Copyright (c) 2015-2016 Google, Inc.
      7 //
      8 // Licensed under the Apache License, Version 2.0 (the "License");
      9 // you may not use this file except in compliance with the License.
     10 // You may obtain a copy of the License at
     11 //
     12 //     http://www.apache.org/licenses/LICENSE-2.0
     13 //
     14 // Unless required by applicable law or agreed to in writing, software
     15 // distributed under the License is distributed on an "AS IS" BASIS,
     16 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     17 // See the License for the specific language governing permissions and
     18 // limitations under the License.
     19 ///////////////////////////////////////////////////////////////////////////////
     20 
     21 #include "vkjson.h"
     22 
     23 #include <assert.h>
     24 #include <string.h>
     25 
     26 #include <cmath>
     27 #include <cinttypes>
     28 #include <cstdio>
     29 #include <limits>
     30 #include <memory>
     31 #include <sstream>
     32 #include <type_traits>
     33 #include <utility>
     34 
     35 #include <cJSON.h>
     36 
     37 namespace {
     38 
     39 inline bool IsIntegral(double value) {
     40   return std::trunc(value) == value;
     41 }
     42 
     43 template <typename T> struct EnumTraits;
     44 template <> struct EnumTraits<VkPhysicalDeviceType> {
     45   static uint32_t min() { return VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE; }
     46   static uint32_t max() { return VK_PHYSICAL_DEVICE_TYPE_END_RANGE; }
     47 };
     48 
     49 template <> struct EnumTraits<VkFormat> {
     50   static uint32_t min() { return VK_FORMAT_BEGIN_RANGE; }
     51   static uint32_t max() { return VK_FORMAT_END_RANGE; }
     52 };
     53 
     54 
     55 // VkSparseImageFormatProperties
     56 
     57 template <typename Visitor>
     58 inline bool Iterate(Visitor* visitor, VkExtent3D* extents) {
     59   return
     60     visitor->Visit("width", &extents->width) &&
     61     visitor->Visit("height", &extents->height) &&
     62     visitor->Visit("depth", &extents->depth);
     63 }
     64 
     65 template <typename Visitor>
     66 inline bool Iterate(Visitor* visitor, VkImageFormatProperties* properties) {
     67   return
     68     visitor->Visit("maxExtent", &properties->maxExtent) &&
     69     visitor->Visit("maxMipLevels", &properties->maxMipLevels) &&
     70     visitor->Visit("maxArrayLayers", &properties->maxArrayLayers) &&
     71     visitor->Visit("sampleCounts", &properties->sampleCounts) &&
     72     visitor->Visit("maxResourceSize", &properties->maxResourceSize);
     73 }
     74 
     75 template <typename Visitor>
     76 inline bool Iterate(Visitor* visitor, VkPhysicalDeviceLimits* limits) {
     77   return
     78     visitor->Visit("maxImageDimension1D", &limits->maxImageDimension1D) &&
     79     visitor->Visit("maxImageDimension2D", &limits->maxImageDimension2D) &&
     80     visitor->Visit("maxImageDimension3D", &limits->maxImageDimension3D) &&
     81     visitor->Visit("maxImageDimensionCube", &limits->maxImageDimensionCube) &&
     82     visitor->Visit("maxImageArrayLayers", &limits->maxImageArrayLayers) &&
     83     visitor->Visit("maxTexelBufferElements", &limits->maxTexelBufferElements) &&
     84     visitor->Visit("maxUniformBufferRange", &limits->maxUniformBufferRange) &&
     85     visitor->Visit("maxStorageBufferRange", &limits->maxStorageBufferRange) &&
     86     visitor->Visit("maxPushConstantsSize", &limits->maxPushConstantsSize) &&
     87     visitor->Visit("maxMemoryAllocationCount", &limits->maxMemoryAllocationCount) &&
     88     visitor->Visit("maxSamplerAllocationCount", &limits->maxSamplerAllocationCount) &&
     89     visitor->Visit("bufferImageGranularity", &limits->bufferImageGranularity) &&
     90     visitor->Visit("sparseAddressSpaceSize", &limits->sparseAddressSpaceSize) &&
     91     visitor->Visit("maxBoundDescriptorSets", &limits->maxBoundDescriptorSets) &&
     92     visitor->Visit("maxPerStageDescriptorSamplers", &limits->maxPerStageDescriptorSamplers) &&
     93     visitor->Visit("maxPerStageDescriptorUniformBuffers", &limits->maxPerStageDescriptorUniformBuffers) &&
     94     visitor->Visit("maxPerStageDescriptorStorageBuffers", &limits->maxPerStageDescriptorStorageBuffers) &&
     95     visitor->Visit("maxPerStageDescriptorSampledImages", &limits->maxPerStageDescriptorSampledImages) &&
     96     visitor->Visit("maxPerStageDescriptorStorageImages", &limits->maxPerStageDescriptorStorageImages) &&
     97     visitor->Visit("maxPerStageDescriptorInputAttachments", &limits->maxPerStageDescriptorInputAttachments) &&
     98     visitor->Visit("maxPerStageResources", &limits->maxPerStageResources) &&
     99     visitor->Visit("maxDescriptorSetSamplers", &limits->maxDescriptorSetSamplers) &&
    100     visitor->Visit("maxDescriptorSetUniformBuffers", &limits->maxDescriptorSetUniformBuffers) &&
    101     visitor->Visit("maxDescriptorSetUniformBuffersDynamic", &limits->maxDescriptorSetUniformBuffersDynamic) &&
    102     visitor->Visit("maxDescriptorSetStorageBuffers", &limits->maxDescriptorSetStorageBuffers) &&
    103     visitor->Visit("maxDescriptorSetStorageBuffersDynamic", &limits->maxDescriptorSetStorageBuffersDynamic) &&
    104     visitor->Visit("maxDescriptorSetSampledImages", &limits->maxDescriptorSetSampledImages) &&
    105     visitor->Visit("maxDescriptorSetStorageImages", &limits->maxDescriptorSetStorageImages) &&
    106     visitor->Visit("maxDescriptorSetInputAttachments", &limits->maxDescriptorSetInputAttachments) &&
    107     visitor->Visit("maxVertexInputAttributes", &limits->maxVertexInputAttributes) &&
    108     visitor->Visit("maxVertexInputBindings", &limits->maxVertexInputBindings) &&
    109     visitor->Visit("maxVertexInputAttributeOffset", &limits->maxVertexInputAttributeOffset) &&
    110     visitor->Visit("maxVertexInputBindingStride", &limits->maxVertexInputBindingStride) &&
    111     visitor->Visit("maxVertexOutputComponents", &limits->maxVertexOutputComponents) &&
    112     visitor->Visit("maxTessellationGenerationLevel", &limits->maxTessellationGenerationLevel) &&
    113     visitor->Visit("maxTessellationPatchSize", &limits->maxTessellationPatchSize) &&
    114     visitor->Visit("maxTessellationControlPerVertexInputComponents", &limits->maxTessellationControlPerVertexInputComponents) &&
    115     visitor->Visit("maxTessellationControlPerVertexOutputComponents", &limits->maxTessellationControlPerVertexOutputComponents) &&
    116     visitor->Visit("maxTessellationControlPerPatchOutputComponents", &limits->maxTessellationControlPerPatchOutputComponents) &&
    117     visitor->Visit("maxTessellationControlTotalOutputComponents", &limits->maxTessellationControlTotalOutputComponents) &&
    118     visitor->Visit("maxTessellationEvaluationInputComponents", &limits->maxTessellationEvaluationInputComponents) &&
    119     visitor->Visit("maxTessellationEvaluationOutputComponents", &limits->maxTessellationEvaluationOutputComponents) &&
    120     visitor->Visit("maxGeometryShaderInvocations", &limits->maxGeometryShaderInvocations) &&
    121     visitor->Visit("maxGeometryInputComponents", &limits->maxGeometryInputComponents) &&
    122     visitor->Visit("maxGeometryOutputComponents", &limits->maxGeometryOutputComponents) &&
    123     visitor->Visit("maxGeometryOutputVertices", &limits->maxGeometryOutputVertices) &&
    124     visitor->Visit("maxGeometryTotalOutputComponents", &limits->maxGeometryTotalOutputComponents) &&
    125     visitor->Visit("maxFragmentInputComponents", &limits->maxFragmentInputComponents) &&
    126     visitor->Visit("maxFragmentOutputAttachments", &limits->maxFragmentOutputAttachments) &&
    127     visitor->Visit("maxFragmentDualSrcAttachments", &limits->maxFragmentDualSrcAttachments) &&
    128     visitor->Visit("maxFragmentCombinedOutputResources", &limits->maxFragmentCombinedOutputResources) &&
    129     visitor->Visit("maxComputeSharedMemorySize", &limits->maxComputeSharedMemorySize) &&
    130     visitor->Visit("maxComputeWorkGroupCount", &limits->maxComputeWorkGroupCount) &&
    131     visitor->Visit("maxComputeWorkGroupInvocations", &limits->maxComputeWorkGroupInvocations) &&
    132     visitor->Visit("maxComputeWorkGroupSize", &limits->maxComputeWorkGroupSize) &&
    133     visitor->Visit("subPixelPrecisionBits", &limits->subPixelPrecisionBits) &&
    134     visitor->Visit("subTexelPrecisionBits", &limits->subTexelPrecisionBits) &&
    135     visitor->Visit("mipmapPrecisionBits", &limits->mipmapPrecisionBits) &&
    136     visitor->Visit("maxDrawIndexedIndexValue", &limits->maxDrawIndexedIndexValue) &&
    137     visitor->Visit("maxDrawIndirectCount", &limits->maxDrawIndirectCount) &&
    138     visitor->Visit("maxSamplerLodBias", &limits->maxSamplerLodBias) &&
    139     visitor->Visit("maxSamplerAnisotropy", &limits->maxSamplerAnisotropy) &&
    140     visitor->Visit("maxViewports", &limits->maxViewports) &&
    141     visitor->Visit("maxViewportDimensions", &limits->maxViewportDimensions) &&
    142     visitor->Visit("viewportBoundsRange", &limits->viewportBoundsRange) &&
    143     visitor->Visit("viewportSubPixelBits", &limits->viewportSubPixelBits) &&
    144     visitor->Visit("minMemoryMapAlignment", &limits->minMemoryMapAlignment) &&
    145     visitor->Visit("minTexelBufferOffsetAlignment", &limits->minTexelBufferOffsetAlignment) &&
    146     visitor->Visit("minUniformBufferOffsetAlignment", &limits->minUniformBufferOffsetAlignment) &&
    147     visitor->Visit("minStorageBufferOffsetAlignment", &limits->minStorageBufferOffsetAlignment) &&
    148     visitor->Visit("minTexelOffset", &limits->minTexelOffset) &&
    149     visitor->Visit("maxTexelOffset", &limits->maxTexelOffset) &&
    150     visitor->Visit("minTexelGatherOffset", &limits->minTexelGatherOffset) &&
    151     visitor->Visit("maxTexelGatherOffset", &limits->maxTexelGatherOffset) &&
    152     visitor->Visit("minInterpolationOffset", &limits->minInterpolationOffset) &&
    153     visitor->Visit("maxInterpolationOffset", &limits->maxInterpolationOffset) &&
    154     visitor->Visit("subPixelInterpolationOffsetBits", &limits->subPixelInterpolationOffsetBits) &&
    155     visitor->Visit("maxFramebufferWidth", &limits->maxFramebufferWidth) &&
    156     visitor->Visit("maxFramebufferHeight", &limits->maxFramebufferHeight) &&
    157     visitor->Visit("maxFramebufferLayers", &limits->maxFramebufferLayers) &&
    158     visitor->Visit("framebufferColorSampleCounts", &limits->framebufferColorSampleCounts) &&
    159     visitor->Visit("framebufferDepthSampleCounts", &limits->framebufferDepthSampleCounts) &&
    160     visitor->Visit("framebufferStencilSampleCounts", &limits->framebufferStencilSampleCounts) &&
    161     visitor->Visit("framebufferNoAttachmentsSampleCounts", &limits->framebufferNoAttachmentsSampleCounts) &&
    162     visitor->Visit("maxColorAttachments", &limits->maxColorAttachments) &&
    163     visitor->Visit("sampledImageColorSampleCounts", &limits->sampledImageColorSampleCounts) &&
    164     visitor->Visit("sampledImageIntegerSampleCounts", &limits->sampledImageIntegerSampleCounts) &&
    165     visitor->Visit("sampledImageDepthSampleCounts", &limits->sampledImageDepthSampleCounts) &&
    166     visitor->Visit("sampledImageStencilSampleCounts", &limits->sampledImageStencilSampleCounts) &&
    167     visitor->Visit("storageImageSampleCounts", &limits->storageImageSampleCounts) &&
    168     visitor->Visit("maxSampleMaskWords", &limits->maxSampleMaskWords) &&
    169     visitor->Visit("timestampComputeAndGraphics", &limits->timestampComputeAndGraphics) &&
    170     visitor->Visit("timestampPeriod", &limits->timestampPeriod) &&
    171     visitor->Visit("maxClipDistances", &limits->maxClipDistances) &&
    172     visitor->Visit("maxCullDistances", &limits->maxCullDistances) &&
    173     visitor->Visit("maxCombinedClipAndCullDistances", &limits->maxCombinedClipAndCullDistances) &&
    174     visitor->Visit("discreteQueuePriorities", &limits->discreteQueuePriorities) &&
    175     visitor->Visit("pointSizeRange", &limits->pointSizeRange) &&
    176     visitor->Visit("lineWidthRange", &limits->lineWidthRange) &&
    177     visitor->Visit("pointSizeGranularity", &limits->pointSizeGranularity) &&
    178     visitor->Visit("lineWidthGranularity", &limits->lineWidthGranularity) &&
    179     visitor->Visit("strictLines", &limits->strictLines) &&
    180     visitor->Visit("standardSampleLocations", &limits->standardSampleLocations) &&
    181     visitor->Visit("optimalBufferCopyOffsetAlignment", &limits->optimalBufferCopyOffsetAlignment) &&
    182     visitor->Visit("optimalBufferCopyRowPitchAlignment", &limits->optimalBufferCopyRowPitchAlignment) &&
    183     visitor->Visit("nonCoherentAtomSize", &limits->nonCoherentAtomSize);
    184 }
    185 
    186 template <typename Visitor>
    187 inline bool Iterate(Visitor* visitor,
    188                     VkPhysicalDeviceSparseProperties* properties) {
    189   return
    190     visitor->Visit("residencyStandard2DBlockShape", &properties->residencyStandard2DBlockShape) &&
    191     visitor->Visit("residencyStandard2DMultisampleBlockShape", &properties->residencyStandard2DMultisampleBlockShape) &&
    192     visitor->Visit("residencyStandard3DBlockShape", &properties->residencyStandard3DBlockShape) &&
    193     visitor->Visit("residencyAlignedMipSize", &properties->residencyAlignedMipSize) &&
    194     visitor->Visit("residencyNonResidentStrict", &properties->residencyNonResidentStrict);
    195 }
    196 
    197 template <typename Visitor>
    198 inline bool Iterate(Visitor* visitor,
    199                     VkPhysicalDeviceProperties* properties) {
    200   return
    201     visitor->Visit("apiVersion", &properties->apiVersion) &&
    202     visitor->Visit("driverVersion", &properties->driverVersion) &&
    203     visitor->Visit("vendorID", &properties->vendorID) &&
    204     visitor->Visit("deviceID", &properties->deviceID) &&
    205     visitor->Visit("deviceType", &properties->deviceType) &&
    206     visitor->Visit("deviceName", &properties->deviceName) &&
    207     visitor->Visit("pipelineCacheUUID", &properties->pipelineCacheUUID) &&
    208     visitor->Visit("limits", &properties->limits) &&
    209     visitor->Visit("sparseProperties", &properties->sparseProperties);
    210 }
    211 
    212 template <typename Visitor>
    213 inline bool Iterate(Visitor* visitor, VkPhysicalDeviceFeatures* features) {
    214   return
    215     visitor->Visit("robustBufferAccess", &features->robustBufferAccess) &&
    216     visitor->Visit("fullDrawIndexUint32", &features->fullDrawIndexUint32) &&
    217     visitor->Visit("imageCubeArray", &features->imageCubeArray) &&
    218     visitor->Visit("independentBlend", &features->independentBlend) &&
    219     visitor->Visit("geometryShader", &features->geometryShader) &&
    220     visitor->Visit("tessellationShader", &features->tessellationShader) &&
    221     visitor->Visit("sampleRateShading", &features->sampleRateShading) &&
    222     visitor->Visit("dualSrcBlend", &features->dualSrcBlend) &&
    223     visitor->Visit("logicOp", &features->logicOp) &&
    224     visitor->Visit("multiDrawIndirect", &features->multiDrawIndirect) &&
    225     visitor->Visit("drawIndirectFirstInstance", &features->drawIndirectFirstInstance) &&
    226     visitor->Visit("depthClamp", &features->depthClamp) &&
    227     visitor->Visit("depthBiasClamp", &features->depthBiasClamp) &&
    228     visitor->Visit("fillModeNonSolid", &features->fillModeNonSolid) &&
    229     visitor->Visit("depthBounds", &features->depthBounds) &&
    230     visitor->Visit("wideLines", &features->wideLines) &&
    231     visitor->Visit("largePoints", &features->largePoints) &&
    232     visitor->Visit("alphaToOne", &features->alphaToOne) &&
    233     visitor->Visit("multiViewport", &features->multiViewport) &&
    234     visitor->Visit("samplerAnisotropy", &features->samplerAnisotropy) &&
    235     visitor->Visit("textureCompressionETC2", &features->textureCompressionETC2) &&
    236     visitor->Visit("textureCompressionASTC_LDR", &features->textureCompressionASTC_LDR) &&
    237     visitor->Visit("textureCompressionBC", &features->textureCompressionBC) &&
    238     visitor->Visit("occlusionQueryPrecise", &features->occlusionQueryPrecise) &&
    239     visitor->Visit("pipelineStatisticsQuery", &features->pipelineStatisticsQuery) &&
    240     visitor->Visit("vertexPipelineStoresAndAtomics", &features->vertexPipelineStoresAndAtomics) &&
    241     visitor->Visit("fragmentStoresAndAtomics", &features->fragmentStoresAndAtomics) &&
    242     visitor->Visit("shaderTessellationAndGeometryPointSize", &features->shaderTessellationAndGeometryPointSize) &&
    243     visitor->Visit("shaderImageGatherExtended", &features->shaderImageGatherExtended) &&
    244     visitor->Visit("shaderStorageImageExtendedFormats", &features->shaderStorageImageExtendedFormats) &&
    245     visitor->Visit("shaderStorageImageMultisample", &features->shaderStorageImageMultisample) &&
    246     visitor->Visit("shaderStorageImageReadWithoutFormat", &features->shaderStorageImageReadWithoutFormat) &&
    247     visitor->Visit("shaderStorageImageWriteWithoutFormat", &features->shaderStorageImageWriteWithoutFormat) &&
    248     visitor->Visit("shaderUniformBufferArrayDynamicIndexing", &features->shaderUniformBufferArrayDynamicIndexing) &&
    249     visitor->Visit("shaderSampledImageArrayDynamicIndexing", &features->shaderSampledImageArrayDynamicIndexing) &&
    250     visitor->Visit("shaderStorageBufferArrayDynamicIndexing", &features->shaderStorageBufferArrayDynamicIndexing) &&
    251     visitor->Visit("shaderStorageImageArrayDynamicIndexing", &features->shaderStorageImageArrayDynamicIndexing) &&
    252     visitor->Visit("shaderClipDistance", &features->shaderClipDistance) &&
    253     visitor->Visit("shaderCullDistance", &features->shaderCullDistance) &&
    254     visitor->Visit("shaderFloat64", &features->shaderFloat64) &&
    255     visitor->Visit("shaderInt64", &features->shaderInt64) &&
    256     visitor->Visit("shaderInt16", &features->shaderInt16) &&
    257     visitor->Visit("shaderResourceResidency", &features->shaderResourceResidency) &&
    258     visitor->Visit("shaderResourceMinLod", &features->shaderResourceMinLod) &&
    259     visitor->Visit("sparseBinding", &features->sparseBinding) &&
    260     visitor->Visit("sparseResidencyBuffer", &features->sparseResidencyBuffer) &&
    261     visitor->Visit("sparseResidencyImage2D", &features->sparseResidencyImage2D) &&
    262     visitor->Visit("sparseResidencyImage3D", &features->sparseResidencyImage3D) &&
    263     visitor->Visit("sparseResidency2Samples", &features->sparseResidency2Samples) &&
    264     visitor->Visit("sparseResidency4Samples", &features->sparseResidency4Samples) &&
    265     visitor->Visit("sparseResidency8Samples", &features->sparseResidency8Samples) &&
    266     visitor->Visit("sparseResidency16Samples", &features->sparseResidency16Samples) &&
    267     visitor->Visit("sparseResidencyAliased", &features->sparseResidencyAliased) &&
    268     visitor->Visit("variableMultisampleRate", &features->variableMultisampleRate) &&
    269     visitor->Visit("inheritedQueries", &features->inheritedQueries);
    270 }
    271 
    272 template <typename Visitor>
    273 inline bool Iterate(Visitor* visitor,
    274                     VkPhysicalDeviceVariablePointerFeaturesKHR* features) {
    275   return visitor->Visit("variablePointersStorageBuffer",
    276                         &features->variablePointersStorageBuffer) &&
    277          visitor->Visit("variablePointers", &features->variablePointers);
    278 }
    279 
    280 template <typename Visitor>
    281 inline bool Iterate(Visitor* visitor, VkMemoryType* type) {
    282   return
    283     visitor->Visit("propertyFlags", &type->propertyFlags) &&
    284     visitor->Visit("heapIndex", &type->heapIndex);
    285 }
    286 
    287 template <typename Visitor>
    288 inline bool Iterate(Visitor* visitor, VkMemoryHeap* heap) {
    289   return
    290     visitor->Visit("size", &heap->size) &&
    291     visitor->Visit("flags", &heap->flags);
    292 }
    293 
    294 template <typename Visitor>
    295 inline bool Iterate(Visitor* visitor, VkPhysicalDeviceMemoryProperties* properties) {
    296   return
    297     visitor->Visit("memoryTypeCount", &properties->memoryTypeCount) &&
    298     visitor->VisitArray("memoryTypes", properties->memoryTypeCount, &properties->memoryTypes) &&
    299     visitor->Visit("memoryHeapCount", &properties->memoryHeapCount) &&
    300     visitor->VisitArray("memoryHeaps", properties->memoryHeapCount, &properties->memoryHeaps);
    301 }
    302 
    303 template <typename Visitor>
    304 inline bool Iterate(Visitor* visitor, VkQueueFamilyProperties* properties) {
    305   return
    306     visitor->Visit("queueFlags", &properties->queueFlags) &&
    307     visitor->Visit("queueCount", &properties->queueCount) &&
    308     visitor->Visit("timestampValidBits", &properties->timestampValidBits) &&
    309     visitor->Visit("minImageTransferGranularity", &properties->minImageTransferGranularity);
    310 }
    311 
    312 template <typename Visitor>
    313 inline bool Iterate(Visitor* visitor, VkExtensionProperties* properties) {
    314   return
    315     visitor->Visit("extensionName", &properties->extensionName) &&
    316     visitor->Visit("specVersion", &properties->specVersion);
    317 }
    318 
    319 template <typename Visitor>
    320 inline bool Iterate(Visitor* visitor, VkLayerProperties* properties) {
    321   return
    322     visitor->Visit("layerName", &properties->layerName) &&
    323     visitor->Visit("specVersion", &properties->specVersion) &&
    324     visitor->Visit("implementationVersion", &properties->implementationVersion) &&
    325     visitor->Visit("description", &properties->description);
    326 }
    327 
    328 template <typename Visitor>
    329 inline bool Iterate(Visitor* visitor, VkFormatProperties* properties) {
    330   return
    331     visitor->Visit("linearTilingFeatures", &properties->linearTilingFeatures) &&
    332     visitor->Visit("optimalTilingFeatures", &properties->optimalTilingFeatures) &&
    333     visitor->Visit("bufferFeatures", &properties->bufferFeatures);
    334 }
    335 
    336 template <typename Visitor>
    337 inline bool Iterate(Visitor* visitor, VkJsonLayer* layer) {
    338   return visitor->Visit("properties", &layer->properties) &&
    339          visitor->Visit("extensions", &layer->extensions);
    340 }
    341 
    342 template <typename Visitor>
    343 inline bool Iterate(Visitor* visitor, VkJsonDevice* device) {
    344   return visitor->Visit("properties", &device->properties) &&
    345          visitor->Visit("features", &device->features) &&
    346          visitor->Visit("variablePointersFeaturesKHR",
    347                         &device->variable_pointer_features) &&
    348          visitor->Visit("memory", &device->memory) &&
    349          visitor->Visit("queues", &device->queues) &&
    350          visitor->Visit("extensions", &device->extensions) &&
    351          visitor->Visit("layers", &device->layers) &&
    352          visitor->Visit("formats", &device->formats);
    353 }
    354 
    355 template <typename Visitor>
    356 inline bool Iterate(Visitor* visitor, VkJsonInstance* instance) {
    357   return visitor->Visit("layers", &instance->layers) &&
    358          visitor->Visit("extensions", &instance->extensions) &&
    359          visitor->Visit("devices", &instance->devices);
    360 }
    361 
    362 template <typename T>
    363 using EnableForArithmetic =
    364     typename std::enable_if<std::is_arithmetic<T>::value, void>::type;
    365 
    366 template <typename T>
    367 using EnableForStruct =
    368     typename std::enable_if<std::is_class<T>::value, void>::type;
    369 
    370 template <typename T>
    371 using EnableForEnum =
    372     typename std::enable_if<std::is_enum<T>::value, void>::type;
    373 
    374 template <typename T, typename = EnableForStruct<T>, typename = void>
    375 cJSON* ToJsonValue(const T& value);
    376 
    377 template <typename T, typename = EnableForArithmetic<T>>
    378 inline cJSON* ToJsonValue(const T& value) {
    379   return cJSON_CreateNumber(static_cast<double>(value));
    380 }
    381 
    382 inline cJSON* ToJsonValue(const uint64_t& value) {
    383   char string[19] = {0};  // "0x" + 16 digits + terminal \0
    384   snprintf(string, sizeof(string), "0x%016" PRIx64, value);
    385   return cJSON_CreateString(string);
    386 }
    387 
    388 template <typename T, typename = EnableForEnum<T>, typename = void,
    389           typename = void>
    390 inline cJSON* ToJsonValue(const T& value) {
    391   return cJSON_CreateNumber(static_cast<double>(value));
    392 }
    393 
    394 template <typename T>
    395 inline cJSON* ArrayToJsonValue(uint32_t count, const T* values) {
    396   cJSON* array = cJSON_CreateArray();
    397   for (unsigned int i = 0; i < count; ++i)
    398     cJSON_AddItemToArray(array, ToJsonValue(values[i]));
    399   return array;
    400 }
    401 
    402 template <typename T, unsigned int N>
    403 inline cJSON* ToJsonValue(const T (&value)[N]) {
    404   return ArrayToJsonValue(N, value);
    405 }
    406 
    407 template <size_t N>
    408 inline cJSON* ToJsonValue(const char (&value)[N]) {
    409   assert(strlen(value) < N);
    410   return cJSON_CreateString(value);
    411 }
    412 
    413 template <typename T>
    414 inline cJSON* ToJsonValue(const std::vector<T>& value) {
    415   assert(value.size() <= std::numeric_limits<uint32_t>::max());
    416   return ArrayToJsonValue(static_cast<uint32_t>(value.size()), value.data());
    417 }
    418 
    419 template <typename F, typename S>
    420 inline cJSON* ToJsonValue(const std::pair<F, S>& value) {
    421   cJSON* array = cJSON_CreateArray();
    422   cJSON_AddItemToArray(array, ToJsonValue(value.first));
    423   cJSON_AddItemToArray(array, ToJsonValue(value.second));
    424   return array;
    425 }
    426 
    427 template <typename F, typename S>
    428 inline cJSON* ToJsonValue(const std::map<F, S>& value) {
    429   cJSON* array = cJSON_CreateArray();
    430   for (auto& kv : value)
    431     cJSON_AddItemToArray(array, ToJsonValue(kv));
    432   return array;
    433 }
    434 
    435 class JsonWriterVisitor {
    436  public:
    437   JsonWriterVisitor() : object_(cJSON_CreateObject()) {}
    438 
    439   ~JsonWriterVisitor() {
    440     if (object_)
    441       cJSON_Delete(object_);
    442   }
    443 
    444   template <typename T> bool Visit(const char* key, const T* value) {
    445     cJSON_AddItemToObjectCS(object_, key, ToJsonValue(*value));
    446     return true;
    447   }
    448 
    449   template <typename T, uint32_t N>
    450   bool VisitArray(const char* key, uint32_t count, const T (*value)[N]) {
    451     assert(count <= N);
    452     cJSON_AddItemToObjectCS(object_, key, ArrayToJsonValue(count, *value));
    453     return true;
    454   }
    455 
    456   cJSON* get_object() const { return object_; }
    457   cJSON* take_object() {
    458     cJSON* object = object_;
    459     object_ = nullptr;
    460     return object;
    461   }
    462 
    463  private:
    464   cJSON* object_;
    465 };
    466 
    467 template <typename Visitor, typename T>
    468 inline void VisitForWrite(Visitor* visitor, const T& t) {
    469   Iterate(visitor, const_cast<T*>(&t));
    470 }
    471 
    472 template <typename T, typename /*= EnableForStruct<T>*/, typename /*= void*/>
    473 cJSON* ToJsonValue(const T& value) {
    474   JsonWriterVisitor visitor;
    475   VisitForWrite(&visitor, value);
    476   return visitor.take_object();
    477 }
    478 
    479 template <typename T, typename = EnableForStruct<T>>
    480 bool AsValue(cJSON* json_value, T* t);
    481 
    482 inline bool AsValue(cJSON* json_value, int32_t* value) {
    483   double d = json_value->valuedouble;
    484   if (json_value->type != cJSON_Number || !IsIntegral(d) ||
    485       d < static_cast<double>(std::numeric_limits<int32_t>::min()) ||
    486       d > static_cast<double>(std::numeric_limits<int32_t>::max()))
    487     return false;
    488   *value = static_cast<int32_t>(d);
    489   return true;
    490 }
    491 
    492 inline bool AsValue(cJSON* json_value, uint64_t* value) {
    493   if (json_value->type != cJSON_String)
    494     return false;
    495   int result = std::sscanf(json_value->valuestring, "0x%016" PRIx64, value);
    496   return result == 1;
    497 }
    498 
    499 inline bool AsValue(cJSON* json_value, uint32_t* value) {
    500   double d = json_value->valuedouble;
    501   if (json_value->type != cJSON_Number || !IsIntegral(d) ||
    502       d < 0.0 || d > static_cast<double>(std::numeric_limits<uint32_t>::max()))
    503     return false;
    504   *value = static_cast<uint32_t>(d);
    505   return true;
    506 }
    507 
    508 inline bool AsValue(cJSON* json_value, uint8_t* value) {
    509   uint32_t value32 = 0;
    510   AsValue(json_value, &value32);
    511   if (value32 > std::numeric_limits<uint8_t>::max())
    512     return false;
    513   *value = static_cast<uint8_t>(value32);
    514   return true;
    515 }
    516 
    517 inline bool AsValue(cJSON* json_value, float* value) {
    518   if (json_value->type != cJSON_Number)
    519     return false;
    520   *value = static_cast<float>(json_value->valuedouble);
    521   return true;
    522 }
    523 
    524 template <typename T>
    525 inline bool AsArray(cJSON* json_value, uint32_t count, T* values) {
    526   if (json_value->type != cJSON_Array ||
    527       cJSON_GetArraySize(json_value) != count)
    528     return false;
    529   for (uint32_t i = 0; i < count; ++i) {
    530     if (!AsValue(cJSON_GetArrayItem(json_value, i), values + i))
    531       return false;
    532   }
    533   return true;
    534 }
    535 
    536 template <typename T, unsigned int N>
    537 inline bool AsValue(cJSON* json_value, T (*value)[N]) {
    538   return AsArray(json_value, N, *value);
    539 }
    540 
    541 template <size_t N>
    542 inline bool AsValue(cJSON* json_value, char (*value)[N]) {
    543   if (json_value->type != cJSON_String)
    544     return false;
    545   size_t len = strlen(json_value->valuestring);
    546   if (len >= N)
    547     return false;
    548   memcpy(*value, json_value->valuestring, len);
    549   memset(*value + len, 0, N-len);
    550   return true;
    551 }
    552 
    553 template <typename T, typename = EnableForEnum<T>, typename = void>
    554 inline bool AsValue(cJSON* json_value, T* t) {
    555   // TODO(piman): to/from strings instead?
    556   uint32_t value = 0;
    557   if (!AsValue(json_value, &value))
    558       return false;
    559   if (value < EnumTraits<T>::min() || value > EnumTraits<T>::max())
    560     return false;
    561   *t = static_cast<T>(value);
    562   return true;
    563 }
    564 
    565 template <typename T>
    566 inline bool AsValue(cJSON* json_value, std::vector<T>* value) {
    567   if (json_value->type != cJSON_Array)
    568     return false;
    569   int size = cJSON_GetArraySize(json_value);
    570   value->resize(size);
    571   return AsArray(json_value, size, value->data());
    572 }
    573 
    574 template <typename F, typename S>
    575 inline bool AsValue(cJSON* json_value, std::pair<F, S>* value) {
    576   if (json_value->type != cJSON_Array || cJSON_GetArraySize(json_value) != 2)
    577     return false;
    578   return AsValue(cJSON_GetArrayItem(json_value, 0), &value->first) &&
    579          AsValue(cJSON_GetArrayItem(json_value, 1), &value->second);
    580 }
    581 
    582 template <typename F, typename S>
    583 inline bool AsValue(cJSON* json_value, std::map<F, S>* value) {
    584   if (json_value->type != cJSON_Array)
    585     return false;
    586   int size = cJSON_GetArraySize(json_value);
    587   for (int i = 0; i < size; ++i) {
    588     std::pair<F, S> elem;
    589     if (!AsValue(cJSON_GetArrayItem(json_value, i), &elem))
    590       return false;
    591     if (!value->insert(elem).second)
    592       return false;
    593   }
    594   return true;
    595 }
    596 
    597 template <typename T>
    598 bool ReadValue(cJSON* object, const char* key, T* value,
    599                std::string* errors) {
    600   cJSON* json_value = cJSON_GetObjectItem(object, key);
    601   if (!json_value) {
    602     if (errors)
    603       *errors = std::string(key) + " missing.";
    604     return false;
    605   }
    606   if (AsValue(json_value, value))
    607     return true;
    608   if (errors)
    609     *errors = std::string("Wrong type for ") + std::string(key) + ".";
    610   return false;
    611 }
    612 
    613 template <typename Visitor, typename T>
    614 inline bool VisitForRead(Visitor* visitor, T* t) {
    615   return Iterate(visitor, t);
    616 }
    617 
    618 class JsonReaderVisitor {
    619  public:
    620   JsonReaderVisitor(cJSON* object, std::string* errors)
    621       : object_(object), errors_(errors) {}
    622 
    623   template <typename T> bool Visit(const char* key, T* value) const {
    624     return ReadValue(object_, key, value, errors_);
    625   }
    626 
    627   template <typename T, uint32_t N>
    628   bool VisitArray(const char* key, uint32_t count, T (*value)[N]) {
    629     if (count > N)
    630       return false;
    631     cJSON* json_value = cJSON_GetObjectItem(object_, key);
    632     if (!json_value) {
    633       if (errors_)
    634         *errors_ = std::string(key) + " missing.";
    635       return false;
    636     }
    637     if (AsArray(json_value, count, *value))
    638       return true;
    639     if (errors_)
    640       *errors_ = std::string("Wrong type for ") + std::string(key) + ".";
    641     return false;
    642   }
    643 
    644 
    645  private:
    646   cJSON* object_;
    647   std::string* errors_;
    648 };
    649 
    650 template <typename T, typename /*= EnableForStruct<T>*/>
    651 bool AsValue(cJSON* json_value, T* t) {
    652   if (json_value->type != cJSON_Object)
    653     return false;
    654   JsonReaderVisitor visitor(json_value, nullptr);
    655   return VisitForRead(&visitor, t);
    656 }
    657 
    658 
    659 template <typename T> std::string VkTypeToJson(const T& t) {
    660   JsonWriterVisitor visitor;
    661   VisitForWrite(&visitor, t);
    662 
    663   char* output = cJSON_Print(visitor.get_object());
    664   std::string result(output);
    665   free(output);
    666   return result;
    667 }
    668 
    669 template <typename T> bool VkTypeFromJson(const std::string& json,
    670                                           T* t,
    671                                           std::string* errors) {
    672   *t = T();
    673   cJSON* object = cJSON_Parse(json.c_str());
    674   if (!object) {
    675     if (errors)
    676       errors->assign(cJSON_GetErrorPtr());
    677     return false;
    678   }
    679   bool result = AsValue(object, t);
    680   cJSON_Delete(object);
    681   return result;
    682 }
    683 
    684 }  // anonymous namespace
    685 
    686 std::string VkJsonInstanceToJson(const VkJsonInstance& instance) {
    687   return VkTypeToJson(instance);
    688 }
    689 
    690 bool VkJsonInstanceFromJson(const std::string& json,
    691                             VkJsonInstance* instance,
    692                             std::string* errors) {
    693   return VkTypeFromJson(json, instance, errors);
    694 }
    695 
    696 std::string VkJsonDeviceToJson(const VkJsonDevice& device) {
    697   return VkTypeToJson(device);
    698 }
    699 
    700 bool VkJsonDeviceFromJson(const std::string& json,
    701                           VkJsonDevice* device,
    702                           std::string* errors) {
    703   return VkTypeFromJson(json, device, errors);
    704 };
    705 
    706 std::string VkJsonImageFormatPropertiesToJson(
    707     const VkImageFormatProperties& properties) {
    708   return VkTypeToJson(properties);
    709 }
    710 
    711 bool VkJsonImageFormatPropertiesFromJson(const std::string& json,
    712                                          VkImageFormatProperties* properties,
    713                                          std::string* errors) {
    714   return VkTypeFromJson(json, properties, errors);
    715 };
    716