| Nalgotradelib | The library: broker-neutral types (core), and the modules below |
| Nanalytics | Returns, rolling statistics, indicators and performance metrics over numeric series |
| CBollingerBands | The three lines of Bollinger bands, each as long as the input |
| CMacdLines | The three lines of a MACD, each as long as the input |
| CMaxDrawdown | The worst peak-to-trough decline of a level series, and where it happened |
| CPanel | One bar field across many instruments: one row per instant, one column per instrument |
| CSeriesBuffer | The most recent observations of a few fields, for a strategy fed one bar at a time |
| CSeriesFrame | One instrument's bars as numeric columns: one row per bar, one column per BarField |
| CTimeIndex | The instants a frame's rows correspond to, strictly ascending |
| Nbacktest | Replays a strategy over stored bars: fill and cost models, the replay ledger, and the report |
| CAppliedRate | The commission rate that charged an execution, as the backtest report lists it |
| CBacktester | Replays bars (and quotes) through one strategy, with a ledger and a fill model |
| CBacktestTag | The broker tag of a replay's order references (they reach no broker) |
| CCommissionCharge | What one execution was charged: the broker's commission and the institution fee |
| CCommissionModel | A flat commission: a rate on traded value, with an optional per-execution minimum |
| CCommissionPolicy | How a backtest charges commission: one stated model, or a schedule resolved per execution |
| CEquityPoint | One point on a replay's equity curve, recorded per bar |
| CExecution | One execution a backtest produced, and what it cost |
| CFillDecision | What NextBarFillModel::decide concluded about one order and one bar |
| CNextBarFillModel | The fill model: market orders at the next bar's open, limit orders when the next bar's range reaches them, stop-limit orders once released |
| CQueuedOrder | One order a replay accepted and has not yet filled or withdrawn |
| CQueueingExecutor | The replay's executor: accepts orders and holds them until they fill or are withdrawn |
| CReplayClock | A backtest's clock: the current instant and market phase, moved by the replayed events |
| CReplayConfig | A replay's settings, besides the strategy and the bars |
| CReplayLedger | Positions, cash and realized profit, updated by each execution of a replay |
| CReplayResult | Everything a replay produced; summarize turns it into a Report |
| CReport | The summary of a replay; read halted_ and caveats_ before the figures |
| CReportCaveats | What a replay's figures assumed and did not account for |
| CSellTax | A tax on sales, stated by the caller; see NextBarFillModel::with_sell_tax |
| CSlippageModel | Slippage: how far a fill price moves against the order (a buy pays more, a sell gets less) |
| Nconformance | The compile-time check behind ATL_ASSERT_BROKER(Client) |
| CPlainCallback | A completion handler with no associated executor (a plain callback) |
| CMoveOnlyCallback | A plain callback that cannot be copied |
| Ndata_only | Placeholder types and the refusal used by DataOnlyTraits |
| CNoAccount | The (empty) account a data-only session binds |
| CNoAck | Placeholder order acknowledgement; never produced |
| CNoAmendment | Placeholder amendment; never produced |
| CNoHistoryQuery | Placeholder history query; never produced |
| CNoWorkingOrders | Placeholder working-order listing; never produced |
| Nkis | The Korea Investment & Securities (KIS) Open API client |
| CBroker | The KIS broker tag: order references are typed by it, so a KIS reference works with both KIS clients and with no other broker |
| CKisAccount | A KIS account: the account number and product code every account request names |
| CKisAmendment | An amendment or cancellation of a KIS order |
| CKisAuth | Obtains and caches KIS access tokens and WebSocket approval keys with blocking requests; thread-safe |
| CKisBlockingClient | A blocking KIS client: each call runs a KisClient request on a private event loop and returns its result. Not thread-safe |
| CKisClient | The asynchronous KIS REST client: market data, account inquiries and orders for domestic stocks |
| CKisConfig | KIS credentials (app key and secret), demo or real account, and the market-data tape |
| CKisHistoryRange | The date range of a KIS order-history inquiry, both ends included (Korean dates) |
| CKisOpenOrder | A KIS order that can still be amended or cancelled |
| CKisOpenOrderPage | KIS's list of orders that can still be amended or cancelled |
| CKisOrderAck | KIS's acknowledgement of an accepted order, amendment or cancellation |
| CKisOrderRef | A KIS order's address: branch number and order number, both kept |
| CKisRest | A KIS REST access token and its expiry |
| CKisWebsocket | A KIS WebSocket approval key and when it was issued |
| Nkiwoom | The Kiwoom Securities REST API client |
| CBroker | The Kiwoom broker tag: order references are typed by it, so a Kiwoom reference works with both Kiwoom clients and with no other broker |
| CKiwoomAccount | The Kiwoom account selector, which is empty: no Kiwoom endpoint takes an account number, since the app key determines the account (ka00001 reports which) |
| CKiwoomAccountInfo | One account Kiwoom's ka00001 reports for the bound credential |
| CKiwoomAmendment | An amendment or cancellation of a Kiwoom order |
| CKiwoomAuth | Obtains and caches a Kiwoom access token with blocking requests; thread-safe |
| CKiwoomBlockingClient | A blocking Kiwoom client: each call runs a KiwoomClient request on a private event loop and returns its result. Not thread-safe. Order references work with either client |
| CKiwoomClient | The asynchronous Kiwoom REST client: market data, account inquiries and orders for domestic stocks |
| CKiwoomConfig | Kiwoom credentials (app key and secret key), demo or real account, the market-data tape, and the holdings settings an account must state before trading |
| CKiwoomDeposit | Kiwoom's deposit detail (kt00001), as reported; buying_power reads spendable_ from it, and the rest is reachable through session.client() |
| CKiwoomHistoryQuery | A Kiwoom order-history query: one date (kt00007 takes no range, so a multi-day query is refused) |
| CKiwoomMarginTier | One margin tier of Kiwoom's kt00010 answer: what may be ordered at that 증거금률 |
| CKiwoomOpenOrder | One Kiwoom order that is still open to modification or cancellation |
| CKiwoomOpenOrderPage | One page of Kiwoom orders that remain modifiable or cancellable |
| CKiwoomOrderableAmount | What may be ordered of one instrument, per margin tier (kt00010), reachable through session.client() |
| CKiwoomOrderAck | Kiwoom's acknowledgement of an accepted order, amendment or cancellation |
| CKiwoomOrderRef | A Kiwoom order's address: order number and symbol, both of which amendments and cancellations require |
| CKiwoomOrderShapeRow | One row of Kiwoom's order-type table: the numeric request code, the Korean names its listings report, and the normalized shape |
| CKiwoomRest | A Kiwoom REST access token (au10001's token) and its expiry (expires_dt) |
| Nlive | Connects a runner to a broker session for live trading |
| CSessionExecutor | The executor that sends a runner's orders and cancellations through a broker session |
| CSessionSource | The source a runner::PollingLoop polls: reads a broker session and feeds bars, quotes, holdings, orders, buying power, price bands and the calendar to a runner |
| CObservedFigure | One charge figure of one order, and the filled quantity it was recorded at |
| CObservedCharge | One order's stated charges, as last recorded |
| Nmath | The numeric vocabulary: Scalar, missing(), and the matrix and vector types |
| CObserved | A series split into zero-filled values and a presence mask, for sums that skip gaps |
| Nnetwork | HTTP and WebSocket transport, OAuth tokens, and request pacing |
| CAsyncHttpClient | An asynchronous HTTP/1.1 client over TLS that keeps one connection to one host, used by the broker clients |
| CAuthBody | An OAuth access token and its expiry, the base of each broker's token-response class |
| CBasicRateLimitBucket | A rate limiter (the generic cell rate algorithm) that computes when a request may go; it neither waits nor reads the clock itself |
| CClientCredentials | OAuth client credentials (an app key and secret), the base of each broker's credentials class |
| CHttpClient | A blocking HTTP/1.1 client over TLS that keeps one connection to one host |
| CHttpClientOptions | Deadlines, size limits and pacing for an HTTP client |
| CHttpRequest | An HTTP request for AsyncHttpClient |
| CRateLimitBudget | The request rate a connection may use |
| CRateLimitController | The rate limiter of one connection (one app key): a RateLimitBucket on the steady clock, plus counters |
| CRateLimitGroupStats | A rate limiter's counters for one traffic class |
| CRateLimitStats | A rate limiter's counters per traffic class, its current budget, and the broker's refusals (from RateLimitController::stats) |
| CWebSocketSessionBase | The base of the WebSocket clients WsSession and WssSession: connecting, sending, receiving, closing and reconnecting |
| CWebSocketSessionOptions | Options for a WebSocket session (WsSession, WssSession) |
| CWsSession | A WebSocket client over plain TCP (no TLS); derive from it and override on_message |
| CWssSession | A WebSocket client over TLS; derive from it and override on_message |
| Nrunner | Runs a strategy: the runner, the polling loop, the order journal, and stopping |
| CBarEvent | One bar, delivered to on_bar |
| CBrokerRefusal | The broker's own code and message for a refusal, kept for diagnosis |
| CCancelIntent | A request to cancel one working order |
| CChargedCosts | Commission and tax the broker stated on the orders a loop happened to poll (Toss states them; KIS does not) |
| CStatedTotal | One currency's running figure and how many statements contributed to it |
| CClockReference | A clock that reads another one, so that two holders (a loop and its journal) read one time |
| CContext | What a strategy's handlers receive as ctx: everything the strategy may read, and where it queues what it wants |
| CLog | A log that keeps lines in memory for the runner to emit or a test to read |
| CDryRunReport | What one runner pass decided and did, sorted by outcome (returned by Runner::feed) |
| CDryTag | The broker tag of a dry run, whose order references reach no broker |
| CFailurePolicy | How a PollingLoop responds to polls that keep failing |
| CFileJournal | The order journal on disk: one JSON object per line, appended and flushed to disk (fsync) before append returns |
| CFileStopChannel | A control file an operator writes to stop a running loop with a given intent |
| CFill | One execution of an order the strategy placed, delivered to on_fill |
| CIndeterminacyLedger | The instruments with an order of unknown outcome, where nothing may be placed until the broker's order list is read and the instrument resolved |
| CIterationReport | What one loop iteration did |
| CJournalBytes | A journal file's bytes, and whether they could be read |
| CJournalEntry | One journal line: an instruction and what was known about it when the line was written |
| CJournalingExecutor | An executor wrapper that records each instruction in a journal before sending it |
| CJournalReplay | The contents of a journal, including what could not be read |
| CLoopReport | What a whole PollingLoop::run did, and why it ended |
| CManualClock | A clock for tests: wait_for advances it instead of sleeping |
| CManualSource | A source for tests: each poll returns a queued or default outcome, without any network |
| CMatchWindow | The time allowances used when matching journalled instructions against a broker listing |
| CMemoryJournal | A journal held in memory, lost when the process exits; for tests and dry runs |
| CObligation | One order a serialized runner still owes (Runner::obligations) |
| COpenInstruction | One instruction of unknown outcome, and the span in which it may have reached the broker |
| COrderIntent | One order a strategy asks the runner to place |
| COrderMatch | One instruction's verdict, with context for the operator |
| COrderUpdateWatch | Turns successive working-order listings into order updates: the rows that changed since the previous listing |
| CPollingLoop | Runs a runner for a live session: polls a source on a schedule, gates placements, derives the market phase, and honours stop requests |
| CPollSchedule | How often a PollingLoop polls each kind; an unset interval disables that poll |
| CPortfolio | What the account holds and which orders are still working, as a strategy sees it |
| CSellableReading | A sellable quantity together with what it covers, read from the same row |
| CQuoteEvent | A quote the runner has just read, delivered to on_quote |
| CReconcileReport | What one sweep of the broker's order list settled, and what is still withheld |
| CRecordingExecutor | An executor that sends nothing and records what it was given (the dry run's default) |
| CRecoveryReport | What a journal showed was left owed by the process that wrote it |
| CRefusedCancel | A cancellation a hold refused (nothing was sent), and which hold |
| CRejectedCancel | A cancellation that was refused, by the broker or before it was sent |
| CRunner | Runs one strategy: feeds it events, reconciles what it asks for, checks the risk limits, and sends through an executor |
| Crunner_counts_kept_drops | Detects whether a runner reports kept_intents_dropped() |
| Crunner_counts_kept_drops< Runner, std::void_t< decltype(std::declval< const Runner & >().kept_intents_dropped())> > | |
| Crunner_counts_warmup | Detects whether a runner reports warmup_instructions_discarded() |
| Crunner_counts_warmup< Runner, std::void_t< decltype(std::declval< const Runner & >().warmup_instructions_discarded())> > | |
| Crunner_keeps_sent_orders | Detects Runner::keeps_sent_orders_until_listed |
| Crunner_keeps_sent_orders< Runner, std::void_t< decltype(Runner::keeps_sent_orders_until_listed)> > | |
| CSeriesKey | Identifies one cached bar series: an instrument at one bar interval |
| CSignalStop | Routes SIGINT and SIGTERM to a StopSource as a quiesce, and ignores SIGHUP where it exists (POSIX); only when install is called |
| Csource_names_buying_power_currencies | Detects whether a source provides const std::vector<Currency>& buying_power_currencies()
const |
| Csource_names_buying_power_currencies< Source, std::void_t< decltype(std::declval< const Source & >().buying_power_currencies())> > | |
| Csource_provides_working_orders | Detects whether a source declares static constexpr bool provides_working_orders = true, meaning it leaves the broker's working orders in the portfolio after an order-list read |
| Csource_provides_working_orders< Source, std::void_t< decltype(Source::provides_working_orders)> > | |
| Csource_states_charged_costs | Detects whether a source provides const ChargedCosts& charged_costs() const, which LoopReport then reports |
| Csource_states_charged_costs< Source, std::void_t< decltype(std::declval< const Source & >().charged_costs())> > | |
| CSteadyClock | The real clock a live loop uses: wall-clock time to stamp events, monotonic time to wait and to measure how long something took |
| CStopSource | A stop request the loop polls; safe to set from a signal handler |
| CTargetPosition | The position a strategy wants to hold in one instrument |
| CWithheldOrder | One order the runner held back without sending, and why |
| CWithheldPlan | One reconciliation plan the runner held back, and what it would have done |
| Nstrategy | What a strategy sees and emits: events, intents, the portfolio, reconciliation and risk limits |
| Nvanilla | The strategies this library ships (buy and hold, crossovers, mean reversion, sizing, liquidation) |
| CBuyAndHold | Holds a fixed quantity of one instrument |
| CParams | The strategy's settings |
| CCrossing | The last two values of an indicator line, for testing a crossing |
| CDonchianBreakout | Donchian channel breakout: holds after the close breaks above the channel, exits after it breaks below |
| CParams | The strategy's settings |
| CEmaCrossover | MovingAverageCrossover with exponential averages |
| CEqualWeightRebalance | Holds an equal fraction of portfolio value in each instrument of a universe |
| CParams | The strategy's settings |
| CMovingAverageCrossover | Holds quantity_ shares while the fast moving average is above the slow one, and is flat otherwise |
| CParams | The strategy's settings |
| CRsiThreshold | Long-only RSI strategy: buys when the index is oversold, sells when it is overbought |
| CParams | The strategy's settings |
| CSmaCrossover | MovingAverageCrossover with simple averages |
| CTimedLiquidation | Flattens every position when the market enters a phase it should not hold through |
| CParams | The strategy's settings |
| CVolatilityTargetSizing | Holds a long position sized so its value volatility per bar matches a risk budget |
| CParams | The strategy's settings |
| CZScoreReversion | Long-only mean reversion on the z-score of the close |
| CParams | The strategy's settings |
| CAllCaps | A capability set in which the broker implements everything optional |
| CBarEvent | One bar, delivered to on_bar |
| CBarSlice | Every instrument's bar of one interval for one period end, delivered to on_bars |
| CCancelIntent | A request to cancel one working order |
| CFill | One execution of an order the strategy placed, delivered to on_fill |
| CGuardDecision | What RiskGuard::evaluate concluded about one order |
| CGuardInputs | What RiskGuard::check needs besides the order and the portfolio |
| CGuardRejection | One order a guard refused, with the limit and the value that exceeded it |
| CInstrumentBasis | An instrument's currency and the price to value it at, for the exposure ceiling |
| CNoCaps | A capability set in which the broker implements nothing optional |
| COrderIntent | One order a strategy asks the runner to place |
| CPlan | What to send: first every cancellation, then every placement |
| CPlannedOrder | One order the runner is to place |
| CPortfolio | What the account holds and which orders are still working, as a strategy sees it |
| CSellableReading | A sellable quantity together with what it covers, read from the same row |
| CPrice | A price known to be on its instrument's tick grid |
| CProbeBroker | The broker tag of a probe context; nothing it issues reaches a market |
| CProbeContextT | A context for testing a strategy without a runner: it records what the strategy asks for |
| CLog | A log that keeps each line in memory for a test to read |
| CQuoteEvent | A quote the runner has just read, delivered to on_quote |
| CReconcileInputs | What reconciliation needs besides the intent and the portfolio; the runner fills it in |
| CRejection | One instruction that was not placed, and why |
| CRiskGuard | Checks planned orders against RiskLimits, holds trading stopped, and counts orders sent |
| CRiskLimits | The limits the operator sets for RiskGuard |
| CSellableConventionProbe | Infers a broker's SellableConvention from successive portfolios |
| CSellableEvidence | How many observations supported each answer |
| CSessionWindow | The intraday session of a market, as the operator states it |
| CSizeSpec | How much an OrderIntent trades: a quantity, a notional amount, or a target weight |
| CStrategyConformance | The checks behind ATL_ASSERT_STRATEGY; instantiating it reports what is wrong with S |
| CTargetPosition | The position a strategy wants to hold in one instrument |
| CTradeTolerance | How small a difference from a target is not worth an order |
| CWeightTarget | The result of weight_target: a target position or a refusal, exactly one of them |
| Ntossinvest | The Toss Securities Open API client |
| CBroker | The Toss Securities broker tag: order references are typed by it, so a Toss reference works with both Toss clients and with no other broker |
| CTossAccount | A Toss account, as account discovery (async_accounts) returns it |
| CTossAmendment | An amendment of a Toss order: a new price, and for a Korean order a new quantity |
| CTossAuth | Obtains and caches a Toss access token with blocking requests; thread-safe |
| CTossBlockingClient | Blocking facade that drives TossClient on a private event loop |
| CTossClient | The asynchronous Toss Securities REST client: market data, accounts and orders |
| CTossConfig | Toss Securities credentials (client id and secret). Toss has no demo environment |
| CTossOrderQuery | A Toss order-listing query |
| CTossRest | A Toss REST access token and its expiry |
| CAccountInfo | One account from a broker's account list |
| CAmendInstruction | A modification or cancellation of a working order |
| CBar | One bar: the prices and volume of one period, as exact decimals |
| CBarQuery | What bars to fetch |
| CBarSeries | The bars of one instrument and interval, oldest first |
| CBlockingSession | A blocking broker client bound to one account, with the same broker operations as BrokerSession, plus accounts() |
| CBrokerCaps | What one broker client implements, as compile-time constants |
| CBrokerError | The error a broker or transport operation returns |
| CBrokerSession | An asynchronous broker client bound to one account, with broker-neutral operations |
| CBrokerTraits | Describes one broker client to the library: its types, capabilities, call thunks and normalizers |
| CBrokerTraits< kis::KisBlockingClient > | The BlockingSession adapter for kis::KisBlockingClient |
| CBrokerTraits< kis::KisClient > | The BrokerSession adapter for kis::KisClient |
| CBrokerTraits< kiwoom::KiwoomBlockingClient > | The BlockingSession adapter for kiwoom::KiwoomBlockingClient |
| CBrokerTraits< kiwoom::KiwoomClient > | The BrokerSession adapter for kiwoom::KiwoomClient |
| CBrokerTraits< tossinvest::TossBlockingClient > | The BlockingSession adapter for tossinvest::TossBlockingClient |
| CBrokerTraits< tossinvest::TossClient > | The BrokerSession adapter for tossinvest::TossClient |
| CBuyingPower | What the broker says may be spent, in one currency |
| CCode | A short uppercase code (letters, digits, _), stored inline without allocation |
| CCommissionRate | One commission rate, the market and venue it applies to, and the dates it applies on |
| CCommissionSchedule | The commission rates a broker published for an account, or a caller stated |
| CRateSelection | The result of rate_for: a rate, or why there is none |
| CCurrency | A three-letter currency code, such as KRW or USD (ISO 4217 style) |
| CDataOnlyTraits | A base for the BrokerTraits of a market-data client that cannot trade |
| CDate | A calendar date with no time of day or time zone |
| CDecimal64 | An exact signed decimal: an int64 coefficient times 10^-scale |
| CDepthLevel | One price level of an order book |
| CDepthSnapshot | An instrument's order book: resting bids and offers |
| CHoldingPosition | One position row in a holdings snapshot |
| CHoldingsSnapshot | An account's positions and per-currency totals at one point in time |
| CHoldingsTotals | The broker's holdings totals for one currency |
| CInstrument | Reference data for one instrument |
| CInstrumentId | Identifies an instrument: its country, venue and symbol |
| CMarketSegment | The market segment an instrument is listed on, such as KOSPI or NASDAQ |
| CMoney | An exact amount of money in one currency |
| COrderAck | The broker's acknowledgement that it accepted an instruction |
| COrderExecution | What has filled on one order, and what it cost |
| COrderHistoryQuery | The filter for an order-history inquiry |
| COrderPage | One page of an order listing |
| COrderRef | A broker's reference to one order, used to amend or cancel it |
| COrderRequest | An order to place, in broker-neutral form |
| COrderShape | An order's type, price, trigger, time in force and session, as an amendment states them |
| COrderSnapshot | The state of one order, as a broker listing reported it |
| CPlacedOrder | An accepted order: the acknowledgement and the reference to address it with |
| CPriceLimits | The highest and lowest price an instrument may trade at today |
| CPriceRule | The price grid (tick sizes) an instrument's order prices must sit on |
| CQuoteSnapshot | A quote: the last traded price of an instrument at a point in time |
| CResult | Either a value or a BrokerError |
| CSellableBasis | What a sellable quantity covers, and how RiskGuard must treat resting sells against it |
| CStatedDate | A date a broker stated, did not state, or stated in a form that could not be read |
| CTickBand | One band of a price grid: the tick size from a price upward, until the next band |
| CTopOfBook | The best bid and offer, with the size at each. An absent field was not stated, never zero |
| CTradePrint | One executed trade, as the broker reported it |
| CTradingCalendar | The trading days a broker reported for one market, ascending by date |
| CTradingDay | One calendar date and whether the market opens on it |
| CVenueKey | Which venue a commission rate applies to: any venue, a normalized Venue, or a raw code |
| CWorkingOrder | An order still open to modification or cancellation |
| CWorkingOrders | The orders open to modification or cancellation at one point in time |
| Nlive_program | |
| CSettings | What a run is told, gathered so main states it once and a test can state it differently |
| Nstd | |
| Chash< algotradelib::OrderRef< Broker > > | Hashes an order reference, so it can key an unordered container |
1.18.0