Questions Tagged With ivyscript

Inconveniences when using inner classes in Ivy Script

Genzer Hawker — Fri, 29 Apr 2016 07:13:17 -0400

Suppose I have two classes, each of them provides Builder API.

// This is in Ivy Script
import example.Person.Builder;

Builder errorPersonBuilder = new Person.Builder(); // this line generates a compilation error saying class Person.Builder not found.

Builder workingPersonBuilder = new Builder(); // this works.

It is still OK if there is only one Builder inside the context. As soon as there is another:

// This is in Ivy Script
import example.Person.Builder;
import example.Company.Builder; // compilation error of collision, there are two classes named Builder.


Builder workingPersonBuilder = new Builder(); // this works, see above.

Builder anotherBuilder = new Builder(); // which builder?

If Ivy Script could supports the same as normal Java, we could do:

import example.Person.Builder;
import example.Company.Builder;

Person.Builder personBuilder = new Person.Builder();
Company.Builder companyBuilder = new Company.Builder();

Should this be supported in Ivy Script?

List converted from an Enum array in Ivy Script doesn't work correctly

Genzer Hawker — Thu, 12 Mar 2015 08:27:40 -0400

Today I found something looks like a bug in Ivy Script.

In Ivy Script, I want to have a List of all the elements of an enum, say WorkflowPriority, I simply call WorkflowPriority.values(). However, the instance of List returned by the call doesn't work correctly, especially with operation contains and remove.

Here are the tests that I made to check:

(This is an Ivy Script snippet)

import org.junit.Assert;
import com.genzerhawherk.bugs.Lists;
import ch.ivyteam.ivy.workflow.WorkflowPriority;

// Below are all failed tests
Assert.assertTrue(WorkflowPriority.values().contains(WorkflowPriority.HIGH));

List<WorkflowPriority> withGenerics = WorkflowPriority.values();
Assert.assertTrue(withGenerics.contains(WorkflowPriority.HIGH));

List fromEnums = Lists.fromEnums(WorkflowPriority.class);
Assert.assertTrue(fromEnums.contains(WorkflowPriority.HIGH));

List fromEnumVarargs = Lists.enumVarArgs(WorkflowPriority.HIGH, WorkflowPriority.EXCEPTION);
Assert.assertTrue(fromEnumVarargs.contains(WorkflowPriority.HIGH));

// Below are all passed tests
List listComprehensive = [WorkflowPriority.HIGH];
Assert.assertTrue(listComprehensive.contains(WorkflowPriority.HIGH));

List newPriorities = new List().addAll(WorkflowPriority.values());
Assert.assertTrue(newPriorities.contains(WorkflowPriority.HIGH));

List fromList = Lists.toArray([WorkflowPriority.HIGH]);
Assert.assertTrue(fromList.contains(WorkflowPriority.HIGH));

List fromVarArgs = Lists.normalVarArgs(WorkflowPriority.HIGH);
Assert.assertTrue(fromVarArgs.contains(WorkflowPriority.HIGH));

List<WorkflowPriority> manuallyConstructed = new List<WorkflowPriority>();
manuallyConstructed.add(WorkflowPriority.HIGH);
Assert.assertTrue(manuallyConstructed.contains(WorkflowPriority.HIGH));

The bug particularly relates to converting <T extends Enum<T>> T[] into a List<T>

Below is the class Lists I use in the test

public class Lists {

    public static Object[] toArray(Collection<?> collection) {
        return collection.toArray();
    }

    @SafeVarargs
    public static <T> T[] normalVarArgs(T...elements) {
        return Arrays.copyOf(elements, elements.length);
    }

    public static <T extends Enum<T>> T[] fromEnums(Class<T> enums) {
        return enums.getEnumConstants();
    }

    @SafeVarargs
    public static <T extends Enum<T>> T[] enumVarArgs(T...enums) {
        return enums;
    }
}

Chaining checking for initialization in Ivy Script

Genzer Hawker — Mon, 04 Aug 2014 11:35:59 -0400

In the Ivy Designer Guide, Chapter 7, section Null handling / Automatic object creation, it states

You can to use the .# operator to suppress the automatic object creation.

if( in.#customer == null)
{
  // object is null
}

if (in.#customer is initialized)
{
  // object is not null or has been set to a non-default value
}

I also discover that we can do a chain of suppresing initialization like this:

if (in.#bigDataClass.#smallerDataClass.#smallDataClass.#tinyDataClass.#fieldXyz is initialized) {
    // Reach here if all of the properties are initialized
} else  {
   // Reach here if any of the properties are null
}

This really reduces the verbosity of the code when I want to check a deep structure of data classes. Despite its usefulness, I cannot find any (Ivy) documentation mentioning about this feature. I only discovered it by chance and have been using it until now.

My question is whether this is an official feature but has been forgotten to mention or it is an unofficial/hidden feature and could be dropped in the future?

Thanks & Regards