openswmm::input Namespace Reference

Classes
class	InputReader
	Reads and parses a SWMM .inp file into a SimulationContext. More...
struct	ParsedLine
	One data row together with its associated object comment. More...
class	SectionRegistry
	Registry that maps section tags (e.g., "[JUNCTIONS]") to handlers. More...
class	Tokenizer
	Stateless multi-delimiter tokenizer for SWMM input lines. More...

Typedefs
using	SectionHandler = std::function< void(SimulationContext &, const std::vector< std::string > &)>
	Handler function type for input file sections.

Functions
void	handle_subcatchments (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [SUBCATCHMENTS] into SubcatchData + subcatch_names.
void	handle_subareas (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [SUBAREAS] — Manning's n + depression storage for each subcatch.
void	handle_infiltration (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [INFILTRATION] — Horton/Green-Ampt/CN params per subcatch.
void	handle_raingages (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [RAINGAGES] into GageData + gage_names.
void	handle_controls (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_report (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_files (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse the [FILES] section into ctx.files.
void	handle_evaporation (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [EVAPORATION] into SimulationOptions evap fields.
void	handle_temperature (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [TEMPERATURE] into SimulationOptions temperature/wind/snow fields.
void	handle_snowpacks (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [SNOWPACKS] into SnowpackStore + snowpack_names.
void	handle_aquifers (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [AQUIFERS] into AquiferStore + aquifer_names.
void	handle_groundwater (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [GROUNDWATER] — link subcatchments to aquifers and nodes.
void	handle_gwf (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [GWF] — custom groundwater flow expressions (stored as raw text).
void	handle_lid_controls (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [LID_CONTROLS] into LidControlStore + lid_names.
void	handle_lid_usage (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [LID_USAGE] into LidUsageStore.
void	handle_patterns (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [PATTERNS] into PatternData with continuation-line support.
void	handle_inflows (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [INFLOWS] into ExtInflowData.
void	handle_dwf (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [DWF] into DwfData.
void	handle_rdii (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [RDII] into RDIIAssignData.
void	handle_hydrographs (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [HYDROGRAPHS] into UnitHydData.
void	handle_rdii_decay (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [RDII_DECAY] into RDIIDecayData (exponential IA model).
void	handle_streets (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [STREETS] — fills ctx.streets.
void	handle_inlets (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [INLETS] — fills ctx.inlets.
void	handle_inlet_usage (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [INLET_USAGE] — fills ctx.inlet_usages.
void	handle_adjustments (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [ADJUSTMENTS] — fills climate adjustment arrays.
void	handle_events (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [EVENTS] — fills ctx.events.
void	handle_conduits (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_pumps (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_orifices (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_weirs (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_outlets (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_xsections (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_losses (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_transects (SimulationContext &ctx, const std::vector< std::string > &lines)
void	handle_junctions (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [JUNCTIONS] into NodeData + node_names.
void	handle_outfalls (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [OUTFALLS] — sets outfall-specific fields for nodes of type OUTFALL.
void	handle_dividers (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [DIVIDERS] — sets divider-specific fields.
void	handle_storage (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [STORAGE] — adds storage nodes and their geometry.
void	handle_coordinates (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [COORDINATES] — fills spatial.node_x / node_y.
void	handle_options (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse the [OPTIONS] section into ctx.options.
void	handle_plugins (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [PLUGINS] into ctx.plugin_specs.
void	handle_pollutants (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [POLLUTANTS] into PollutantData + pollutant_names.
void	handle_landuses (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [LANDUSES] into LanduseData + landuse_names.
void	handle_coverages (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [COVERAGES] — land use coverage fractions per subcatchment.
void	handle_buildup (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [BUILDUP] — buildup functions per (landuse x pollutant).
void	handle_washoff (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [WASHOFF] — washoff functions per (landuse x pollutant).
void	handle_treatment (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [TREATMENT] — treatment expressions per (node x pollutant).
void	handle_loadings (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [LOADINGS] — initial pollutant buildup on subcatchments.
void	handle_map (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [MAP] — fills spatial.map_x1/y1/x2/y2 and map_units.
void	handle_vertices (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [VERTICES] — fills spatial.link_vertices_x/y.
void	handle_polygons (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [POLYGONS] — fills spatial.subcatch_polygon_x/y.
void	handle_symbols (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [SYMBOLS] — fills spatial.gage_x/y.
void	handle_tags (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [TAGS] — writes per-index tags onto ctx.nodes.tags / ctx.links.tags / ctx.subcatches.tags (resolves name → idx via the matching NameIndex; unresolved lines are skipped).
void	handle_timeseries (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [TIMESERIES] into TableData + table_names.
void	handle_curves (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [CURVES] into TableData + table_names.
void	handle_title (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [TITLE] into ctx.title_notes.
void	handle_user_flags (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [USER_FLAGS] into ctx.user_flags.
void	handle_user_flag_values (SimulationContext &ctx, const std::vector< std::string > &lines)
	Parse [USER_FLAG_VALUES] into ctx.user_flags (per-object values).
double	to_double (std::string_view sv, double def=0.0) noexcept
	Parse a double from a string_view, returning a default on failure.
int	to_int (std::string_view sv, int def=0) noexcept
	Parse an int from a string_view, returning a default on failure.
double	parse_date (std::string_view sv)
	Parse a date string in MM/DD/YYYY format to a DateTime (decimal days).
double	parse_time_seconds (std::string_view sv)
	Parse a time string to seconds.
double	parse_time_day_fraction (std::string_view sv)
	Parse a time string HH:MM:SS to a fractional day (DateTime).
double	parse_datetime (std::string_view date_sv, std::string_view time_sv)
	Parse a combined date + time pair to a DateTime.
void	resolve_cross_references (SimulationContext &ctx)
	Resolve all cross-references in ctx after all sections are parsed.
std::vector< ParsedLine >	parse_section (const std::vector< std::string > &raw_lines)
	Split raw section lines into (data, comment) pairs.

Typedef Documentation

SectionHandler

using openswmm::input::SectionHandler = typedef std::function<void( SimulationContext&, const std::vector<std::string>& )>

Handler function type for input file sections.

Called once per section with all non-comment, non-empty lines in that section. The handler is responsible for parsing each line and populating the SimulationContext.

Parameters

ctx	Simulation context to populate.
lines	All non-blank, non-comment lines in the section (after comment stripping but before tokenization).

Function Documentation

handle_adjustments()

void openswmm::input::handle_adjustments	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [ADJUSTMENTS] — fills climate adjustment arrays.

Here is the call graph for this function:

handle_aquifers()

void openswmm::input::handle_aquifers	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [AQUIFERS] into AquiferStore + aquifer_names.

Here is the call graph for this function:

Here is the caller graph for this function:

handle_buildup()

void openswmm::input::handle_buildup	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [BUILDUP] — buildup functions per (landuse x pollutant).

Here is the call graph for this function:

handle_conduits()

void openswmm::input::handle_conduits	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_controls()

void openswmm::input::handle_controls	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_coordinates()

void openswmm::input::handle_coordinates	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [COORDINATES] — fills spatial.node_x / node_y.

Here is the call graph for this function:

handle_coverages()

void openswmm::input::handle_coverages	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [COVERAGES] — land use coverage fractions per subcatchment.

Here is the call graph for this function:

handle_curves()

void openswmm::input::handle_curves	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [CURVES] into TableData + table_names.

Here is the call graph for this function:

handle_dividers()

void openswmm::input::handle_dividers	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [DIVIDERS] — sets divider-specific fields.

Here is the call graph for this function:

handle_dwf()

void openswmm::input::handle_dwf	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [DWF] into DwfData.

Here is the call graph for this function:

handle_evaporation()

void openswmm::input::handle_evaporation	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [EVAPORATION] into SimulationOptions evap fields.

Here is the call graph for this function:

Here is the caller graph for this function:

handle_events()

void openswmm::input::handle_events	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [EVENTS] — fills ctx.events.

Here is the call graph for this function:

handle_files()

void openswmm::input::handle_files	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse the [FILES] section into ctx.files.

Parameters

ctx	Simulation context to populate.
lines	Non-comment, non-empty lines from the section.

Here is the call graph for this function:

handle_groundwater()

void openswmm::input::handle_groundwater	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [GROUNDWATER] — link subcatchments to aquifers and nodes.

Here is the call graph for this function:

Here is the caller graph for this function:

handle_gwf()

void openswmm::input::handle_gwf	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [GWF] — custom groundwater flow expressions (stored as raw text).

Here is the call graph for this function:

Here is the caller graph for this function:

handle_hydrographs()

void openswmm::input::handle_hydrographs	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [HYDROGRAPHS] into UnitHydData.

Here is the call graph for this function:

handle_infiltration()

void openswmm::input::handle_infiltration	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [INFILTRATION] — Horton/Green-Ampt/CN params per subcatch.

Here is the call graph for this function:

handle_inflows()

void openswmm::input::handle_inflows	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [INFLOWS] into ExtInflowData.

Here is the call graph for this function:

handle_inlet_usage()

void openswmm::input::handle_inlet_usage	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [INLET_USAGE] — fills ctx.inlet_usages.

Here is the call graph for this function:

handle_inlets()

void openswmm::input::handle_inlets	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [INLETS] — fills ctx.inlets.

Here is the call graph for this function:

handle_junctions()

void openswmm::input::handle_junctions	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [JUNCTIONS] into NodeData + node_names.

Here is the call graph for this function:

handle_landuses()

void openswmm::input::handle_landuses	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [LANDUSES] into LanduseData + landuse_names.

Here is the call graph for this function:

handle_lid_controls()

void openswmm::input::handle_lid_controls	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [LID_CONTROLS] into LidControlStore + lid_names.

Here is the call graph for this function:

Here is the caller graph for this function:

handle_lid_usage()

void openswmm::input::handle_lid_usage	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [LID_USAGE] into LidUsageStore.

Here is the call graph for this function:

Here is the caller graph for this function:

handle_loadings()

void openswmm::input::handle_loadings	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [LOADINGS] — initial pollutant buildup on subcatchments.

Here is the call graph for this function:

handle_losses()

void openswmm::input::handle_losses	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_map()

void openswmm::input::handle_map	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [MAP] — fills spatial.map_x1/y1/x2/y2 and map_units.

Here is the call graph for this function:

handle_options()

void openswmm::input::handle_options	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse the [OPTIONS] section into ctx.options.

Built-in handler registered in SWMMEngine::register_builtin_handlers(). Unknown keys are stored in ctx.options.ext_options (R05). The CRS key also populates ctx.spatial.crs (R06).

Parameters

ctx	Simulation context to populate.
lines	Non-blank, comment-stripped lines from the [OPTIONS] section.

Here is the call graph for this function:

handle_orifices()

void openswmm::input::handle_orifices	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_outfalls()

void openswmm::input::handle_outfalls	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [OUTFALLS] — sets outfall-specific fields for nodes of type OUTFALL.

Here is the call graph for this function:

handle_outlets()

void openswmm::input::handle_outlets	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_patterns()

void openswmm::input::handle_patterns	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [PATTERNS] into PatternData with continuation-line support.

Here is the call graph for this function:

handle_plugins()

void openswmm::input::handle_plugins	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [PLUGINS] into ctx.plugin_specs.

Here is the call graph for this function:

handle_pollutants()

void openswmm::input::handle_pollutants	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [POLLUTANTS] into PollutantData + pollutant_names.

Here is the call graph for this function:

handle_polygons()

void openswmm::input::handle_polygons	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [POLYGONS] — fills spatial.subcatch_polygon_x/y.

Here is the call graph for this function:

handle_pumps()

void openswmm::input::handle_pumps	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_raingages()

void openswmm::input::handle_raingages	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [RAINGAGES] into GageData + gage_names.

Here is the call graph for this function:

handle_rdii()

void openswmm::input::handle_rdii	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [RDII] into RDIIAssignData.

Here is the call graph for this function:

handle_rdii_decay()

void openswmm::input::handle_rdii_decay	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [RDII_DECAY] into RDIIDecayData (exponential IA model).

Here is the call graph for this function:

handle_report()

void openswmm::input::handle_report	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_snowpacks()

void openswmm::input::handle_snowpacks	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [SNOWPACKS] into SnowpackStore + snowpack_names.

Here is the call graph for this function:

Here is the caller graph for this function:

handle_storage()

void openswmm::input::handle_storage	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [STORAGE] — adds storage nodes and their geometry.

Here is the call graph for this function:

handle_streets()

void openswmm::input::handle_streets	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [STREETS] — fills ctx.streets.

Here is the call graph for this function:

handle_subareas()

void openswmm::input::handle_subareas	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [SUBAREAS] — Manning's n + depression storage for each subcatch.

Here is the call graph for this function:

handle_subcatchments()

void openswmm::input::handle_subcatchments	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [SUBCATCHMENTS] into SubcatchData + subcatch_names.

Here is the call graph for this function:

handle_symbols()

void openswmm::input::handle_symbols	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [SYMBOLS] — fills spatial.gage_x/y.

Here is the call graph for this function:

handle_tags()

void openswmm::input::handle_tags	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [TAGS] — writes per-index tags onto ctx.nodes.tags / ctx.links.tags / ctx.subcatches.tags (resolves name → idx via the matching NameIndex; unresolved lines are skipped).

Here is the call graph for this function:

handle_temperature()

void openswmm::input::handle_temperature	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [TEMPERATURE] into SimulationOptions temperature/wind/snow fields.

Here is the call graph for this function:

Here is the caller graph for this function:

handle_timeseries()

void openswmm::input::handle_timeseries	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [TIMESERIES] into TableData + table_names.

Here is the call graph for this function:

handle_title()

void openswmm::input::handle_title	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [TITLE] into ctx.title_notes.

Format:

[TITLE]
;;Project Title/Notes
First line of project title or notes
Second line...

Each non-blank, non-comment line is stored verbatim in ctx.title_notes as a separate entry.

handle_transects()

void openswmm::input::handle_transects	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_treatment()

void openswmm::input::handle_treatment	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [TREATMENT] — treatment expressions per (node x pollutant).

Here is the call graph for this function:

handle_user_flag_values()

void openswmm::input::handle_user_flag_values	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [USER_FLAG_VALUES] into ctx.user_flags (per-object values).

Here is the call graph for this function:

handle_user_flags()

void openswmm::input::handle_user_flags	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [USER_FLAGS] into ctx.user_flags.

Format:

[USER_FLAGS]
;;Name            Type      Default   Description
ENABLE_DEBUG_OUT  BOOLEAN   NO        "Write extra debug output"
MAX_ITERATIONS    INTEGER   10        "Override Newton iterations"
STABILITY_FACTOR  REAL      1.0       "Global stability multiplier"
LABEL_PREFIX      STRING    "SIM"     "Prefix for output labels"

Here is the call graph for this function:

handle_vertices()

void openswmm::input::handle_vertices	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [VERTICES] — fills spatial.link_vertices_x/y.

Here is the call graph for this function:

handle_washoff()

void openswmm::input::handle_washoff	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Parse [WASHOFF] — washoff functions per (landuse x pollutant).

Here is the call graph for this function:

handle_weirs()

void openswmm::input::handle_weirs	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

handle_xsections()

void openswmm::input::handle_xsections	(	SimulationContext &	ctx,
		const std::vector< std::string > &	lines
	)

Here is the call graph for this function:

parse_date()

double openswmm::input::parse_date ( std::string_view  sv )

inline

Parse a date string in MM/DD/YYYY format to a DateTime (decimal days).

Here is the call graph for this function:

Here is the caller graph for this function:

parse_datetime()

double openswmm::input::parse_datetime ( std::string_view  date_sv, std::string_view  time_sv  )

inline

Parse a combined date + time pair to a DateTime.

Parameters

date_sv	Date string in MM/DD/YYYY format.
time_sv	Time string in HH:MM:SS format.

Returns

DateTime value (decimal days).

Here is the call graph for this function:

Here is the caller graph for this function:

parse_section()

std::vector< ParsedLine > openswmm::input::parse_section ( const std::vector< std::string > &  raw_lines )

inline

Split raw section lines into (data, comment) pairs.

Rules applied in order:

• Lines starting with ";;" are column-header or dashes markers — discarded, and any accumulated pending comment is reset.
• Lines starting with ";" (but not ";;") are object-comment lines. The leading semicolon is stripped and the text is appended to the pending comment, separated from any prior line by the literal "\\n" token.
• All other non-empty lines are data lines. They receive the pending comment (which is then cleared) and are appended to the result.
• A trailing comment block with no subsequent data line is silently discarded (there is no object to attach it to).

Parameters

raw_lines

Lines as accumulated by InputReader (may contain ";;" and ";" lines verbatim, plus stripped data lines).

Returns

Vector of ParsedLine, one entry per data line.

Here is the caller graph for this function:

parse_time_day_fraction()

double openswmm::input::parse_time_day_fraction ( std::string_view  sv )

inline

Parse a time string HH:MM:SS to a fractional day (DateTime).

For use with datetime::encodeTime. Returns fractional day [0, 1).

Here is the call graph for this function:

Here is the caller graph for this function:

parse_time_seconds()

double openswmm::input::parse_time_seconds ( std::string_view  sv )

inline

Parse a time string to seconds.

Accepts:

• HH:MM:SS → hours*3600 + min*60 + sec
• HH:MM → hours*3600 + min*60
• N → N (plain seconds, floating point)

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_cross_references()

void openswmm::input::resolve_cross_references

(

SimulationContext &

ctx

)

Resolve all cross-references in ctx after all sections are parsed.

This is a best-effort pass: references that still can't be resolved after the full file is read are left as -1 and a warning is stored in ctx.warning_code.

Parameters

ctx	Simulation context (mutated in place).

Here is the call graph for this function:

to_double()

double openswmm::input::to_double ( std::string_view  sv, double  def = 0.0  )

inlinenoexcept

Parse a double from a string_view, returning a default on failure.

Here is the call graph for this function:

Here is the caller graph for this function:

to_int()

int openswmm::input::to_int ( std::string_view  sv, int  def = 0  )

inlinenoexcept

Parse an int from a string_view, returning a default on failure.

Here is the caller graph for this function: