CountNodeW (Votorola Java API)

java.lang.Object
- CountNodeW

All Implemented Interfaces:

Serializable, Cloneable, CountNode

Direct Known Subclasses:

CountNodeIC
```
public class CountNodeW
extends Object
implements Cloneable, CountNode, Serializable
```
A positional accounting node that is writable. It is only partly serializeable. Any deserialized instance (d) is detached from the backing table, with the consequence that calling any table-dependent method such as d.write or d.trace will result in a runtime exception.

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface CountNodeW.Runner
A routine that runs in the context of a count node.

Nested Classes
Modifier and Type	Class and Description
`static interface`	`CountNodeW.Runner` A routine that runs in the context of a count node.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static String`	`CARRY_VOLUME_ORDER_CLAUSE` An SQL order clause "ORDER BY carryVolume DESC, email" that sorts (1) numerically from highest to lowest carry count, and (2) lexically by email address.
`static Comparator<CountNode>`	`DART_SECTOR_COMPARATOR` A comparator that sorts by dart sector.
`(package private) static String`	`RECEIVE_COUNT_ORDER_CLAUSE` An SQL order clause "ORDER BY receiveVolume DESC, email" that sorts (1) numerically from highest to lowest receive count, and (2) lexically by email address.

Fields inherited from interface CountNode
DART_SECTOR_MAX

Constructor Summary

Constructors
Constructor and Description
`CountNodeW(CountTable.PollView _tablePV)` Partially creates a CountNodeW with default values, for init to finish.
`CountNodeW(CountTable.PollView _tablePV, IDPair _person)` Creates a CountNodeW with default values.
`CountNodeW(CountTable.PollView _tablePV, IDPair _person, String _bar, String _candidateEmail, long _carryVolume, byte _dartSector, long _directVoterCount, boolean _isCast, boolean _isCycler, long _rank, long _rankIndex, long _receiveVolume, long _time, String xml)` Constructs a CountNodeW.

Method Summary

Methods
Modifier and Type	Method and Description
`String`	`candidateName()` Identifies the candidate selected by the person, for whom a vote is to be cast if the person is a voter.
`long`	`carryVolume()` The volume of received votes that flows to the candidate node along with the cast volume.
`(package private) CountNodeW[]`	`cast()` Casts the vote if there is one, and returns the resulting vote trace.
`(package private) void`	`castCyclic(CountNodeW[] trace)` Casts and carries down a cyclic trace that involves this node.
`(package private) CountNodeW[]`	`castSolo()` Casts the vote (if there is one) without carrying any received votes along.
`(package private) void`	`castStraight(CountNodeW[] trace)` Casts and carries down an acyclic trace.
`long`	`castVolume()` The weight of any original vote that is actually cast for the candidate by this node; either 0 or 1.
`CountNodeW`	`clone()`
`byte`	`dartSector()` The dart sector occupied by this node, if any.
`Long`	`directVoterCount()` The number of other nodes that name this node as a candidate.
`String`	`displayTitle()` The display title of the person's position, or null if there is none.
`String`	`email()` Returns person().
`boolean`	`equals(Object o)` Returns true iff the o is a count node for the same person.
`static String`	`finalRecipientOrNobody(CountNodeW[] trace, ResourceBundle resA)` Returns the email address of the final recipient of the trace, or the localized string for "nobody".
`String`	`getBar()` Describes any bar against the person voting in the poll.
`String`	`getCandidateEmail()` Identifies the candidate selected by the person, for whom a vote is to be cast if the person is a voter.
`String`	`getLocation()` The non-default location of the person's position document, or null if the document is at the default location in the pollwiki.
`long`	`getRank()` The rank assigned to this node, with respect to votes received.
`long`	`getRankIndex()` The unique index that is assigned to this node by order of rank, and (secondarily) email address.
`String`	`getSource()` The mnemonic of the source engine if it is not the local vote-server.
`long`	`getTime()` Specifies the time at which the person last altered the vote.
`long`	`holdVolume()` The volume of votes held.
`(package private) void`	`init(IDPair _person)` Initializes the node by identifying the person.
`(package private) boolean`	`isBarrable()` Answers whether a bar might be set.
`(package private) static boolean`	`isBarrable(String username, ReadyDirectory readyDirectory)` Answers whether the specified person would be barrable.
`boolean`	`isBaseCandidate()` Answers whether this node is a root candidate or a cycler.
`boolean`	`isCandidate()` Answers whether this node has a voter.
`boolean`	`isCast()` Answers whether a vote of any weight (zero or one) has actually been cast for the chosen candidate.
`boolean`	`isCycler()` Answers whether this node is voting for a voter of it's own, directly or indirectly.
`boolean`	`isImage()` True if the source of the vote is another voting engine, false if the source is the local vote-server.
`boolean`	`isPersonal()` Answers whether the person is actual (true), as opposed to merely formal (false).
`(package private) static boolean`	`isPersonal(String username, ReadyDirectory readyDirectory)` Answers whether the specified person would be personal.
`boolean`	`isRootCandidate()` Answers whether this node is a candidate who is not a voter.
`boolean`	`isVoter()` Answers whether the candidate is non-null and non-identical with the person.
`String`	`name()` The mailish username of the person for whom this node accounts.
`IDPair`	`person()` The person for whom this node accounts.
`long`	`receiveVolume()` The volume of votes received from other nodes.
`(package private) void`	`setBar(String newBar)` Sets a bar against the person.
`(package private) void`	`setCandidateEmail(String newCandidateEmail)` Changes the candidate selected by the person.
`(package private) void`	`setDartSector(int _newSector)` Sets the dart sector occupied by this node.
`(package private) void`	`setDisplayTitle(String newDisplayTitle)` Sets the display title.
`(package private) void`	`setLocation(String newLocation)` Sets the non-default location of the person's position document.
`(package private) void`	`setRank(long newRank)` Assigns a rank to this node.
`(package private) void`	`setRankIndex(long newRankIndex)` Assigns a rank index to this node.
`(package private) void`	`setSource(String newSource)` Sets the source engine.
`(package private) void`	`setTime(long newTime)` Sets the time at which the person last altered the vote.
`CountTable.PollView`	`tablePV()` The table in which this node is stored, or null if this is a deserialized, read-only node.
`String`	`toString()` Returns the person's email address.
`CountNodeW[]`	`trace()` Traces the route that a vote would follow if it were cast from this node, without forcing the trace beyond uncast nodes.
`(package private) CountNodeW[]`	`trace(boolean toForce)` Traces the route that a vote would follow if it were cast from this node.
`(package private) CountNodeW[]`	`uncast()` Withdraws the vote if one was cast, and returns the resulting vote trace.
`(package private) void`	`uncastCyclic(CountNodeW[] trace)` Withdraws cast and carried votes from a cyclic trace that involves this node.
`(package private) void`	`uncastStraight(CountNodeW[] trace)` Withdraws cast and carried votes from an acyclic trace.
`long`	`voteWeight()` The weight of original votes castable for a candidate by this node; either 0 or 1.
`(package private) void`	`write()` Writes this node to the table if it has unwritten changes.

Methods inherited from class java.lang.Object
finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - CARRY_VOLUME_ORDER_CLAUSE
```
static final String CARRY_VOLUME_ORDER_CLAUSE
```
    An SQL order clause "ORDER BY carryVolume DESC, email" that sorts (1) numerically from highest to lowest carry count, and (2) lexically by email address. The purpose of including the email address is to stabilize the order.
    
    See Also:
    Constant Field Values
  - DART_SECTOR_COMPARATOR
```
public static final Comparator<CountNode> DART_SECTOR_COMPARATOR
```
    A comparator that sorts by dart sector.
  - RECEIVE_COUNT_ORDER_CLAUSE
```
static final String RECEIVE_COUNT_ORDER_CLAUSE
```
    An SQL order clause "ORDER BY receiveVolume DESC, email" that sorts (1) numerically from highest to lowest receive count, and (2) lexically by email address. The purpose of including the email address is to stabilize the order.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - CountNodeW
```
CountNodeW(CountTable.PollView _tablePV)
```
    Partially creates a CountNodeW with default values, for init to finish.
    
    See Also:
    tablePV()
  - CountNodeW
```
CountNodeW(CountTable.PollView _tablePV,
          IDPair _person)
