Get value of MapElement

[liranyogev]

Not really sure if this is the right place for a question, but I saw you answer here, so I'll give it a try.
First off, amazing library!!

I am trying to figure something and I can't find any example in your code on how to do it.

I created a custom visitor.
Using the accept function I am able to traverse all changes.

I am trying to get the actual element behind a node (element is in a collection).
Once I reach such an element I wrote the following code that works:

Map:
Integer key = (Integer) ((MapElement) node.getPathElement()).getKey();

List/Set:
SomeObject object = (SomeObject) ((CollectionElement) node.getPathElement()).getItem();

These seem to work, but I wonder...

1. Is there an easier way to perform this task?
2. How can I get the value in a mapElement?

Thanks for this great library!

[SQiShER]

Thanks for the nice feedback! Glad you like it!

To answer your question: yes, there is an easier way to access the value of a map entry. Here's a little example:

final Map<String, String> base = new TreeMap<String, String>();
final Map<Integer, String> working = new TreeMap<Integer, String>();
working.put(4, "Locke");
working.put(8, "Reyes");
working.put(15, "Ford");
working.put(16, "Jarrah");
working.put(23, "Shephard");
working.put(42, "Kwon");

final Node mapNode = ObjectDifferFactory.getInstance().compare(working, base);
mapNode.visitChildren(new Node.Visitor()
{
    @Override
    public void accept(final Node node, final Visit visit)
    {
        final Object key = ((MapElement) node.getPathElement()).getKey(); 
        //                 ^^^ I do not encourage this, but currently it's the only way
        final Object value = node.canonicalGet(working);
        System.out.println(key + " => " + value);
    }
});

Notice the call to node.canonicalGet(working). Every Node knows how to access the value of the element it represents on any instance of the same type as its originating object. There are the methods get, set and unset, which are all relative to the parent object. There are also absolute versions of these methods, called canonicalGet, canonicalSet and canonicalUnset, which simply take the object type you originally passed to the ObjectDiffer.

Map entry keys are a whole different story. I didn't really think about them as anything else but a simple identifiers for map values in my initial design. That was clearly an oversight and I even think map keys deserve to get diffed like any other object. However, for now, your solution to use MapElement#getKey() is the only way to easily get hold of the key. Although the method wasn't really intended for public use. I guess I'll make it package private, as soon as I found a better solution, to prevent too many people to rely on it.

I hope this helps!

[liranyogev]

Thanks for the quick and elaborate answer!

Now I finally understand what is target in these get functions...

Also working perfectly for a set/list.

I still don't understand what Node.get does.

Thanks!

[SQiShER]

Here is another example for you, that should clear things up.

First we set up a little pseudo address book that contains exactly one change (the nickname "Heisenberg"):

final AddressBook workingAddressBook = new AddressBook();
final Contact workingContact = new Contact("Walter White", "Heisenberg");
workingAddressBook.setContacts(asList(workingContact));

final AddressBook baseAddressBook = new AddressBook();
final Contact baseContact = new Contact("Walter White");
baseAddressBook.setContacts(asList(baseContact));

When we compare both versions and print the result...

final Node rootNode = ObjectDifferFactory.getInstance().compare(workingAddressBook, baseAddressBook);
rootNode.visit(new NodeHierarchyVisitor());

… we get the following output:

/ ===> DefaultNode(state=CHANGED, type=de.danielbechler.diff.example.CanonicalAccessorExample.AddressBook, 1 child, accessed via root element)
  /contacts ===> CollectionNode(state=CHANGED, type=java.util.List, 1 child, accessed via property 'contacts')
    /contacts[Contact{name='Walter White'}] ===> DefaultNode(state=CHANGED, type=de.danielbechler.diff.example.CanonicalAccessorExample.Contact, 1 child, accessed via collection item [Contact{name='Walter White'}])
      /contacts[Contact{name='Walter White'}]/nickname ===> DefaultNode(state=ADDED, type=java.lang.String, no children, accessed via property 'nickname')

Then we manually extract all nodes from the graph into variables...

final Node contactsNode = getFirstChildOf(rootNode);
final Node contactNode = getFirstChildOf(contactsNode);
final Node nicknameNode = getFirstChildOf(contactNode);

...and use those to extract their corresponding values from the working version:

final AddressBook addressBook = (AddressBook) rootNode.get(workingAddressBook);
final List<Contact> contacts = (List<Contact>) contactsNode.get(addressBook);
final Contact contact = (Contact) contactNode.get(contacts);

Now we finally have everything we need in order to express the difference between get and canonicalGet in four simple assertions:

assert rootNode.get(workingAddressBook) == rootNode.canonicalGet(workingAddressBook);
assert contactsNode.get(addressBook) == contactsNode.canonicalGet(workingAddressBook);
assert contactNode.get(contacts) == contactNode.canonicalGet(workingAddressBook);
assert nicknameNode.get(contact) == nicknameNode.canonicalGet(workingAddressBook);

In a nutshell, get always starts from the value of its parent node, whereas canonicalGet always starts from the root object. Hope this helps!

[liranyogev]

Thanks a lot for this!
Now I understand it!
You really did an amazing job here, thanks!