refactor: refactor enum migration but not finished

Assets/CodeGen/EnumsMigration/EnumsRender/json_loader.py

@@ -0,0 +1,190 @@
+import json
+import typing
+import utils
+
+
+class BEnumEntry:
+    """The struct to describe the entry of an enum."""
+
+    __entry_name: str
+    """The name of this entry."""
+    __entry_value: str | None
+    """The value of this entry. None if this entry do not have explicit value."""
+    __entry_comment: str | None
+    """The comment of this entry. None if no comment."""
+
+    def __init__(
+        self, entry_name: str, entry_value: str | None, entry_comment: str | None
+    ):
+        self.__entry_name = entry_name
+        self.__entry_value = entry_value
+        self.__entry_comment = entry_comment
+
+    def get_entry_name(self) -> str:
+        """Get the name of this entry."""
+        return self.__entry_name
+
+    def get_entry_value(self) -> str | None:
+        """Get the value of this entry. None if this entry do not have explicit value."""
+        return self.__entry_value
+
+    def get_entry_comment(self) -> str | None:
+        """Get the comment of this entry. None if no comment."""
+        return self.__entry_comment
+
+    @staticmethod
+    def from_json(data: dict[str, typing.Any]) -> "BEnumEntry":
+        return BEnumEntry(
+            data["name"],
+            data.get("value", None),
+            data.get("comment", None),
+        )
+
+
+class BHierarchyEnumEntry(BEnumEntry):
+    """
+    The specialized EnumEntry type which can store extra hierarchy info.
+    Used in CK_CLASSID parsing.
+    """
+
+    __hierarchy: list[str]
+    """
+    The list to store this CK_CLASSID inheritance relationship.
+    The first item is the oldest parent in inheritance.
+    The last item is self.
+    """
+
+    def __init__(
+        self,
+        entry_name: str,
+        entry_value: str | None,
+        entry_comment: str | None,
+        hierarchy: list[str],
+    ):
+        super().__init__(entry_name, entry_value, entry_comment)
+        self.__hierarchy = hierarchy
+
+    def iter_hierarchy(self, benum: "BEnum") -> typing.Iterator["BHierarchyEnumEntry"]:
+        return map(
+            lambda e: typing.cast(BHierarchyEnumEntry, benum.get_entry_by_name(e)),
+            self.__hierarchy,
+        )
+
+    @staticmethod
+    def from_json(data: dict[str, typing.Any]) -> "BHierarchyEnumEntry":
+        return BHierarchyEnumEntry(
+            data["name"],
+            data.get("value", None),
+            data.get("comment", None),
+            data["hierarchy"],
+        )
+
+
+class BEnum:
+    """The struct to describe an enum."""
+
+    __enum_name: str
+    """The name of this enum."""
+    __enum_comment: str | None
+    """The comment of this enum. None if no comment."""
+    __can_unsigned: bool
+    """True if this enum can use unsigned integer as its underlying type."""
+    __use_flags: bool
+    """True if this enum will use flags feature (supporting OR, AND, operators)."""
+    __entries: list[BEnumEntry]
+    """The list to store entries of this enum."""
+
+    __entries_map: dict[str, BEnumEntry]
+    """The name map for `entries`."""
+
+    def __init__(
+        self,
+        enum_name: str,
+        enum_comment: str | None,
+        can_unsigned: bool,
+        use_flags: bool,
+        entries: list[BEnumEntry],
+    ):
+        self.__enum_name = enum_name
+        self.__enum_comment = enum_comment
+        self.__can_unsigned = can_unsigned
+        self.__use_flags = use_flags
+        self.__entries = entries
+        self.__entries_map = {e.get_entry_name(): e for e in entries}
+
+    def get_enum_name(self) -> str:
+        """Get the name of this enum."""
+        return self.__enum_name
+
+    def get_enum_comment(self) -> str | None:
+        """Get the comment of this enum. None if no comment."""
+        return self.__enum_comment
+
+    def get_can_unsigned(self) -> bool:
+        """True if this enum can use unsigned integer as its underlying type."""
+        return self.__can_unsigned
+
+    def get_use_flags(self) -> bool:
+        """True if this enum will use flags feature (supporting OR, AND, operators)."""
+        return self.__use_flags
+
+    def iter_entries(self) -> typing.Iterator[BEnumEntry]:
+        """Get the iterator of entries of this enum."""
+        return iter(self.__entries)
+
+    def get_entry_by_name(self, name: str) -> BEnumEntry:
+        return self.__entries_map[name]
+
+    @staticmethod
+    def from_json(data: dict[str, typing.Any]) -> "BEnum":
+        return BEnum(
+            data["name"],
+            data.get("comment", None),
+            data["can_unsigned"],
+            data["use_flags"],
+            list(map(lambda i: BEnum.__create_entry_by_content(i), data["entries"])),
+        )
+
+    @staticmethod
+    def __create_entry_by_content(data: dict[str, typing.Any]) -> "BEnumEntry":
+        if "hierarchy" in data:
+            return BHierarchyEnumEntry.from_json(data)
+        else:
+            return BEnumEntry.from_json(data)
+
+
+class BEnumCollection:
+    """The struct to describe a collection of enums."""
+
+    __enums: list[BEnum]
+    """The list to store enums."""
+
+    def __init__(self, enums: list[BEnum]):
+        self.__enums = enums
+
+    def iter_enums(self) -> typing.Iterator[BEnum]:
+        """Get the iterator of enums."""
+        return iter(self.__enums)
+
+    def get_enums_count(self) -> int:
+        """Get the count of enums."""
+        return len(self.__enums)
+
+    def get_enum_by_index(self, index: int) -> BEnum:
+        """Get the enum by index."""
+        return self.__enums[index]
+
+    @staticmethod
+    def from_json(data: list[typing.Any]) -> "BEnumCollection":
+        return BEnumCollection(list(map(lambda i: BEnum.from_json(i), data)))
+
+
+def load_enums(filename: str) -> BEnumCollection:
+    with open(utils.get_input_file_path(filename), "r", encoding="utf-8") as f:
+        return BEnumCollection.from_json(json.load(f))
+
+
+def load_enum(filename: str) -> BEnum:
+    collection = load_enums(filename)
+    assert collection.get_enums_count() == 1
+    return collection.get_enum_by_index(0)