IncludeCPP 3.4.10__py3-none-any.whl → 3.5.0__py3-none-any.whl

includecpp/core/cssl/cssl_types.py

@@ -64,6 +64,14 @@ class DataStruct(list):
             return target_type(self[0])
         return None
 
+    def begin(self) -> int:
+        """Return iterator to beginning (C++ style)"""
+        return 0
+
+    def end(self) -> int:
+        """Return iterator to end (C++ style)"""
+        return len(self)
+
 
 class Stack(list):
     """Stack data structure (LIFO).
@@ -86,6 +94,11 @@ class Stack(list):
         self.append(item)
         return self
 
+    def push_back(self, item: Any) -> 'Stack':
+        """Push item onto stack (alias for push)"""
+        self.append(item)
+        return self
+
     def peek(self) -> Any:
         """View top item without removing"""
         return self[-1] if self else None
@@ -94,10 +107,53 @@ class Stack(list):
         """Check if stack is empty"""
         return len(self) == 0
 
+    def isEmpty(self) -> bool:
+        """Check if stack is empty (camelCase alias)"""
+        return len(self) == 0
+
     def size(self) -> int:
         """Return stack size"""
         return len(self)
 
+    def length(self) -> int:
+        """Return stack length (alias for size)"""
+        return len(self)
+
+    def contains(self, item: Any) -> bool:
+        """Check if stack contains item"""
+        return item in self
+
+    def indexOf(self, item: Any) -> int:
+        """Find index of item (-1 if not found)"""
+        try:
+            return self.index(item)
+        except ValueError:
+            return -1
+
+    def toArray(self) -> list:
+        """Convert stack to array"""
+        return list(self)
+
+    def swap(self) -> 'Stack':
+        """Swap top two elements"""
+        if len(self) >= 2:
+            self[-1], self[-2] = self[-2], self[-1]
+        return self
+
+    def dup(self) -> 'Stack':
+        """Duplicate top element"""
+        if self:
+            self.append(self[-1])
+        return self
+
+    def begin(self) -> int:
+        """Return iterator to beginning (C++ style)"""
+        return 0
+
+    def end(self) -> int:
+        """Return iterator to end (C++ style)"""
+        return len(self)
+
 
 class Vector(list):
     """Dynamic array (vector) data structure.
@@ -120,6 +176,24 @@ class Vector(list):
         self.append(item)
         return self
 
+    def push_back(self, item: Any) -> 'Vector':
+        """Add item to end (alias for push)"""
+        self.append(item)
+        return self
+
+    def push_front(self, item: Any) -> 'Vector':
+        """Add item to front"""
+        self.insert(0, item)
+        return self
+
+    def pop_back(self) -> Any:
+        """Remove and return last element"""
+        return self.pop() if self else None
+
+    def pop_front(self) -> Any:
+        """Remove and return first element"""
+        return self.pop(0) if self else None
+
     def at(self, index: int) -> Any:
         """Get item at index"""
         if 0 <= index < len(self):
@@ -136,10 +210,18 @@ class Vector(list):
         """Return vector size"""
         return len(self)
 
+    def length(self) -> int:
+        """Return vector length (alias for size)"""
+        return len(self)
+
     def empty(self) -> bool:
         """Check if vector is empty"""
         return len(self) == 0
 
+    def isEmpty(self) -> bool:
+        """Check if vector is empty (camelCase alias)"""
+        return len(self) == 0
+
     def front(self) -> Any:
         """Get first element"""
         return self[0] if self else None
@@ -148,6 +230,321 @@ class Vector(list):
         """Get last element"""
         return self[-1] if self else None
 
