Serialized Form

Package it.univr.di.cstnu.algorithms

Class it.univr.di.cstnu.algorithms.AbstractCSTN.CSTNCheckStatus

class CSTNCheckStatus extends STN.STNCheckStatus implements Serializable

Serialized Fields

labeledValuePropagationCalls

int labeledValuePropagationCalls

Counters #applications of the label propagation rule

potentialUpdate

int potentialUpdate

Counters #applications of potential update

r0calls

int r0calls

Counters #applications of r0 rule

r3calls

int r3calls

Counters #applications of r3 rule

Class it.univr.di.cstnu.algorithms.CSTNU.CSTNUCheckStatus

class CSTNUCheckStatus extends AbstractCSTN.CSTNCheckStatus implements Serializable

Serialized Fields

crossCaseRuleCalls

int crossCaseRuleCalls

Counts the # of applications of different rules.

letterRemovalRuleCalls

int letterRemovalRuleCalls

Counts the # of applications of different rules.

lowerCaseRuleCalls

int lowerCaseRuleCalls

Counts the # of applications of different rules.

zExclamationRuleCalls

int zExclamationRuleCalls

Counts the # of applications of different rules.

Class it.univr.di.cstnu.algorithms.OSTNU.OSTNUCheckStatus

class OSTNUCheckStatus extends AbstractCSTN.CSTNCheckStatus implements Serializable

Serialized Fields

crossCaseRuleCalls

int crossCaseRuleCalls

Counts the # of applications of different rules.

firstProposition

char firstProposition

First free proposition

letterRemovalRuleCalls

int letterRemovalRuleCalls

Counts the # of applications of different rules.

lowerCaseRuleCalls

int lowerCaseRuleCalls

Counts the # of applications of different rules.

negativeScenarios

LabeledIntMap negativeScenarios

Scenario containing a negative cycle.
I use LabeledIntTreeMap for maintaining the set minimally with respect to the length of the label, but without the simplification on (¬a, 0)(a,1)-->(empty,0)(a,1).
Don't access this map directly, but use methods OSTNU.OSTNUCheckStatus.addNegativeScenario(Label), OSTNU.OSTNUCheckStatus.getNegativeScenarios(), OSTNU.OSTNUCheckStatus.isInNegativeScenarios(Label).

oracleRuleCalls

int oracleRuleCalls

Counts the # of applications of different rules.

proposition2Pair

it.unimi.dsi.fastutil.chars.Char2ObjectMap<ObjectPair<LabeledNode>> proposition2Pair

Map (proposition)-->(ctg,node)

propositionOfPair

it.unimi.dsi.fastutil.objects.Object2ObjectMap<LabeledNode, it.unimi.dsi.fastutil.objects.Object2CharMap<LabeledNode>> propositionOfPair

Map (Ctg, Node)-->proposition

upperCaseRuleCalls

int upperCaseRuleCalls

Counts the # of applications of different rules.

Class it.univr.di.cstnu.algorithms.PSTN.PSTNCheckStatus

class PSTNCheckStatus extends STN.STNCheckStatus implements Serializable

serialVersionUID:

1L

Serialized Fields

exitFlag

int exitFlag

xit flag of the minimization procedure.

probabilityMass

double probabilityMass

the conjuncted probability mass obtained by setting the contingent bounds in PSTN.PSTNCheckStatus.approximatingSTNU.

srn

it.unimi.dsi.fastutil.objects.ObjectImmutableList<STNUEdge> srn

Possible semi-reducible negative cycle;

srncKind

STNU.STNUCheckStatus.SRNCKind srncKind

Kind of SRNC

Class it.univr.di.cstnu.algorithms.STN.STNCheckStatus

class STNCheckStatus extends Object implements Serializable

serialVersionUID:

2L

Serialized Fields

consistency

boolean consistency

Consistency status (it is assumed true at the initialization).

cycles

int cycles

Counts the # of applications of different rules.

executionTimeNS

long executionTimeNS

Execution time in nanoseconds.

finished

boolean finished

Becomes true if no rule can be applied anymore.

initialized

boolean initialized

Becomes true when all data structures have been initialized.

negativeCycle

it.unimi.dsi.fastutil.objects.ObjectList<LabeledNode> negativeCycle

The list of LabeledNode representing a negative loop has been found (if the network is not consistent, the algorithm can build it).

negativeLoopNode

LabeledNode negativeLoopNode

The node with a negative loop when the graph is not consistent, and the algorithm can determine only the node with a negative loop.

note

String note

A possible note

partialExecutionTimeNS

long partialExecutionTimeNS

Another counter for storing the execution time of a part of the process. In nanoseconds.

propagationCalls

int propagationCalls

Number of propagations

stdDevExecutionTimeNS

long stdDevExecutionTimeNS

Standard Deviation of execution time if this last one is a mean. In nanoseconds.

stdDevPartialExecutionTimeNS

long stdDevPartialExecutionTimeNS

