A navigable reference for the public nxpp surface, focused on signatures, result shapes, and header-level behavior notes.

This site is the declaration-driven API reference for nxpp. Use it when you need to answer concrete questions such as:

• which header owns a helper or method
• what a result wrapper contains
• which overloads are public and how they are named
• which API path is precise versus convenience-oriented in multigraph mode
• where a helper lives in the semantic-header split under include/nxpp/

Use the longer markdown guides in docs/ when you want policy, rationale, packaging guidance, or curated usage notes rather than declaration-level facts.

Start here

If you are new to the generated reference, the fastest path is usually:

1. start with nxpp::Graph and the Graph Core module
2. jump to one semantic module such as Shortest Paths or Flow and Cut
3. open the matching companion guide if you need curated tables or policy notes
4. return to the declaration pages for exact signatures and result shapes

Reader paths

• learning the library for the first time: start with nxpp::Graph, then the Graph Core module
• looking up one algorithm family: jump straight to a semantic module such as Shortest Paths, Flow and Cut, or Centrality
• looking up one result wrapper: use the wrapper links below, which now include short embedded usage examples
• looking for policy or rationale: leave the generated pages and open the companion markdown guides

Use this site for

• public class and function signatures
• inline API documentation taken directly from the headers
• concrete return types and result wrappers
• namespace, type, and member navigation

Common starting points

• learning the main wrapper type: nxpp::Graph
• finding the broad public API companion tables: API Reference
• checking where a helper belongs architecturally: API Architecture
• understanding the current external-consumption paths: External Usage
• checking verification guidance and test layers: Testing Guide

Companion guides

• API Reference: public API tables and syntax notes
• API Architecture: placement policy for methods and helpers
• Complexity Guide: complexity policy and wrapper cost model
• External Usage: integration paths and compile guidance
• Testing Guide: verification layers and local test commands

If you arrive here from GitHub Pages and need more explanation than raw declaration comments usually provide, the usual next hop is one of those companion guides rather than a deeper symbol index page.

Main entry points

• include/nxpp.hpp: umbrella include for the whole library
• include/nxpp/graph.hpp: core graph type, aliases, and wrapper surface
• include/nxpp/traversal.hpp: BFS / DFS helpers and visitor APIs
• include/nxpp/shortest_paths.hpp: shortest-path wrappers and result types
• include/nxpp/flow.hpp: flow, cut, and min-cost helpers
• include/nxpp/centrality.hpp: centrality helpers such as degree_centrality() and pagerank()
• include/nxpp/generators.hpp: graph generators

Frequently used result wrappers

• SingleSourceShortestPathResult: distances, predecessors, and path reconstruction helpers
• MaximumFlowResult: max-flow value plus endpoint and edge_id flow views
• MinCostMaxFlowResult: max-flow plus cost and precise per-edge flow views
• MinimumCutResult: cut value, partition, endpoint cut view, and precise cut-edge IDs

The declaration pages for those wrappers now also include short embedded usage examples, so they can serve as both shape reference and small result-oriented example pages inside the generated site.

Library modules

• Graph Core: main graph type, aliases, and proxy surface
• Attributes: attribute-oriented helpers and wrapper methods
• Multigraph: precise edge_id-based multigraph helpers
• Traversal: BFS / DFS helpers and visitors
• Shortest Paths: shortest-path wrappers and result types
• Components: connected-component and SCC helpers
• Spanning and Ordering: MST and topological-sort helpers
• Flow and Cut: flow, cut, and min-cost-flow helpers
• Centrality: degree, PageRank, and betweenness centrality
• Generators: graph-construction helpers
• 2-SAT: 2-SAT utilities

Practical navigation tips

• use the module pages first if you are browsing by problem area
• use the file pages if you already know the semantic header you care about
• use the class/struct pages when you want the exact shape of a result wrapper
• use the companion markdown guides when you need policy, caveats, or curated examples that would be too long for declaration comments

Published-site note

The GitHub Pages version of this site is meant to feel like a small formal reference portal, not only a raw symbol dump. The theme and layout now put more weight on module navigation, wrapper discovery, and readable declaration pages while still keeping the public headers as the source of truth.

Generated-reference scope

This generated site is intentionally focused on the public reference surface. It is meant to complement the longer markdown guides, not replace them. The root README.md remains the overview page for the repository, while this Doxygen site is the authoritative declaration-level reference for the current public API.