export: Factor out CMake-specific export generation (2/2)

In order to support generation of Common Package Specifications, the
mechanisms CMake uses to export package information need to be made more
abstract. The prior commits began this refactoring; this continues by
(actually) restructuring the classes used to generate the actual export files.
To minimize churn, this introduces virtual base classes and
diamond inheritance in order to separate logic which is format-agnostic
but depends on the export mode (build-tree versus install-tree) from
logic which is format-specific but mode-agnostic.

This could probably be refactored further to use helper classes instead,
and a future commit may do that, however an initial attempt to do that
was proving even more invasive, such that this approach was deemed more
manageable.

While we're at it, add 'const' in more places where possible.

Source/cmExportAndroidMKGenerator.h

@@ -5,58 +5,69 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include <iosfwd>
+#include <map>
 #include <string>
 
-#include "cmExportBuildFileGenerator.h"
+#include <cm/string_view>
+
+#include "cmExportFileGenerator.h"
 #include "cmStateTypes.h"
 
 class cmGeneratorTarget;
 
 /** \class cmExportAndroidMKGenerator
- * \brief Generate a file exporting targets from a build tree.
+ * \brief Generate CMake configuration files exporting targets from a build or
+ * install tree.
  *
- * cmExportAndroidMKGenerator generates a file exporting targets from
- * a build tree.  This exports the targets to the Android ndk build tool
- * makefile format for prebuilt libraries.
- *
- * This is used to implement the export() command.
+ * cmExportAndroidMKGenerator is the superclass for
+ * cmExportBuildAndroidMKGenerator and cmExportInstallAndroidMKGenerator.
+ * It contains common code generation routines for the two kinds of export
+ * implementations.
  */
-class cmExportAndroidMKGenerator : public cmExportBuildFileGenerator
+class cmExportAndroidMKGenerator : virtual public cmExportFileGenerator
 {
 public:
   cmExportAndroidMKGenerator();
-  // this is so cmExportInstallAndroidMKGenerator can share this
-  // function as they are almost the same
+
+  using cmExportFileGenerator::GenerateImportFile;
+
+protected:
   enum GenerateType
   {
     BUILD,
     INSTALL
   };
-  static void GenerateInterfaceProperties(cmGeneratorTarget const* target,
-                                          std::ostream& os,
-                                          ImportPropertyMap const& properties,
-                                          GenerateType type,
-                                          std::string const& config);
+  virtual GenerateType GetGenerateType() const = 0;
 
-protected:
-  // Implement virtual methods from the superclass.
-  void GeneratePolicyHeaderCode(std::ostream&) override {}
-  void GeneratePolicyFooterCode(std::ostream&) override {}
-  void GenerateImportHeaderCode(std::ostream& os,
-                                std::string const& config = "") override;
-  void GenerateImportFooterCode(std::ostream& os) override;
-  void GenerateImportTargetCode(
+  using ImportPropertyMap = std::map<std::string, std::string>;
+
+  cm::string_view GetImportPrefixWithSlash() const override;
+
+  void GenerateInterfaceProperties(cmGeneratorTarget const* target,
+                                   std::ostream& os,
+                                   ImportPropertyMap const& properties);
+
+  // Methods to implement export file code generation.
+  bool GenerateImportFile(std::ostream& os) override;
+  virtual void GenerateImportHeaderCode(std::ostream& os,
+                                        std::string const& config = "") = 0;
+  virtual void GenerateImportTargetCode(
     std::ostream& os, cmGeneratorTarget const* target,
-    cmStateEnums::TargetType /*targetType*/) override;
-  void GenerateExpectedTargetsCode(
-    std::ostream& os, std::string const& expectedTargets) override;
-  void GenerateImportPropertyCode(
-    std::ostream& os, std::string const& config, std::string const& suffix,
-    cmGeneratorTarget const* target, ImportPropertyMap const& properties,
-    std::string const& importedXcFrameworkLocation) override;
-  void GenerateMissingTargetsCheckCode(std::ostream& os) override;
-  void GenerateFindDependencyCalls(std::ostream&) override {}
-  void GenerateInterfaceProperties(
-    cmGeneratorTarget const* target, std::ostream& os,
-    ImportPropertyMap const& properties) override;
+    cmStateEnums::TargetType targetType) = 0;
+
+  void GenerateImportTargetsConfig(std::ostream& /*os*/,
+                                   std::string const& /*config*/,
+                                   std::string const& /*suffix*/) override
+  {
+  }
+
+  std::string GetCxxModuleFile(std::string const& /*name*/) const override
+  {
+    return {};
+  }
+
+  void GenerateCxxModuleConfigInformation(std::string const& /*name*/,
+                                          std::ostream& /*os*/) const override
+  {
+  }
 };