```
    Creates a CountNodeW with default values.
    
    See Also:
    tablePV(), person()
  - CountNodeW
```
CountNodeW(CountTable.PollView _tablePV,
          IDPair _person,
          String _bar,
          String _candidateEmail,
          long _carryVolume,
          byte _dartSector,
          long _directVoterCount,
          boolean _isCast,
          boolean _isCycler,
          long _rank,
          long _rankIndex,
          long _receiveVolume,
          long _time,
          String xml)
     throws XMLStreamException
```
    Constructs a CountNodeW.
    
    Parameters:
    xml - the XML encoding of the node's non-relational properties, displayTitle, location and source, or null if all of them are at default values.
    
    Throws:
    
    XMLStreamException
    See Also:
    tablePV(), person(), getBar(), getCandidateEmail(), carryVolume(), dartSector(), directVoterCount(), isCast(), isCycler(), getRank(), getRankIndex(), receiveVolume(), getTime()
- Method Detail
  - init
```
final void init(IDPair _person)
```
    Initializes the node by identifying the person.
    
    Throws:
    
    IllegalStateException - if the person was already identified.
    See Also:
    person()
  - carryVolume
```
public final long carryVolume()
```
    The volume of received votes that flows to the candidate node along with the cast volume. The cast volume is excluded from this count.
  - castVolume
```
public final long castVolume()
```
    The weight of any original vote that is actually cast for the candidate by this node; either 0 or 1.
    
    See Also:
    carryVolume()
  - email
```
public final String email()
```
    Returns person().email().
  - finalRecipientOrNobody
```
public static String finalRecipientOrNobody(CountNodeW[] trace,
                            ResourceBundle resA)
