8:05 p.m.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:06 a.m.
New subject: [Hibernate-JIRA] Updated: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik updated HV-390:
---------------------------------
Description:
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
was:
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:30 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
Just wondering whether you thought about allowing more than one boolean operation on a
composing constraint definition. Something like {{((Email | Address) & Phone)}}? The
limiting factor here is probably what the annotation syntax allows you to do.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:30 a.m.
New subject: [Hibernate-JIRA] Updated: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik updated HV-390:
---------------------------------
Fix Version/s: 4.2.0
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:36 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
{quote}
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
{quote}
Do you have a patch you can attach to the issue? Or you could fork the Validator git repo
(http://github.com/hibernate/hibernate-validator) and send a pull request.
Btw, what about {{@CompositionType}} instead of {{@Bool}}?
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:50 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
We did think about more constraints at once, but could not come up with an elegant
solution for it, due to the limitations on the possible types an annotation element can
have. With the current @Bool it is of course possible to express ((Email | Address) &
Phone) by first creating the annotation
containing
@Bool(OR)
@Email
@Address
@interface Or1{}
and then
@Bool(AND)
@Or1
@Phone
@interface OrAnd {}
As far as the name is concerned, we are open to suggestions, and @CompositionType is just
fine.
I can attach a log file with the changes required, or directly the three modified files
which can be just replaced in the validator. (As soon as I get access to the computer I
forgot at home....)
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:53 p.m.
New subject: [Hibernate-JIRA] Updated: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini updated HV-390:
--------------------------------
Attachment: modified classes.zip
Here are the modified classes to replace in the validator to use boolean composition.
There is also a changelog to easily find the code that has been added to the classes, and
a "stupid" test package for boolean composition based on the one for testing
composition.
The problem we had seem to depend on the error message in the annotation. If two
annotations have the same error message, and both fail on the same value, then one is lost
on the way and therefore fewer violations are reported. We still have to investigate
this.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:04 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
The problem seems to appear only when both annotations with the same error message also
both have @ReportAsSingleViolation, is this supposed to happen?
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:39 p.m.
New subject: [Hibernate-JIRA] Issue Comment Edited: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik edited comment on HV-390 at 10/17/10 1:39 PM:
----------------------------------------------------------------
We did think about more constraints at once, but could not come up with an elegant
solution for it, due to the limitations on the possible types an annotation element can
have. With the current @Bool it is of course possible to express ((Email | Address) &
Phone) by first creating the annotation
containing
{code}
@Bool(OR)
@Email
@Address
@interface Or1{}
{code}
and then
{code}
@Bool(AND)
@Or1
@Phone
@interface OrAnd {}
{code}
As far as the name is concerned, we are open to suggestions, and @CompositionType is just
fine.
I can attach a log file with the changes required, or directly the three modified files
which can be just replaced in the validator. (As soon as I get access to the computer I
forgot at home....)
was (Author: federicom):
We did think about more constraints at once, but could not come up with an elegant
solution for it, due to the limitations on the possible types an annotation element can
have. With the current @Bool it is of course possible to express ((Email | Address) &
Phone) by first creating the annotation
containing
@Bool(OR)
@Email
@Address
@interface Or1{}
and then
@Bool(AND)
@Or1
@Phone
@interface OrAnd {}
As far as the name is concerned, we are open to suggestions, and @CompositionType is just
fine.
I can attach a log file with the changes required, or directly the three modified files
which can be just replaced in the validator. (As soon as I get access to the computer I
forgot at home....)
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:41 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
Thanks guys. I have to look at the code to give you some feedback regarding the error
message problem.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:57 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Emmanuel Bernard commented on HV-390:
-------------------------------------
Guys are you sure ALLFALSE (ALL_FALSE, NOT?) is well defined?
What error report is generated in this case? The one that is true, but it does not
generate error report by definition.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:33 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
We have not tested {{ALLFALSE}} (probably ALL_FALSE rather than NOT) properly yet, but it
should be well defined in the sense that it contributes correctly to the constraint
evaluation. For simplicity, at the moment everything is reported just as a
{{@ReportAsSingleViolation}} was present in the top level annotation (so that only the
overall composed test is reported to fail). The problem is that if the boolean constraint
is very nested, error messages on single annotations might be meaningless in itself,
without
considering where the annotation is in the "boolean path". That is why we wanted
to discuss this with you before implementing some more advanced solution for this.
The current proposal is therefore that:
1) For {{AND}} nothing changes.
2) For {{OR}} I understand that you would like us to report ALL tests that fail, when the
OR itself fails, or nothing otherwise.
3) For {{ALLFASE}} we should report ALL the ones that are true, when ALLFALSE fails.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:41 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Emmanuel Bernard commented on HV-390:
-------------------------------------
Remember that a constraint when failing can adjust the error report (ConstraintViolation)
it generates. That's why I am skeptical about how ALL_FALSE could work in a portable
way.
On the OR side, returning all the failures seems right but somehow being able to identify
them as part of a OR groups could be helpful. Not sure how to do that though.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:54 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
Yes, violation reporting with boolean constraints is a pain. I understand what you mean
with {{ALL_FALSE}}. It is not easy to come up with meaningful default messages, especially
when a constraint should be reported as failed even if it actually succeeded. How do you
use the customized error message in this case? That is why our first instinct was to just
hide the complexity of the boolean tree defined by a composed annotation behind a default
@ReportAsSingleViolation.
The problem as I see it is mainly that, as long as you allow only {{AND}}, you don't
really have a constraint tree to evaluate, but a list. Whenever a single constraint fails,
you can stop and say that there is a violation. No matter how nested the contraint was in
the composed annotation.
That is, such composed annotations, do not really define new constraints, they are only a
container. That is why it makes sense to want to report the single violations form inside
the container: because their individual meaning is preserved, just as they where written
individually on the property to validate.
When instroducing boolean operators, you have to evaluate the constraints in a tree-like
fashion, and it makes a difference where the constraints that fails is in the tree.
In this case you are really defining a new constraint with a new meaning, where its
composing parts do not make much sense alone.
If some user really still wants to see a list of all composing constraints that caused the
violation, I can suggest we try to report the violations in a tree structure mirroring the
way the constraints are composed.
In this way the violations would be grouped by boolean operator, and a meaningful message
could be given for each subtree.
The user could then decide how many levels of this tree he would want to be reported or
shown, since I think the context in which a constraint fails is as important as the
constraint itself.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:45 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
We could enforce {{@ReportAsSingleViolation}} where it is hard to define a meaningful
default message like in {{ALL_FALSE}}. I am not sure how usable a tree structure of
violations would be.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:54 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Emmanuel Bernard commented on HV-390:
-------------------------------------
Right, I was thinking along the same line.
Let's enforce @ReportAsSingleViolation for now and see if we can come up with an
decent structure down the line and if there is a need.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:38 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
In the files I uploaded, @ReportAsSingleViolation is already enforced, but for both {{OR}}
and {{ALL_FALSE}}. It is straightforward to do it only for {{ALL_FALSE}}. It can be done
in ConstraintTree.java by deleting the "OR" line:
{code}
... reportAsSingleViolation() {
return getDescriptor().isReportAsSingleViolation()
|| getDescriptor().getBool() == OR
|| getDescriptor().getBool() == ALLFALSE;
}
{code}
We will try to set up a better set of tests as soon as possible to check that everything
is at least correct.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:55 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
Thanks. I will integrate your patch probably during this week and keep you updated on how
it goes.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:53 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
Nice, thanks. By the way, just feel free to change {{@Bool}} into {{@CompositionType}} if
you think it is better (and {{ALLFALSE}} into {{ALL_FALSE}} or {{NOT}}).
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:13 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
I've applied the changes you've attached (renamed the annotation as discussed). In
case you guys still want to provide some more tests that would be great. In this case you
probably should sync again with the latest code. Remember though that we moved from svn to
git during the last couple of weeks. You find the source now under
http://github.com/hibernate/hibernate-validator
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:52 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Dag Hovland commented on HV-390:
--------------------------------
We have been thinking about an alternative solution to the error reporting: Using some
easy transformations on boolean expressions (deMorgans laws), we can "push" the
negations "down" to the level of basic (not composed) tests. In this way, we do
not need to give error messages for negated composed tests, only for negated simple tests.
(This form is called "negation normal form" in logic). If we do this, then we
can add a second error message to simple tests, which should be returned in the cases when
the test should have failed. The rest of the error reporting can the remain as today.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:59 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
If i understand correctly you are thinking about having to messages on a constraint.
Something like _message_ (which we have now) and an additional _inverseMessage_ (or
whatever you want to call it). The problem is that this would not work with the exiting
constraints (because they are part of the specification and cannot be modified) and I
think two messages might be confusing for the user.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:10 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
Ok, I see the problem there. We'll keep thinking then :)
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:59 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Dag Hovland commented on HV-390:
--------------------------------
We wondered if a composed annotation can have its own Validator in addition (to save one
annotation declaration)?
It seems that in such a case, the constraint represented by the validator, is not treated
as a composing constraint. So, if we use boolean, the ConstraintComposition is not applied
to the value returned by this validator.
For example:
{code}
@ConstraintComposition(ALL_FALSE)
@ComposingConstraint1
@ComposingConstraint2
@Constraint(validatedBy = {ComposedConstraintValidator.class})
@interface ComposedConstraint{...}
{code}
In this case {{ALL_FALSE}} is not applied to the value returned by
ComposedConstraintValidator itself.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:38 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Dag Hovland commented on HV-390:
--------------------------------
We made some more tests for OR and ALL_FALSE, they have been tested with the code
presently in the git repository. The files are attached in a zip. Is this ok, or do you
want some other format?
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:44 p.m.
New subject: [Hibernate-JIRA] Updated: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Dag Hovland updated HV-390:
---------------------------
Attachment: booltest.zip
New tests of ALL_FALSE, OR and AND. Contains new and changed files in the package
org.hibernate.validator.test.constraints.boolcomposition
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:54 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
{quote}
The files are attached in a zip. Is this ok, or do you want some other format?
{quote}
Now that we moved to git, the easiest way for us to integrate a patch is via a [pull
request|http://help.github.com/pull-requests]. Alternatively a patch file is ok as well.
See also - http://community.jboss.org/wiki/ContributingtoHibernateValidator
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:47 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Emmanuel Bernard commented on HV-390:
-------------------------------------
"We wondered if a composed annotation can have its own Validator in addition (to save
one annotation declaration)?"
Good question.
It is definitely accepted for @ConstraintComposition(AND), I'd say it makes sense for
OR as well.
Should we use the same rule for ALL_FALSE? Why did you want to exclude it?
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:59 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
We do not want to exclude it, we would like to have it as well, but we just noticed that
it does not seem to work with {{ALL_FALSE}}, and probably {{OR}} as well.
I had a suspect that such constraints are treated differently than the other composing
ones, and we tested it to make sure.
I should examine better the code, but I think that it is because the local validator (in
the example {{ComposedConstraintValidator.class}}) is not treated as a child of
{{ComposedConstraint}} in the annotation tree representing this annotation, but it is
checked independently by {{validateSingleConstraint()}} in the class {{ConstrintTree}}, as
if an annotation with children cannot have its own validator.
This of course does not make difference with {{@ConstraintComposition(AND)}}, since the
order in which constraints are checked is
unimportant in a conjunction, but for boolean evaluation purpouses, it should be treated
as a child and not an independent constraint.
From a quick test, it seems like it is enough to move the call to
{{validateSingleConstraint()}} so that its result is counted with the violations caused by
the children in the first loop of {{validateConstraints()}}.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:51 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
Ok, it wasn't enough to just move method calls around, since it had some side effects
other places, but I think I managed to fix it now keeping the modifications to a
minimum(at least all the other tests still succeed as well as the new ones).
Tomorrow I will try to pull the new version using Git.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:14 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik commented on HV-390:
--------------------------------------
Great. I'll have a look at the changes then.
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:57 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Federico Mancini commented on HV-390:
-------------------------------------
just to make sure i did things right, did the pull request arrived?
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:06 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Emmanuel Bernard commented on HV-390:
-------------------------------------
yes it's here
https://github.com/hibernate/hibernate-validator/pull/3
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:19 p.m.
New subject: [Hibernate-JIRA] Resolved: (HV-390) Boolean composition of constraints
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-390?page=com...
]
Hardy Ferentschik resolved HV-390.
----------------------------------
Resolution: Fixed
thanks for all the work
Boolean composition of constraints
----------------------------------
Key: HV-390
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-390
Project: Hibernate Validator
Issue Type: New Feature
Components: engine
Reporter: Federico Mancini
Assignee: Hardy Ferentschik
Fix For: 4.2.0
Attachments: booltest.zip, modified classes.zip
By adding a built-in annotation @Bool (or some other name) with element values OR,
ALLFALSE and AND (which would be the default) it would be possible to
compose constraints in a boolean fashion.
For example:
{code}
//Specify that at least one of the patterns must match
@Bool(OR)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface WhiteList{..}
{code}
{code}
//Specify that none of the patterns must match
@Bool(ALLFALSE)
@List({@Pattern(regexp="pat1"),@Pattern(regexp="pat2"),@Pattern(regexp="pat3"),@Pattern(regexp="pat4")})
@interface BlackList{..}
{code}
{code}
//At least on valid contact method must match
@Bool(OR)
@Email
@Address
@Phone
@interface ContactDetails{...}
{code}
This would greatly increase the type of new constraints that can be defined just by
reusing some existing ones.
Possible extensions might be for example further operators like XOR (meaning exactly one
of the constraints must hold) or similar.
It seems like it is possible to implement this feature by adding very little code to just
a couple of classes, and adding the new @Bool annotation to the API.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4977
days inactive
5004
days old
hibernate-issues@lists.jboss.org
33 comments
4 participants
participants (4)
-
Dag Hovland (JIRA) -
Emmanuel Bernard (JIRA)
-
Federico Mancini (JIRA)
-
Hardy Ferentschik (JIRA)