util.jar file in Idea/lib folderregistry.properties file from misc folder and add required propertyCreate register form with password confirmation and validation messages next to field as shown on image below.
tuple level, instead of globalErrors.
Usercase class User(login: String, password: String)
User case class val registrationForm: Form[User] = Form(
mapping(
"login" -> nonEmptyText.verifying("user.registration.userExists", User.findByLogin(_) == None),
"passwordWithConfirmation" -> tuple(
"password" -> text(minLength = 6, maxLength = 30)
.verifying("user.registration.passwordOneDigit", name => {
(name + "A").split("\\d").size > 1
}),
"confirmation" -> text
).verifying("user.registration.passwordDontMatch", verifyPassword(_)).transform(
{ case (password, confirmation) => password},
(password: String) => ("", "")
)
)(User.apply)(User.unapply)
)
def verifyPassword(passwordWithConfirmation: Tuple2[String, String]): Boolean = passwordWithConfirmation match {
case (password: String, confirmation: String) => password.equals(confirmation)
}
passwordWithConfirmation which is tuple mapping for password and confirmation inputs. For this tuple I added verification rule, checking if both fields are equal. Last thing to do is to convert tuple into data that will be stored in User entity. For this purpose transform function is used. The transformation works both ways:
{ case (password, confirmation) => password}(password: String) => ("", "")Form object may look like this:
@(registrationForm: Form[model.User])(implicit flash: Flash)
@import helper.twitterBootstrap._
@import helper._
@main {
<h2>@Messages("user.registration.registerAccount")</h2>
@helper.form(action=routes.UserCtrl.register) {
<fieldset>
@inputText(registrationForm("login"))
@inputPassword(registrationForm("passwordWithConfirmation.password"))
@inputPassword(registrationForm("passwordWithConfirmation.confirmation"))
</fieldset>
<input class="btn btn-primary" type="submit" value="@Messages("user.registration.register")" />
}
}
Last thing that I need to do is to show error message for unmatched passwords. This will not work automatically, because there is no passwordWithConfirmation element in my form. @if(registrationForm.hasErrors) {
@registrationForm.error("passwordWithConfirmation") match {
case Some(err:FormError) => {<span class="help-inline">@Messages(err.message)</span>}
case _ => {}
}
}
scala.MatchedError: 0 (of class java.lang.Integer) in overridden renderComponent method of scala.swing.Table, when I tried to add rows.
val table = new Table(0, 2) {
override protected def rendererComponent(sel: Boolean, foc: Boolean, row: Int, col: Int): Component = {
col match {
case 1 => tcr.componentFor(this, sel, foc, "bar", row, col)
}
}
}
It turned out that I need a match for all possible values. In this particular case for 0, because I have two columns. So adding undermentioned code solved the problem
case 0 => super.rendererComponent(sel, foc, row, col)At the beginning I was confused by the error message and thought that there might be some casting problem. So I tried to store 1 into value
val table = new Table(0, 2) {
override protected def rendererComponent(sel: Boolean, foc: Boolean, row: Int, col: Int): Component = {
val columnIndex: Int = 1
col match {
case columnIndex => tcr.componentFor(this, sel, foc, "bar", row, col)
}
}
}
Ta-dah! Program compiles, adding rows to table works, it seemed that I fixed the problem, but in fact I just made one of the most common mistakes that Scala beginners do. It is the second time when I fall into this trap, that is why I chose to mention about it on my blog.columnIndex inside match is not the same columnIndex that was defined in first line of the function. It is variable initialized with col value. As there is no condition check just an assignment, the expression to the right of the arrow is always executed and each column contains component that I only wanted to appear in second one. val table = new Table(0, 2) {
override protected def rendererComponent(sel: Boolean, foc: Boolean, row: Int, col: Int): Component = {
val ColumnIndex: Int = 1
col match {
case ColumnIndex => tcr.componentFor(this, sel, foc, "bar", row, col)
}
}
}
or be surrounded by backticks
val table = new Table(0, 2) {
override protected def rendererComponent(sel: Boolean, foc: Boolean, row: Int, col: Int): Component = {
val columnIndex: Int = 1
col match {
case `columnIndex` => tcr.componentFor(this, sel, foc, "bar", row, col)
}
}
}
The first solution seems to be much better as it is agreeable with Scala's naming convention, according to which constants names should start with capital letter.columnIndex as variable. Changing val to var in last two snippets will produce compile error.
private SomeObject obj;
public SomeObject getObject() {
if (obj == null)
obj = computeObjectValue();
return obj;
}
synchronized keyword to getObject method is sufficient to avoid repeated initialization for instance and static fields, but harms performance. That's why it is good to use several idioms proposed by Joshua Bloch. private volatile SomeObject obj;
public SomeObject getObject() {
SomeObject result = obj;
if(result == null)
obj = result = computeObjectValue();
return result;
}
When to use: if an instance field can tolerate repeated initializationvolatile can be removed, but in this situation we will face more repeated initializations caused by caching field value by VM private volatile SomeObject obj;
public SomeObject getObject() {
SomeObject result = obj;
if (result == null) {
synchronized (this) {
result = obj;
if (result == null)
obj = result = computeObjectValue();
}
}
return result;
}
When to use: if an instance field should be initialized only once. public static SomeObject getObject() {
return FieldHolder.obj;
}
private static class FieldHolder {
private static final SomeObject obj = computeObjectValue();
}
When to use: if you want to lazy initialize static field
class Enclosing {
private val x = 5
new Inner().z // value z in class Inner cannot be accessed in Enclosing.this.Inner
class Inner {
private val z = 9
def out = x + z // no problem
}
}
If you want to make it work similarly to Java you need to add enclosing class qualifier.private[Enclosing] val z = 9
private[this] val member = 1which stipulates that the member can only be seen by members called on that same object, not from different objects, even if they are of the same type.
class Calculator (implicit val dataProvider:DataProvider, implicit val operation:Operation) {
def calculate(): Int = operation.exec(dataProvider.nextArgument, dataProvider.nextArgument)
}
val calc = new Calculator
object AdditionFromFakeDbDataConfig {
implicit val operation: Operation = new Addition
implicit val dataProvider: DataProvider = new FakeDbDataProvider
}
import AdditionFromFakeDbDataConfig._ val calc = new Calculator
Calculator(dataProvider: { val x: Int; val y: Int}, operation: { def exec(a: Int, b: Int): Int}) { ... }
Calculator class requires two arguments to be passed to its constructor. First needs to define two values x and y, and the second one must contains function exec taking two integers and returns integer. For example you can pass two objects:
object Data {
val x = 5
val y = 3
}
object Avg {
def exec(a: Int, b: Int): Int = (a + b) / 2
}
Addition and Multiplication are containted in Operations namespace, additionally there is abstract value defined that need to be instantiate in non-abstract object. trait Operations {
val operation: Operation
trait Operation {
def exec(a: Int, b: Int): Int
}
class Addition extends Operation {
def exec(a: Int, b: Int): Int = a + b
}
class Multiplication extends Operation {
def exec(a: Int, b: Int): Int = a * b
}
}
CalculatorComponent requires two traits DataProviders and Operations, both of them are in fact namespaces with abstract values: dataProvider and operation, that is why they can be accessed in Calculator class trait CalculatorComponent { this: DataProviders with Operations =>
val calculator = new Calculator
class Calculator {
def calculate(): Int = operation.exec(dataProvider.nextArgument, dataProvider.nextArgument)
}
}
object AdditionFromFakeDbDataConfig extends CalculatorComponent with Operations with DataProviders {
val operation = new Addition
val dataProvider = new FakeDbDataProvider
}
DefaultMessageListenerContainer with SimpleMessageListenerContainer I spotted that the second one ignores autoStartup setting.SimpleMessageListenerContainer creates a fixed number of JMS sessions at startup and uses them throughout the lifespan of the container, but why this happens before checking the autoStartup flag. I chose to explore source code for an answer.Lifecycle interface. It is worth to remember that lazy-init flag is ignored for lifecycle beans.doStart method depends on autoStartup flag which is checked in DefaultLifecycleProcessor.startBeans. Both containers use AbstractJmsListeningContainer’s doStart implementation:
@Override
protected void doStart() throws JMSException {
super.doStart();
initializeConsumers();
}
doStart establishes shared connection and resume all defined tasks. Default container task creates connection, session and consumer. Simple container doesn’t define any asynchronous tasks, instead it creates all these JMS components synchronously in its doInitialize method. So consumers initialization in doStart method is redundant in this case.SimpleMessageListenerContainer has additional property connectLazily,that can be used to skip initialization of JMS components in doInitialize method. When this flag is set to true and autoStartup to false, then message listener container needs to be started manually.