```
    Returns the email address of the final recipient of the trace, or the localized string for "nobody".
    
    Parameters:
    resA - a resource bundle of type application (A).
  - getBar
```
public final String getBar()
```
    Describes any bar against the person voting in the poll. A barred person may still cast a vote, but the vote has a weight of zero. Bars are set only for barrable nodes.
    
    Returns:
    a description of the bar, or null if no bar has been set.
    See Also:
    VoteCastingContext.getBar(), isBarrable(), setBar(String)
  - isBarrable
```
final boolean isBarrable()
```
    Answers whether a bar might be set. Bars are not set for impersonal nodes, which are always zero-weight regardless.
    
    See Also:
    getBar()
  - isBarrable
```
static boolean isBarrable(String username,
                 ReadyDirectory readyDirectory)
```
    Answers whether the specified person would be barrable.
    
    See Also:
    getBar()
  - setBar
```
final void setBar(String newBar)
```
    Sets a bar against the person.
    
    See Also:
    getBar()
  - getCandidateEmail
```
public final String getCandidateEmail()
```
    Identifies the candidate selected by the person, for whom a vote is to be cast if the person is a voter.
    
    Returns:
    the canonical email address of the candidate, or null if none was selected.
    See Also:
    candidateName(), setCandidateEmail(String)
  - setCandidateEmail
```
final void setCandidateEmail(String newCandidateEmail)
```
    Changes the candidate selected by the person. In order for the change to properly affect the count, call uncast beforehand, then cast afterwards.
    
    See Also:
    getCandidateEmail()
  - getLocation
```
public final String getLocation()
```
    The non-default location of the person's position document, or null if the document is at the default location in the pollwiki. This facility is intended for the support of vote mirroring and currently has no connection with the remote drafts of free-range drafting.
    
    See Also:
    setLocation(String), Category:Draft
  - setLocation
```
final void setLocation(String newLocation)
```
    Sets the non-default location of the person's position document.
    
    See Also:
    getLocation()
  - getRank
```
public final long getRank()
```
    The rank assigned to this node, with respect to votes received. The numerical minimum is a rank of 1 (top rank), assigned to the node(s) receiving the most votes. Rank progresses incrementally, with gaps. All nodes receiving the same volume of votes are assigned the same rank. This can result in gaps, as shown here (rank 3 is missing):
    1, 2, 2, 4, 5, 5, 5, 5, 5, 5, 5
    
    In the example above, two candidates are tied for second place (rank 2). The bottom rank of 5 is shared by 7 people who are probably non-candidates, receiving no votes.
    
    Returns:
    a rank of 1, or larger. Or zero if no rank has been assigned, because the count is still in progress.
    See Also:
    setRank(long)
  - setRank
```
final void setRank(long newRank)
```
    Assigns a rank to this node.
    
    See Also:
    getRank()
  - getRankIndex
```
public final long getRankIndex()
```
    The unique index that is assigned to this node by order of rank, and (secondarily) email address.
    
    Returns:
    a rank index of 0 or larger.
    See Also:
    setRankIndex(long), CountTable.createIndices()
  - setRankIndex
```
final void setRankIndex(long newRankIndex)
```
    Assigns a rank index to this node.
    
    See Also:
    getRankIndex()
  - getSource
```
public final String getSource()
```
    The mnemonic of the source engine if it is not the local vote-server. When non-null, the return value is the name of a mirror source directory S located at ~/votorola/in/vomir/S, and any vote that is cast is an image.
    
    Returns:
    mnemonic of source engine, or null if the source is the local vote-server.
    See Also:
    setSource(String), InputStore.U.mirrorSourceDirectories(VoteServer)
  - setSource
```
final void setSource(String newSource)
```
    Sets the source engine.
    
    See Also:
    getSource()
  - getTime
```
public final long getTime()
```
    Specifies the time at which the person last altered the vote.
    
    Returns:
    time in milliseconds since the Epoch, or 0L if unknown or if the vote has never been altered by the person.
    See Also:
    setTime(long), Vote.getTime()
  - setTime
```
final void setTime(long newTime)
```
    Sets the time at which the person last altered the vote.
    
    See Also:
    getTime()
  - holdVolume
```
public final long holdVolume()
```
    The volume of votes held. This is simply receiveVolume - carryVolume.
  - isCast
```
public final boolean isCast()
```
    Answers whether a vote of any weight (zero or one) has actually been cast for the chosen candidate. The value is identical to isVoter in a fully tallied count, or after cast or castSolo is called.
    
    See Also:
    uncast()
  - cast
```
final CountNodeW[] cast()
                 throws SQLException,
                        XMLStreamException
