/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to viz/linegraph.py

  • Committer: Gary van der Merwe
  • Date: 2007-09-20 19:32:17 UTC
  • mto: (256.2.54 gtk)
  • mto: This revision was merged to the branch mainline in revision 289.
  • Revision ID: garyvdm@gmail.com-20070920193217-3i3jk6rem24tz2e3
Take out a whole bunch of code for better performance.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/linegraph.py
53
53
    branch_lines = {}
54
54
    linegraph = []    
55
55
    
56
 
    for (index, (sequence_number,
57
 
                 revid,
58
 
                 merge_depth,
59
 
                 revno_sequence,
60
 
                 end_of_merge)) in enumerate(merge_sorted_revisions):
 
56
    for (rev_index, (sequence_number,
 
57
                     revid,
 
58
                     merge_depth,
 
59
                     revno_sequence,
 
60
                     end_of_merge)) in enumerate(merge_sorted_revisions):
61
61
        
62
 
        revid_index[revid] = index
63
 
        revno_index[revno_sequence] = index
 
62
        revid_index[revid] = rev_index
 
63
        revno_index[revno_sequence] = rev_index
64
64
        
65
65
        branch_id = revno_sequence[0:-1]
66
66
        
69
69
            branch_line = {"line_type": "branch_line",
70
70
                           "branch_id": branch_id,
71
71
                           "rev_indexes": [],
72
 
                           "min_index": index,
 
72
                           "min_index": rev_index,
73
73
                           "max_index": 0}
74
74
            branch_lines[branch_id] = branch_line
75
75
        else:
76
76
            branch_line = branch_lines[branch_id]
77
 
        branch_line["rev_indexes"].append(index)
78
 
        if index > branch_line["max_index"]:
79
 
            branch_line["max_index"] = index
 
77
        branch_line["rev_indexes"].append(rev_index)
 
78
        if rev_index > branch_line["max_index"]:
 
79
            branch_line["max_index"] = rev_index
80
80
        
81
81
        parents = graph_parents[revid]
82
82
        for parent_revid in parents:
98
98
        return cmp(len_x, len_y)
99
99
        
100
100
    branch_ids.sort(branch_id_cmp)
101
 
    inter_branch_lines = {}
102
 
    all_lines = []
 
101
    lines = []
 
102
    columns = []
103
103
    
104
104
    for branch_id in branch_ids:
105
105
        branch_line = branch_lines[branch_id]
106
 
        branch_parent_revno = None
107
 
        all_lines.append(branch_line)
108
106
        
109
 
        for rev_index in branch_line["rev_indexes"]:
110
 
            (sequence_number,
111
 
                 revid,
112
 
                 merge_depth,
113
 
                 revno_sequence,
114
 
                 end_of_merge) = merge_sorted_revisions[rev_index]
115
 
            for parent_revid in graph_parents[revid]:
116
 
                if parent_revid in revid_index:
117
 
                    parent_index = revid_index[parent_revid]
118
 
                    if parent_index - rev_index > 1:
119
 
                        parent_revno = merge_sorted_revisions[parent_index][3]
120
 
                        parent_branch_id = parent_revno[0:-1]
121
 
                        if branch_id != parent_branch_id:
122
 
                            inter_branch_line = {"line_type": "inter_branch_line",
123
 
                                                 "min_index": rev_index,
124
 
                                                 "max_index": parent_index,
125
 
                                                 "child_branch_id": branch_id,
126
 
                                                 "parent_branch_id": parent_branch_id}
127
 
                            inter_branch_lines[(rev_index, parent_index)] = \
128
 
                                                                inter_branch_line
129
 
                            all_lines.append (inter_branch_line)
130
 
    
131
 
    columns = []
132
 
    for line in all_lines:
133
 
        for col_index, column in enumerate(columns):
134
 
            has_overlaping_line = False
135
 
            for col_line in column:
136
 
                if not (col_line["min_index"] >= line["max_index"] or \
137
 
                        col_line["max_index"] <=  line["min_index"]):
138
 
                    has_overlaping_line = True
139
 
                    break
140
 
            if not has_overlaping_line:
141
 
                break
142
 
        else:
143
 
            col_index = len(columns)
144
 
            columns.append([])
145
 
        line["col_index"] = col_index
146
 
        columns[col_index].append(line)
147
 
 
148
 
    for branch_line in branch_lines.itervalues():
 
107
        append_line(columns, branch_line)
149
108
        branch_id = branch_line["branch_id"]
150
109
        color = reduce(lambda x, y: x+y, branch_id, 0)
151
110
        col_index = branch_line["col_index"]
152
 
        node = (col_index, color)
 
111
        node = (col_index, color)        
153
112
        
154
113
        for rev_index in branch_line["rev_indexes"]:
155
114
            (sequence_number,
157
116
                 merge_depth,
158
117
                 revno_sequence,
159
118
                 end_of_merge) = merge_sorted_revisions[rev_index]
160
 
            children = graph_children[revid]
