Merge lp:~davidmhewitt/pantheon-photos/temp-fix-crash into lp:~pantheon-photos/pantheon-photos/trunk

[David Hewitt]

Switch to new comparators

Switch to new comparators to fix crash.

[lp:~davidmhewitt/pantheon-photos/temp-fix-crash]

3184. By David Hewitt on 2017-03-28

Removed unnecessary parts of code

[Danielle Foré (danrabbit)]

Can confirm that this fixes the crash

review: Approve

=== modified file 'src/events/Branch.vala'
--- src/events/Branch.vala	2017-01-12 18:13:48 +0000
+++ src/events/Branch.vala	2017-03-28 22:34:40 +0000
@@ -347,11 +347,11 @@
     }
 
     private void graft_event (Sidebar.Entry parent, Event event,
-                              owned CompareDataFunc<Sidebar.Entry>? comparator = null) {
+                              owned CompareFunc<Sidebar.Entry>? comparator = null) {
         Events.EventEntry entry = new Events.EventEntry (event);
         entry_map.set (event, entry);
 
-        graft (parent, entry, (owned) comparator);
+        graft (parent, entry, comparator);
     }
 
     private void reparent_event (Event event, Sidebar.Entry new_parent) {

=== modified file 'src/sidebar/Branch.vala'
--- src/sidebar/Branch.vala	2017-01-12 18:13:48 +0000
+++ src/sidebar/Branch.vala	2017-03-28 22:34:40 +0000
@@ -52,17 +52,17 @@
 
         public Sidebar.Entry entry;
         public weak Node? parent;
-        public CompareDataFunc<Sidebar.Entry> comparator;
+        public CompareFunc<Sidebar.Entry> comparator;
         public Gee.SortedSet<Node>? children = null;
 
         public Node (Sidebar.Entry entry, Node? parent,
-                     owned CompareDataFunc<Sidebar.Entry> comparator) {
+                     CompareFunc<Sidebar.Entry> comparator) {
             this.entry = entry;
             this.parent = parent;
-            this.comparator = (owned) comparator;
+            this.comparator = comparator;
         }
 
-        private static int comparator_wrapper (Node? a, Node? b) {
+        private static int comparator_wrapper (Node a, Node b) {
             if (a == b)
                 return 0;
 
@@ -185,16 +185,16 @@
             cb (this);
         }
 
-        public void change_comparator (owned CompareDataFunc<Sidebar.Entry> comparator, bool recursive,
+        public void change_comparator (CompareFunc<Sidebar.Entry> comparator, bool recursive,
                                        ChildrenReorderedCallback cb) {
-            this.comparator = (owned) comparator;
+            this.comparator = comparator;
 
             // reorder children, but need to do manual recursion to set comparator
             reorder_children (false, cb);
 
             if (recursive) {
                 foreach (Node child in children)
-                    child.change_comparator ((owned) comparator, true, cb);
+                    child.change_comparator (comparator, true, cb);
             }
         }
     }
@@ -202,7 +202,7 @@
     private Node root;
     private Options options;
     private bool shown = true;
-    private CompareDataFunc<Sidebar.Entry> default_comparator;
+    private CompareFunc<Sidebar.Entry> default_comparator;
     private Gee.HashMap<Sidebar.Entry, Node> map = new Gee.HashMap<Sidebar.Entry, Node> ();
 
     public signal void entry_added (Sidebar.Entry entry);
@@ -218,18 +218,11 @@
     public signal void show_branch (bool show);
 
     public Branch (Sidebar.Entry root, Options options,
-                   owned CompareDataFunc<Sidebar.Entry> default_comparator,
-                   owned CompareDataFunc<Sidebar.Entry>? root_comparator = null) {
-        this.default_comparator = (owned) default_comparator;
-
-        CompareDataFunc<Sidebar.Entry>? broken_ternary_workaround;
-
-        if (root_comparator != null)
-            broken_ternary_workaround = (owned) root_comparator;
-        else
-            broken_ternary_workaround = (owned) default_comparator;
-
-        this.root = new Node (root, null, (owned) broken_ternary_workaround);
+                   CompareFunc<Sidebar.Entry> default_comparator,
+                   CompareFunc<Sidebar.Entry>? root_comparator = null) {
+        
+        this.default_comparator = default_comparator;
+        this.root = new Node(root, null, (root_comparator != null) ? root_comparator : default_comparator);
         this.options = options;
 
         map.set (root, this.root);
@@ -267,7 +260,7 @@
     }
 
     public void graft (Sidebar.Entry parent, Sidebar.Entry entry,
-                       owned CompareDataFunc<Sidebar.Entry>? comparator = null) {
+                       CompareFunc<Sidebar.Entry>? comparator = null) {
         assert (map.has_key (parent));
         assert (!map.has_key (entry));
 
@@ -276,14 +269,7 @@
 
         Node parent_node = map.get (parent);
 
-        CompareDataFunc<Sidebar.Entry>? broken_ternary_workaround;
-
-        if (comparator != null)
-            broken_ternary_workaround = (owned) comparator;
-        else
-            broken_ternary_workaround = (owned) default_comparator;
-
-        Node entry_node = new Node (entry, parent_node, (owned) broken_ternary_workaround);
+        Node entry_node = new Node(entry, parent_node, (comparator != null) ? comparator : default_comparator);
 
         parent_node.add_child (entry_node);
         map.set (entry, entry_node);
@@ -360,16 +346,16 @@
         entry_node.reorder_children (recursive, children_reordered_callback);
     }
 
-    public void change_all_comparators (owned CompareDataFunc<Sidebar.Entry>? comparator) {
-        root.change_comparator ((owned) comparator, true, children_reordered_callback);
+    public void change_all_comparators (CompareFunc<Sidebar.Entry>? comparator) {
+        root.change_comparator (comparator, true, children_reordered_callback);
     }
 
     public void change_comparator (Sidebar.Entry entry, bool recursive,
-                                   owned CompareDataFunc<Sidebar.Entry>? comparator) {
+                                   CompareFunc<Sidebar.Entry>? comparator) {
         Node? entry_node = map.get (entry);
         assert (entry_node != null);
 
-        entry_node.change_comparator ((owned) comparator, recursive, children_reordered_callback);
+        entry_node.change_comparator (comparator, recursive, children_reordered_callback);
     }
 
     public int get_child_count (Sidebar.Entry parent) {