```
    Casts the vote if there is one, and returns the resulting vote trace.
    
    Throws:
    
    IllegalStateException - if the vote is already cast.
    
    SQLException
    
    XMLStreamException
    See Also:
    isCast()
  - castSolo
```
final CountNodeW[] castSolo()
                     throws SQLException,
                            XMLStreamException
```
    Casts the vote (if there is one) without carrying any received votes along. This is relatively fast and straightforward, but it works only when exhaustively casting all nodes from scratch. Do not use this method when shifting a vote.
    
    Returns:
    the resulting vote trace, which is a forced trace.
    
    Throws:
    
    IllegalStateException - if the vote is already cast.
    
    SQLException
    
    XMLStreamException
    See Also:
    isCast()
  - uncast
```
final CountNodeW[] uncast()
                   throws SQLException,
                          XMLStreamException
```
    Withdraws the vote if one was cast, and returns the resulting vote trace. Does not null the candidate.
    
    Throws:
    
    SQLException
    
    XMLStreamException
    See Also:
    isCast()
  - isImage
```
public final boolean isImage()
```
    True if the source of the vote is another voting engine, false if the source is the local vote-server.
    
    See Also:
    getSource()
  - isPersonal
```
public final boolean isPersonal()
```
    Answers whether the person is actual (true), as opposed to merely formal (false). Only an actual person may cast a vote of non-zero weight.
    
    See Also:
    Category:Impersonal user
  - isPersonal
```
static boolean isPersonal(String username,
                 ReadyDirectory readyDirectory)
```
    Answers whether the specified person would be personal.
  - person
```
public final IDPair person()
```
    The person for whom this node accounts.
  - receiveVolume
```
public final long receiveVolume()
```
    The volume of votes received from other nodes.
    
    See Also:
    carryVolume, holdVolume()
  - tablePV
```
public final CountTable.PollView tablePV()
```
    The table in which this node is stored, or null if this is a deserialized, read-only node.
  - trace
```
public final CountNodeW[] trace()
                         throws SQLException,
                                XMLStreamException
```
    Traces the route that a vote would follow if it were cast from this node, without forcing the trace beyond uncast nodes.
    
    Returns:
    array of nodes from the casting node (index 0) to the terminal node (length-1).
    
    Throws:
    
    SQLException
    
    XMLStreamException
  - trace
```
final CountNodeW[] trace(boolean toForce)
                  throws SQLException,
                         XMLStreamException
