Packages

  • package root
    Definition Classes
    root
  • package ostrat

    This is the root package for the Openstrat project.

    This is the root package for the Openstrat project. The top of this package contains, 32 bit Int based Colours, the Multiple type class, a show and persistence library using RCON (Name may change), Rich Compact Object Notation, array based compound value collections of same length elements, an Either based errors framework and general utilities.

    Definition Classes
    root
  • package geom

    I chose the package name to not clash with "geometry" that may be use in other libraries This package contains Basic geometry.

    I chose the package name to not clash with "geometry" that may be use in other libraries This package contains Basic geometry. A number of implementation Value classes of the Int and Double product classes defined in ostrat. 2d graphical objects for generalised use. They are of particular use for the generic canvas based classes defined in pCanv but can be used in any display framework and for printing.

    Definition Classes
    ostrat
  • package pCanv

    The package attempts to encapsulate the various abstract canvas traits while the actual objects that populate a canvas go in package geom.

    The package attempts to encapsulate the various abstract canvas traits while the actual objects that populate a canvas go in package geom.

    Definition Classes
    ostrat
  • package pDev
    Definition Classes
    ostrat
  • package pEarth
    Definition Classes
    ostrat
  • package pExt
    Definition Classes
    ostrat
  • package pFx

    This package is for JavaFx code.

    This package is for JavaFx code.

    Definition Classes
    ostrat
  • package pGames

    This pSimp contains the a number of games in varying stages of development.

    This pSimp contains the a number of games in varying stages of development.

    Definition Classes
    ostrat
  • package pGrid

    This package works with hexagonal and Square tile grids.

    This package works with hexagonal and Square tile grids. The tile objects themselves will not in the general case the contain grid coordinates, although it may be necessary to include this data for complex Tile values interacting with their wider environment. Its fundamental components are the grid data itself. This is just a linear array of tile data. Compile-time typed grid data. So for example a chess board can be represented by a 64 element Arr, its context determines that it is to be interpreted as an 8 by 8 square grid. Grid descriptions that describe the grid representation in the Array and GridFunctions which implement Cood to T. The grid and grid-gui hierarchies currently contain a mix of new and old systems.

    Definition Classes
    ostrat
  • package pParse

    This is the RSON package.

    This is the RSON package. Readable Succinct Object Notation. It could be just as accurately be described as Readable Succinct Data Notation, but that wouldn't scan as well and indicate it as a better replacement for JSON. RSON uses the standard semicolon separated statements combined with multilevel bracket hierarchy syntax familiar from C, C++, Java and JavaScript. Its main innovations over JSON and XML are allowing statements to be partitioned into comma delineated clauses, the empty statement, the empty clause and type inference. It uses a context free operator precedence hierarchy, with the exception of allowing the 4 ( - + ~ !) operator to be used as prefix operators. Beyond this it generally follows Scala syntax where this doesn't conflict with the preceding rules. Unlike Scala statements must finish with a semicolon unless it is the last statement of a file or a bracket block. Allowing statements to end with a newline introduces horrendous ambiguities unless one is willing to go completely down the significant whitespace route and I'm not sure if that could work even work for such a general purpose basic syntax.

    The above allows it to combine a high level of human readability, succinctness, non-programmer / non-expert write-ability, programmer flexibility and composability and fast-parsing. The initial motivating use case was strategy games, which require huge amounts of modable date files. XML and JSON, the current defaults are simply not fit for purpose. RSON aims to break down the walls between game player, game modder, professional game artist, professional game scripter, professional imperative programming wizards in languages such as C / C++ and Rust and professional functional programming wizards in languages such as Scala, Haskell and Idris.

    Definition Classes
    ostrat
  • AlphaBracketExpr
  • AlphaParenth
  • AlphaSquareParenth
  • AlphaToken
  • AsignExpr
  • AsignToken
  • BlockMember
  • BlockMemberToken
  • BracketBlock
  • BracketClose
  • BracketOpen
  • BracketToken
  • CharToken
  • Clause
  • ClausedStatement
  • ClausesExpr
  • CommaToken
  • CurlyBlock
  • CurlyClose
  • CurlyOpen
  • DotToken
  • EmptyClause
  • EmptyExprToken
  • EmptyStatement
  • Expr
  • ExprCompound
  • ExprMember
  • ExprMemberToken
  • ExprSeq
  • ExprToken
  • FileStatements
  • FloatToken
  • GetStatements
  • HashAlphaToken
  • IntDecToken
  • IntHexToken
  • IntToken
  • LongIntToken
  • MonoStatement
  • OperatorToken
  • OtherOperatorToken
  • ParenthBlock
  • ParenthClose
  • ParenthOpen
  • PersistConsImplicit
  • PersistIterable
  • PersistListImplicit
  • PersistNilImplicit
  • PersistSeqImplicit
  • PersistSeqLike
  • PersistVectorImplicit
  • PlusInToken
  • PreOpExpr
  • PrefixToken
  • SemicolonToken
  • ShowSeqLike
  • SquareBlock
  • SquareClose
  • SquareOpen
  • Statement
  • StatementMember
  • StatementSeq
  • StringStatements
  • StringToken
  • Token
  • TokenOrBlock
  • TokensFind
  • UnClausedStatement
  • UnimplementedExpr
  • package pStrat

    Package for miscellaneous game utilities and data.

    Package for miscellaneous game utilities and data.

    Definition Classes
    ostrat
  • package pWeb

    This package for the manipulation of Html, XML CSS and Javascript.

    This package for the manipulation of Html, XML CSS and Javascript. Some of the functionality could be replaced by Scalatags. As it currently stands the code and design quality of this package is not up to standard, but due to many other higher priorities, I have not been able to take the next step, which is to 1 improve and document it, rewrite it from scratch or 3 replace it with a Scala-tags dependency or some other library.

    Definition Classes
    ostrat
  • package strat
    Definition Classes
    ostrat
