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)