vkjson: Rename VkJsonAllProperties to VkJsonDevice

In preparation for introducing VkJsonInstance. Typedefs and inline
functions are included in vkjson.h to preserve source compatibility.

5 files changed, 76 insertions, 68 deletions

diff --git a/libs/vkjson/vkjson.cc b/libs/vkjson/vkjson.cc
index f86d3e38..4a49457d 100644
--- a/libs/vkjson/vkjson.cc
+++ b/libs/vkjson/vkjson.cc
@@ -327,15 +327,14 @@ inline bool Iterate(Visitor* visitor, VkFormatProperties* properties) {
 }
 
 template <typename Visitor>
-inline bool Iterate(Visitor* visitor, VkJsonAllProperties* properties) {
-  return
-    visitor->Visit("properties", &properties->properties) &&
-    visitor->Visit("features", &properties->features) &&
-    visitor->Visit("memory", &properties->memory) &&
-    visitor->Visit("queues", &properties->queues) &&
-    visitor->Visit("extensions", &properties->extensions) &&
-    visitor->Visit("layers", &properties->layers) &&
-    visitor->Visit("formats", &properties->formats);
+inline bool Iterate(Visitor* visitor, VkJsonDevice* device) {
+  return visitor->Visit("properties", &device->properties) &&
+         visitor->Visit("features", &device->features) &&
+         visitor->Visit("memory", &device->memory) &&
+         visitor->Visit("queues", &device->queues) &&
+         visitor->Visit("extensions", &device->extensions) &&
+         visitor->Visit("layers", &device->layers) &&
+         visitor->Visit("formats", &device->formats);
 }
 
 
@@ -663,15 +662,14 @@ template <typename T> bool VkTypeFromJson(const std::string& json,
 
 }  // anonymous namespace
 
-std::string VkJsonAllPropertiesToJson(
-    const VkJsonAllProperties& properties) {
-  return VkTypeToJson(properties);
+std::string VkJsonDeviceToJson(const VkJsonDevice& device) {
+  return VkTypeToJson(device);
 }
 
-bool VkJsonAllPropertiesFromJson(
-    const std::string& json, VkJsonAllProperties* properties,
-    std::string* errors) {
-  return VkTypeFromJson(json, properties, errors);
+bool VkJsonDeviceFromJson(const std::string& json,
+                          VkJsonDevice* device,
+                          std::string* errors) {
+  return VkTypeFromJson(json, device, errors);
 };
 
 std::string VkJsonImageFormatPropertiesToJson(
diff --git a/libs/vkjson/vkjson.h b/libs/vkjson/vkjson.h
index e60135b2..ee2fb292 100644
--- a/libs/vkjson/vkjson.h
+++ b/libs/vkjson/vkjson.h
@@ -33,8 +33,8 @@
 #undef max
 #endif
 
-struct VkJsonAllProperties {
-  VkJsonAllProperties() {
+struct VkJsonDevice {
+  VkJsonDevice() {
           memset(&properties, 0, sizeof(VkPhysicalDeviceProperties));
           memset(&features, 0, sizeof(VkPhysicalDeviceFeatures));
           memset(&memory, 0, sizeof(VkPhysicalDeviceMemoryProperties));
@@ -48,13 +48,11 @@ struct VkJsonAllProperties {
   std::map<VkFormat, VkFormatProperties> formats;
 };
 
-VkJsonAllProperties VkJsonGetAllProperties(VkPhysicalDevice physicalDevice);
-
-std::string VkJsonAllPropertiesToJson(
-    const VkJsonAllProperties& properties);
-bool VkJsonAllPropertiesFromJson(
-    const std::string& json, VkJsonAllProperties* properties,
-    std::string* errors);
+VkJsonDevice VkJsonGetDevice(VkPhysicalDevice device);
+std::string VkJsonDeviceToJson(const VkJsonDevice& device);
+bool VkJsonDeviceFromJson(const std::string& json,
+                          VkJsonDevice* device,
+                          std::string* errors);
 
 std::string VkJsonImageFormatPropertiesToJson(
     const VkImageFormatProperties& properties);
@@ -62,4 +60,20 @@ bool VkJsonImageFormatPropertiesFromJson(const std::string& json,
                                          VkImageFormatProperties* properties,
                                          std::string* errors);
 
+// Backward-compatibility aliases
+typedef VkJsonDevice VkJsonAllProperties;
+inline VkJsonAllProperties VkJsonGetAllProperties(
+    VkPhysicalDevice physicalDevice) {
+  return VkJsonGetDevice(physicalDevice);
+}
+inline std::string VkJsonAllPropertiesToJson(
+    const VkJsonAllProperties& properties) {
+  return VkJsonDeviceToJson(properties);
+}
+inline bool VkJsonAllPropertiesFromJson(const std::string& json,
+                                        VkJsonAllProperties* properties,
+                                        std::string* errors) {
+  return VkJsonDeviceFromJson(json, properties, errors);
+}
+
 #endif  // VKJSON_H_
diff --git a/libs/vkjson/vkjson_device.cc b/libs/vkjson/vkjson_device.cc
index 88f4d44d..2e740614 100644
--- a/libs/vkjson/vkjson_device.cc
+++ b/libs/vkjson/vkjson_device.cc
@@ -23,19 +23,19 @@
 
 #include <utility>
 
-VkJsonAllProperties VkJsonGetAllProperties(VkPhysicalDevice physical_device) {
-  VkJsonAllProperties properties;
-  vkGetPhysicalDeviceProperties(physical_device, &properties.properties);
-  vkGetPhysicalDeviceFeatures(physical_device, &properties.features);
-  vkGetPhysicalDeviceMemoryProperties(physical_device, &properties.memory);
+VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) {
+  VkJsonDevice device;
+  vkGetPhysicalDeviceProperties(physical_device, &device.properties);
+  vkGetPhysicalDeviceFeatures(physical_device, &device.features);
+  vkGetPhysicalDeviceMemoryProperties(physical_device, &device.memory);
 
   uint32_t queue_family_count = 0;
   vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count,
                                            nullptr);
   if (queue_family_count > 0) {
-    properties.queues.resize(queue_family_count);
+    device.queues.resize(queue_family_count);
     vkGetPhysicalDeviceQueueFamilyProperties(
-        physical_device, &queue_family_count, properties.queues.data());
+        physical_device, &queue_family_count, device.queues.data());
   }
 
   // Only device extensions.
@@ -44,18 +44,17 @@ VkJsonAllProperties VkJsonGetAllProperties(VkPhysicalDevice physical_device) {
   vkEnumerateDeviceExtensionProperties(physical_device, nullptr,
                                        &extension_count, nullptr);
   if (extension_count > 0) {
-    properties.extensions.resize(extension_count);
-    vkEnumerateDeviceExtensionProperties(physical_device, nullptr,
-                                         &extension_count,
-                                         properties.extensions.data());
+    device.extensions.resize(extension_count);
+    vkEnumerateDeviceExtensionProperties(
+        physical_device, nullptr, &extension_count, device.extensions.data());
   }
 
   uint32_t layer_count = 0;
   vkEnumerateDeviceLayerProperties(physical_device, &layer_count, nullptr);
   if (layer_count > 0) {
-    properties.layers.resize(layer_count);
+    device.layers.resize(layer_count);
     vkEnumerateDeviceLayerProperties(physical_device, &layer_count,
-                                     properties.layers.data());
+                                     device.layers.data());
   }
 
   VkFormatProperties format_properties = {};
@@ -67,8 +66,8 @@ VkJsonAllProperties VkJsonGetAllProperties(VkPhysicalDevice physical_device) {
     if (format_properties.linearTilingFeatures ||
         format_properties.optimalTilingFeatures ||
         format_properties.bufferFeatures) {
-      properties.formats.insert(std::make_pair(format, format_properties));
+      device.formats.insert(std::make_pair(format, format_properties));
     }
   }
-  return properties;
+  return device;
 }
diff --git a/libs/vkjson/vkjson_info.cc b/libs/vkjson/vkjson_info.cc
index b5b0c3e7..90277d76 100644
--- a/libs/vkjson/vkjson_info.cc
+++ b/libs/vkjson/vkjson_info.cc
@@ -79,8 +79,8 @@ bool ParseOptions(int argc, char* argv[], Options* options) {
   return true;
 }
 
-bool DumpProperties(const VkJsonAllProperties& props, const Options& options) {
-  std::string device_name(props.properties.deviceName);
+bool DumpProperties(const VkJsonDevice& device, const Options& options) {
+  std::string device_name(device.properties.deviceName);
   std::string output_file = options.output_file;
   if (output_file.empty())
     output_file = device_name + ".json";
@@ -95,7 +95,7 @@ bool DumpProperties(const VkJsonAllProperties& props, const Options& options) {
     }
   }
 
-  std::string json = VkJsonAllPropertiesToJson(props) + '\n';
+  std::string json = VkJsonDeviceToJson(device) + '\n';
   fwrite(json.data(), 1, json.size(), file);
 
   if (output_file != "-") {
@@ -163,19 +163,19 @@ int main(int argc, char* argv[]) {
                 << std::endl;
       return 1;
     }
-    auto props = VkJsonGetAllProperties(physical_devices[options.device_index]);
-    if (!DumpProperties(props, options))
+    auto device = VkJsonGetDevice(physical_devices[options.device_index]);
+    if (!DumpProperties(device, options))
       return 1;
     return 0;
   }
 
   bool found = false;
   for (auto physical_device : physical_devices) {
-    auto props = VkJsonGetAllProperties(physical_device);
+    auto device = VkJsonGetDevice(physical_device);
     if (!options.device_name.empty() &&
-        options.device_name != props.properties.deviceName)
+        options.device_name != device.properties.deviceName)
       continue;
-    if (!DumpProperties(props, options))
+    if (!DumpProperties(device, options))
       return 1;
     found = true;
   }
diff --git a/libs/vkjson/vkjson_unittest.cc b/libs/vkjson/vkjson_unittest.cc
index 26ae6b76..cdd677be 100644
--- a/libs/vkjson/vkjson_unittest.cc
+++ b/libs/vkjson/vkjson_unittest.cc
@@ -46,36 +46,33 @@ int main(int argc, char* argv[]) {
   bool result = false;
 
   const char name[] = "Test device";
-  VkJsonAllProperties device_props;
-  memcpy(device_props.properties.deviceName, name, sizeof(name));
-  device_props.properties.limits.maxImageDimension1D = 3;
-  device_props.properties.limits.maxSamplerLodBias = 3.5f;
-  device_props.properties.limits.bufferImageGranularity = 0x1ffffffffull;
-  device_props.properties.limits.maxViewportDimensions[0] = 1;
-  device_props.properties.limits.maxViewportDimensions[1] = 2;
+  VkJsonDevice device;
+  memcpy(device.properties.deviceName, name, sizeof(name));
+  device.properties.limits.maxImageDimension1D = 3;
+  device.properties.limits.maxSamplerLodBias = 3.5f;
+  device.properties.limits.bufferImageGranularity = 0x1ffffffffull;
+  device.properties.limits.maxViewportDimensions[0] = 1;
+  device.properties.limits.maxViewportDimensions[1] = 2;
   VkFormatProperties format_props = {
       VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
       VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
       VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT};
-  device_props.formats.insert(
-      std::make_pair(VK_FORMAT_R8_UNORM, format_props));
-  device_props.formats.insert(
-      std::make_pair(VK_FORMAT_R8G8_UNORM, format_props));
-  std::string json = VkJsonAllPropertiesToJson(device_props);
+  device.formats.insert(std::make_pair(VK_FORMAT_R8_UNORM, format_props));
+  device.formats.insert(std::make_pair(VK_FORMAT_R8G8_UNORM, format_props));
+  std::string json = VkJsonDeviceToJson(device);
   std::cout << json << std::endl;
 
-  VkJsonAllProperties device_props2;
-  result = VkJsonAllPropertiesFromJson(json, &device_props2, &errors);
+  VkJsonDevice device2;
+  result = VkJsonDeviceFromJson(json, &device2, &errors);
   EXPECT(result);
   if (!result)
     std::cout << "Error: " << errors << std::endl;
 
-  EXPECT(!memcmp(&device_props.properties,
-                 &device_props2.properties,
-                 sizeof(device_props.properties)));
-  for (auto& kv : device_props.formats) {
-    auto it = device_props2.formats.find(kv.first);
-    EXPECT(it != device_props2.formats.end());
+  EXPECT(!memcmp(&device.properties, &device2.properties,
+                 sizeof(device.properties)));
+  for (auto& kv : device.formats) {
+    auto it = device2.formats.find(kv.first);
+    EXPECT(it != device2.formats.end());
     EXPECT(!memcmp(&kv.second, &it->second, sizeof(kv.second)));
   }