p

ostrat

pParse

package pParse

This is the RSON package. Readable Succinct Object Notation. It could be just as accurately be described as Readable Succinct Data Notation, but that wouldn't scan as well and indicate it as a better replacement for JSON. RSON uses the standard semicolon separated statements combined with multilevel bracket hierarchy syntax familiar from C, C++, Java and JavaScript. Its main innovations over JSON and XML are allowing statements to be partitioned into comma delineated clauses, the empty statement, the empty clause and type inference. It uses a context free operator precedence hierarchy, with the exception of allowing the 4 ( - + ~ !) operator to be used as prefix operators. Beyond this it generally follows Scala syntax where this doesn't conflict with the preceding rules. Unlike Scala statements must finish with a semicolon unless it is the last statement of a file or a bracket block. Allowing statements to end with a newline introduces horrendous ambiguities unless one is willing to go completely down the significant whitespace route and I'm not sure if that could work even work for such a general purpose basic syntax.

The above allows it to combine a high level of human readability, succinctness, non-programmer / non-expert write-ability, programmer flexibility and composability and fast-parsing. The initial motivating use case was strategy games, which require huge amounts of modable date files. XML and JSON, the current defaults are simply not fit for purpose. RSON aims to break down the walls between game player, game modder, professional game artist, professional game scripter, professional imperative programming wizards in languages such as C / C++ and Rust and professional functional programming wizards in languages such as Scala, Haskell and Idris.

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. pParse
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. case class AlphaBracketExpr(name: AlphaToken, blocks: Refs[BracketBlock]) extends ExprCompound with Product with Serializable
  2. case class AlphaToken(startPosn: TextPosn, srcStr: String) extends ExprToken with Product with Serializable

    An Alphanumeric Token.

    An Alphanumeric Token. It contains a symbol rather than a String to represent the AlphaNumeric token as commonly used Symbols have better better performance than the equivalent Strings.

  3. case class AsignExpr(asToken: AsignToken, left: Expr, right: Expr) extends ExprCompound with Product with Serializable
  4. case class AsignToken(startPosn: TextPosn) extends ExprMemberToken with Product with Serializable
  5. trait BlockMember extends TokenOrBlock
  6. trait BlockMemberToken extends BlockMember with Token
  7. sealed trait BracketBlock extends StatementSeq
  8. sealed trait BracketClose extends BracketToken
  9. sealed trait BracketOpen extends BracketToken
  10. sealed trait BracketToken extends Token
  11. case class CharToken(startPosn: TextPosn, char: Char) extends ExprToken with Product with Serializable
  12. case class Clause(expr: Expr, optComma: Opt[CommaToken]) extends TextSpan with Product with Serializable

    Statements in RCON can be unclaused or multi comma separated.

    Statements in RCON can be unclaused or multi comma separated. The empty Clause just contains a comma. The comma at the end of the last Clause of a Statement is optional.

  13. case class ClausedStatement(clauses: Refs[Clause], optSemi: Opt[SemicolonToken]) extends Statement with TextSpanCompound with Product with Serializable

    This statement has 1 or more comma separated clauses.

    This statement has 1 or more comma separated clauses. If there is only 1 Clause, it must be terminated by a comma, otherwise the trailing comma on the last Clauses is optional.

  14. case class ClausesExpr(exprs: Refs[Expr]) extends ExprSeq with Product with Serializable
  15. case class CommaToken(startPosn: TextPosn) extends EmptyExprToken with StatementMember with Product with Serializable
  16. case class CurlyBlock(statements: Refs[Statement], startBracket: BracketOpen, endBracket: BracketClose) extends BracketBlock with Product with Serializable
  17. case class CurlyClose(startPosn: TextPosn) extends BracketClose with Product with Serializable
  18. case class CurlyOpen(startPosn: TextPosn) extends BracketOpen with Product with Serializable
  19. case class DotToken(startPosn: TextPosn) extends ExprMemberToken with Product with Serializable

    The Dot or Stop Token.

  20. class EmptyClause extends Clause with TextSpanCompound

    Empty Clause class, rperesentated by just a comma.

  21. trait EmptyExprToken extends BlockMemberToken with ExprToken
  22. case class EmptyStatement(st: SemicolonToken) extends UnClausedStatement with TextSpanCompound with Product with Serializable

    The Semicolon of the Empty statement is the expression of this special case of the unclaused statement

  23. trait Expr extends TokenOrBlock with ExprMember

    The fundamental expression trait.

    The fundamental expression trait. As it currently stands properly formed Statements either is empty or contains an expression or a sequence of clauses that contain each contain an expression.

  24. trait ExprCompound extends Expr with TextSpanCompound

    A compound expression.

    A compound expression. The traits sole purpose is to give an Expr, the start and end text positions from its first and last components.

  25. trait ExprMember extends StatementMember

    I think its helpful to have an expression member trait for syntax that is not expressions.

    I think its helpful to have an expression member trait for syntax that is not expressions. So I don't think it would be helpful if say an opening brace was an expression. All Expressions are Expression members.

  26. trait ExprMemberToken extends BlockMemberToken with ExprMember
  27. trait ExprSeq extends ExprCompound
  28. trait ExprToken extends Expr with ExprMemberToken

    A Token that is an Expression.

    A Token that is an Expression. Most tokens are expressions, but some are not such as braces, commas and semicolons.

  29. case class FileStatements(statements: Refs[Statement]) extends StatementSeq with Product with Serializable
  30. case class FloatToken(startPosn: TextPosn, srcStr: String, floatValue: Double) extends ExprToken with Product with Serializable

    A Double Floating point token.

  31. case class HashAlphaToken(startPosn: TextPosn, srcStr: String) extends ExprToken with Product with Serializable

    The purpose of this token is for use at the beginning of a file, to make the the rest of the Statements, sub-statements.

    The purpose of this token is for use at the beginning of a file, to make the the rest of the Statements, sub-statements. As if they were the statements inside parenthesis.

  32. case class IntDecToken(startPosn: TextPosn, intValue: Int) extends IntToken with Product with Serializable

    A 32 bit integer token in standard decimal format.

  33. case class IntHexToken(startPosn: TextPosn, srcStr: String, intValue: Int) extends IntToken with Product with Serializable
  34. trait IntToken extends ExprToken

    A 32 bit Integer Token.

  35. case class LongIntToken(startPosn: TextPosn, srcStr: String, longValue: Long) extends ExprToken with Product with Serializable

    A 64bit signed integer token

  36. case class MonoStatement(expr: Expr, optSemi: Opt[SemicolonToken]) extends UnClausedStatement with TextSpanCompound with Product with Serializable

    An un-claused Statement that is not the empty statement.

  37. trait OperatorToken extends ExprMemberToken

    An Operator token.

  38. case class OtherOperatorToken(startPosn: TextPosn, srcStr: String) extends OperatorToken with Product with Serializable
  39. case class ParenthBlock(statements: Refs[Statement], startBracket: BracketOpen, endBracket: BracketClose) extends BracketBlock with Product with Serializable
  40. case class ParenthClose(startPosn: TextPosn) extends BracketClose with Product with Serializable
  41. case class ParenthOpen(startPosn: TextPosn) extends BracketOpen with Product with Serializable
  42. class PersistConsImplicit[A] extends PersistIterable[A, ::[A]]
  43. abstract class PersistIterable[A, R <: Iterable[A]] extends PersistSeqLike[A, R]
  44. class PersistListImplicit[A] extends PersistIterable[A, List[A]]
  45. class PersistNilImplicit[A] extends PersistSeqLike[A, Nil.type]
  46. class PersistSeqImplicit[A] extends PersistIterable[A, Seq[A]]
  47. abstract class PersistSeqLike[A, R] extends ShowSeqLike[A, R] with PersistCompound[R]
  48. class PersistVectorImplicit[A] extends PersistIterable[A, Vector[A]]
  49. case class PlusInToken(startPosn: TextPosn, srcStr: String) extends OperatorToken with Product with Serializable

    A + or - infix Operator token

  50. case class PreOpExpr(op: OperatorToken, right: Expr) extends ExprCompound with Product with Serializable
  51. case class PrefixToken(startPosn: TextPosn, srcStr: String) extends OperatorToken with Product with Serializable

    A + or - Prefix Operator token

  52. case class SemicolonToken(startPosn: TextPosn) extends EmptyExprToken with Product with Serializable
  53. trait ShowSeqLike[A, R] extends ShowCompound[R]
  54. case class SquareBlock(statements: Refs[Statement], startBracket: BracketOpen, endBracket: BracketClose) extends BracketBlock with Product with Serializable
  55. case class SquareClose(startPosn: TextPosn) extends BracketClose with Product with Serializable
  56. case class SquareOpen(startPosn: TextPosn) extends BracketOpen with Product with Serializable
  57. sealed trait Statement extends TextSpan

    The top level compositional unit of Syntax in CRON: Compact Readable Object Notation.

    The top level compositional unit of Syntax in CRON: Compact Readable Object Notation. A statement can be claused consisting of comma separated clauses containing a single expression. An empty statement is a special case of the UnClausedStatement where the semicolon character is the expression.

  58. trait StatementMember extends BlockMember
  59. trait StatementSeq extends ExprSeq
  60. case class StringStatements(statements: Refs[Statement]) extends StatementSeq with Product with Serializable
  61. case class StringToken(startPosn: TextPosn, stringStr: String) extends ExprToken with Product with Serializable
  62. trait Token extends TextSpan
  63. trait TokenOrBlock extends TextSpan

    This trait includes all the tokens except braces plus the Bracket syntactic blocks.

    This trait includes all the tokens except braces plus the Bracket syntactic blocks. The Block in the name block member is either the top level statements in the file or the statements with in a bracket block. Conceptually the source file is considered a special case of bracket block where the beginning of substitutes for the opening bracket and the end of file substitutes for the closing bracket. BlockMember has only two sub traits StatementMember and SemiToken. So a sequence of TokenOrBlocks is simply a series of tokens which has been parsed into Blocks.

  64. case class TokensFind(srcStr: String) extends Product with Serializable

    not sure about comment tokens

  65. sealed trait UnClausedStatement extends Statement

    An unclaused Statement has a single expression.

  66. case class UnimplementedExpr(bMems: Refs[BlockMember]) extends ExprCompound with Product with Serializable

Value Members

  1. def getStatements(input: String, inputSourceName: String): ERefs[Statement]

    Returns an EMon of a sequence of Statements from a file.

    Returns an EMon of a sequence of Statements from a file. This uses the fromString method. Non fatal exceptions or if the file doesn't exist will be returned as errors.

  2. def stringToStatements(input: String): ERefs[Statement]

    Returns an EMon of a sequence of Statements from a String.

  3. def stringToTokens(srcStr: String): EMon[Refs[Token]]

    Max numbers for long and hexidecimal formats needs to be implemented

  4. object AlphaParenth
  5. object AlphaSquareParenth
  6. object EmptyClause extends Serializable

    Factory object for the empty clause.

    Factory object for the empty clause. Not sure if it is necessary

  7. object EmptyStatement extends Serializable
  8. object GetStatements

    Just a holding object for methods to get Statements from Token.

  9. object IntToken
  10. object Statement
  11. object Token

Inherited from AnyRef

Inherited from Any

Ungrouped