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​(Output<?> output,
                                            I item)

      • sizeOfValue

        public abstract int sizeOfValue​(V value)

      • writeValue

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

      • sizeOfBlockValue

        public abstract int sizeOfBlockValue​(V value)

      • writeBlockValue

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

      • sizeOfAttr

        public int sizeOfAttr​(V key,
                      V value)

      • writeAttr

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

      • sizeOfSlot

        public int sizeOfSlot​(V key,
                      V value)

      • writeSlot

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

      • sizeOfBlockItem

        public abstract int sizeOfBlockItem​(I item)

      • writeBlockItem

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

      • sizeOfBlock

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

      • writeBlock

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

      • sizeOfBlock

        public int sizeOfBlock​(I item)

      • writeBlock

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

      • sizeOfRecord

        public int sizeOfRecord​(I item)

      • writeRecord

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

      • sizeOfPrimary

        public int sizeOfPrimary​(V value)

      • writePrimary

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

      • isBlockSafe

        public boolean isBlockSafe​(Iterator<I> items)

      • isMarkupSafe

        public boolean isMarkupSafe​(Iterator<I> items)

      • sizeOfMarkupText

        public int sizeOfMarkupText​(I item)

      • writeMarkupText

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

      • sizeOfMarkupText

        public int sizeOfMarkupText​(String text)

      • writeMarkupText

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

      • 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​(Output<?> output,
                                  int value)

      • sizeOfNum

        public int sizeOfNum​(long value)

      • writeNum

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

      • sizeOfNum

        public int sizeOfNum​(float value)

      • writeNum

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

      • sizeOfNum

        public int sizeOfNum​(double value)

      • writeNum

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

      • sizeOfNum

        public int sizeOfNum​(BigInteger value)

      • sizeOfUint32

        public int sizeOfUint32​(int value)

      • writeUint32

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

      • sizeOfUint64

        public int sizeOfUint64​(long value)

      • writeUint64

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

      • sizeOfBool

        public int sizeOfBool​(boolean value)

      • writeBool

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

      • sizeOfLambdaFunc

        public int sizeOfLambdaFunc​(V bindings,
                            V template)

      • writeLambdaFunc

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

      • sizeOfConditionalOperator

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

      • writeConditionalOperator

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

      • sizeOfInfixOperator

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

      • writeInfixOperator

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

      • sizeOfPrefixOperator

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

      • writePrefixOperator

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

      • sizeOfInvokeOperator

        public int sizeOfInvokeOperator​(V func,
                                V args)

      • writeInvokeOperator

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

      • sizeOfThen

        public abstract int sizeOfThen​(V then)

      • writeThen

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

      • 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​(Output<?> output,
                                              I item,
                                              V then)

      • sizeOfThenLiteralSelector

        public int sizeOfThenLiteralSelector​(I item,
                                     V then)

      • writeThenLiteralSelector

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

      • sizeOfGetSelector

        public int sizeOfGetSelector​(V key,
                             V then)

      • writeGetSelector

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

      • sizeOfThenGetSelector

        public int sizeOfThenGetSelector​(V key,
                                 V then)

      • writeThenGetSelector

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

      • sizeOfGetAttrSelector

        public int sizeOfGetAttrSelector​(V key,
                                 V then)

      • writeGetAttrSelector

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

      • sizeOfThenGetAttrSelector

        public int sizeOfThenGetAttrSelector​(V key,
                                     V then)

      • writeThenGetAttrSelector

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

      • sizeOfGetItemSelector

        public int sizeOfGetItemSelector​(V index,
                                 V then)

      • writeGetItemSelector

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

      • sizeOfThenGetItemSelector

        public int sizeOfThenGetItemSelector​(V index,
                                     V then)

      • writeThenGetItemSelector

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

      • sizeOfKeysSelector

        public int sizeOfKeysSelector​(V then)

      • writeKeysSelector

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

      • sizeOfThenKeysSelector

        public int sizeOfThenKeysSelector​(V then)

      • writeThenKeysSelector

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

      • sizeOfValuesSelector

        public int sizeOfValuesSelector​(V then)

      • writeValuesSelector

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

      • sizeOfThenValuesSelector

        public int sizeOfThenValuesSelector​(V then)

      • writeThenValuesSelector

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

      • sizeOfChildrenSelector

        public int sizeOfChildrenSelector​(V then)

      • writeChildrenSelector

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

      • sizeOfThenChildrenSelector

        public int sizeOfThenChildrenSelector​(V then)

      • writeThenChildrenSelector

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

      • sizeOfDescendantsSelector

        public int sizeOfDescendantsSelector​(V then)

      • writeDescendantsSelector

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

      • sizeOfThenDescendantsSelector

        public int sizeOfThenDescendantsSelector​(V then)

      • writeThenDescendantsSelector

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

      • sizeOfFilterSelector

        public int sizeOfFilterSelector​(V predicate,
                                V then)

      • writeFilterSelector

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

      • sizeOfThenFilterSelector

        public int sizeOfThenFilterSelector​(V predicate,
                                    V then)

      • writeThenFilterSelector

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

      • sizeOfExtant

        public int sizeOfExtant()

      • writeExtant

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

      • sizeOfAbsent

        public int sizeOfAbsent()

      • writeAbsent

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