```
    Traces the route that a vote would follow if it were cast from this node.
    
    Parameters:
    toForce - true to continue tracing beyond nodes that have yet to cast; false to end the trace at the first such node.
    
    Returns:
    array of nodes from the casting node (index 0) to the terminal node (length-1).
    
    Throws:
    
    SQLException
    
    XMLStreamException
  - voteWeight
```
public final long voteWeight()
```
    The weight of original votes castable for a candidate by this node; either 0 or 1. The weight is 1 only if no bar is present and the node is personal.
    
    See Also:
    castVolume()
  - write
```
final void write()
          throws SQLException
```
    Writes this node to the table if it has unwritten changes.
    
    Throws:
    
    SQLException
  - candidateName
```
public final String candidateName()
```
    Identifies the candidate selected by the person, for whom a vote is to be cast if the person is a voter. This method is relatively slow in comparison to getCandidateEmail.
    
    Specified by:
    
    candidateName in interface CountNode
    
    Returns:
    the mailish username of the candidate, or null if none was selected.
  - dartSector
```
public final byte dartSector()
```
    Description copied from interface: CountNode
    The dart sector occupied by this node, if any. Dart sectors are used to construct user interface views that are relatively stable over long periods of time despite vote shifts. A node must be in the top 20 of its respective board (peers or end-candidates) in regard to vote flow in order to occupy a dart sector. The sector is assigned at random. The occupying node will not ordinarily be displaced from its assigned sector so long as it remains in the top 20. This is the rule of non-displacement. An exception to the rule occurs in the case of cyclers.
    A cycler has two roles for purposes of sectoring: voter and end-candidate. If the cycler is not among the top 20 of end-candidates, then she (or he) will occupy no sector in either role. Otherwise she will occupy the same sector in both roles. It is therefore possible that she (now in the role of voter) will displace a co-voting peer from a pre-occupied sector. This is the one exception to the rule of non-displacement. To illustrate, consider the cycle pictured below. If the cycle is formed by (s) casting for (c), then it is possible for one of (p) to be forced to a different dart sector.
```
           ( )       ( )
             \  ( )  /
              \  |  /
               \ | /          |
   ( )          \|/           | vote flow
     \    ( )---(s)   (p)     V
      \   /       \   /
       \ /         \ /
       ( )         (c)----(p)
         \         /
          \       /
          ( )---( )


               <---
