uk.ac.starlink.table.TestTableScheme Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of stil Show documentation
Show all versions of stil Show documentation
Starlink Tables Infrastructure Library
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 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 "[[,]]";
}
public String getExampleSpecification() {
return "10,is";
}
public String getXmlDescription() {
return String.join( "\n",
"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.",
"
",
"The table specification has two comma-separated parameters:",
"
",
"<nrow>: row count<opts>:",
"a string of letter options specifying what types of data",
"will be included; options are:",
"",
OPTS.values().stream().map( opt -> new StringBuffer()
.append( "- " )
.append( opt.idChr_ )
.append( ": " )
.append( opt.description_ )
.append( "
\n" )
.toString()
).collect( Collectors.joining( "\n" ) ),
"- *: equivalent to all of the above
",
"
",
"
",
"If <opts> and/or <nrow>",
"are omitted, some default values are used.",
"",
"" );
}
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 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 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 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 void addColumn( ColumnStarTable table,
String name, Class clazz,
int nullPhase,
IntFunction 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 void addShapeColumn( ColumnStarTable table,
String name, Class clazz,
int[] shape, int nullPhase,
IntFunction 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 void addVarColumn( ColumnStarTable table,
String name, Class clazz,
int nullPhase,
IntFunction 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 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 addContent ) {
idChr_ = idChr;
name_ = name;
description_ = description;
addContent_ = addContent;
}
}
}