Renault True Code V1.2.1 Program
Raingarda Krzynowek
This chapter covers the syntax of the Groovy programming language.The grammar of the language derives from the Java grammar,but enhances it with specific constructs for Groovy, and allows certain simplifications.
A multiline comment starts with /* and can be found at any position in the line.The characters following /* will be considered part of the comment, including new line characters,up to the first */ closing the comment.Multiline comments can thus be put at the end of a statement, or even inside a statement.
Similarly to multiline comments, Groovydoc comments are multiline, but start with /** and end with */.Lines following the first Groovydoc comment line can optionally start with a star *.Those comments are associated with:
Beside the single-line comment, there is a special line comment, often called the shebang line understood by UNIX systemswhich allows scripts to be run directly from the command-line, provided you have installed the Groovy distributionand the groovy command is available on the PATH.
Using such names might be confusing and is often best to avoid.The trick is primarily intended to enable certain Java integration scenariosand certain DSL scenarios wherehaving "verbs" and "nouns" with the same name as keywords may be desirable.
Quoted identifiers appear after the dot of a dotted expression.For instance, the name part of the person.name expression can be quoted with person."name" or person.'name'.This is particularly interesting when certain identifiers contain illegal characters that are forbidden by the Java Language Specification,but which are allowed by Groovy when quoted. For example, characters like a dash, a space, an exclamation mark, etc.
Text literals are represented in the form of chain of characters called strings.Groovy lets you instantiate java.lang.String objects, as well as GStrings (groovy.lang.GString)which are also called interpolated strings in other programming languages.
Triple-single-quoted strings may span multiple lines.The content of the string can cross line boundaries without the need to split the string in several piecesand without concatenation or newline escape characters:
If your code is indented, for example in the body of the method of a class, your string will contain the whitespace of the indentation.The Groovy Development Kit contains methods for stripping out the indentation with the String#stripIndent() method,and with the String#stripMargin() method that takes a delimiter character to identify the text to remove from the beginning of a string.
Any Groovy expression can be interpolated in all string literals, apart from single and triple-single-quoted strings.Interpolation is the act of replacing a placeholder in the string with its value upon evaluation of the string.The placeholder expressions are surrounded by $. The curly braces may be omitted for unambiguous dotted expressions,i.e. we can use just a $ prefix in those cases.If the GString is ever passed to a method taking a String, the expression value inside the placeholderis evaluated to its string representation (by calling toString() on that expression) and the resultingString is passed to the method.
When a method (whether implemented in Java or Groovy) expects a java.lang.String,but we pass a groovy.lang.GString instance,the toString() method of the GString is automatically and transparently called.
Beyond the usual quoted strings, Groovy offers slashy strings, which use / as the opening and closing delimiter.Slashy strings are particularly useful for defining regular expressions and patterns,as there is no need to escape backslashes.
Dollar slashy strings are multiline GStrings delimited with an opening $/ and a closing /$.The escaping character is the dollar sign, and it can escape another dollar, or a forward slash.Escaping for the dollar and forward slash characters is only needed where conflicts arise withthe special use of those characters. The characters $foo would normally indicate a GStringplaceholder, so those four characters can be entered into a dollar slashy string by escaping the dollar, i.e. $$foo.Similarly, you will need to escape a dollar slashy closing delimiter if you want it to appear in your string.
Conveniently for exact decimal number calculations, Groovy chooses java.math.BigDecimal as its decimal number type.In addition, both float and double are supported, but require an explicit type declaration, type coercion or suffix.Even if BigDecimal is the default for decimal numbers, such literals are accepted in methods or closures taking float or double as parameter types.
The division operators / (and /= for division and assignment) produce a double resultif either operand is a float or double, and a BigDecimal result otherwise(when both operands are any combination of an integral type short, char, byte, int, long,BigInteger or BigDecimal).
BigDecimal division is performed with the divide() method if the division is exact(i.e. yielding a result that can be represented within the bounds of the same precision and scale),or using a MathContext with a precisionof the maximum of the two operands' precision plus an extra precision of 10,and a scaleof the maximum of 10 and the maximum of the operands' scale.
The power operation is represented by the ** operator, with two parameters: the base and the exponent.The result of the power operation depends on its operands, and the result of the operation(in particular if the result can be represented as an integral value).
We mentioned that by default, list literals are actually instances of java.util.ArrayList,but it is possible to use a different backing type for our lists,thanks to using type coercion with the as operator, or with explicit type declaration for your variables:
You can access elements of the list with the [] subscript operator (both for reading and setting values)with positive indices or negative indices to access elements from the end of the list, as well as with ranges,and use the
Groovy has always supported literal list/array definitions using square bracketsand has avoided Java-style curly braces so as not to conflict with closure definitions.In the case where the curly braces come immediately after an array type declaration however,there is no ambiguity with closure definitions,so Groovy 3 and above support that variant of the Java array initialization expression.
Sometimes called dictionaries or associative arrays in other languages, Groovy features maps.Maps associate keys to values, separating keys and values with colons, and each key/value pairs with commas,and the whole keys and values surrounded by square brackets.
Here, we used numbers as keys, as numbers can unambiguously be recognized as numbers,so Groovy will not create a string key like in our previous examples.But consider the case you want to pass a variable in lieu of the key, to have the value of that variable become the key:
Bitwise operators can be applied on arguments which are of type byte, short, int, long, or BigInteger.If one of the arguments is a BigInteger, the result will be of type BigInteger;otherwise, if one of the arguments is a long, the result will be of type long;otherwise, the result will be of type int:
All three operators are applicable where the left argument is of type byte, short, int, or long.The first two operators can also be applied where the left argument is of type BigInteger.If the left argument is a BigInteger, the result will be of type BigInteger;otherwise, if the left argument is a long, the result will be of type long;otherwise, the result will be of type int:
The "not" operator is represented with an exclamation mark (!) and inverts the result of the underlying boolean expression. Inparticular, it is possible to combine the not operator with the Groovy truth:
The "Elvis operator" is a shortening of the ternary operator. One instance of where this is handy is for returninga 'sensible default' value if an expression resolves to false-ish (as inGroovy truth). A simple example might look like this:
Usage of the Elvis operator reduces the verbosity of your code and reduces the risks of errors in case of refactorings,by removing the need to duplicate the expression which is tested in both the condition and the positive return value.
The Safe Navigation operator is used to avoid a NullPointerException. Typically when you have a reference to an objectyou might need to verify that it is not null before accessing methods or properties of the object. To avoid this, the safenavigation operator will simply return null instead of throwing an exception, like so:
The user.name call triggers a call to the property of the same name, that is to say, here, to the getter for name. Ifyou want to retrieve the field instead of calling the getter, you can use the direct field access operator:
There are multiple advantages in using method pointers. First of all, the type of such a method pointer isa groovy.lang.Closure, so it can be used in any place a closure would be used. In particular, it is suitable toconvert an existing method for the needs of the strategy pattern:
Method pointers are bound by the receiver and a method name. Arguments are resolved at runtime, meaning that if you havemultiple methods with the same name, the syntax is not different, only resolution of the appropriate method to be calledwill be done at runtime:
The Spread-dot Operator (*.), often abbreviated to just Spread Operator, is used to invoke an action on all itemsof an aggregate object. It is equivalent to calling the action on each item and collecting the result into a list:
There may be situations when the arguments of a method call can be found in a list that you need to adapt to the methodarguments. In such situations, you can use the spread operator to call the method. For example, imagine you have thefollowing method signature:
Ranges implementation is lightweight, meaning that only the lower and upper bounds are stored. You can create a rangefrom any Comparable object that has next() and previous() methods to determine the next / previous item in the range.For example, you can create a range of characters this way:
b1e95dc632