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 swim.codec.Writer<?,​?> writeItem​(I item,
                                                       swim.codec.Output<?> output)

      • sizeOfValue

        public abstract int sizeOfValue​(V value)

      • writeValue

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

      • sizeOfBlockValue

        public abstract int sizeOfBlockValue​(V value)

      • writeBlockValue

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

      • sizeOfAttr

        public int sizeOfAttr​(V key,
                      V value)

      • writeAttr

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

      • sizeOfSlot

        public int sizeOfSlot​(V key,
                      V value)

      • writeSlot

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

      • sizeOfBlockItem

        public abstract int sizeOfBlockItem​(I item)

      • writeBlockItem

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

      • sizeOfBlock

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

      • writeBlock

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

      • sizeOfBlock

        public int sizeOfBlock​(I item)

      • writeBlock

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

      • sizeOfRecord

        public int sizeOfRecord​(I item)

      • writeRecord

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

      • sizeOfPrimary

        public int sizeOfPrimary​(V value)

      • writePrimary

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

      • isBlockSafe

        public boolean isBlockSafe​(Iterator<I> items)

      • isMarkupSafe

        public boolean isMarkupSafe​(Iterator<I> items)

      • sizeOfMarkupText

        public int sizeOfMarkupText​(I item)

      • writeMarkupText

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

      • sizeOfMarkupText

        public int sizeOfMarkupText​(String text)

      • writeMarkupText

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

      • sizeOfData

        public int sizeOfData​(int length)

      • writeData

        public swim.codec.Writer<?,​?> writeData​(ByteBuffer value,
                                              swim.codec.Output<?> output)

      • isIdent

        public boolean isIdent​(I item)

      • isIdent

        public boolean isIdent​(String value)

      • sizeOfText

        public int sizeOfText​(String value)

      • writeText

        public swim.codec.Writer<?,​?> writeText​(String value,
                                              swim.codec.Output<?> output)

      • sizeOfNum

        public int sizeOfNum​(int value)

      • writeNum

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

      • sizeOfNum

        public int sizeOfNum​(long value)

      • writeNum

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

      • sizeOfNum

        public int sizeOfNum​(float value)

      • writeNum

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

      • sizeOfNum

        public int sizeOfNum​(double value)

      • writeNum

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

      • sizeOfNum

        public int sizeOfNum​(BigInteger value)

      • writeNum

        public swim.codec.Writer<?,​?> writeNum​(BigInteger value,
                                             swim.codec.Output<?> output)

      • sizeOfUint32

        public int sizeOfUint32​(int value)

      • writeUint32

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

      • sizeOfUint64

        public int sizeOfUint64​(long value)

      • writeUint64

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

      • sizeOfBool

        public int sizeOfBool​(boolean value)

      • writeBool

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

      • sizeOfLambdaFunc

        public int sizeOfLambdaFunc​(V bindings,
                            V template)

      • writeLambdaFunc

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

      • sizeOfConditionalOperator

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

      • writeConditionalOperator

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

      • sizeOfInfixOperator

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

      • writeInfixOperator

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

      • sizeOfPrefixOperator

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

      • writePrefixOperator

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

      • sizeOfInvokeOperator

        public int sizeOfInvokeOperator​(V func,
                                V args)

      • writeInvokeOperator

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

      • sizeOfThen

        public abstract int sizeOfThen​(V then)

      • writeThen

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

      • sizeOfIdentitySelector

        public int sizeOfIdentitySelector()

      • writeIdentitySelector

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

      • sizeOfThenIdentitySelector

        public int sizeOfThenIdentitySelector()

      • writeThenIdentitySelector

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

      • sizeOfLiteralSelector

        public int sizeOfLiteralSelector​(I item,
                                 V then)

      • writeLiteralSelector

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

      • sizeOfThenLiteralSelector

        public int sizeOfThenLiteralSelector​(I item,
                                     V then)

      • writeThenLiteralSelector

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

      • sizeOfGetSelector

        public int sizeOfGetSelector​(V key,
                             V then)

      • writeGetSelector

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

      • sizeOfThenGetSelector

        public int sizeOfThenGetSelector​(V key,
                                 V then)

      • writeThenGetSelector

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

      • sizeOfGetAttrSelector

        public int sizeOfGetAttrSelector​(V key,
                                 V then)

      • writeGetAttrSelector

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

      • sizeOfThenGetAttrSelector

        public int sizeOfThenGetAttrSelector​(V key,
                                     V then)

      • writeThenGetAttrSelector

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

      • sizeOfGetItemSelector

        public int sizeOfGetItemSelector​(V index,
                                 V then)

      • writeGetItemSelector

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

      • sizeOfThenGetItemSelector

        public int sizeOfThenGetItemSelector​(V index,
                                     V then)

      • writeThenGetItemSelector

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

      • sizeOfKeysSelector

        public int sizeOfKeysSelector​(V then)

      • writeKeysSelector

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

      • sizeOfThenKeysSelector

        public int sizeOfThenKeysSelector​(V then)

      • writeThenKeysSelector

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

      • sizeOfValuesSelector

        public int sizeOfValuesSelector​(V then)

      • writeValuesSelector

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

      • sizeOfThenValuesSelector

        public int sizeOfThenValuesSelector​(V then)

      • writeThenValuesSelector

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

      • sizeOfChildrenSelector

        public int sizeOfChildrenSelector​(V then)

      • writeChildrenSelector

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

      • sizeOfThenChildrenSelector

        public int sizeOfThenChildrenSelector​(V then)

      • writeThenChildrenSelector

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

      • sizeOfDescendantsSelector

        public int sizeOfDescendantsSelector​(V then)

      • writeDescendantsSelector

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

      • sizeOfThenDescendantsSelector

        public int sizeOfThenDescendantsSelector​(V then)

      • writeThenDescendantsSelector

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

      • sizeOfFilterSelector

        public int sizeOfFilterSelector​(V predicate,
                                V then)

      • writeFilterSelector

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

      • sizeOfThenFilterSelector

        public int sizeOfThenFilterSelector​(V predicate,
                                    V then)

      • writeThenFilterSelector

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

      • sizeOfExtant

        public int sizeOfExtant()

      • writeExtant

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

      • sizeOfAbsent

        public int sizeOfAbsent()

      • writeAbsent

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