+    def contains(self, item: Any) -> bool:
+        """Check if vector contains item"""
+        return item in self
+
+    def indexOf(self, item: Any) -> int:
+        """Find index of item (-1 if not found)"""
+        try:
+            return self.index(item)
+        except ValueError:
+            return -1
+
+    def lastIndexOf(self, item: Any) -> int:
+        """Find last index of item (-1 if not found)"""
+        for i in range(len(self) - 1, -1, -1):
+            if self[i] == item:
+                return i
+        return -1
+
+    def find(self, predicate: Callable[[Any], bool]) -> Any:
+        """Find first item matching predicate"""
+        for item in self:
+            if callable(predicate) and predicate(item):
+                return item
+            elif item == predicate:
+                return item
+        return None
+
+    def findIndex(self, predicate: Callable[[Any], bool]) -> int:
+        """Find index of first item matching predicate"""
+        for i, item in enumerate(self):
+            if callable(predicate) and predicate(item):
+                return i
+            elif item == predicate:
+                return i
+        return -1
+
+    def slice(self, start: int, end: int = None) -> 'Vector':
+        """Return slice of vector"""
+        if end is None:
+            result = Vector(self._element_type)
+            result.extend(self[start:])
+        else:
+            result = Vector(self._element_type)
+            result.extend(self[start:end])
+        return result
+
+    def join(self, separator: str = ',') -> str:
+        """Join elements into string"""
+        return separator.join(str(item) for item in self)
+
+    def map(self, func: Callable[[Any], Any]) -> 'Vector':
+        """Apply function to all elements"""
+        result = Vector(self._element_type)
+        result.extend(func(item) for item in self)
+        return result
+
+    def filter(self, predicate: Callable[[Any], bool]) -> 'Vector':
+        """Filter elements by predicate"""
+        result = Vector(self._element_type)
+        result.extend(item for item in self if predicate(item))
+        return result
+
+    def forEach(self, func: Callable[[Any], None]) -> 'Vector':
+        """Execute function for each element"""
+        for item in self:
+            func(item)
+        return self
+
+    def toArray(self) -> list:
+        """Convert to plain list"""
+        return list(self)
+
+    def fill(self, value: Any, start: int = 0, end: int = None) -> 'Vector':
+        """Fill range with value"""
+        if end is None:
+            end = len(self)
+        for i in range(start, min(end, len(self))):
+            self[i] = value
+        return self
+
+    def every(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if all elements match predicate"""
+        return all(predicate(item) for item in self)
+
+    def some(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if any element matches predicate"""
+        return any(predicate(item) for item in self)
+
+    def reduce(self, func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
+        """Reduce vector to single value"""
+        from functools import reduce as py_reduce
+        if initial is None:
+            return py_reduce(func, self)
+        return py_reduce(func, self, initial)
+
+    def begin(self) -> int:
+        """Return iterator to beginning (C++ style)"""
+        return 0
+
+    def end(self) -> int:
+        """Return iterator to end (C++ style)"""
+        return len(self)
+
+
+class Array(list):
+    """Array data structure with CSSL methods.
+
+    Standard array with push/pop/length operations.
+
+    Usage:
+        array<string> arr;
+        arr.push("Item");
+        arr.length();  # Returns 1
+    """
+
+    def __init__(self, element_type: str = 'dynamic'):
+        super().__init__()
+        self._element_type = element_type
+
+    def push(self, item: Any) -> 'Array':
+        """Add item to end"""
+        self.append(item)
+        return self
+
+    def push_back(self, item: Any) -> 'Array':
+        """Add item to end (alias for push)"""
+        self.append(item)
+        return self
+
+    def push_front(self, item: Any) -> 'Array':
+        """Add item to front"""
+        self.insert(0, item)
+        return self
+
+    def pop_back(self) -> Any:
+        """Remove and return last element"""
+        return self.pop() if self else None
+
+    def pop_front(self) -> Any:
+        """Remove and return first element"""
+        return self.pop(0) if self else None
+
+    def at(self, index: int) -> Any:
+        """Get item at index"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
+    def set(self, index: int, value: Any) -> 'Array':
+        """Set item at index"""
+        if 0 <= index < len(self):
+            self[index] = value
+        return self
+
+    def size(self) -> int:
+        """Return array size"""
+        return len(self)
+
+    def length(self) -> int:
+        """Return array length"""
+        return len(self)
+
+    def empty(self) -> bool:
+        """Check if array is empty"""
+        return len(self) == 0
+
+    def isEmpty(self) -> bool:
+        """Check if array is empty (camelCase alias)"""
+        return len(self) == 0
+
+    def first(self) -> Any:
+        """Get first element"""
+        return self[0] if self else None
+
+    def last(self) -> Any:
+        """Get last element"""
+        return self[-1] if self else None
+
+    def contains(self, item: Any) -> bool:
+        """Check if array contains item"""
+        return item in self
+
+    def indexOf(self, item: Any) -> int:
+        """Find index of item (-1 if not found)"""
+        try:
+            return self.index(item)
+        except ValueError:
+            return -1
+
+    def lastIndexOf(self, item: Any) -> int:
+        """Find last index of item (-1 if not found)"""
+        for i in range(len(self) - 1, -1, -1):
+            if self[i] == item:
+                return i
+        return -1
+
+    def find(self, predicate: Callable[[Any], bool]) -> Any:
+        """Find first item matching predicate"""
+        for item in self:
+            if callable(predicate) and predicate(item):
+                return item
+            elif item == predicate:
+                return item
+        return None
+
+    def findIndex(self, predicate: Callable[[Any], bool]) -> int:
+        """Find index of first item matching predicate"""
+        for i, item in enumerate(self):
+            if callable(predicate) and predicate(item):
+                return i
+            elif item == predicate:
+                return i
+        return -1
+
+    def slice(self, start: int, end: int = None) -> 'Array':
+        """Return slice of array"""
+        if end is None:
+            result = Array(self._element_type)
+            result.extend(self[start:])
+        else:
+            result = Array(self._element_type)
+            result.extend(self[start:end])
+        return result
+
+    def join(self, separator: str = ',') -> str:
+        """Join elements into string"""
+        return separator.join(str(item) for item in self)
+
+    def map(self, func: Callable[[Any], Any]) -> 'Array':
+        """Apply function to all elements"""
+        result = Array(self._element_type)
+        result.extend(func(item) for item in self)
+        return result
+
+    def filter(self, predicate: Callable[[Any], bool]) -> 'Array':
+        """Filter elements by predicate"""
+        result = Array(self._element_type)
+        result.extend(item for item in self if predicate(item))
+        return result
+
+    def forEach(self, func: Callable[[Any], None]) -> 'Array':
+        """Execute function for each element"""
+        for item in self:
+            func(item)
+        return self
+
+    def toArray(self) -> list:
+        """Convert to plain list"""
+        return list(self)
+
+    def fill(self, value: Any, start: int = 0, end: int = None) -> 'Array':
+        """Fill range with value"""
+        if end is None:
+            end = len(self)
+        for i in range(start, min(end, len(self))):
+            self[i] = value
+        return self
+
+    def every(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if all elements match predicate"""
+        return all(predicate(item) for item in self)
+
+    def some(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if any element matches predicate"""
+        return any(predicate(item) for item in self)
+
+    def reduce(self, func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
+        """Reduce array to single value"""
+        from functools import reduce as py_reduce
+        if initial is None:
+            return py_reduce(func, self)
+        return py_reduce(func, self, initial)
+
+    def concat(self, *arrays) -> 'Array':
+        """Concatenate with other arrays"""
+        result = Array(self._element_type)
+        result.extend(self)
+        for arr in arrays:
+            result.extend(arr)
+        return result
+
+    def flat(self, depth: int = 1) -> 'Array':
+        """Flatten nested arrays"""
+        result = Array(self._element_type)
+        for item in self:
+            if isinstance(item, (list, Array)) and depth > 0:
+                if depth == 1:
+                    result.extend(item)
+                else:
+                    nested = Array(self._element_type)
+                    nested.extend(item)
+                    result.extend(nested.flat(depth - 1))
+            else:
+                result.append(item)
+        return result
+
+    def unique(self) -> 'Array':
+        """Return array with unique elements"""
+        result = Array(self._element_type)
+        seen = set()
+        for item in self:
+            key = item if isinstance(item, (int, str, float, bool)) else id(item)
+            if key not in seen:
+                seen.add(key)
+                result.append(item)
+        return result
+
+    def begin(self) -> int:
+        """Return iterator to beginning (C++ style)"""
+        return 0
+
+    def end(self) -> int:
+        """Return iterator to end (C++ style)"""
+        return len(self)
+
 
 class Shuffled(list):
     """Unorganized fast storage for multiple returns.
@@ -542,11 +939,15 @@ def create_parameter(args: List[Any] = None) -> Parameter:
     """Create a Parameter object for accessing exec arguments"""
     return Parameter(args)
 
+def create_array(element_type: str = 'dynamic') -> Array:
+    """Create an Array object"""
+    return Array(element_type)
+
 
 __all__ = [
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter', 'Stack', 'Vector',
+    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array',
     'create_datastruct', 'create_shuffled', 'create_iterator',
     'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
-    'create_stack', 'create_vector'
+    'create_stack', 'create_vector', 'create_array'
 ]