timeout

boolean timeout

Becomes true if the check has been interrupted because a given time-out has occurred.

Class it.univr.di.cstnu.algorithms.STNU.STNUCheckStatus

class STNUCheckStatus extends STN.STNCheckStatus implements Serializable

serialVersionUID:

1L

Serialized Fields

checkAlgorithm

STNU.CheckAlgorithm checkAlgorithm

The algorithm was used to check the network last time.

maxMinConstraint

int maxMinConstraint

maxMin constraint added;

negativeSTNUCycle

STNU.STNUPath negativeSTNUCycle

Negative STNU cycle. This field may represent a simple negative cycle made of ordinary constraints or a semi-reducible negative cycle, i.e., a negative cycle also contains lower-case or upper-case edges.

srncKind

STNU.STNUCheckStatus.SRNCKind srncKind

Kind of SRNC

Exception Class it.univr.di.cstnu.algorithms.WellDefinitionException

class WellDefinitionException extends Exception implements Serializable

serialVersionUID:

2L

Serialized Fields

type

WellDefinitionException.Type type

Type of exception.

Package it.univr.di.cstnu.graph

Class it.univr.di.cstnu.graph.AbstractComponent

class AbstractComponent extends Object implements Serializable

serialVersionUID:

2L

Serialized Fields

inNegativeCycle

boolean inNegativeCycle

Both for nodes and edges, some algorithms can set this variable to true if the component is in a negative cycle.

name

String name

Possible name

nameManagedByGraph

boolean nameManagedByGraph

Once set, AbstractComponent.setName(String) rejects any further direct call: the name is then managed by the graph that owns this component, and must be changed only through TemporalConstraintGraph.renameNode/ renameEdge. Set by every graph insertion path, including the fast ones that skip other checks.

This is a one-way lock, not an ownership counter: it is never cleared by removal or by a graph clear(). A counter would need to be decremented on every removal path (including bulk clear() and predecessor-graph reuse) and would still miss instances shared outside a DenseTCGraph/SparseTCGraph (e.g., a TCPredecessorGraph), so it cannot safely detect "no longer shared" and re-allow direct renaming; see RENAME_AUDIT.md §3.4.

pcs

PropertyChangeSupport pcs

Since Java 9, Observable has no longer been supported. I decided to replace Observable using java.bean.PropertyChangeSupport allows the registration of listeners indexed by a key (string) that represents the property. Then, when a property is changed, it is enough to call pcs.firePropertyChange("theProperty", old, val);

A listener 'l' of a property 'X' must be registered as addObserver("X",l).

A listener must be implement PropertyChangeListener.

Class it.univr.di.cstnu.graph.AbstractEdge

class AbstractEdge extends AbstractComponent implements Serializable

serialVersionUID:

1L

Serialized Fields

constraintType

Edge.ConstraintType constraintType

The type of the edge.

route

EdgeRoute route

The explicit routing of the edge, or null for automatic. A view attribute (like the name): it survives clear() and is carried by takeIn and by the cloning constructors.

Class it.univr.di.cstnu.graph.AbstractNode

class AbstractNode extends AbstractComponent implements Serializable

serialVersionUID:

2L

Class it.univr.di.cstnu.graph.BasicCSTNUEdgePluggable

class BasicCSTNUEdgePluggable extends CSTNEdgePluggable implements Serializable

serialVersionUID:

3L

Serialized Fields

consideredUpperCaseValue

it.unimi.dsi.fastutil.objects.Object2IntMap<it.unimi.dsi.fastutil.objects.Object2ObjectMap.Entry<Label,ALabel>> consideredUpperCaseValue

The CSTNU controllability check algorithm needs to know if a labeled value has already been considered in the past to avoid adding it a second time.

upperCaseValue

LabeledALabelIntTreeMap upperCaseValue

Morris Upper case value augmented by a propositional label.

The name of the node has to be equal to the original name. No case modifications are necessary!

Class it.univr.di.cstnu.graph.CSTNEdgePluggable

class CSTNEdgePluggable extends AbstractEdge implements Serializable

serialVersionUID:

6L

Serialized Fields

consideredLabeledValue

it.unimi.dsi.fastutil.objects.Object2IntMap<Label> consideredLabeledValue

Maintains the log of labeled values that have already been inserted and, therefore, cannot be reinserted. This is used to speed up the label management.

labeledValue

LabeledIntMap labeledValue

Labeled value.

labeledValueMapImpl

Class<? extends LabeledIntMap> labeledValueMapImpl

Labeled value class used in the class.

Class it.univr.di.cstnu.graph.CSTNPSUEdgePluggable

class CSTNPSUEdgePluggable extends BasicCSTNUEdgePluggable implements Serializable

serialVersionUID:

1L

Serialized Fields

consideredLowerCaseValue

it.unimi.dsi.fastutil.objects.Object2IntMap<it.unimi.dsi.fastutil.objects.Object2ObjectMap.Entry<Label,ALabel>> consideredLowerCaseValue

