c# barcode generator library open source The Table in Font

Draw ECC200 in Font The Table

Next, we define the trait that holds the table itself. The Table trait takes a type parameter that is the type of the class that is implementing the trait. This type, MyType, will also be applied to fields and queries so that we can make sure that the only fields that are specified in queries to a particular table instance are fields defined by that table. We re also extending SuperTuple, which is a builder of Tuples that have extra type information. We ll get to that in a little while.

And the instances must also define the type of the columns. This must be a Product. Product is the supertrait of all the Tuple classes. This does not give a lot of type safety standing on its own, because lots and lots of classes subclass from Product. However, you ll see how we make sure the type defined here ties to the actual fields, and the compiler will make sure that things are defined correctly.

Next, the implementer must specify the columns in the database. The type here is ColumnTypes with FieldProduct[MyType]. We just defined ColumnTypes, so the type that columns returns must check with the types we defined in ColumnTypes. Further, the only way to construct a FieldType is via the SuperTuple building mechanism that we mixed into this trait. So, we know that the ColumnType with FieldProduct[MyType] will check such that ColumnTypes has to be a Tuple, and it has to be a Tuple with the same arity (number of places) and same type as the columns.

def columns: ColumnTypes with FieldProduct[MyType]

We re going to create a subtrait of BasicColumn that has a helper method, ~, that allows chaining of fields in definitions.9 So, you can write id ~ name ~ birthday as a definition of a Tuple of fields. These Tuples are special as they are subclasses of FieldProduct[MyType].

trait MyColumn[T] extends BasicColumn[MyType, T] { def ~[OT](p: MyColumn[OT]): MyTuple2[MyType, T, OT] = { val col = this new MyTuple2[MyType, T, OT](col.default, p.default) { def fields = List(col, p) def fieldProduct: (MyColumn[T], MyColumn[OT]) = (col, p) } } }

The IntColumn is a column that holds an Int, has a default value, and can convert itself to and from JDBC.

case class IntColumn(name: String) extends MyColumn[Int] { def default = 0 def set(st: PreparedStatement, offset: Int, value: Int) { st.setInt(offset, value)

} def getField(rs: ResultSet): Int = rs.getInt(name) }

And we now define column representations for Long, String, and Date:

case class LongColumn(name: String) extends MyColumn[Long] { def default = 0 def set(st: PreparedStatement, offset: Int, value: Long) { st.setLong(offset, value) } def getField(rs: ResultSet): Long = rs.getLong(name) } case class StringColumn(name: String) extends MyColumn[String] { def default = "" def set(st: PreparedStatement, offset: Int, value: String) { st.setString(offset, value) } def getField(rs: ResultSet): String = rs.getString(name) } case class DateColumn(name: String) extends MyColumn[Date] { def default = new Date(0) def set(st: PreparedStatement, offset: Int, value: Date) { st.setDate(offset, new java.sql.Date(value.getTime)) } def getField(rs: ResultSet): Date = rs.getDate(name) }

Previously, we ve defined the column types. Now, let s see how we define a method that can handle a query. The find method takes two parameters: the columns to return and the query parameters. You might call it as such:

findCols(id ~ name, By(age, 33)).

Such a call would return a List[(Int, String)]. Let s look at the type declaration. First we define the type parameter FT, which must be a Product with FieldProduct[MyType]. That means it s one of those nifty Tuples that can be constructed by chaining fields together with the ~. The first parameter, cols, must be an FT. That means that the cols parameter is composed of fields that represent columns in the current table. The return type is the ReturnType type on FieldProduct, which will be the column types.