# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
  Class | Description
  --- | ---
  ActivateBonusWrapper |
  AllRuleSets | Stores rule sets, and allows lookup by name.
  AnalyzeTranscripts | Methods for the statistical analysis of game transcripts.
  AnalyzeTranscripts.P0andR |
  AnalyzeTranscripts.TrialListMap | Lists all trial lists for an experiment plan.
  AppContextListener | This listener is used so that we can safely stop the MaintenanceThread when the web app is undeployed.
  ArithmeticResult | A tool for an easy online testing of arithmetic expression evaluation.
  Arrows |
  AutomaticRuleGenerator | An AutomaticRuleGenerator is used to create multiple rule set files based on the same pattern.
  AutomaticRuleGeneratorService | The AutomaticRuleGenerator demo service.
  Board |
  Board.Pos | Can be used to describe the position of a piece on the [1:N]x[1:N] grid, or that of a bucket (at (0,0), ...
  BoardConditionsChecker | For the training/testing restrictions on boards, as introduced in GS 6.010.
  BoardDisplayService | HTML display for user-upload boards (in JSON format), for use by the ML team (Shubham)
  BoardDisplayService.BoardList |
  BoardManager | Reading and writing Boards to CSV files
  Captive | The main class for the Captive Game Server
  ChatWriteReport |
  CheckPlanService | The "Check my experiment plan" service.
  Clustering |
  ColorMap |
  Comparandum | Represents a thing to be compared using the Mann-Whitney-test: either an algo (which is to be compared with other algos based on its performance on some rule set), or a rule set (which is being compare to other rule set based on how a particular algo, or the set of humans, perform on it).
  Composite | The description of a single composite ImageObject, or a family of such objects, obtained by parsing its name (which may contain wildcards).
  Composite.Generator | A tool for drawing concrete ImageObjects from a family defined by a Composite object, or a union of such families.
  ContextInfo | Prepares some information needed for proper URL construction in our app.
  ConvertRules | This class is used for a one-off project: converting the list of rules found in Kevin's GUI (stored in a JSON file there) to text files describing rules in a similar, but slightly different, format used by our server.
  CreateRoles | A very simple, stand-alone program that creates necessary Role entities in the roles table, and at least one User entity.
  CsvData | Represents the entire content of a CSV file.
  CsvData.BasicLineEntry |
  CsvData.CommentEntry | Stores a comment line from the CSV file.
  CsvData.LineEntry |
  Display | An annotation describing how, if at all, a particular data field (content of a SQL database column) is to be displayed in HTML tables and data entry forms etc.
  Ecd |
  EligibilityForOrders | At present, pieces in which cells are eligible for picking under each of the existing orders? (For example, which pieces are presently in the topmost occupied row? Which piece is the first in the English reading order?) This structure needs to be updated every time a piece is removed from the board.
  Episode | An Episode is a single instance of a Game played by a person or machine with our game server.
  Episode.CODE | Return codes for the /move and /display API web API calls, and for the MOVE command in the captive game server.
  Episode.FINISH_CODE | Values that may be returned by getFinishCode(), describing the episode's status
  Episode.Move | A Move instance describes an [attempted] act of picking a piece and dropping it into a bucket.
  Episode.OutputMode |
  Episode.Pick | A Pick instance describes the act of picking a piece, without specifying its destination
  EpisodeHandle | An auxiliary structure containing an episode's metadata.
  EpisodeInfo | An EpisodeInfo instance extends an Episode, containing additional information related to it being played as part of an experiment.
  EpisodeMemory | Auxiliary data structures for the Episode class, keeping track of "memory variables".
  ExportTable | This is a substitute for something like this:
  Expression |
  Expression.AdditiveExpression |
  Expression.ArithmeticExpression | An arithmetic expression is composed of variables, constants, and arithmetic operations; parentheses can be used for ordering operations.
  Expression.BracketList |
  Expression.ColonExpression | Id:ArithmeticExpression; used in GS 3
  Expression.ComparisonExpression | Has exactly two operands, and the operator is one of '==', '!=', '<=', '>', etc
  Expression.ExList | Can be overridden as needed
  Expression.Id | A variable.
  Expression.Mapper | A Mapper is something that can take a variable (Expression.Id) and produce another Expression (e.g.
  Expression.MapTo<T> | A HashMap storing a set of values of a given type T for each key
  Expression.MultiplicativeExpression |
  Expression.NegationExpression | !E evaluates to [1] if E is an empty set, or to [] otherwise
  Expression.Num | A numeric constant
  Expression.ParenList |
  Expression.PropMap | Values are String or Integer
  Expression.QualifiedId | A.B
  Expression.RangeExpression | [Num..Num]
  Expression.SerialExpression | Additive or multiplicative
  Expression.Star | A Star expression is simply "*".
  Expression.VarMap |
  Expression.VarMap2 | Objects in question may be Integer, String, or PropMap (ImageObject or equivalent)
  ExtendedSessionManagement | This class is used to manage extended sessions, which survive over the web server restart.
  Files | Information about the data files the Rule Game web server reads and writes.
  Files.Saved | Names of subdirectories under "saved"
  FileUploadResource |
  FileWriteReport | This data structure is converted to JSON and send to the client in response to the /writeFile web API call.
  Fmter | Auxiliary class for formatting output as plain text of HTML.
  FrontEndForm2 | For Tanvi: helps the player to generate a unique playerID
  Game | A Game object defines how an Episode may be created.
  GameGenerator | A GameGenerator generates random games (with the same rule set and randomly created initial boards) based on the provided parameter range specifications
  GameGenerator.Features |
  GamePlayException |
  GameService | The "First Batch" of API calls, primarily for use in the research environment, where a player can choose any game to play
  GameService2 | The "Second Batch" of API calls, primarily for use with players constrained by an experiment plan, and playing a sequence of games as outlined in the trial list to which the player is assigned.
  GameService2Html | The page generator for the HTML Play interface.
  GameServiceHtml | The HTML wrapper for the First Batch calls, to allow for the "HTML Play".
  GameSocketServer | The socket implementation of a captive game server.
  GeminiPlayer |
  GeminiRequest |
  GeminiRequest.ContentElement |
  GeminiRequest.ElementPart |
  GeminiRequest.InstructionElement |
  GetBookletPageServlet | Returns the content of an image file (SVG, PNG, etc) for one of the pages of the instruction booklet.
  GetBookletPageWrapper | Returns the content of the specified page of the instruction booklet for the specified player
  GetImageServlet | Returns the content of an image file (SVG, PNG, etc) for the specified shape.
  GetSvgWrapper | Returns the content of the SVG file for the specified shape
  GiveUpWrapper |
  GuessWriteReport | This data structure is converted to JSON and send to the client in response to the /guess web API call.
  Hosts | Convenience routines to determine the host name etc
  HtmlDisplay | Drawing boards in HTML.
  HTMLFmter | Auxiliary class for formatting output as HTML.
  IllegalInputException | An exception of this type is thrown when we want to report to the user that the data he's entered are invalid
  ImageObject | Describes an image-and-properties-based object.
  ImageObject.Generator | An image generator is an object that can be used to obtain a random IPB object.
  ImageObject.PickFromList | A Generator interface to a stored list of ImageObjects, from which they can be retrieved at random.
  ImageObjectReport |
  ImportCSV | Methods responsible for parsing CSV files.
  JsonReflect | Tools for exporting Java objects as JSON structures
  JsonToJava | Tools for importing Java objects from JSON structures.
  LabelMap | Maps "false.someThingXandY" to "X", etc.
  LaunchMain | As requested by Paul, "Rule Game -- challenge UWisc faculty and staff", 2021-09-23.
  LaunchRules | The Launch page that allows one to play all rule sets from a specific subdirectory of the rules directory, such as rules/APP, rules/BRM, or rules/CGS.
  LaunchRulesBase | The common base for the Launch pages that allows one to play all rule sets from rules/APP, rules/MLC, and others.
  LaunchRulesBase.AndroidRuleInfoReport | The list of rule sets to be displayed in the Android app
  LaunchRulesBase.Mode | The name refers to the directory from whih trial lists or rule sets are read
  LaunchRulesBase.RuleInfo | An auxiliary class that can be used to transmit information about the buttons etc the Android app needs to display
  ListShapesWrapper | Lists all available shapes
  Logging | Methods used by CHEETA to log warning and error messages.
  LoginServlet |
  LogoutServlet |
  Main | An object that is responsible for getting EntityManager object(s) for the application.
  MainConfig | A MainConfig is a structure storing the content of a configuration file.
  MaintenanceThread | This thread performs maintenance functions, such as marking episodes as "abandoned"
  ManagerDashboardService | Tools for the manager dashboard.
  MannWhitney | The Mann-Whitney math
  MannWhitneyComparison | Comparing players or rules based on the Mann-Whitney test
  MannWhitneyComparison.Mode |
  MergeDatasets |
  MlcEntry | An MlcEntry contains the data for a (participant, ruleset, run) tuple.
  MlcLog | An auxiliary class used by the Captive Game Server for the optional logging of MLC run results.
  MlcLog.LogFormat | Supported log file formats
  MlcLoginServlet | The login page for the MLC results sumbission tool
  MlcMain | The back end behind web/mlc/index.jsp
  MlcManagerDashboard |
  MlcUploadService | Uploading and processing results files by MLC participants.
  MwByHuman | Ranking rule sets by the ease of learning by human players.
  MwByHuman.PrecMode | Used to control how series are assigned to comparanda
  MwSeries | An auxiliary class for MwByHuman, an MWSeries object contains the data for one series (group of episodes played by one player under the same rule set) needed to contribute a number to an M-W Comparandum.
  NewEpisodeWrapper |
  NewEpisodeWrapper2 | This is an object that's converted to a JSON structure and sent to the client as a response in /GameService2/newEpisode calls.
  Order | An Order object describe a built-in or custom ordering of board cells (positions)
  Order.PositionSelector | Names of built-in (predefined) orders
  OurTable | All our entities (corresponding to table rows) implement this.
  Pairing | Auxiliary methods for two-player games, introduced in GS 7.*.
  Pairing.State | A player's current state in the pairing system.
  ParaSet |
  ParaSet.Incentive | Various incentive schemes available to experiment designers.
  ParseConfig | This class is used to obtain configuration parameters, from a configuration file or from Java System Properties.
  Piece | Represents a piece of a specified type at a specified location.
  Piece.Color |
  Piece.PseudoEnum | A flexible replacement for an Enum
  Piece.Shape |
  PlanStats | Lists experiment plans and the number of players who played them, etc
  PlayerInfo | A PlayerInfo object represent information about a player (what trial list he's in, what episodes he's done etc) stored in the SQL database.
  PlayerInfo.Action | What type of action takes the player to a particular destination?
  PlayerInfo.COMPLETION | Completion modes
  PlayerInfo.Transition | Where can we go from here?
  PlayerResponse | The object returned by the /player call.
  PositionList | Represents the restrictions on the positions from which game pieces can be picked.
  PostOrder |
  PredefinedBoardGameGenerator | This class generates games based on a set of predefined initial boards
  PregameService | Retrieving various pages needed by the client to customize the player's pregame and postgame experience.
  PregameService.BookletSize | An HTML page + error code
  PregameService.Page | An HTML page + error code
  PregameService.PregameResponseBase | Some info + error code
  PropertiesTable | This is an auxiliary class, used to read the entire content of a properties file, and to create ImageObject objects for all image files in the directory.
  Pseudo |
  PVTest | Testing Apache Commons methods for MW and KS p-values.
  RandomGameGenerator | This class generates random games (with the same rule set and randomly created initial boards) based on the provided parameter range specifications
  RandomImageGameGenerator | This class generates random games (with the same rule set and randomly created initial boards) using image-and-property based game pieces based on the provided parameter range specifications
  RandomRG |
  RecentKnowledge | An auxiliary data structure, used as an element of EpisodeInfo.ExtendedDisplay, used to sent to the GUI client, in a concise form, the info about the knowledge of the board acquired through the recent players' actions (those since the last board change, i.e the last successful move).
  RecentKnowledge.Datum | Which game piece do we know something about, and what do we know about it?
  Reflect | A bunch of methods to figure what fields a class has, and how to print them out in a more or less sensible way.
  Reflect.Entry | An entry describes one field of the class, complete with its access methods (getter and setter) and the display hints
  ReplayedEpisode | Built on top of an Episode object, a ReplayedEpisode is created during the analysis of transcripts, in order to recreate the episode's events step by step.
  ReplayedEpisode.RandomPlayer | The possible random player models.
  ResponseBase | The parent class for various structures that are returned, in JSON form,' by REST calls.
  ResultsBase | The base of all "results object" classes used in JSP pages
  Role | A role is simply a database-storable wrapper around the role name
  Role.Name |
  RuleParseException |
  RuleSet | A RuleSet describes the rules of a game.
  RuleSet.Atom | Syntax:(counter,shape,color,position,bucketFunctions)
  RuleSet.BucketList | A BucketList represents the information about the destination buckets given in the "buckets" field of an atom.
  RuleSet.BucketSelector | The list of "legacy" variables that can be used in the bucket expression.
  RuleSet.Row | A row object represents the content of one line of the rule set description file, i.e.
  SessionData | A single instance of this class is associated with a particular session of the Rule Game web app.
  StalemateTester | Tools for testing a rule set for a possibility of a stalemate.
  SvgEcd | Utilities for generating SVG plots for ECD data
  SvgEcd.Point |
  Test | Used for testing JPA persistence features
  TestChild | An EpisodeInfo instance extends an Episode, containing additional information related to it being played as part of an experiment.
  TestParent |
  Token | A token represents an element of the input text.
  Token.Type |
  Tools | Various methods related to generating HTML forms and their components, and processing requests sent by the web browser when those forms are filled
  TranscriptManager | An auxiliary class for writing and reading transcript files.
  TranscriptManager.ReadTranscriptData | Some of the transcript data read back from a file.
  TranscriptManager.ReadTranscriptData.Entry | Stores the content of one line (representing one move/pick attempt) read back from the transcript file
  TrialList |
  TrialList.ExperimentPlanHandle | Identifies an experiment plan as a static or dynamic (P: or R: type) one
  TrivialGameGenerator | Just keeps returning the same game every time
  User | Information about a repeat user (who may own multiple playerId) stored in the SQL database.
  UserResponse | Used by LoginServlet and the Android app for registering new users and logging in
  Util | Auxiliary methods for manipulating hash tables etc
  Util.CopyInfo | File copy statistics
  WatchPlayer |
  WatchPlayer.PickEncoder | See https://docs.oracle.com/javaee/7/tutorial/websocket007.htm or https://www.baeldung.com/java-websockets for documentation on encoders
  WatchPlayer.Ready | Messages sent to a GUI client to tell it that something is ready for it, and it can make another /newEpisode or /display call
  WatchPlayer.ReadyEncoder |
  WatchPlayer.WatchMessage |
  WebException | This is used when a lower-level function can tell a higher-level function what kind of error it shoudl report to the end user.