IncludeCPP 3.4.8__py3-none-any.whl → 3.4.21__py3-none-any.whl

includecpp/core/cssl/cssl_types.py

@@ -64,6 +64,487 @@ 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).
+
+    Standard stack with push/pop operations.
+
+    Usage:
+        stack<string> myStack;
+        myStack.push("Item1");
+        myStack.push("Item2");
+        item = myStack.pop();  # Returns "Item2"
+    """
+
+    def __init__(self, element_type: str = 'dynamic'):
+        super().__init__()
+        self._element_type = element_type
+
+    def push(self, item: Any) -> 'Stack':
+        """Push item onto stack"""
+        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
+
+    def is_empty(self) -> bool:
+        """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.
+
+    Resizable array with efficient random access.
+
+    Usage:
+        vector<int> myVector;
+        myVector.push(1);
+        myVector.push(2);
+        myVector.at(0);  # Returns 1
+    """
+
+    def __init__(self, element_type: str = 'dynamic'):
+        super().__init__()
+        self._element_type = element_type
+
+    def push(self, item: Any) -> 'Vector':
+        """Add item to end"""
+        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):
+            return self[index]
+        return None
+
+    def set(self, index: int, value: Any) -> 'Vector':
+        """Set item at index"""
+        if 0 <= index < len(self):
+            self[index] = value
+        return self
+
+    def size(self) -> int:
+        """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
+
+    def back(self) -> Any:
+        """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.
@@ -356,10 +837,13 @@ class Parameter:
         parameter.get(1)  # Get second argument
         parameter.count() # Get total argument count
         parameter.all()   # Get all arguments as list
+        parameter.return(value)  # Yield a return value (generator-like)
+        parameter.returns()  # Get all yielded return values
     """
 
     def __init__(self, args: List[Any] = None):
         self._args = args if args is not None else []
+        self._returns: List[Any] = []
 
     def get(self, index: int, default: Any = None) -> Any:
         """Get argument at index, returns default if not found"""
@@ -379,6 +863,27 @@ class Parameter:
         """Check if argument exists at index"""
         return 0 <= index < len(self._args)
 
+    # Using 'return_' to avoid Python keyword conflict
+    def return_(self, value: Any) -> None:
+        """Yield a return value (generator-like behavior).
+
+        Multiple calls accumulate values that can be retrieved via returns().
+        The CSSL runtime will collect these as the exec() return value.
+        """
+        self._returns.append(value)
+
+    def returns(self) -> List[Any]:
+        """Get all yielded return values"""
+        return list(self._returns)
+
+    def clear_returns(self) -> None:
+        """Clear all yielded return values"""
+        self._returns.clear()
+
+    def has_returns(self) -> bool:
+        """Check if any values have been returned"""
+        return len(self._returns) > 0
+
     def __iter__(self):
         return iter(self._args)
 
@@ -424,15 +929,25 @@ def create_dataspace(space_type: str = 'dynamic') -> DataSpace:
 def create_openquote(db_ref: Any = None) -> OpenQuote:
     return OpenQuote(db_ref)
 
+def create_stack(element_type: str = 'dynamic') -> Stack:
+    return Stack(element_type)
 
-__all__ = [
-    'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter',
-    'create_datastruct', 'create_shuffled', 'create_iterator',
-    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter'
-]
-
+def create_vector(element_type: str = 'dynamic') -> Vector:
+    return Vector(element_type)
 
 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', 'Array',
+    'create_datastruct', 'create_shuffled', 'create_iterator',
+    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
+    'create_stack', 'create_vector', 'create_array'
+]