The CSTNU controllability check algorithm needs to know if a labeled value has already been considered in the past to avoid adding it a second time.

lowerCaseValues

LabeledALabelIntTreeMap lowerCaseValues

Morris Lower case value augmented by a propositional label.

The name of the node has to be equal to the original name. No case modifications are necessary!

Class it.univr.di.cstnu.graph.CSTNUEdgePluggable

class CSTNUEdgePluggable extends BasicCSTNUEdgePluggable implements Serializable

serialVersionUID:

3L

Serialized Fields

lowerCaseValue

LabeledLowerCaseValue lowerCaseValue

Morris Lower case value augmented by a propositional label.

The name of the node has to be equal to the original name. No case modifications are necessary!

Class it.univr.di.cstnu.graph.DenseTCGraph

class DenseTCGraph extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

adjacency

E extends Edge[][] adjacency

The graph is represented by its adjacency matrix.

aLabelAlphabet

ALabelAlphabet aLabelAlphabet

Alphabet for A-Label

annotations

List<GraphAnnotation> annotations

Presentation-only notes stored with the graph.

checkOutcome

CheckOutcome checkOutcome

Optional trusted result of a check performed on this graph.

childrenOfObserver

Map<LabeledNode, Label> childrenOfObserver

Children of observation nodes

dispatchabilityOutcome

DispatchabilityOutcome dispatchabilityOutcome

Optional dispatchability representation derived from this graph.

edge2index

it.unimi.dsi.fastutil.objects.Object2ObjectMap<String, DenseTCGraph<E extends Edge>.it.univr.di.cstnu.graph.DenseTCGraph.EdgeIndex> edge2index

Map (edge-->adjacency position)

edgeFactory

EdgeSupplier<E extends Edge> edgeFactory

Edge factory

inAdj

it.unimi.dsi.fastutil.ints.IntArrayList[] inAdj

Incremental in-incidence index: inAdj[j] is the list of row indices i such that adjacency[i][j] != null.

