CountNodeJS (Votorola Java API)

java.lang.Object
- com.google.gwt.core.client.JavaScriptObject
- - CountNodeJS

All Implemented Interfaces:

CountNode
```
public final class CountNodeJS
extends JavaScriptObject
implements CountNode
```
A positional accounting node in a delegate cascade implemented as a JavaScript overlay type. It holds the registers for all resource superaccounts at the position. It is immutable, except that its voters may be lazily initialized.

See Also:
SacRegisterJS, Category:Position

Field Summary

Fields
Modifier and Type Field and Description

static JsArray<CountNodeJS> NULL_BOARD
An array of length 20 filled with null values.
- Fields inherited from interface CountNode
  DART_SECTOR_MAX

Fields
Modifier and Type	Field and Description
`static JsArray<CountNodeJS>`	`NULL_BOARD` An array of length 20 filled with null values.

Constructor Summary

Constructors
Modifier Constructor and Description

protected CountNodeJS()

Constructors
Modifier	Constructor and Description
`protected`	`CountNodeJS()`

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.
`CountJS`	`count()` The parent count of this count node.
`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.
`static CountNodeJS`	`findNode(String name, JsArray<CountNodeJS> nodes)` Returns the node of the specified name from the array of nodes, or null if there is no such node.
`(package private) void`	`init(String name, JsMap<CountNodeJS> wiredNodes, CountJS count)` Initializes this node from a server response.
`(package private) void`	`initVoters(JsArrayString voterNames, JsMap<CountNodeJS> wiredNodes)` Initializes this node's voters from a server response.
`boolean`	`isBaseCandidate()` Answers whether this node is a root candidate or a cycler.
`boolean`	`isCandidate()` Answers whether this node has a voter.
`boolean`	`isCycler()` Answers whether this node is voting for a voter of it's own, directly or indirectly.
`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.
`<R extends SacRegisterJS> R`	`register(String countingMethodName, String accountName)` Returns this node's superaccount register for the specified counting method and account name; or null if no such register exists.
`<R extends SacRegisterJS> JsMap<CountingMethodJS<R>>`	`registers()` Superaccount registers at this node, indexed first by the page name of the counting method, then by the account name.
`StringBuilder`	`requestVoters_loc(StringBuilder b)` Appends the location for calls to `requestVoters` and returns the string builder.
`JsonpRequest<CountCache.WAPResponse>`	`requestVoters(String loc, AsyncCallback<CountNodeJS> callback)` Requests this node's voters from the count engine.
`SacRegisterJS_v`	`voteRegister()` The vote register at this node.
`JsArray<CountNodeJS>`	`voters()` A sparse array of the dart sectored voters, if known.

Methods inherited from class com.google.gwt.core.client.JavaScriptObject
_delete, _get, _getBoolean, _getByte, _getChar, _getDouble, _getFloat, _getInt, _getShort, _getString, _hasOwnProperty, _hasProperty, _propertyIsEnumerable, _set, _setBoolean, _setByte, _setChar, _setDouble, _setFloat, _setInt, _setShort, _setString, cast, createArray, createArray, createFunction, createObject, equals, hashCode, toSource, toString

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

- Field Detail
  - NULL_BOARD
```
public static final JsArray<CountNodeJS> NULL_BOARD
```
    An array of length 20 filled with null values. Do not modify it.
- Constructor Detail
  - CountNodeJS
```
protected CountNodeJS()
```
- Method Detail
  - init
```
void init(String name,
        JsMap<CountNodeJS> wiredNodes,
        CountJS count)
```
    Initializes this node from a server response. If this node does not exist on the server, it is assigned default values for all state variables, including its voters.
    
    Parameters:
    wiredNodes - the "nodes" as received in the response.
    See Also:
    name()
  - initVoters
```
void initVoters(JsArrayString voterNames,
              JsMap<CountNodeJS> wiredNodes)
```
    Initializes this node's voters from a server response.
    
    Parameters:
    voterNames - the 'voters' as named in the response.
    wiredNodes - the "nodes" as received in the response.
  - count
```
public CountJS count()
```
    The parent count of this count node.
  - findNode
```
public static CountNodeJS findNode(String name,
                   JsArray<CountNodeJS> nodes)
```
    Returns the node of the specified name from the array of nodes, or null if there is no such node.
    
    Parameters:
    nodes - the array of nodes to search, which may contain null elements.
  - register
```
public <R extends SacRegisterJS> R register(String countingMethodName,
                                   String accountName)
```
    Returns this node's superaccount register for the specified counting method and account name; or null if no such register exists.
  - registers
```
public <R extends SacRegisterJS> JsMap<CountingMethodJS<R>> registers()
```
    Superaccount registers at this node, indexed first by the page name of the counting method, then by the account name.
    
    See Also:
    CountWAP
  - requestVoters
```
public JsonpRequest<CountCache.WAPResponse> requestVoters(String loc,
                                                 AsyncCallback<CountNodeJS> callback)
```
    Requests this node's voters from the count engine.
    
    Parameters:
    callback - the callback to receive the response, the response being this count node with its voters set.
    See Also:
    voters(), requestVoters_loc(StringBuilder)
  - requestVoters_loc
```
public StringBuilder requestVoters_loc(StringBuilder b)
```
    Appends the location for calls to requestVoters and returns the string builder.
  - voteRegister
```
public SacRegisterJS_v voteRegister()
```
    The vote register at this node.
  - voters
```
public JsArray<CountNodeJS> voters()
```
    A sparse array of the dart sectored voters, if known. The array is indexed from zero with null elements for empty sectors. When the value of this array becomes known, the cache fires a count node event via the event bus.
    
    Returns:
    an array of length 20, or null if the voters are not yet known.
    See Also:
    requestVoters(String,AsyncCallback), initVoters(JsArrayString,JsMap)
  - candidateName
```
public String candidateName()
```
    Description copied from interface: CountNode
    
    Identifies the candidate selected by the person, for whom a vote is to be cast if the person is a voter.
    
    Specified by:
    
    candidateName in interface CountNode
    
    Returns:
    the mailish username of the candidate, or null if none was selected.
  - dartSector
```
public 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.
  - directVoterCount
```
public 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 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:
    Property:Display_title
  - isBaseCandidate
```
public 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 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 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 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 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:
    theory.xht#cycle
  - 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

Class CountNodeJS

Field Summary

Fields inherited from interface CountNode

Constructor Summary

Method Summary

Methods inherited from class com.google.gwt.core.client.JavaScriptObject

Methods inherited from class java.lang.Object

Field Detail

NULL_BOARD

Constructor Detail

CountNodeJS

Method Detail

init

initVoters

count

findNode

register

registers

requestVoters

requestVoters_loc

voteRegister

voters

candidateName

dartSector

directVoterCount

displayTitle

isBaseCandidate

isCandidate

isCycler

isRootCandidate

isVoter

name