```
    Dart sector assignments are persisted from count to count in the voter input table. Reassignments occur at count time due to collisions from vote shifts and these are persisted individually. Where a count based on an old snapshot of the voter input is remounted, the reassignments of that count might (supposedly) clobber those of historically more recent counts. The result would be a degree of sector displacement surfacing on the next count, based on a new snapshot of the voter input. This should be corrected when voter input storage is expanded to include historical vote shifts and other changes of vote data, as sector reassignments would then be recorded in historical sequence.
    
    Acknowledgement: Dart sectoring was first proposed by Thomas von der Elbe. See Start/Metagov 2011-April/003824.
    Specified by:
    
    dartSector in interface CountNode
    
    Returns:
    a value of 1 to 20, or zero if this node occupies no dart sector.
    See Also:
    setDartSector(int)
  - setDartSector
```
final void setDartSector(int _newSector)
```
    Sets the dart sector occupied by this node.
    
    See Also:
    dartSector()
  - directVoterCount
```
public final Long directVoterCount()
```
    Description copied from interface: CountNode
    
    The number of other nodes that name this node as a candidate.
    
    Specified by:
    
    directVoterCount in interface CountNode
  - displayTitle
```
public final String displayTitle()
```
    Description copied from interface: CountNode
    
    The display title of the person's position, or null if there is none.
    
    Specified by:
    
    displayTitle in interface CountNode
    
    See Also:
    setDisplayTitle(String)
  - setDisplayTitle
```
final void setDisplayTitle(String newDisplayTitle)
```
    Sets the display title.
    
    See Also:
    displayTitle()
  - isBaseCandidate
```
public final boolean isBaseCandidate()
```
    Description copied from interface: CountNode
    
    Answers whether this node is a root candidate or a cycler.
    
    Specified by:
    
    isBaseCandidate in interface CountNode
    
    See Also:
    glossary#base_candidate
  - isCandidate
```
public final boolean isCandidate()
```
    Description copied from interface: CountNode
    
    Answers whether this node has a voter.
    
    Specified by:
    
    isCandidate in interface CountNode
    
    See Also:
    glossary#candidate
  - isCycler
```
public final boolean isCycler()
```
    Description copied from interface: CountNode
    
    Answers whether this node is voting for a voter of it's own, directly or indirectly.
    
    Specified by:
    
    isCycler in interface CountNode
    
    See Also:
    glossary#cycler
  - isRootCandidate
```
public final boolean isRootCandidate()
```
    Description copied from interface: CountNode
    
    Answers whether this node is a candidate who is not a voter.
    
    Specified by:
    
    isRootCandidate in interface CountNode
    
    See Also:
    glossary#root_candidate
  - isVoter
```
public final boolean isVoter()
```
    Description copied from interface: CountNode
    
    Answers whether the candidate is non-null and non-identical with the person. One may vote for oneself only in a manner of speaking, because such a "vote" is actually a "null cycle, equivalent to a withheld vote." Here it is accounted as not voting at all. Meanwhile, a zero-weight vote for another person, even if it happens to carry no other votes along with it, is nevertheless accounted as voting; although it cannot affect the count in the present, it will affect the count in future if this node ever receives (and thus carries) a weight of votes.
    
    Specified by:
    
    isVoter in interface CountNode
    
    See Also:
    isCast()
  - name
```
public String name()
```
    Description copied from interface: CountNode
    
    The mailish username of the person for whom this node accounts.
    
    Specified by:
    
    name in interface CountNode
    
    See Also:
    person()
  - clone
```
public final CountNodeW clone()
```
    Overrides:
    
    clone in class Object
  - equals
```
public final boolean equals(Object o)
```
    Returns true iff the o is a count node for the same person.
    
    Overrides:
    
    equals in class Object
  - toString
```
public final String toString()
```
    Returns the person's email address.
    
    Overrides:
    
    toString in class Object
  - castCyclic
```
@Warning(value="non-API")
final void castCyclic(CountNodeW[] trace)
```
    Casts and carries down a cyclic trace that involves this node. This is the most complicated case. Carried votes are not held at any single terminal node, but rather are deposited here and there depending on where they entered the cycle.
    Let the following denote a series of nodes N[i], where i = 0 to n-1, in two states B and C:
```
          -> B[0]    B[1] -> B[2] -> ... -> B[n-1] --
         |                                           |
          - - - - - - - - - - - - - - - - - - - - - -


          -> C[0] -> C[1] -> C[2] -> ... -> C[n-1] --
         |                                           |
          - - - - - - - - - - - - - - - - - - - - - -
     
```
    where:
```
         -> is the route of votes within the series proper (other
         votes may enter from outside the series, but their
         entry is not shown here)

         B[i] is the state of N[i] when N[0] has withheld its vote

         C[i] is the state of N[i] when N[0] has cast for N[1],
         thus causing a cyclic cascade

         n is the number of nodes in the trace
     
```
    Given vote counts for B, calculate those for C.
```
  (1)
         C[0].receive  =  B[0].receive
     
```
    Votes received by N[0] remain constant. No vote can ever actually cycle, so the input to N[0] cannot increase when its output increases.
```
  (2)
         C[i].receive  =  C[j].receive ,   for all i, j
     
```
    Equation 2 is the flood rule. It states that all nodes in the cycle will receive the same volume of votes. This follows from the fact that a vote entering the cycle will travel until just before it encounters the entry node again. Therefore it will be received by all nodes. Likewise for casts originating within the cycle; they too are evenly distributed.
    
    From 1 and 2:
```
  (3)
         C[i].receive  =  B[0].receive ,   for all i
     
```
    Also:
```
  (4)
         C[i].hold  =  B[i+1].receive  -  B[i].receive ,   for i = 1...n-1
     
```
    Equation 4 states: except N[0], each node will come to hold whatever the following node had received before the cycle was formed, less whatever it itself had received. In other words, a node will hold whatever its successor had introduced to the cycle. This is guaranteed because each introduced vote must stop before it actually cycles.
    
    Known are C[i].receive (3) and C[i].hold (4), for i = 1...n-1. C[i].carry may therefore be calculated:
```
  (5)
         N.hold  =  N.receive  -  N.carry

         C[i].carry  =  C[i].receive  -  C[i].hold ,   for all i
     
