sensorml

type AbstractProcess ¶

type AbstractProcess struct {
	ID              string             `json:"id,omitempty"`
	Label           string             `json:"label,omitempty"`
	Description     string             `json:"description,omitempty"`
	Definition      string             `json:"definition,omitempty"`
	UniqueID        string             `json:"uniqueId,omitempty"`
	Identifiers     IdentifierList     `json:"identifiers,omitempty"`
	Classifiers     ClassifierList     `json:"classifiers,omitempty"`
	Characteristics CharacteristicList `json:"characteristics,omitempty"`
	Capabilities    CapabilityList     `json:"capabilities,omitempty"`
	Keywords        []string           `json:"keywords,omitempty"`
	Inputs          DataComponentList  `json:"inputs,omitempty"`
	Outputs         DataComponentList  `json:"outputs,omitempty"`
	Parameters      DataComponentList  `json:"parameters,omitempty"`
	TypeOf          *Reference         `json:"typeOf,omitempty"`
}

AbstractProcess holds the fields shared by every concrete SensorML process kind per OGC 12-000r2. Concrete types embed this struct by value.

Field names mirror the SensorML JSON property names; pointer fields are optional. The struct is a hand-written subset of the full schema — fields outside CS API v1.0's critical path are intentionally omitted (see doc.go's Scope section).

type AggregateProcess ¶

type AggregateProcess struct {
	AbstractProcess
	Components  []Process      `json:"components,omitempty"`
	Connections ConnectionList `json:"connections,omitempty"`
}

AggregateProcess is a SensorML concrete composite process — a container that orchestrates child processes via the Components list and the Connections among them.

func (a *AggregateProcess) Base() *AbstractProcess

func (a *AggregateProcess) LocalID() string

func (a *AggregateProcess) MarshalJSON() ([]byte, error)

func (AggregateProcess) Type() string

type Asset ¶

type Asset struct {
	Process Process
	// ChildIDFn maps a child component's local id (the inner
	// SensorML id field, e.g. "battery") to its 6-part SemStreams
	// entity ID. When nil, child triples reference the bare
	// local id — fine for in-document graph queries but a
	// downgrade for cross-system entity resolution.
	ChildIDFn func(localID string) string
	// contains filtered or unexported fields
}

Asset pairs a parsed SensorML Process with the 6-part SemStreams entity ID assigned by the operator. Asset implements the [graph.Graphable] contract; the underlying Process does not, because SensorML's document-local id is not a SemStreams entity ID.

Multiple Assets may share the same underlying Process value (e.g. when ingestion deduplicates structurally identical system descriptions across deployments). EntityID is the stable handle; pair construction is the operator's responsibility.

func NewAsset(entityID string, process Process) *Asset

func (a *Asset) EntityID() string

func (a *Asset) Triples() []message.Triple

type CapabilityList ¶

type CapabilityList []Term

CapabilityList groups capability Terms (operating range, performance bounds).

type CharacteristicList ¶

type CharacteristicList []Term

CharacteristicList groups characteristic Terms (physical properties of the procedure / device).

type ClassifierList ¶

type ClassifierList []Term

ClassifierList groups classifier Terms (taxonomies, types).

type Connection ¶

type Connection struct {
	Source      string `json:"source"`
	Destination string `json:"destination"`
}

Connection wires together two PhysicalSystem components via their data ports. The source / destination fields are dotted-path references into the embedded components' data dictionaries (e.g. "battery/output/voltage" → "controller/input/sensorReading").

type ConnectionList ¶

type ConnectionList []Connection

ConnectionList groups Connection entries inside a PhysicalSystem.

type DataComponent ¶

type DataComponent struct {
	Name       string `json:"name"`
	Type       string `json:"type,omitempty"`
	Definition string `json:"definition,omitempty"`
	Label      string `json:"label,omitempty"`
	UoM        string `json:"uom,omitempty"`
}

DataComponent is the SensorML reference to a SWE Common typed field used as an input, output, or parameter slot. We intentionally model only the cross-cutting fields rather than the full SWE Common type hierarchy — the SWE IRI roster ships in vocabulary/swe and the parser's job is to surface the type reference, not to revalidate the SWE Common payload shape.

type DataComponentList ¶

type DataComponentList []DataComponent

DataComponentList groups DataComponents under a SensorML inputs / outputs / parameters slot.

type IdentifierList ¶

type IdentifierList []Term

IdentifierList groups identifier Terms. SensorML uses lists instead of bare arrays so the list itself can carry a label / definition; we collapse to a flat slice for the common case.

type PhysicalComponent ¶