161
119
            
162
120
            linegraph[rev_index][1] = node
163
 
            linegraph[rev_index][4] = children
164
 
            for child_revid in children:
165
 
                if child_revid in revid_index:
166
 
                    child_index = revid_index[child_revid]
167
 
                    inter_branch_line_id = (child_index, rev_index)
168
 
                    if inter_branch_line_id in inter_branch_lines:
169
 
                        inter_branch_line = \
170
 
                                    inter_branch_lines[inter_branch_line_id]
171
 
                        child_branch_id = inter_branch_line["child_branch_id"]
172
 
                        child_col_index = \
173
 
                                    branch_lines[child_branch_id]["col_index"]
174
 
                        inter_branch_line_col_index = \
175
 
                                                inter_branch_line["col_index"]
176
 
                        linegraph[child_index][2].append(
177
 
                            (child_col_index,
178
 
                             inter_branch_line_col_index,
179
 
                             color))
180
 
                        for line_part_index in range(child_index+1,
181
 
                                                     rev_index-1):
182
 
                            linegraph[line_part_index][2].append(
183
 
                                (inter_branch_line_col_index,   
184
 
                                 inter_branch_line_col_index,
185
 
                                 color))
186
 
 
187
 
                        linegraph[rev_index-1][2].append(
188
 
                            (inter_branch_line_col_index,
189
 
                             col_index,
190
 
                             color))
191
 
 
192
 
                    else:
193
 
                        child_revno_sequence = \
194
 
                                        merge_sorted_revisions[child_index][3]
195
 
                        child_branch_id = child_revno_sequence[0:-1]                    
196
 
                        child_col_index = \
197
 
                                    branch_lines[child_branch_id]["col_index"]
198
 
                        
199
 
                        linegraph[child_index][2].append(
200
 
                            (child_col_index,
201
 
                             col_index,
202
 
                             color))
203
 
                        for line_part_index in range(child_index+1, rev_index):
204
 
                            linegraph[line_part_index][2].append(
205
 
                                (col_index,   
206
 
                                 col_index,
207
 
                                 color))
208
 
                        
 
121
            linegraph[rev_index][4] = graph_children[revid]
 
122
            
 
123
            for parent_revid in graph_parents[revid]:
 
124
                if parent_revid in revid_index:
 
125
                    parent_index = revid_index[parent_revid]
 
126
                    parent_revno = merge_sorted_revisions[parent_index][3]
 
127
                    parent_branch_id = parent_revno[0:-1]
 
128
                    line = {"line_type": "inter_branch_line",
 
129
                            "min_index": rev_index,
 
130
                            "max_index": parent_index}
 
131
                    lines.append(line)
 
132
                    if branch_id != parent_branch_id and \
 
133
                                    parent_index - rev_index > 1:
 
134
                        append_line(columns, line)
 
135
    
 
136
    for line in lines:
 
137
        parent_index = line["max_index"]
 
138
        parent_node = linegraph[parent_index][1]
 
139
        parent_col_index = parent_node[0]
 
140
        color = parent_node[1]
 
141
        
 
142
        child_index = line["min_index"]
 
143
        child_col_index = linegraph[child_index][1][0]
 
144
        
 
145
        if "col_index" in line:
 
146
            line_col_index = line["col_index"]
 
147
            linegraph[child_index][2].append(
 
148
                (child_col_index,
 
149
                 line_col_index,
 
150
                 color))
 
151
            for line_part_index in range(child_index+1, parent_index-1):
 
152
                linegraph[line_part_index][2].append(
 
153
                    (line_col_index,   
 
154
                     line_col_index,
 
155
                     color))
 
156
            linegraph[parent_index-1][2].append(
 
157
                (line_col_index,
 
158
                 parent_col_index,
 
159
                 color))
 
160
        else:
 
161
            linegraph[child_index][2].append(
 
162
                (child_col_index,
 
163
                 parent_col_index,
 
164
                 color))
 
165
            for line_part_index in range(child_index+1, parent_index):
 
166
                linegraph[line_part_index][2].append(
 
167
                    (parent_col_index,   
 
168
                     parent_col_index,
 
169
                     color))
 
170
                    
209
171
    
210
172
    return (linegraph, revid_index)
211
173
 
 
174
def append_line(columns, line):
 
175
    for col_index, column in enumerate(columns):
 
176
        has_overlaping_line = False
 
177
        for col_line in column:
 
178
            if not (col_line["min_index"] >= line["max_index"] or \
 
179
                    col_line["max_index"] <=  line["min_index"]):
 
180
                has_overlaping_line = True
 
181
                break
 
182
        if not has_overlaping_line:
 
183
            break
 
184
    else:
 
185
        col_index = len(columns)
 
186
        columns.append([])
 
187
    line["col_index"] = col_index
 
188
    columns[col_index].append(line)
 
189
    
 
190
 
212
191
 
213
192
def same_branch(a, b):
214
193
    """Return whether we think revisions a and b are on the same branch."""