Module swim.recon
Package swim.recon

Class ReconWriter<I,​V>

  • Direct Known Subclasses:
    ReconStructureWriter
    public abstract class ReconWriter<I,​V>
extends Object
    Factory for constructing Recon writers.

    • Constructor Detail

      • ReconWriter

        public ReconWriter()

    • Method Detail

      • isField

        public abstract boolean isField​(I item)

      • isAttr

        public abstract boolean isAttr​(I item)

      • isSlot

        public abstract boolean isSlot​(I item)

      • isValue

        public abstract boolean isValue​(I item)

      • isRecord

        public abstract boolean isRecord​(I item)

      • isText

        public abstract boolean isText​(I item)

      • isNum

        public abstract boolean isNum​(I item)

      • isBool

        public abstract boolean isBool​(I item)

      • isExpression

        public abstract boolean isExpression​(I item)

      • isExtant

        public abstract boolean isExtant​(I item)

      • items

        public abstract Iterator<I> items​(I item)

      • item

        public abstract I item​(V value)

      • key

        public abstract V key​(I item)

      • value

        public abstract V value​(I item)

      • string

        public abstract String string​(I item)

      • precedence

        public abstract int precedence​(I item)

      • sizeOfItem

        public abstract int sizeOfItem​(I item)

      • writeItem

        public abstract Writer<?,​?> writeItem​(I item,
                                            Output<?> output)

      • sizeOfValue

        public abstract int sizeOfValue​(V value)

      • writeValue

        public abstract Writer<?,​?> writeValue​(V value,
                                             Output<?> output)

      • sizeOfBlockValue

        public abstract int sizeOfBlockValue​(V value)

      • writeBlockValue

        public abstract Writer<?,​?> writeBlockValue​(V value,
                                                  Output<?> output)

      • sizeOfAttr

        public int sizeOfAttr​(V key,
                      V value)

      • writeAttr

        public Writer<?,​?> writeAttr​(V key,
                                   V value,
                                   Output<?> output)

      • sizeOfSlot

        public int sizeOfSlot​(V key,
                      V value)

      • writeSlot

        public Writer<?,​?> writeSlot​(V key,
                                   V value,
                                   Output<?> output)

      • sizeOfBlockItem

        public abstract int sizeOfBlockItem​(I item)

      • writeBlockItem

        public abstract Writer<?,​?> writeBlockItem​(I item,
                                                 Output<?> output)

      • sizeOfBlock

        public int sizeOfBlock​(Iterator<I> items,
                       boolean inBlock,
                       boolean inMarkup)

      • writeBlock

        public Writer<?,​?> writeBlock​(Iterator<I> items,
                                    Output<?> output,
                                    boolean inBlock,
                                    boolean inMarkup)

      • sizeOfBlock

        public int sizeOfBlock​(I item)

      • writeBlock

        public Writer<?,​?> writeBlock​(I item,
                                    Output<?> output)

      • sizeOfRecord

        public int sizeOfRecord​(I item)

      • writeRecord

        public Writer<?,​?> writeRecord​(I item,
                                     Output<?> output)

      • sizeOfPrimary

        public int sizeOfPrimary​(V value)

      • writePrimary

        public Writer<?,​?> writePrimary​(V value,
                                      Output<?> output)

      • isBlockSafe

        public boolean isBlockSafe​(Iterator<I> items)

      • isMarkupSafe

        public boolean isMarkupSafe​(Iterator<I> items)

      • sizeOfMarkupText

        public int sizeOfMarkupText​(I item)

      • writeMarkupText

        public Writer<?,​?> writeMarkupText​(I item,
                                         Output<?> output)

      • sizeOfMarkupText

        public int sizeOfMarkupText​(String text)

      • writeMarkupText

        public Writer<?,​?> writeMarkupText​(String text,
                                         Output<?> output)

      • sizeOfData

        public int sizeOfData​(int length)

      • isIdent

        public boolean isIdent​(I item)

      • isIdent

        public boolean isIdent​(String value)

      • sizeOfText

        public int sizeOfText​(String value)

      • sizeOfNum

        public int sizeOfNum​(int value)

      • writeNum

        public Writer<?,​?> writeNum​(int value,
                                  Output<?> output)

      • sizeOfNum

        public int sizeOfNum​(long value)

      • writeNum

        public Writer<?,​?> writeNum​(long value,
                                  Output<?> output)

      • sizeOfNum

        public int sizeOfNum​(float value)

      • writeNum

        public Writer<?,​?> writeNum​(float value,
                                  Output<?> output)

      • sizeOfNum

        public int sizeOfNum​(double value)

      • writeNum

        public Writer<?,​?> writeNum​(double value,
                                  Output<?> output)

      • sizeOfNum

        public int sizeOfNum​(BigInteger value)

      • sizeOfUint32

        public int sizeOfUint32​(int value)

      • writeUint32

        public Writer<?,​?> writeUint32​(int value,
                                     Output<?> output)

      • sizeOfUint64

        public int sizeOfUint64​(long value)

      • writeUint64

        public Writer<?,​?> writeUint64​(long value,
                                     Output<?> output)

      • sizeOfBool

        public int sizeOfBool​(boolean value)

      • writeBool

        public Writer<?,​?> writeBool​(boolean value,
                                   Output<?> output)

      • sizeOfLambdaFunc

        public int sizeOfLambdaFunc​(V bindings,
                            V template)

      • writeLambdaFunc

        public Writer<?,​?> writeLambdaFunc​(V bindings,
                                         V template,
                                         Output<?> output)

      • sizeOfConditionalOperator

        public int sizeOfConditionalOperator​(I ifTerm,
                                     I thenTerm,
                                     I elseTerm,
                                     int precedence)

      • writeConditionalOperator

        public Writer<?,​?> writeConditionalOperator​(I ifTerm,
                                                  I thenTerm,
                                                  I elseTerm,
                                                  int precedence,
                                                  Output<?> output)

      • sizeOfInfixOperator

        public int sizeOfInfixOperator​(I lhs,
                               String operator,
                               I rhs,
                               int precedence)

      • writeInfixOperator

        public Writer<?,​?> writeInfixOperator​(I lhs,
                                            String operator,
                                            I rhs,
                                            int precedence,
                                            Output<?> output)

      • sizeOfPrefixOperator

        public int sizeOfPrefixOperator​(String operator,
                                I operand,
                                int precedence)

      • writePrefixOperator

        public Writer<?,​?> writePrefixOperator​(String operator,
                                             I operand,
                                             int precedence,
                                             Output<?> output)

      • sizeOfInvokeOperator

        public int sizeOfInvokeOperator​(V func,
                                V args)

      • writeInvokeOperator

        public Writer<?,​?> writeInvokeOperator​(V func,
                                             V args,
                                             Output<?> output)

      • sizeOfThen

        public abstract int sizeOfThen​(V then)

      • writeThen

        public abstract Writer<?,​?> writeThen​(V then,
                                            Output<?> output)

      • sizeOfIdentitySelector

        public int sizeOfIdentitySelector()

      • writeIdentitySelector

        public Writer<?,​?> writeIdentitySelector​(Output<?> output)

      • sizeOfThenIdentitySelector

        public int sizeOfThenIdentitySelector()

      • writeThenIdentitySelector

        public Writer<?,​?> writeThenIdentitySelector​(Output<?> output)

      • sizeOfLiteralSelector

        public int sizeOfLiteralSelector​(I item,
                                 V then)

      • writeLiteralSelector

        public Writer<?,​?> writeLiteralSelector​(I item,
                                              V then,
                                              Output<?> output)

      • sizeOfThenLiteralSelector

        public int sizeOfThenLiteralSelector​(I item,
                                     V then)

      • writeThenLiteralSelector

        public Writer<?,​?> writeThenLiteralSelector​(I item,
                                                  V then,
                                                  Output<?> output)

      • sizeOfGetSelector

        public int sizeOfGetSelector​(V key,
                             V then)

      • writeGetSelector

        public Writer<?,​?> writeGetSelector​(V key,
                                          V then,
                                          Output<?> output)

      • sizeOfThenGetSelector

        public int sizeOfThenGetSelector​(V key,
                                 V then)

      • writeThenGetSelector

        public Writer<?,​?> writeThenGetSelector​(V key,
                                              V then,
                                              Output<?> output)

      • sizeOfGetAttrSelector

        public int sizeOfGetAttrSelector​(V key,
                                 V then)

      • writeGetAttrSelector

        public Writer<?,​?> writeGetAttrSelector​(V key,
                                              V then,
                                              Output<?> output)

      • sizeOfThenGetAttrSelector

        public int sizeOfThenGetAttrSelector​(V key,
                                     V then)

      • writeThenGetAttrSelector

        public Writer<?,​?> writeThenGetAttrSelector​(V key,
                                                  V then,
                                                  Output<?> output)

      • sizeOfGetItemSelector

        public int sizeOfGetItemSelector​(V index,
                                 V then)

      • writeGetItemSelector

        public Writer<?,​?> writeGetItemSelector​(V index,
                                              V then,
                                              Output<?> output)

      • sizeOfThenGetItemSelector

        public int sizeOfThenGetItemSelector​(V index,
                                     V then)

      • writeThenGetItemSelector

        public Writer<?,​?> writeThenGetItemSelector​(V index,
                                                  V then,
                                                  Output<?> output)

      • sizeOfKeysSelector

        public int sizeOfKeysSelector​(V then)

      • writeKeysSelector

        public Writer<?,​?> writeKeysSelector​(V then,
                                           Output<?> output)

      • sizeOfThenKeysSelector

        public int sizeOfThenKeysSelector​(V then)

      • writeThenKeysSelector

        public Writer<?,​?> writeThenKeysSelector​(V then,
                                               Output<?> output)

      • sizeOfValuesSelector

        public int sizeOfValuesSelector​(V then)

      • writeValuesSelector

        public Writer<?,​?> writeValuesSelector​(V then,
                                             Output<?> output)

      • sizeOfThenValuesSelector

        public int sizeOfThenValuesSelector​(V then)

      • writeThenValuesSelector

        public Writer<?,​?> writeThenValuesSelector​(V then,
                                                 Output<?> output)

      • sizeOfChildrenSelector

        public int sizeOfChildrenSelector​(V then)

      • writeChildrenSelector

        public Writer<?,​?> writeChildrenSelector​(V then,
                                               Output<?> output)

      • sizeOfThenChildrenSelector

        public int sizeOfThenChildrenSelector​(V then)

      • writeThenChildrenSelector

        public Writer<?,​?> writeThenChildrenSelector​(V then,
                                                   Output<?> output)

      • sizeOfDescendantsSelector

        public int sizeOfDescendantsSelector​(V then)

      • writeDescendantsSelector

        public Writer<?,​?> writeDescendantsSelector​(V then,
                                                  Output<?> output)

      • sizeOfThenDescendantsSelector

        public int sizeOfThenDescendantsSelector​(V then)

      • writeThenDescendantsSelector

        public Writer<?,​?> writeThenDescendantsSelector​(V then,
                                                      Output<?> output)

      • sizeOfFilterSelector

        public int sizeOfFilterSelector​(V predicate,
                                V then)

      • writeFilterSelector

        public Writer<?,​?> writeFilterSelector​(V predicate,
                                             V then,
                                             Output<?> output)

      • sizeOfThenFilterSelector

        public int sizeOfThenFilterSelector​(V predicate,
                                    V then)

      • writeThenFilterSelector

        public Writer<?,​?> writeThenFilterSelector​(V predicate,
                                                 V then,
                                                 Output<?> output)

      • sizeOfExtant

        public int sizeOfExtant()

      • writeExtant

        public Writer<?,​?> writeExtant​(Output<?> output)

      • sizeOfAbsent

        public int sizeOfAbsent()

      • writeAbsent

        public Writer<?,​?> writeAbsent​(Output<?> output)