From: Ole Streicher <ole@aip.de>
Date: Fri, 30 Jul 2021 12:24:54 +0200
Subject: Temporarily add TestTableScheme

until we use a newer version of starlink-table-java
---
 src/main/uk/ac/starlink/table/TestTableScheme.java | 456 +++++++++++++++++++++
 1 file changed, 456 insertions(+)
 create mode 100644 src/main/uk/ac/starlink/table/TestTableScheme.java

diff --git a/src/main/uk/ac/starlink/table/TestTableScheme.java b/src/main/uk/ac/starlink/table/TestTableScheme.java
new file mode 100644
index 0000000..6b4b119
--- /dev/null
+++ b/src/main/uk/ac/starlink/table/TestTableScheme.java
@@ -0,0 +1,456 @@
+package uk.ac.starlink.table;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.IntFunction;
+import java.util.stream.Collectors;
+
+/**
+ * TableScheme implementation for test data.
+ *
+ * @author   Mark Taylor
+ * @since    26 Apr 2021
+ */
+public class TestTableScheme implements TableScheme, Documented {
+
+    private static final int DFLT_NROW = 10;
+    private static final Map<Character,ContentOpt> OPTS = createOpts();
+    private static final String OPT_CHRS =
+        OPTS.keySet().stream().map( Object::toString )
+            .collect( Collectors.joining() );
+    private static final int ZP = 10;
+
+    public TestTableScheme() {
+    }
+
+    public String getSchemeName() {
+        return "test";
+    }
+
+    public String getSchemeUsage() {
+        return "[<nrow>[,<opts-" + OPT_CHRS + "*>]]";
+    }
+
+    public String getExampleSpecification() {
+        return "10,is";
+    }
+
+    public String getXmlDescription() {
+        return String.join( "\n",
+            "<p>Generates a table containing test data.",
+            "The idea is to include columns of different data types,",
+            "for instance to provide an example for testing",
+            "I/O handler implementations.",
+            "The columns will contain some variety of more or less meaningless",
+            "values, but the content is reproducible between runs,",
+            "so the same specification will produce the same output each time.",
+            "Updates of the implementation might change the output however,",
+            "so the output is not guaranteed to be the same for all time.",
+            "</p>",
+            "<p>The table specification has two comma-separated parameters:",
+            "<ul>",
+            "<li><code>&lt;nrow&gt;</code>: row count</li>",
+            "<li><code>&lt;opts&gt;</code>:",
+                "a string of letter options specifying what types of data",
+                "will be included; options are:",
+                "<ul>",
+                OPTS.values().stream().map( opt -> new StringBuffer()
+                    .append( "<li><strong>" )
+                    .append( opt.idChr_ )
+                    .append( "</strong>: " )
+                    .append( opt.description_ )
+                    .append( "</li>\n" )
+                    .toString()
+                ).collect( Collectors.joining( "\n" ) ),
+                "<li><strong>*</strong>: equivalent to all of the above</li>",
+                "</ul>",
+                "</li>",
+            "</ul>",
+            "If <code>&lt;opts&gt;</code> and/or <code>&lt;nrow&gt;</code>",
+            "are omitted, some default values are used.",
+            "</p>",
+        "" );
+    }
+
+    public StarTable createTable( String spec ) throws TableFormatException {
+        String[] args = spec.split( ",", -1 );
+        if ( args.length > 2 ) {
+            throw new TableFormatException( "Too many args" );
+        }
+        final int nrow;
+        try {
+            nrow = args.length > 0 && args[ 0 ].trim().length() > 0
+                 ? Integer.parseInt( args[ 0 ].trim() )
+                 : DFLT_NROW;
+        }
+        catch ( NumberFormatException e ) {
+            throw new TableFormatException( "Bad row count \""
+                                          + args[ 0 ] + "\"" );
+        }
+        String optsTxt = args.length > 1
+                       ? args[ 1 ]
+                       : "b";
+        List<ContentOpt> optList = new ArrayList<>();
+        for ( int ic = 0; ic < optsTxt.length(); ic++ ) {
+            Character chr = Character.valueOf( optsTxt.charAt( ic ) );
+            if ( chr == '*' ) {
+                optList.addAll( OPTS.values() );
+            }
+            else {
+                ContentOpt opt = OPTS.get( chr );
+                if ( opt == null ) {
+                    throw new TableFormatException( "Unknown content option '"
+                                                  + chr + "' - must be one of ["
+                                                  + OPT_CHRS + "*]" );
+                }
+                optList.add( opt );
+            }
+        }
+        ColumnStarTable table = new ColumnStarTable() {
+            public long getRowCount() {
+                return nrow;
+            }
+        };
+        for ( ContentOpt opt : optList ) {
+            opt.addContent_.accept( table );
+        }
+        return table;
+    }
+
+    /**
+     * Creates the list of run-time options for table content.
+     *
+     * @param   map from identifier character to option
+     */
+    private static Map<Character,ContentOpt> createOpts() {
+        ContentOpt[] opts = new ContentOpt[] {
+            new ContentOpt( 'i', "index", "an integer index column", t -> {
+                t.addColumn( new ColumnData( new ColumnInfo( "i_index",
+                                                             Integer.class,
+                                                             "Row index" ) ) {
+                    public Object readValue( long irow ) {
+                        return Integer.valueOf( (int) irow );
+                    }
+                } );
+            } ),
+            new ContentOpt( 'b', "basic", "a few basic columns", t -> {
+                int nPhase = 1;
+                addColumn( t, "b_int", Integer.class, nPhase++,
+                           i -> Integer.valueOf( i ) );
+                addColumn( t, "b_double", Double.class, nPhase++,
+                           i -> Double.valueOf( i ) );
+                addColumn( t, "b_string", String.class, nPhase++,
+                           i -> valString( i, false ) );
+            } ),
+            new ContentOpt( 's', "scalars",
+                            "a selection of typed scalar columns", t -> {
+                int nPhase = 1;
+                addColumn( t, "s_byte", Byte.class, nPhase++,
+                           i -> Byte.valueOf( (byte) valInt( i ) ) );
+                addColumn( t, "s_short", Short.class, nPhase++,
+                           i -> Short.valueOf( (short) valInt( i ) ) );
+                addColumn( t, "s_int", Integer.class, nPhase++,
+                           i -> Integer.valueOf( valInt( i ) ) );
+                addColumn( t, "s_long", Long.class, nPhase++,
+                           i -> Long.valueOf( valInt( i ) ) );
+                addColumn( t, "s_float", Float.class, nPhase++,
+                           i -> Float.valueOf( (float) valDouble( i ) ) );
+                addColumn( t, "s_double", Double.class, nPhase++,
+                           i -> Double.valueOf( valDouble( i ) ) );
+                addColumn( t, "s_string", String.class, nPhase++,
+                           i -> valString( i, true ) );
+                addColumn( t, "s_boolean", Boolean.class, nPhase++,
+                           i -> Boolean.valueOf( i % 2 == 1 ) );
+            } ),
+            new ContentOpt( 'f', "fixed-vectors",
+                            "a selection of fixed-length 1-d array columns",
+                            t -> {
+                int nPhase = 1;
+                int[] s3 = new int[] { 3 };
+                addShapeColumn( t, "f_byte", byte[].class, s3, nPhase++,
+                                i -> new byte[] { (byte) ( i + 0 ),
+                                                  (byte) ( i + 1 ),
+                                                  (byte) ( i + 2 ) } );
+                addShapeColumn( t, "f_short", short[].class, s3, nPhase++,
+                                i -> new short[] { (short) ( i + 0 ),
+                                                   (short) ( i + 1 ),
+                                                   (short) ( i + 2 ) } ); 
+                addShapeColumn( t, "f_int", int[].class, s3, nPhase++,
+                                i -> new int[] { i + 0, i + 1, i + 2 } );
+                addShapeColumn( t, "f_long", long[].class, s3, nPhase++,
+                                i -> new long[] { i + 0, i + 1, i + 2 } );
+                addShapeColumn( t, "f_float", float[].class, s3, nPhase++,
+                                i -> new float[] { i, Float.NaN, i + 2.5f } );
+                addShapeColumn( t, "f_double", double[].class, s3, nPhase++,
+                                i -> new double[] { i, Double.NaN, i + 2.5 } );
+                addShapeColumn( t, "f_string", String[].class, s3, nPhase++,
+                                i -> new String[] { "foo", null,
+                                                    valString( i, true ) } );
+                addShapeColumn( t, "f_boolean", boolean[].class, s3, nPhase++,
+                                i -> new boolean[] { (i/1)%2==1,
+                                                     (i/2)%2==1,
+                                                     (i/4)%2==1 } );
+            } ),
+            new ContentOpt( 'v', "var-vectors",
+                            "a selection of variable-length 1-d array columns",
+                            t -> {
+                int nPhase = 1;
+                addVarColumn( t, "v_byte", byte[].class, nPhase++,
+                              i -> new byte[] { (byte) ( i + 0 ),
+                                                (byte) ( i + 1 ),
+                                                (byte) ( i + 2 ) } );
+                addVarColumn( t, "v_short", short[].class, nPhase++,
+                              i -> new short[] { (short) ( i + 0 ),
+                                                 (short) ( i + 1 ),
+                                                 (short) ( i + 2 ) } ); 
+                addVarColumn( t, "v_int", int[].class, nPhase++,
+                              i -> new int[] { i + 0, i + 1, i + 2 } );
+                addVarColumn( t, "v_long", long[].class, nPhase++,
+                              i -> new long[] { i + 0, i + 1, i + 2 } );
+                addVarColumn( t, "v_float", float[].class, nPhase++,
+                              i -> new float[] { i + 0, Float.NaN, i + 2.5f } );
+                addVarColumn( t, "v_double", double[].class, nPhase++,
+                              i -> new double[] { i + 0, Double.NaN, i + 2.5 });
+                addVarColumn( t, "v_string", String[].class, nPhase++,
+                              i -> new String[] { "foo", null,
+                                                  valString( i, true ) } );
+                addVarColumn( t, "v_boolean", boolean[].class, nPhase++,
+                              i -> new boolean[] { (i/1)%2==1,
+                                                   (i/2)%2==1,
+                                                   (i/4)%2==1 } );
+            } ),
+            new ContentOpt( 'm', "multi-d arrays",
+                            "a selection of multi-dimensional array columns",
+                            t -> {
+                int nPhase = 1;
+                addShapeColumn( t, "m_int", int[].class, new int[] { 2, 4 },
+                                nPhase++,
+                                i -> new int[] { 1000 + i, 1001 + i,
+                                                 2000 + i, 2001 + i,
+                                                 3000 + i, 3001 + i,
+                                                 4000 + i, 4001 + i, } );
+                addShapeColumn( t, "m_double", double[].class,
+                                new int[] { 3, 2 }, nPhase++,
+                                i -> new double[] {
+                                    i + .25,   i + .50,   i + .75,
+                                  - i - .25, - i - .50, - i - .75,
+                                } );
+            } ),
+            new ContentOpt( 'k', "kilo-column", "almost a thousand columns",
+                            t -> {
+                for ( int j = 0; j < 995; j++ ) {
+                    addColumn( t, "k_" + (j + 1), Integer.class, 0,
+                               i -> Integer.valueOf( valInt( i ) ) );
+                }
+            } ),
+        };
+        Map<Character,ContentOpt> map = new LinkedHashMap<>();
+        for ( ContentOpt opt : opts ) {
+            char chr = Character.valueOf( opt.idChr_ );
+            assert ! map.containsKey( chr );
+            map.put( chr, opt );
+        }
+        return Collections.unmodifiableMap( map );
+    }
+
+    /**
+     * Gives a nominal numeric integer value for a given row index.
+     *
+     * @param  ix  row index
+     * @return  integer numeric value
+     */
+    private static int valInt( int ix ) {
+        return ix * ( ( ( ix / 10 ) % 2 == 0 ) ? +1 : -1 );
+    }
+
+    /**
+     * Gives a nominal floating point value for a given row index.
+     *
+     * @param  ix  row index
+     * @return  floating point numeric value
+     */
+    private static double valDouble( int ix ) {
+        return isBlank( ix ) ? Double.NaN : valInt( ix );
+    }
+
+    /**
+     * Gives a nominal string value for a given row index.
+     *
+     * @param  ix  row index
+     * @param  isTricky  true to include some specially weird strings
+     * @return   string value
+     */
+    private static String valString( int ix, boolean isTricky ) {
+        if ( isBlank( ix ) ) {
+            return "";
+        }
+        else if ( isTricky && isFunny( ix ) ) {
+            return "' \"\\\"\"' ; '&<>";
+        }
+        else if ( ix == 0 ) {
+            return "zero";
+        }
+        int u = ix % 10;
+        int t = ( ix / 10 ) * 10;
+        int v = ix / 10;
+        StringBuffer sbuf = new StringBuffer();
+        String[] qpairs = { null, "\"\"", "''", "<>", "()", "{}", "[]", ",;" };
+        String qpair = isTricky ? qpairs[ v % qpairs.length ] : null;
+        final String preQuote = qpair == null ? "" : qpair.substring( 0, 1 );
+        final String postQuote = qpair == null ? "" : qpair.substring( 1, 2 );
+        if ( t != 0 ) {
+            sbuf.append( Integer.toString( t ) );
+            if ( u != 0 ) {
+                sbuf.append( isTricky ? " + " : "+" );
+            }
+        }
+        if ( u != 0 ) {
+            sbuf.append( preQuote )
+                .append( (new String[] {
+                    "zero", "one", "two", "three", "four",
+                    "five", "six", "seven", "eight", "nine",
+                 })[ u ] )
+                .append( postQuote );
+        }
+        return sbuf.toString();
+    }
+
+    /**
+     * Utility function that indicates whether a value at a given index
+     * should be set to a non-null blank value.
+     *
+     * @param  ix  row index
+     * @return   true for blank
+     */
+    private static boolean isBlank( int ix ) {
+        return ix % 10 == 9;
+    }
+
+    /**
+     * Utility function that indicates whether a value at a given index
+     * should be set to a test value out of the normal sequence.
+     *
+     * @param  ix  row index
+     * @return   true for funny value
+     */
+    private static boolean isFunny( int ix ) {
+        return ix % 10 == 8;
+    }
+
+    /**
+     * Adds a column to a table given a value mapping from row index.
+     *
+     * @param  table  table to add column to
+     * @param  name  column name
+     * @param  clazz  cell content class
+     * @param  nullPhase  row phase at which nulls should be substituted
+     * @param  cellData  produces basic value for given row index
+     */
+    private static <T> void addColumn( ColumnStarTable table,
+                                       String name, Class<T> clazz,
+                                       int nullPhase,
+                                       IntFunction<T> cellData ) {
+        table.addColumn( new ColumnData( new ColumnInfo( name, clazz, null ) ) {
+            public T readValue( long irow ) {
+                return irow % ZP == nullPhase ? null
+                                              : cellData.apply( (int) irow );
+            }
+        } );
+    }
+
+    /**
+     * Adds a column to a table with a supplied array shape.
+     * No checking is done to ensure that the shape makes sense.
+     *
+     * @param  table  table to add column to
+     * @param  name  column name
+     * @param  clazz  cell content class
+     * @param  shape   array shape 
+     * @param  nullPhase  row phase at which nulls should be substituted
+     * @param  cellData  produces basic value for given row index
+     */
+    private static <T> void addShapeColumn( ColumnStarTable table,
+                                            String name, Class<T> clazz,
+                                            int[] shape, int nullPhase,
+                                            IntFunction<T> cellData ) {
+        addColumn( table, name, clazz, nullPhase, cellData );
+        table.getColumnInfo( table.getColumnCount() - 1 )
+             .setShape( shape );
+    }
+
+    /**
+     * Adds a variable-length column to a table given a value mapping
+     * from row index to a fixed-length array value.
+     *
+     * @param  table  table to add column to
+     * @param  name  column name
+     * @param  clazz  cell content class, an array type
+     * @param  nullPhase  row phase at which nulls should be substituted
+     * @param  cellData  produces basic array value for given row index
+     */
+    private static <T> void addVarColumn( ColumnStarTable table,
+                                          String name, Class<T> clazz,
+                                          int nullPhase,
+                                          IntFunction<T> cellData ) {
+        final Class<?> elClazz = clazz.getComponentType();
+        table.addColumn( new ColumnData( new ColumnInfo( name, clazz, null ) ) {
+            public T readValue( long irow ) {
+                if ( irow % ZP == nullPhase ) {
+                    return null;
+                }
+                else {
+                    T value0 = cellData.apply( (int) irow );
+                    if ( value0 != null ) {
+                        int leng0 = Array.getLength( value0 );
+                        int leng1 = leng0 - ( ((int) irow) % (leng0 + 1) );
+                        if ( leng1 == leng0 ) {
+                            return value0;
+                        }
+                        else {
+                            T value1 =
+                                clazz.cast( Array.newInstance( elClazz,
+                                                               leng1 ) );
+                            for ( int i = 0; i < leng1; i++ ) {
+                                Array.set( value1, i, Array.get( value0, i ) );
+                            }
+                            return value1;
+                        }
+                    }
+                    else {
+                        return value0;
+                    }
+                }
+            }
+        } );
+    }
+
+    /**
+     * Defines an output table content option.
+     */
+    private static class ContentOpt {
+        final char idChr_;
+        final String name_;
+        final String description_;
+        final Consumer<ColumnStarTable> addContent_;
+
+        /**
+         * @param  idChr  identifier character
+         * @param  name  option name
+         * @param  description   user-oriented short description
+         * @param  addContent   adds content to table
+         */
+        ContentOpt( char idChr, String name, String description,
+                    Consumer<ColumnStarTable> addContent ) {
+            idChr_ = idChr;
+            name_ = name;
+            description_ = description;
+            addContent_ = addContent;
+        }
+    }
+}