It is maintained in sync with DenseTCGraph.adjacency so that iterating the incoming edges of a node costs O(in-degree) instead of O(#nodes). The array is sized like DenseTCGraph.adjacency; entries beyond DenseTCGraph.order are unused.

index2node

it.unimi.dsi.fastutil.ints.Int2ObjectMap<LabeledNode> index2node

Map (adjacency row-->node)

inEdgesAndSourcesCache

Map<String, Collection<TemporalConstraintGraph.EdgeAndNode<E extends Edge>>> inEdgesAndSourcesCache

Immutable snapshots for the library-independent traversal API.

inEdgesCache

Map<LabeledNode, it.unimi.dsi.fastutil.objects.ObjectList<it.unimi.dsi.fastutil.objects.ObjectObjectImmutablePair<E extends Edge, LabeledNode>>> inEdgesCache

Map (node) --> list of its `(in-going edge, sourceNode)` pairs. It works as a cache.

inputFile

File inputFile

A possible input file containing this graph.

lowerCaseEdges

it.unimi.dsi.fastutil.objects.ObjectList<BasicCSTNUEdge> lowerCaseEdges

List of edges with their lower-case label set not empty

name

String name

Name

nodeFactory

LabeledNodeSupplier nodeFactory

Node factory

nodeName2index

it.unimi.dsi.fastutil.objects.Object2IntMap<String> nodeName2index

Map (node-->adjacency row)

observer2Z

it.unimi.dsi.fastutil.objects.ObjectList<E extends Edge> observer2Z

List of edges from observers to Z

order

int order

Current number of nodes;

outAdj

it.unimi.dsi.fastutil.ints.IntArrayList[] outAdj

Incremental out-incidence index: outAdj[i] is the list of column indices j such that adjacency[i][j] != null.

It is maintained in sync with DenseTCGraph.adjacency so that iterating the outgoing edges of a node costs O(out-degree) instead of O(#nodes). The array is sized like DenseTCGraph.adjacency; entries beyond DenseTCGraph.order are unused.

outEdgesAndDestinationsCache

Map<String, Collection<TemporalConstraintGraph.EdgeAndNode<E extends Edge>>> outEdgesAndDestinationsCache

Immutable snapshots for the library-independent traversal API.

outEdgesCache

Map<LabeledNode, it.unimi.dsi.fastutil.objects.ObjectList<it.unimi.dsi.fastutil.objects.ObjectObjectImmutablePair<E extends Edge, LabeledNode>>> outEdgesCache

Map (node) --> list of its `(outgoing edge, destinationNode)` pairs. It works as a cache.

proposition2Observer

it.unimi.dsi.fastutil.chars.Char2ObjectMap<LabeledNode> proposition2Observer

Map of (proposition-->Observer node).

type

TemporalConstraintNetworkType type

Type of network

Z

LabeledNode Z

Zero node. In a temporal constraint network, such a node is the first node to execute.

Class it.univr.di.cstnu.graph.DenseTCGraph.UnmodifiableDenseTCGraph

class UnmodifiableDenseTCGraph extends DenseTCGraph<K extends Edge> implements Serializable

serialVersionUID:

2L

Class it.univr.di.cstnu.graph.LabeledNode

class LabeledNode extends AbstractNode implements Serializable

serialVersionUID:

4L

Serialized Fields

aLabel

ALabel aLabel

ALabel associated with this node. This field has the scope to speed up the DC checking since it represents the name of a contingent time point as ALabel instead of calculating it every time. Used in CSTNU.

isContingent

boolean isContingent

Flag for the contingent node. Used in STNU/CSTNU.

isParameter

boolean isParameter

Flag for parameter node. Used in PCSTNU.

label

Label label

Label associated with this node. Used in CSTNU/CSTN.

labeledPotential

LabeledALabelIntTreeMap labeledPotential

Labeled potential values. This map can also represent Upper-case labeled potentials. Used in HP20 and derived algorithms.

logNormalDistributionParameter

LogNormalDistributionParameter logNormalDistributionParameter

LogNormalDistributionParameter is used to represent the probability function of the contingent-link duration. Since a probabilistic STN is approximated by an STNU, we prefer to maintain the representation of the network using the STNUEdges and to represent the location and standard deviation of the probability distribution as a record in the contingent node.

propositionObserved

char propositionObserved

Possible proposition observed. Used in CSTNU/CSTN.

x

double x

Position Coordinates. It must be double, even if it is not necessary for Jung library compatibility.

y

double y

Position Coordinates. It must be double, even if it is not necessary for Jung library compatibility.

Class it.univr.di.cstnu.graph.OSTNUEdgePluggable

class OSTNUEdgePluggable extends CSTNUEdgePluggable implements Serializable

serialVersionUID:

1L

Class it.univr.di.cstnu.graph.STNEdgeInt

class STNEdgeInt extends AbstractEdge implements Serializable

serialVersionUID:

2L

Serialized Fields

value

int value

the value associated with the edge

Class it.univr.di.cstnu.graph.STNUEdge.CaseLabel

class CaseLabel extends it.unimi.dsi.fastutil.objects.ObjectBooleanImmutablePair<ALabelAlphabet.ALetter> implements Serializable

serialVersionUID:

1L

Class it.univr.di.cstnu.graph.STNUEdgeInt

class STNUEdgeInt extends STNEdgeInt implements Serializable

serialVersionUID:

4L

Serialized Fields

caseLabel

STNUEdge.CaseLabel caseLabel

The upper/lower case label.

The first component is the node label; the second specifies the nature: true for upper-case, false for lower-case.

labeledValue

int labeledValue

The labeled value associated with the edge when it is a contingent link or a wait constraint. Its value is Constants.INT_NULL when this edge is ordinary.

Package it.univr.di.cstnu.gui

Class it.univr.di.cstnu.gui.EditorView

class EditorView extends JPanel implements Serializable

serialVersionUID:

1L

Serialized Fields

alignTopLeftButton

JButton alignTopLeftButton

«Align» button of the input view: shifts the input graph so its top-left corner lands in (0,0).

annotationEditorChanged

boolean annotationEditorChanged

annotationEditorCreated

boolean annotationEditorCreated

annotationEditorInput

boolean annotationEditorInput

annotationOriginalText

String annotationOriginalText

applyLayoutButton

JButton applyLayoutButton

asyncMode

boolean asyncMode

cancelButton

JButton cancelButton

Explicit cancellation action for the currently running check.

checkStartedNanos

long checkStartedNanos

commandButtons

List<JButton> commandButtons

commandButtonsEnabled

boolean commandButtonsEnabled

Last value passed to EditorView.setButtonsEnabled(boolean): false while a command is running, so the per-button enable state computed by EditorView.refreshCommandButtons() never re-enables a button in the middle of an execution.

commandPanel

JPanel commandPanel

curvaMinusButton

JButton curvaMinusButton

curvaPlusButton

JButton curvaPlusButton

derivedAlignTopLeftButton

JButton derivedAlignTopLeftButton

«Align» button of the derived view: shifts the derived graph so its top-left corner lands in (0,0).

derivedCanvas

GraphCanvas<Edge> derivedCanvas

derivedFitButton

JButton derivedFitButton

derivedHScrollBar

JScrollBar derivedHScrollBar

derivedVScrollBar

JScrollBar derivedVScrollBar

derivedZoomInButton

JButton derivedZoomInButton

derivedZoomOutButton

JButton derivedZoomOutButton

elapsedLabel

JLabel elapsedLabel

Elapsed-time readout shown while an asynchronous check is running.

exportDerivedMenuItem

JMenuItem exportDerivedMenuItem

«Export Resulting…» menu item, kept so it can be enabled/disabled with the network state.

exportInputMenuItem

JMenuItem exportInputMenuItem

«Export Input…» menu item, kept so it can be enabled/disabled with the network state.

fileChooserInteractionInProgress

boolean fileChooserInteractionInProgress

true while a File-menu chooser interaction (Open, Save As, or either export entry) is showing its dialog and resolving the user's choice: EditorView.updateNetworkDependentMenuItems() forces the four network-dependent items disabled for that duration, restored — cancellation and error included, not just the success path — by the finally block of EditorView.runFileChooserInteraction(Supplier). See N23 point 2: a re-enable added only to the success branch stays correct today and breaks again the next time an early return is added.

fitButton

JButton fitButton

fullMessage

String fullMessage

Full text of the current action message, kept for the tooltip and the ellipsis truncation.

graphInfoPanel

JPanel graphInfoPanel

Column 1 of the status bar: the graph information (File, Type, Nodes, Edges, Contingent, Observed), kept at its natural width so a long message in column 2 never pushes it out.

ignoreDcSemanticsEvent

boolean ignoreDcSemanticsEvent

Guard flag used to suppress ItemListener reactions during programmatic updates of EditorView.dcSemanticsCombo (e.g. when reverting an invalid selection or locking to IR for HunsbergerPosenato20).

inputCanvas

GraphCanvas<Edge> inputCanvas

inputHScrollBar

JScrollBar inputHScrollBar

inputVScrollBar

JScrollBar inputVScrollBar

inspector

InspectorPanel inspector

The attribute inspector, or null while it is not installed. It is not created by the constructor on purpose: a view without an inspector is still fully functional, and the existing tests build one that way.

inspectorPanelContainer

JPanel inspectorPanelContainer

inspectorSplit

JSplitPane inspectorSplit

Vertical split between the views (top) and the inspector container (bottom); the user can drag its divider to adjust the inspector's height. Assigned by EditorView.assembleUI().

lastDerivedGraph

TemporalConstraintGraph<?> lastDerivedGraph

lastInputEdgeCount

int lastInputEdgeCount

lastInputGraph

TemporalConstraintGraph<?> lastInputGraph

lastInputVertexCount

int lastInputVertexCount

Vertex/edge counts of the input graph as of the last EditorView.doOnDocumentChanged() run: the cheap signal used to detect that an edge or a node was added or removed in place (same graph object, EditorView.lastInputGraph unchanged) since the previous document-changed notification, so that GraphCanvas.invalidateImplicitCurvatures() is called exactly when the topology actually changed and never on every repaint (see EditorView.doOnDocumentChanged()).

lastRequestedEdge

Edge lastRequestedEdge

lastRequestedNode

LabeledNode lastRequestedNode

layoutCombo

JComboBox<GraphLayout> layoutCombo

layoutLabel

JLabel layoutLabel

menuBar

JMenuBar menuBar

messageLabel

JLabel messageLabel

noticeLabel

JLabel noticeLabel

progressBar

JProgressBar progressBar

saveAsMenuItem

JMenuItem saveAsMenuItem

«Save As…» menu item, kept so it can be enabled/disabled with the network state.

saveMenuItem

JMenuItem saveMenuItem

«Save» menu item, kept so it can be enabled/disabled with the network state.

savePlainSTNUMenuItem

JMenuItem savePlainSTNUMenuItem

«Save as plainStnu» menu item, visible only for an open STNU document.

saveResultingMenuItem

JMenuItem saveResultingMenuItem

«Save Resulting…» menu item, enabled only after a command produces a result graph.

scrollAdjusting

boolean scrollAdjusting

Guards the scrollbar ↔ transform synchronization against feedback: while this flag is set, a scrollbar value change is ignored because it was caused by the synchronization itself.

settingsPanel

JPanel settingsPanel

statusBar

JPanel statusBar

Single full-width bar, split in two columns: column 1 (west, natural width) shows the graph information and column 2 (center, elastic) shows the action outcome — message, notice and progress bar on one row.

zoomInButton

JButton zoomInButton

zoomOutButton

JButton zoomOutButton

Class it.univr.di.cstnu.gui.GraphCanvas

class GraphCanvas extends JComponent implements Serializable

serialVersionUID:

1L

Class it.univr.di.cstnu.gui.TNEditor

class TNEditor extends JFrame implements Serializable

serialVersionUID:

1L

Serialized Fields

view

EditorView view

The editor view installed as the content pane.

Package it.univr.di.cstnu.gui.inspector

Class it.univr.di.cstnu.gui.inspector.CheckPropertyField

class CheckPropertyField extends PropertyField<JCheckBox> implements Serializable

serialVersionUID:

1L

Serialized Fields

applier

Consumer<Boolean> applier

renderer

Function<Object,String> renderer

Class it.univr.di.cstnu.gui.inspector.ComboPropertyField

class ComboPropertyField extends PropertyField<JComboBox<String>> implements Serializable

serialVersionUID:

1L

Serialized Fields

applier

Consumer<Object> applier

browsing

boolean browsing

true while the combo's popup is open (between popupMenuWillBecomeVisible and popupMenuWillBecomeInvisible): the in-progress-browse guard used by the ActionEvent listener, replacing the unreliable isPopupVisible() check — see the class comment.

loading

boolean loading

Set around every programmatic setSelectedItem performed by ComboPropertyField.loadFromModel(Object) and ComboPropertyField.restoreText(String): those must never reach the model through the same ActionEvent path a real user pick commits through.

parser

Function<String,Object> parser

renderer

Function<Object,String> renderer

Class it.univr.di.cstnu.gui.inspector.InspectorPanel

class InspectorPanel extends JPanel implements Serializable

serialVersionUID:

1L

Serialized Fields

columnSeparator

JComponent columnSeparator

Thin vertical separator between the identity and the values columns: a separator, not a border.

content

JPanel content

Content area, rebuilt on every InspectorPanel.showNode(TemporalConstraintGraph, GraphRole, String)/InspectorPanel.showEdge(TemporalConstraintGraph, GraphRole, String)/{#clear}. It lays out the bold header row (full width), the compact two-column identity/values block with the thin separator, and the tables below. Everything is anchored at the top: a trailing filler row absorbs the extra vertical space.

contingentNote

JLabel contingentNote

The measured contingent-edge note (N18 points 7 and 8), or null when the current target does not show one. Exposed to the tests through InspectorPanel.contingentNoteText().

contingentNoteIsWarning

boolean contingentNoteIsWarning

true when InspectorPanel.contingentNote is showing the point-7 consistency warning rather than the point-8 static help line.

controller

EditorController controller

currentEdge

Edge currentEdge

currentNode

LabeledNode currentNode

The currently inspected target, or null for the neutral panel.

fields

Map<String, PropertyField<?>> fields

Fields keyed by a stable id, exposed package-private for the tests.

header

JLabel header

The read-only header row of the current target, or null for the neutral panel.

identityColumn

JPanel identityColumn

The narrow identity column: the element's name and (for edges) the type, one row each. It is sized to its content and never stretches to fill the available width.

readOnly

boolean readOnly

Whether the inspected element belongs to the derived (computed) graph. Derived elements are shown read-only: every field and every table is built non-editable, and no path reaches the controller. Set from the GraphRole declared by the caller of InspectorPanel.showNode(TemporalConstraintGraph, GraphRole, String)/InspectorPanel.showEdge(TemporalConstraintGraph, GraphRole, String).

tablesColumn

JPanel tablesColumn

The labeled-value and upper/lower-case tables. They are shown full width below the identity/values block when the values column holds scalar fields; when the values column would be empty they are relocated into it, one table per column (see InspectorPanel.addEdgeFields(Edge)).

topFiller

JComponent topFiller

Empty trailing row with vertical weight: it absorbs the extra vertical space of a tall inspector, keeping the content anchored at the top instead of floating in the middle.

valuesColumn

JPanel valuesColumn

The values column holding the simple attribute fields (scalar value, case value, label, proposition, parameter).

Class it.univr.di.cstnu.gui.inspector.LabeledValueTable

class LabeledValueTable extends JPanel implements Serializable

serialVersionUID:

1L

Serialized Fields

addButton

JButton addButton

columnToolTips

String[] columnToolTips

Per-column header tooltip text, in model column order, or null when no header tooltip has been installed. Set through LabeledValueTable.setColumnToolTips(String[]).

draftRow

int draftRow

The row currently being added, or -1 when there is none. Its editable cells are editable even when onEdit is absent; it becomes a regular row as soon as both columns are filled and committed.

errorLabel

JLabel errorLabel

keyColumn

int keyColumn

keyIsPropositionLabel

boolean keyIsPropositionLabel

true when the key column holds a propositional Label (the two-column CSTN/CSTNU/CSTNPSU ordinary labeled-value table) rather than a case (node) name (the three-column upper/lower-case table). The empty label is always a valid label on every network that carries labeled values, so only this variant offers and defaults to it; a contingent node name has no such universal default.

labelColumnEditable

boolean labelColumnEditable

The editor used to type a label/case name: an editable combo suggests known names but accepts free text (so the user can type a lowercase name for a lower-case value), an uneditable combo restricts to the offered names.

onAdd

LabeledValueTable.RowMutation onAdd

onEdit

LabeledValueTable.RowEdit onEdit

onRemove

LabeledValueTable.LabelMutation onRemove

removeButton

JButton removeButton

scrollPane

JScrollPane scrollPane

table

JTable table

tableHeaderInstalled

boolean tableHeaderInstalled

Whether the header-tooltip JTableHeader override has already been installed, so a repeated LabeledValueTable.setColumnToolTips(String[]) call only refreshes the array it reads, not the header component itself.

tableModel

DefaultTableModel tableModel

title

String title

valueColumn

int valueColumn

Exception Class it.univr.di.cstnu.gui.inspector.LabeledValueTable.ValueNotStoredException

class ValueNotStoredException extends RuntimeException implements Serializable

serialVersionUID:

1L

Class it.univr.di.cstnu.gui.inspector.PropertyField

class PropertyField extends JPanel implements Serializable

serialVersionUID:

1L

Serialized Fields

committedText

String committedText

The last value successfully committed, kept as the text the editor showed at commit time, so a no-op commit and a revert can be detected against it.

editor

E extends JComponent editor

The editor component managed by this field.

errorLabel

JLabel errorLabel

The inline error message, shown under the editor only when invalid. Lazily created.

fieldId

String fieldId

Optional stable identifier used by tests to look up a field by purpose; null if unset.

label

JLabel label

The label describing the property to the left of the editor.

readOnly

boolean readOnly

Whether this field is read-only. A read-only field never writes to the model: PropertyField.commit() refuses to apply and the checkbox path is guarded separately in CheckPropertyField#toggle(). This is the single point where the inspector's read-only rule is enforced — disabling the editor is only the visual part, the guard is here.

Class it.univr.di.cstnu.gui.inspector.TextPropertyField

class TextPropertyField extends PropertyField<JTextField> implements Serializable

serialVersionUID:

1L

Serialized Fields

applier

Consumer<Object> applier

parser

Function<String,Object> parser

renderer

Function<Object,String> renderer

Package it.univr.di.cstnu.util

Class it.univr.di.cstnu.util.LogNormalDistributionParameter

class LogNormalDistributionParameter extends Object implements Serializable

Serialized Fields

location

double location

Considering the associated normal distribution, this is the mean μ of the normal distribution.

logNormalDistribution

org.apache.commons.math3.distribution.LogNormalDistribution logNormalDistribution

The PDF

scale

double scale

Considering the associated normal distribution, this is the standard deviation σ of the normal distribution.

shift

int shift

It is possible that a rigid distance shifts the activation time point. In such a case, the log-normal distribution of the contingent link is the same, but the sample values must be simply added to the shift to have the right value. It would be possible to adjust the location and scale of the log-normal distribution to incorporate such a shift. Still, we verified that such an adjustment introduces some approximation errors.

Class it.univr.di.cstnu.util.ObjectArrayFIFOSetQueue

class ObjectArrayFIFOSetQueue extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readObject

private void readObject(ObjectInputStream s)
                 throws ClassNotFoundException,
IOException

Parameters:

s - input stream

Throws:

ClassNotFoundException - none

IOException - none

writeObject

private void writeObject(ObjectOutputStream s)
                  throws IOException

Parameters:

s - out stream

Throws:

IOException - none

Serialized Fields

backingArray

K[] backingArray

The backing array.

Class it.univr.di.cstnu.util.ObjectPair

class ObjectPair extends Object implements Serializable

serialVersionUID:

2L

Serialized Fields

first

T first

second

T second

Package it.univr.di.labeledvalue

Class it.univr.di.labeledvalue.AbstractLabeledIntMap

class AbstractLabeledIntMap extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

count

int count

The number of elements in the map

optimize

boolean optimize

Optimize. In some applications, it is important to maintain '¬C,0', and 'C,1'. The optimization would reduce them to '⊡,0' and 'C,1'. So, set false optimized to maintain '¬C,0', and 'C,1'. The default is true.

Class it.univr.di.labeledvalue.ALabel

class ALabel extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

alphabet

ALabelAlphabet alphabet

Alphabet to map the name into an ALetter

bit0

long bit0

One long has 64 bits.
Each position is associated with an ALetter.

Status of the i-th ALetter
             bit0[i]
not present          0
present              1

cacheOfSize

byte cacheOfSize

The number of ALetters in the label Value -1 means that the size has to be calculated!

maxIndex

byte maxIndex

Index of the last significant ALetter of the label.

On 2016-03-30, I showed by SizeofUtilTest.java that using byte, it is also possible to define the 'size' field without incrementing the memory footprint of the object.

Class it.univr.di.labeledvalue.ALabel.EmptyLabel

class EmptyLabel extends ALabel implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.ALabelAlphabet

class ALabelAlphabet extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

size

byte size

The number of valid entries in ALabelAlphabet.value.

value

ALabelAlphabet.ALetter[] value

The ALetters of this alphabet.
Such an array does not contain holes.

value2int

it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<ALabelAlphabet.ALetter> value2int

To speed up the #index method, a map int2Aletter is maintained.

Class it.univr.di.labeledvalue.ALabelAlphabet.ALetter

class ALetter extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

name

String name

Class it.univr.di.labeledvalue.Constants

class Constants extends Object implements Serializable

serialVersionUID:

2L

Class it.univr.di.labeledvalue.Label

class Label extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

bit0

int bit0

Using two ints, it is possible to represent four states for each position.

Each position is associated with a proposition.

Status of the i-th literal
             bit1[i] bit0[i]
not present          0   0
straight             0   1
negated              1   0
unknown              1   1

bit1

int bit1

Using two ints, it is possible to represent four states for each position.

Each position is associated with a proposition.

Status of the i-th literal
             bit1[i] bit0[i]
not present          0   0
straight             0   1
negated              1   0
unknown              1   1

count

byte count

The number of literals in the label Value -1 means that the size has to be calculated!

maxIndex

byte maxIndex

Index of the highest-order ("leftmost") literal of the label with respect to lexicographical order.

On 2016-03-30, I showed by SizeofUtilTest.java that using byte, it is also possible to define a 'size' field without incrementing the memory footprint of the object.

Class it.univr.di.labeledvalue.LabeledALabelIntTreeMap

class LabeledALabelIntTreeMap extends Object implements Serializable

serialVersionUID:

3L

Serialized Fields

count

int count

Number of elements

labeledValueMapImpl

Class<? extends LabeledIntMap> labeledValueMapImpl

Labeled value class used in the class.

map

it.unimi.dsi.fastutil.objects.Object2ObjectRBTreeMap<ALabel, LabeledIntMap> map

Data structure.

1. An Upper/Lower Case value is a pair (nodeName, value) where nodeName is the name of a node and can be written either in all UPPER case or in all lower case. Morris & Muscettola 2005 have introduced such a constraint.
2. A labeled Upper/Lower Case value is a pair (nodeName, (proposition_label, value)), where proposition_label represents a scenario where the value holds. Such a constraint was introduced by Hunsberger, Combi, and Posenato in 2012.
3. Each proposition_label is a conjunction of literals, i.e., of type Label.
4. Since there may be more pairs with the same 'nodeName', a labeled Upper/Lower Case value is represented as a map of (nodeName, LabeledIntMap).
   See LabeledIntMap.
5. In 2017-10, `nodeName` was substituted by ALabel. ALabel represents the name of a node or a conjunction of node names.
   Such a modification has been introduced because the CSTNU DC checking algorithm requires such values.

Class it.univr.di.labeledvalue.LabeledALabelIntTreeMap.LabeledALabelIntTreeMapView

class LabeledALabelIntTreeMapView extends LabeledALabelIntTreeMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntHierarchyMap

class LabeledIntHierarchyMap extends AbstractLabeledIntMap implements Serializable

serialVersionUID:

3L

Serialized Fields

putHistory

String putHistory

Just for debugging

root

LabeledIntHierarchyMap.HierarchyNode root

Root of hierarchy

Design choice: the set of labeled values of this map is organized as a double-linked hierarchy of labeled values. A labeled value (label, value) is the father of another labeled value (label1, value1) if label1 subsumes label and value1 < value.

wellFormatCheck

boolean wellFormatCheck

Just to force the control that, after each put, the format of hierarchy is still valid. Don't set true in a production program!

Class it.univr.di.labeledvalue.LabeledIntHierarchyMap.LabeledIntHierarchyMapView

class LabeledIntHierarchyMapView extends LabeledIntHierarchyMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntSimpleMap

class LabeledIntSimpleMap extends AbstractLabeledIntMap implements Serializable

serialVersionUID:

2L

Serialized Fields

mainMap

it.unimi.dsi.fastutil.objects.Object2IntMap<Label> mainMap

Deprecated.

Map of label

updateCount

it.unimi.dsi.fastutil.objects.Object2IntMap<Label> updateCount

Deprecated.

Counter of labeled value updates.

Class it.univr.di.labeledvalue.LabeledIntSimpleMap.LabeledIntNotMinMapView

class LabeledIntNotMinMapView extends LabeledIntSimpleMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntTreeMap

class LabeledIntTreeMap extends AbstractLabeledIntMap implements Serializable

serialVersionUID:

2L

Serialized Fields

base

char[] base

A set of propositions forming a base for the labels of the map.

mainInt2SetMap

it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap<it.unimi.dsi.fastutil.objects.Object2IntMap<Label>> mainInt2SetMap

Design choice: the set of labeled values of this map is organized as a collection of sets, each containing labels of the same length. This allows the label minimization task to be performed more systematically and efficiently. The efficiency has been proved by comparing this implementation with one in which the map has been realized with a standard map, and the minimization task determines the same length labels every time it needs them.

Class it.univr.di.labeledvalue.LabeledIntTreeMap.LabeledIntTreeMapView

class LabeledIntTreeMapView extends LabeledIntTreeMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntTreeSimpleMap

class LabeledIntTreeSimpleMap extends LabeledIntTreeMap implements Serializable

Class it.univr.di.labeledvalue.LabeledLowerCaseValue

class LabeledLowerCaseValue extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

hashCode

int hashCode

cached hash code

label

Label label

nodeName

ALabel nodeName

Even if this field could be just an ALetter, it is an ALabel because the comparison between ALabels is faster than ALetter and ALabel.

value

int value