fom_documents.h

Go to the documentation of this file.

// === fom_documents.h =================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_LIBS_CORE_SRC_LANG_FOM_DOCUMENTS_H
#define SEN_LIBS_CORE_SRC_LANG_FOM_DOCUMENTS_H
 
// sen
#include "sen/core/base/compiler_macros.h"
#include "sen/core/lang/stl_resolver.h"
#include "sen/core/meta/callable.h"
#include "sen/core/meta/class_type.h"
#include "sen/core/meta/event.h"
#include "sen/core/meta/method.h"
#include "sen/core/meta/property.h"
#include "sen/core/meta/type.h"
#include "sen/core/meta/type_registry.h"
 
// xml parser
#include "pugixml.hpp"
 
// std
#include <array>
#include <cstdint>
#include <filesystem>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace sen::lang::fom
{

struct Document
{
  std::filesystem::path path;
  pugi::xml_document xml;
  pugi::xml_node objectModel;
  std::string name;     
  std::string package;  
  bool isExtension {};  
  bool built {};        
  std::vector<Document*> dependencies;
  std::vector<Document*> mappingImports;  
  std::vector<pugi::xml_node> classNodes;
  std::vector<pugi::xml_node> interactionNodes;

  CustomTypeRegistry registry;
  std::vector<ConstTypeHandle<>> storage;
};

struct MappingDocument final
{
  std::filesystem::path path;
  pugi::xml_document xml;
};

struct DocumentTypeSet
{
  std::filesystem::path path;
  std::unique_ptr<TypeSet> typeSet;
};

struct Declaration
{
  pugi::xml_node node;
  Document* document {};
};

struct Declarations
{
  std::vector<Declaration> all;  
  Document* owner {};            
  bool ownerIsComplete {false};  
};

class FomDocuments
{
  SEN_NOCOPY_NOMOVE(FomDocuments)
 
public:
  FomDocuments(const std::vector<std::filesystem::path>& paths,
               const std::vector<std::filesystem::path>& extensions,
               const std::vector<std::filesystem::path>& mappings,
               TypeSettings settings);
  ~FomDocuments() = default;
 
public:
  [[nodiscard]] std::vector<DocumentTypeSet> takeTypeSets();
  [[nodiscard]] const TypeSet& rootTypeSet() const& noexcept;

  [[nodiscard]] std::unique_ptr<TypeSet> takeRootTypeSet() &&;
 
private:
  //--------------------------------------------------------------------------------------------------------------
  // Reading
  //--------------------------------------------------------------------------------------------------------------

  void readDirectory(const std::filesystem::path& path);

  void readExtension(const std::filesystem::path& path);

  Document& readDocument(const std::filesystem::path& path, const std::string& package, bool isExtension);

  void resolveDependencies();

  [[nodiscard]] Document* findDocument(const std::string& identification) const;
 
  //--------------------------------------------------------------------------------------------------------------
  // Indexing
  //--------------------------------------------------------------------------------------------------------------

  void indexDeclarations();

  void record(const std::string& key, pugi::xml_node node, Document& document);

  [[nodiscard]] std::optional<Declaration> ownedElsewhere(const std::string& key, const Document& document) const;

  [[nodiscard]] std::vector<Declaration> contributions(const std::string& key,
                                                       pugi::xml_node own,
                                                       const Document& document) const;

  [[nodiscard]] std::optional<Declaration> introducedType(const std::string& category,
                                                          const std::string& fomName) const;

  void buildRootTypeSet();
 
  //--------------------------------------------------------------------------------------------------------------
  // Building
  //--------------------------------------------------------------------------------------------------------------

  void ensureBuilt(Document& document);

  void populateTypes(Document& document);

  template <typename F>
  [[nodiscard]] ConstTypeHandle<> processTypeSource(Document& document, const pugi::xpath_node& node, F func);
 
  template <typename F>
  void processTypeSource(Document& document, const pugi::xpath_node_set& nodes, F func);

  template <typename F>
  [[nodiscard]] std::optional<ConstTypeHandle<>> processTypeQuery(Document& document,
                                                                  const std::string& query,
                                                                  const std::string& queryPostFix,
                                                                  F func);

  [[nodiscard]] ConstTypeHandle<> storeType(ConstTypeHandle<> type, Document& document);

  [[nodiscard]] std::pair<ConstTypeHandle<>, Document*> getOrCreateType(const std::string& fomName, Document& document);

  [[nodiscard]] std::optional<std::pair<ConstTypeHandle<>, Document*>> searchType(const std::string& fomName,
                                                                                  Document& document);
  [[nodiscard]] std::optional<std::pair<ConstTypeHandle<>, Document*>> searchTypeHere(const std::string& fomName,
                                                                                      Document& document);
  [[nodiscard]] std::optional<std::pair<ConstTypeHandle<>, Document*>> searchBySenName(
    const std::string& qualifiedName) const;

  struct Category
  {
    const char* container;
    const char* element;
    ConstTypeHandle<> (FomDocuments::*build)(pugi::xml_node, Document&);
  };

  [[nodiscard]] static const std::array<Category, 5>& dataTypeCategories();

  [[nodiscard]] static std::string categoryQuery(const Category& category);
 
  [[nodiscard]] ConstTypeHandle<> simpleData(pugi::xml_node node, Document& document);
  [[nodiscard]] ConstTypeHandle<> arrayType(pugi::xml_node node, Document& document);
  [[nodiscard]] ConstTypeHandle<> recordType(pugi::xml_node node, Document& document);
  [[nodiscard]] ConstTypeHandle<> variantRecord(pugi::xml_node node, Document& document);
  [[nodiscard]] ConstTypeHandle<> enumeration(pugi::xml_node node, Document& document);
  [[nodiscard]] ConstTypeHandle<> classNode(pugi::xml_node node, Document& document);

  void applyMappings(ClassSpec& classSpec,
                     std::vector<PropertySpec>& propertySpecs,
                     const MaybeConstTypeHandle<>& parentType,
                     Document& document);

  [[nodiscard]] PropertySpec propertyFromAttribute(pugi::xml_node attrNode,
                                                   Document& document,
                                                   const ClassAnnotations* annotations);

  void basicDataRepresentation(pugi::xml_node node, const Document& document);

  [[nodiscard]] ConstTypeHandle<> optionalPropertyType(const std::string& fomElementTypeName, Document& document);
 
  //--------------------------------------------------------------------------------------------------------------
  // Interactions
  //--------------------------------------------------------------------------------------------------------------
 
  enum class CallableEnum : uint8_t
  {
    method,
    event
  };
 
  struct FoundInteraction
  {
    pugi::xml_node node;
    Document* document {};
  };
 
  [[nodiscard]] FoundInteraction findInteraction(const std::string& path, Document& document);
  [[nodiscard]] FoundInteraction findInteractionAnywhere(const std::string& path, const std::string& askedBy);
  [[nodiscard]] Arg argFromParameter(pugi::xml_node paramNode, Document& document);
  [[nodiscard]] std::vector<Arg> collectArgs(pugi::xml_node interactionNode,
                                             const std::vector<std::string>& ignoredParams,
                                             Document& document);
  [[nodiscard]] ConstTypeHandle<> structFromInteraction(pugi::xml_node node,
                                                        Document& document,
                                                        const std::vector<std::string>& ignoredParams);
  [[nodiscard]] CallableSpec makeCallableSpec(pugi::xml_node interactionNode,
                                              const std::vector<std::string>& ignoredParams,
                                              Document& document,
                                              CallableEnum callableEnum,
                                              bool packArguments);
  [[nodiscard]] EventSpec makeEventSpec(pugi::xml_node interactionNode,
                                        const std::vector<std::string>& ignoredParams,
                                        Document& document,
                                        bool packArguments);
  [[nodiscard]] MethodSpec makeMethodSpec(pugi::xml_node interactionNode,
                                          pugi::xml_node returnNode,
                                          const std::vector<std::string>& ignoredParams,
                                          Document& document,
                                          bool packArguments,
                                          bool localOnly,
                                          const std::string& qualifiedClassName);
 
  //--------------------------------------------------------------------------------------------------------------
  // Names
  //--------------------------------------------------------------------------------------------------------------
 
  [[nodiscard]] std::string senName(const std::string& fomTypeName) const;
  [[nodiscard]] std::string senQualifiedName(const Document& document, const std::string& fomTypeName) const;
  [[nodiscard]] std::string withPackage(const Document& document, const std::string& str) const;
  [[nodiscard]] ConstTypeHandle<> representationToType(const std::string& representation) const;
 
private:
  TypeSettings settings_;
  std::vector<std::unique_ptr<Document>> documents_;
  std::vector<MappingDocument> mappings_;

  std::map<std::string, std::vector<std::string>> argsStructIgnores_;

  std::vector<std::string> packedWithIgnores_;

  std::vector<std::filesystem::path> extensionPaths_;

  std::map<std::string, Declarations> declarations_;
 
  std::unordered_map<std::string, ConstTypeHandle<>> representations_;
  std::unordered_map<std::string, std::string> units_;
  std::unique_ptr<TypeSet> rootSet_;
  std::optional<TypeHandle<ClassType>> rootClass_;

  std::vector<std::pair<std::string, const Document*>> resolving_;
};
 
}  // namespace sen::lang::fom
 
#endif  // SEN_LIBS_CORE_SRC_LANG_FOM_DOCUMENTS_H