type PhysicalComponent struct {
	AbstractProcess
	Method     *Reference `json:"method,omitempty"`
	AttachedTo *Reference `json:"attachedTo,omitempty"`
}

PhysicalComponent is a SensorML concrete leaf physical process — a single sensor / actuator / sampler unit. The Method reference points to the procedure the component executes (sosa:Procedure semantics).

Physical-process types extend AbstractProcess with an AttachedTo field (the physical thing the component is mounted on). Per OGC 12-000r2 §6.4.

func (p *PhysicalComponent) Base() *AbstractProcess

func (p *PhysicalComponent) LocalID() string

func (p *PhysicalComponent) MarshalJSON() ([]byte, error)

func (PhysicalComponent) Type() string

type PhysicalSystem ¶

type PhysicalSystem struct {
	AbstractProcess
	AttachedTo  *Reference     `json:"attachedTo,omitempty"`
	Components  []Process      `json:"components,omitempty"`
	Connections ConnectionList `json:"connections,omitempty"`
}

PhysicalSystem is a SensorML concrete composite physical process — a hardware assembly containing PhysicalComponent children (sensors, actuators, samplers) and Connection entries describing how their data ports link.

In OGC API Connected Systems terms, a PhysicalSystem record IS a SOSA/SSN System, and its Components are typically SOSA Sensors / Actuators hosted on the System's Platform.

func (p *PhysicalSystem) Base() *AbstractProcess

func (p *PhysicalSystem) LocalID() string

func (p *PhysicalSystem) MarshalJSON() ([]byte, error)

func (PhysicalSystem) Type() string

type Process ¶

type Process interface {
	// Type returns the SensorML JSON type-discriminator string
	// ("PhysicalSystem", "PhysicalComponent", "SimpleProcess",
	// "AggregateProcess").
	Type() string

	// Base returns the embedded AbstractProcess block carrying
	// the fields shared by every SensorML process kind. Never
	// nil for a well-formed value (the embedded struct is
	// value-typed, not pointer-typed).
	Base() *AbstractProcess

	// LocalID returns the document-local id field. Local IDs are
	// scoped to the SensorML document — they are NOT 6-part
	// SemStreams entity IDs. Pair through [NewAsset] before
	// feeding to the graph layer.
	LocalID() string
}

Process is the SensorML JSON polymorphic root. Every concrete process type (PhysicalSystem, PhysicalComponent, SimpleProcess, AggregateProcess) implements Process by reporting its type-discriminator string and exposing the shared AbstractProcess block.

Operate on the concrete types when you need type-specific fields (e.g. PhysicalSystem.Components); operate through Process when you only need the shared fields or are walking a heterogeneous list.

func UnmarshalProcess(data []byte) (Process, error)

process, err := sensorml.UnmarshalProcess(data)
switch p := process.(type) {
case *sensorml.PhysicalSystem:    …
case *sensorml.PhysicalComponent: …
}

type Reference ¶

type Reference struct {
	Href  string `json:"href,omitempty"`
	Title string `json:"title,omitempty"`
	Role  string `json:"role,omitempty"`
}

Reference is a SensorML JSON typed cross-reference. It carries at minimum an href (the target IRI / URI); other fields are optional and used for display or content-negotiation hints.

References show up everywhere — procedure links, typeOf, featureOfInterest, configuration overlays. A bare string in JSON is also accepted by UnmarshalJSON for callers that emit the IRI directly without the full envelope.

type SimpleProcess ¶

type SimpleProcess struct {
	AbstractProcess
	Method *Reference `json:"method,omitempty"`
}

SimpleProcess is a SensorML concrete leaf process — an algorithmic / procedural unit with no sub-processes. The Method reference points to the procedure that defines what the process does.

func (s *SimpleProcess) Base() *AbstractProcess

func (s *SimpleProcess) LocalID() string

func (s *SimpleProcess) MarshalJSON() ([]byte, error)

func (SimpleProcess) Type() string

type Term ¶

type Term struct {
	Definition string `json:"definition,omitempty"`
	Label      string `json:"label,omitempty"`
	Value      any    `json:"value,omitempty"`
	UoM        string `json:"uom,omitempty"`
	SweTypeOf  string `json:"sweType,omitempty"`
}

Term is the SensorML "Term" structure used for identifiers, classifiers, characteristics, and capabilities. It carries a definition IRI (the semantic kind of the term), a human- readable label, and the value the term holds.

SensorML 2.x JSON encoding represents Term values as a single JSON object even when the underlying SWE Common shape would be a typed AbstractDataComponent. We surface only the load-bearing fields; the SWE typing is preserved as a raw IRI in SweTypeOf so downstream consumers can resolve via vocabulary/swe when needed.