```
    Equation 5 states that votes are conserved. Votes that are held are those received minus those carried to the candidate node. It only remains to solve for C[0].
```
  (6)
         C[0].hold  =  B[1].receive  +  B[1].cast
     
```
    Equation 6 is another instance of the rule (4) that a node holds whatever its successor had introduced into the cycle.
    
    Known are C[0].hold (6) and C[0].receive (1). C[0].carry may therefore be calculated (5).
    See Also:
    uncastCyclic(CountNodeW[]), theory.xht#cycle
  - castStraight
```
@Warning(value="non-API")
final void castStraight(CountNodeW[] trace)
```
    Casts and carries down an acyclic trace. A cycle may be present downstream in the trace, but this node (topmost) is not part of it.
    
    See Also:
    uncastStraight(CountNodeW[])
  - uncastCyclic
```
@Warning(value="non-API")
final void uncastCyclic(CountNodeW[] trace)
```
    Withdraws cast and carried votes from a cyclic trace that involves this node. This is the opposite of castCyclic, (q.v. for prior equations). Again, let the following denote a series of nodes N[i], where i = 0 to n-1, in two states C and B.
```
          -> C[0] -> C[1] -> C[2] -> ... -> C[n-1] --
         |                                           |
          - - - - - - - - - - - - - - - - - - - - - -


          -> B[0]    B[1] -> B[2] -> ... -> B[n-1] --
         |                                           |
          - - - - - - - - - - - - - - - - - - - - - -
     
```
    Given vote counts for C (when N[0] is cast and carried), calculate those for B (when N[0] is withdrawn).
```
  (7)
         B[i].hold  =  0 ,   for i = 1...n-1
     
```
    Equation 7 is true because all votes cascade to B[0]. The B series has no cycle, therefore no other node holds votes.
```
  (8)
         C[i].carry  -  B[i].carry  =  sum( C[j].hold ) ,  or

         B[i].carry  =  C[i].carry - sum( C[j].hold ) ,

         for i = 1...n-1 ,   j = i+1...n-1
     
```
    When N[0] was originally cast, the increase in carriage it caused at each node had to be balanced by an increase in holds among that node's successors. And there could have been no increase in carriage at N[n-1] (1). Therefore equation 8 must hold.
    
    Known are B[i].hold (7) and B[i].carry (8), for i = 1...n-1. B[i].receive may therefore be calculated (5).
    
    It only remains to solve for B[0]. But its vote is witheld, so there is no carriage to other nodes:
```
  (9)
         B[0].carry  =  0
     
```
    Known are B[0].carry (9) and B[0].receive (1). So B[0].hold may be calculated (5).
    See Also:
    castCyclic(CountNodeW[])
  - uncastStraight
```
@Warning(value="non-API")
final void uncastStraight(CountNodeW[] trace)
```
    Withdraws cast and carried votes from an acyclic trace. A cycle may be present downstream in the trace, but this node (topmost) is not part of it.
    
    See Also:
    castStraight(CountNodeW[])

Class CountNodeW

Nested Class Summary

Field Summary

Fields inherited from interface CountNode

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CARRY_VOLUME_ORDER_CLAUSE

DART_SECTOR_COMPARATOR

RECEIVE_COUNT_ORDER_CLAUSE

Constructor Detail

CountNodeW

CountNodeW

CountNodeW

Method Detail

init

carryVolume

castVolume

email

finalRecipientOrNobody

getBar

isBarrable

isBarrable

setBar

getCandidateEmail

setCandidateEmail

getLocation

setLocation

getRank

setRank

getRankIndex

setRankIndex

getSource

setSource

getTime

setTime

holdVolume

isCast

cast

castSolo

uncast

isImage

isPersonal

isPersonal

person

receiveVolume

tablePV

trace

trace

voteWeight

write

candidateName

dartSector

setDartSector

directVoterCount

displayTitle

setDisplayTitle

isBaseCandidate

isCandidate

isCycler

isRootCandidate

isVoter

name

clone

equals

toString

castCyclic

castStraight

uncastCyclic

uncastStraight