Object Pool

from iso8583sim.core.pool import MessagePool
from iso8583sim.core.parser import ISO8583Parser

# Create a pool with 1000 pre-allocated messages
pool = MessagePool(size=1000)

# Create parser with pool
parser = ISO8583Parser(pool=pool)

# Parse messages (objects are recycled)
for raw_message in raw_messages:
    message = parser.parse(raw_message)

    # Process the message...
    process(message)

    # Return message to pool for reuse
    pool.release(message)

from iso8583sim.core.pool import MessagePool
from iso8583sim.core.parser import ISO8583Parser

pool = MessagePool(size=100)
parser = ISO8583Parser(pool=pool)

message = parser.parse(raw)
# ... use message ...
pool.release(message)

with pool.acquire() as message:
    # Configure message
    message.mti = "0100"
    message.fields[2] = "4111111111111111"
    # ... build/process ...
# Automatically released when exiting context

pool = MessagePool(size=1000)
parser = ISO8583Parser(pool=pool)

results = []
for raw in batch:
    msg = parser.parse(raw)
    results.append(process(msg))
    pool.release(msg)

import concurrent.futures

pool = MessagePool(size=1000)
parser = ISO8583Parser(pool=pool)

def process_message(raw):
    msg = parser.parse(raw)
    result = process(msg)
    pool.release(msg)
    return result

with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(process_message, raw_messages))

# Single-threaded processing
pool = MessagePool(size=10)

# Multi-threaded (4 workers)
pool = MessagePool(size=100)

# High-throughput server
pool = MessagePool(size=1000)

pool = MessagePool(size=10)

# Acquire 15 messages
messages = []
for _ in range(15):
    msg = pool.acquire()
    messages.append(msg)

# First 10 from pool, next 5 created new
# Pool automatically expands

pool = MessagePool(size=100)

print(f"Pool size: {pool.size}")
print(f"Available: {pool.available}")
print(f"In use: {pool.in_use}")

# Always release messages when done
message = parser.parse(raw)
try:
    process(message)
finally:
    pool.release(message)

# Use context manager for automatic release
with pool.acquire() as message:
    process(message)

# Don't hold references after release
message = parser.parse(raw)
pool.release(message)
print(message.mti)  # Bad! Message may be reused

# Don't release twice
pool.release(message)
pool.release(message)  # Error or undefined behavior