Module swim.recon
Package swim.recon

Class ReconWriter<I,V>

java.lang.Object
swim.recon.ReconWriter<I,V>
Direct Known Subclasses:
ReconStructureWriter
public abstract class ReconWriter<I,V> extends Object
Factory for constructing Recon writers.

  • Constructor Details

    • ReconWriter

      public ReconWriter()

  • Method Details

    • 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)

    • writeData

      public Writer<?,?> writeData(Output<?> output, ByteBuffer value)

    • isIdent

      public boolean isIdent(I item)

    • isIdent

      public boolean isIdent(String value)

    • sizeOfText

      public int sizeOfText(String value)

    • writeText

      public Writer<?,?> writeText(Output<?> output, 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)

    • writeNum

      public Writer<?,?> writeNum(Output<?> output, 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)