Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




EMF Model Query Developer Guide
Previous Page Home Next Page

Basic Conditions

The EMF Model Query Framework provides a variety of convenient conditions that implement predicates on simple data values, including strings, numbers, and booleans. Because they work with types that are modeled in EMF using EDataTypes, these conditions are typically used as predicates on the EAttributes of model elements.

Basic Condition API
[ as SVG]

Condition Framework

The root of the condition hierarchy is, unsurprisingly, the Condition class. It defines the basic protocol of predicate evaluation, the boolean isSatisfied(Object) method. It also provides static factory methods for boolean operators, allowing multiple conditions to be combined in a string of code that vaguely resembles an expression:

Object subject = ... ; // a subject on which to test a complex condition

Condition a = ... ; // conditions obtained from somewhere
Condition b = ... ;
Condition c = ... ;

Condition complex = a.IMPLIES(b.OR(c));

System.out.println("Test: " + complex.isSatisfied(subject));

These boolean operators are implemented as private inner classes of the Condition class.

The ObjectInstanceCondition is different. As its name implies, it checks whether an object under test is a particular known instance, supplied to the condition upon construction. We show elsewhere how the shared IS_NULL instance of this condition class is the standard (and only) way to check whether the value of an EAttribute in a model element contains nulls.

Condition Policies

The ConditionPolicy class implements a quantifier, either "exists" (ANY) or "for all" (ALL). A ConditionPolicy may be used to test a single condition against multiple subject:

Collection subjects = ... ; // some subjects on which to test a condition

Condition cond = ... ; // a condition obtained from somewhere

System.out.println("Test all: " + ConditionPolicy.ALL.isSatisfied(cond, subjects);
System.out.println("Test any: " + ConditionPolicy.ANY.isSatisfied(cond, subjects);

or multiple conditions against a single subject:

Object subject = ... ; // a subjects on which to test some conditions

Condition[] conditions = ... ; // some conditions obtained from somewhere

System.out.println("Test all: " + ConditionPolicy.ALL.isSatisfied(conditions, subject);
System.out.println("Test any: " + ConditionPolicy.ANY.isSatisfied(conditions, subject);

These condition objects may not be very exciting on their own, but they form the basis of every executable query.

Conditions on Primitive Types

The EMF Model Query framework includes, in the box, a variety of conditions on the commonly used Java boolean, numeric, and string primitive types. These conditions, by default, assume their inputs to be of the appropriate Java wrapper types. Optionally, they can be configured with value adapters that convert other data types to a value suitable for testing with these conditions.

Primitive Type Conditions
[ as SVG]

The BooleanCondition class defines a predicate on boolean values.

Object subject = Boolean.TRUE;
BooleanCondition cond = new BooleanCondition(true);

System.out.println("Test: " + cond.isSatisfied(subject));

The abstract NumberCondition class defines predicates on numeric values. The concrete *Value subclasses are inner classes handling each of Java's different numeric types. The condition is a range test: a numeric value that falls within the range is accepted. Exact matches are also supported, with convenience constructors taking a single value to specify the same upper and lower bound. Ranges are inclusive on both bounds.

Object subject = new Double(Math.E);
NumberCondition cond = new NumberCondition.DoubleValue(2.0, 3.0);  // J2SE 5.0 auto-boxing

System.out.println("Test: " + cond.isSatisfied(subject));

The abstract StringCondition class defines predicates on string values. The concrete StringValue, SubStringValue, and StringRegularExpressionValue test string inputs for equality, substring containment, and regular expression pattern match, respectively. All support case-insensitive matching as an option; the default is case-sensitive.

The StringRegularExpressionValue looks for a pattern-match using Matcher.find(), not Matcher.matches(). Thus, in order to specify a regex that matches the entire string, it is necessary to use the beginning-of-input and end-of-input anchors: ^ and $.

The StringLength condition tests the length of a string, using the same range strategy as the NumberConditions.

Object subject = "CATGGTGCCAC";
StringCondition cond = new StringRegularExpressionValue("G+");

System.out.println("Test: " + cond.isSatisfied(subject));

Copyright (c) 2000, 2007 IBM Corporation and others. All Rights Reserved.

  Published under the terms of the Eclipse Public License Version 1.0 ("EPL") Design by Interspire