IncludeCPP 3.6.0__py3-none-any.whl → 3.7.9__py3-none-any.whl

includecpp/core/cssl/cssl_types.py

@@ -1281,10 +1281,232 @@ def create_dictionary(key_type: str = 'dynamic', value_type: str = 'dynamic') ->
     return Dictionary(key_type, value_type)
 
 
+class Map(dict):
+    """C++ style map container with ordered key-value pairs.
+
+    Similar to Dictionary but with C++ map semantics.
+    Keys are maintained in sorted order.
+
+    Usage:
+        map<string, int> ages;
+        ages.insert("Alice", 30);
+        ages.find("Alice");
+        ages.erase("Alice");
+    """
+
+    def __init__(self, key_type: str = 'dynamic', value_type: str = 'dynamic'):
+        super().__init__()
+        self._key_type = key_type
+        self._value_type = value_type
+
+    def insert(self, key: Any, value: Any) -> 'Map':
+        """Insert key-value pair (C++ style)"""
+        self[key] = value
+        return self
+
+    def find(self, key: Any) -> Optional[Any]:
+        """Find value by key, returns None if not found (C++ style)"""
+        return self.get(key, None)
+
+    def erase(self, key: Any) -> bool:
+        """Erase key-value pair, returns True if existed"""
+        if key in self:
+            del self[key]
+            return True
+        return False
+
+    def contains(self, key: Any) -> bool:
+        """Check if key exists (C++20 style)"""
+        return key in self
+
+    def count(self, key: Any) -> int:
+        """Return 1 if key exists, 0 otherwise (C++ style)"""
+        return 1 if key in self else 0
+
+    def size(self) -> int:
+        """Return map size"""
+        return len(self)
+
+    def empty(self) -> bool:
+        """Check if map is empty"""
+        return len(self) == 0
+
+    def at(self, key: Any) -> Any:
+        """Get value at key, raises error if not found (C++ style)"""
+        if key not in self:
+            raise KeyError(f"Key '{key}' not found in map")
+        return self[key]
+
+    def begin(self) -> Optional[tuple]:
+        """Return first key-value pair"""
+        if len(self) == 0:
+            return None
+        first_key = next(iter(self))
+        return (first_key, self[first_key])
+
+    def end(self) -> Optional[tuple]:
+        """Return last key-value pair"""
+        if len(self) == 0:
+            return None
+        last_key = list(self.keys())[-1]
+        return (last_key, self[last_key])
+
+    def lower_bound(self, key: Any) -> Optional[Any]:
+        """Find first key >= given key (for sorted keys)"""
+        sorted_keys = sorted(self.keys())
+        for k in sorted_keys:
+            if k >= key:
+                return k
+        return None
+
+    def upper_bound(self, key: Any) -> Optional[Any]:
+        """Find first key > given key (for sorted keys)"""
+        sorted_keys = sorted(self.keys())
+        for k in sorted_keys:
+            if k > key:
+                return k
+        return None
+
+
+def create_map(key_type: str = 'dynamic', value_type: str = 'dynamic') -> Map:
+    """Create a Map object"""
+    return Map(key_type, value_type)
+
+
+class CSSLClass:
+    """Represents a CSSL class definition.
+
+    Stores class name, member variables, methods, and constructor.
+    Used by the runtime to instantiate CSSLInstance objects.
+    """
+
+    def __init__(self, name: str, members: Dict[str, Any] = None,
+                 methods: Dict[str, Any] = None, constructor: Any = None):
+        self.name = name
+        self.members = members or {}  # Default member values/types
+        self.methods = methods or {}  # Method AST nodes
+        self.constructor = constructor  # Constructor AST node
+
+    def __repr__(self):
+        return f"<CSSLClass '{self.name}' with {len(self.methods)} methods>"
+
+
+class CSSLInstance:
+    """Represents an instance of a CSSL class.
+
+    Holds instance member values and provides access to class methods.
+    Supports this-> member access pattern.
+    """
+
+    def __init__(self, class_def: CSSLClass):
+        self._class = class_def
+        self._members: Dict[str, Any] = {}
+        # Initialize members with defaults from class definition
+        for name, default in class_def.members.items():
+            if isinstance(default, dict):
+                # Type declaration with optional default
+                member_type = default.get('type')
+                member_default = default.get('default')
+
+                if member_default is not None:
+                    self._members[name] = member_default
+                elif member_type:
+                    # Create instance of container types
+                    self._members[name] = self._create_default_for_type(member_type)
+                else:
+                    self._members[name] = None
+            else:
+                self._members[name] = default
+
+    def _create_default_for_type(self, type_name: str) -> Any:
+        """Create a default value for a given type name."""
+        # Container types
+        if type_name == 'map':
+            return Map()
+        elif type_name in ('stack',):
+            return Stack()
+        elif type_name in ('vector',):
+            return Vector()
+        elif type_name in ('array',):
+            return Array()
+        elif type_name in ('list',):
+            return List()
+        elif type_name in ('dictionary', 'dict'):
+            return Dictionary()
+        elif type_name == 'datastruct':
+            return DataStruct()
+        elif type_name == 'dataspace':
+            return DataSpace()
+        elif type_name == 'shuffled':
+            return Shuffled()
+        elif type_name == 'iterator':
+            return Iterator()
+        elif type_name == 'combo':
+            return Combo()
+        # Primitive types
+        elif type_name == 'int':
+            return 0
+        elif type_name == 'float':
+            return 0.0
+        elif type_name == 'string':
+            return ""
+        elif type_name == 'bool':
+            return False
+        elif type_name == 'json':
+            return {}
+        return None
+
+    def get_member(self, name: str) -> Any:
+        """Get member value by name"""
+        if name in self._members:
+            return self._members[name]
+        raise AttributeError(f"'{self._class.name}' has no member '{name}'")
+
+    def set_member(self, name: str, value: Any) -> None:
+        """Set member value by name"""
+        self._members[name] = value
+
+    def has_member(self, name: str) -> bool:
+        """Check if member exists"""
+        return name in self._members
+
+    def get_method(self, name: str) -> Any:
+        """Get method AST node by name"""
+        if name in self._class.methods:
+            return self._class.methods[name]
+        raise AttributeError(f"'{self._class.name}' has no method '{name}'")
+
+    def has_method(self, name: str) -> bool:
+        """Check if method exists"""
+        return name in self._class.methods
+
+    def __getattr__(self, name: str) -> Any:
+        """Allow direct attribute access for members"""
+        if name.startswith('_'):
+            raise AttributeError(name)
+        if name in self._members:
+            return self._members[name]
+        raise AttributeError(f"'{self._class.name}' has no member '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Allow direct attribute setting for members"""
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            if hasattr(self, '_members'):
+                self._members[name] = value
+            else:
+                object.__setattr__(self, name, value)
+
+    def __repr__(self):
+        return f"<CSSLInstance of '{self._class.name}'>"
+
+
 __all__ = [
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array', 'List', 'Dictionary',
+    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array', 'List', 'Dictionary', 'Map',
+    'CSSLClass', 'CSSLInstance',
     'create_datastruct', 'create_shuffled', 'create_iterator',
     'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
-    'create_stack', 'create_vector', 'create_array', 'create_list', 'create_dictionary'
+    'create_stack', 'create_vector', 'create_array', 'create_list', 'create_dictionary', 'create_map'
 ]