Overview
| SHA1 Hash: | 87cf60902113c7564a2ae43de7ede9e83d23af1c |
|---|---|
| Date: | 2007-11-24 05:31:30 |
| User: | aku |
| Comment: | Created convenience methods to create the human readable repesentation of a changeset and lists of such, and made liberal use of them. |
| Timelines: | ancestors | descendants | both | trunk |
| Other Links: | files | ZIP archive | manifest |
Tags And Properties
- branch=trunk inherited from [a28c83647d]
- sym-trunk inherited from [a28c83647d]
Changes
[hide diffs]Modified tools/cvs2fossil/lib/c2f_cyclebreaker.tcl from [a02d54b2ad] to [ddec7fb99c].
@@ -153,11 +153,11 @@
set dg [struct::graph dg]
foreach cset $changesets {
$dg node insert $cset
$dg node set $cset timerange [$cset timerange]
- $dg node set $cset label [ID $cset]
+ $dg node set $cset label [$cset str]
$dg node set $cset __id__ [$cset id]
}
# 2. Find for all relevant changeset their revisions and their
# dependencies. Map the latter back to changesets and
@@ -182,17 +182,17 @@
# breaking the relevant changesets apart. So having
# one indicates big trouble in pass 5. We report them
# and dump internal structures to make it easier to
# trace the links causing the problem.
if {$succ eq $cset} {
- trouble fatal "Self-referencing changeset <[$cset id]>"
- log write 2 cyclebreaker "LOOP changeset <[$cset id]> __________________"
+ trouble fatal "Self-referencing changeset [$cset str]"
+ log write 2 cyclebreaker "LOOP changeset [$cset str] __________________"
array set nmap [$cset nextmap]
foreach r [lsort -dict [array names nmap]] {
foreach succrev $nmap($r) {
log write 2 cyclebreaker \
- "LOOP * rev <$r> --> rev <$succrev> --> cs [join [struct::list map [project::rev ofrev $succrev] [myproc ID]] { }]"
+ "LOOP * rev <$r> --> rev <$succrev> --> cs [project::rev strlist [project::rev ofrev $succrev]]"
}
}
}
}
}
@@ -262,11 +262,11 @@
log write 10 cyclebreaker \
"Pending: [struct::list map $mybottom [myproc FormatPendingItem]]"
return
}
- proc FormatPendingItem {item} { lreplace $item 0 0 <[[lindex $item 0] id]> }
+ proc FormatPendingItem {item} { lreplace $item 0 0 [[lindex $item 0] str] }
proc FindCycle {dg} {
# This procedure is run if and only the graph is not empty and
# all nodes have predecessors. This means that each node is
# either part of a cycle or (indirectly) depending on a node
@@ -298,20 +298,18 @@
}
return [struct::list reverse [lrange $path $seen($start) end]]
}
- proc ID {cset} { return "<[$cset id]>" }
-
proc BreakCycle {dg cycle} {
# The cycle we have gotten is broken by breaking apart one or
# more of the changesets in the cycle. This causes us to
# create one or more changesets which are to be committed,
# added to the graph, etc. pp.
# NOTE/TODO. Move this map operation to project::rev, as typemethod.
- set cprint [join [struct::list map $cycle [myproc ID]] { }]
+ set cprint [project::rev strlist $cycle]
lappend cycle [lindex $cycle 0] [lindex $cycle 1]
set bestlink {}
set bestnode {}
@@ -336,11 +334,11 @@
} else {
$link destroy
}
}
- log write 5 cyclebreaker "Breaking cycle ($cprint) by splitting changeset <[$bestnode id]>"
+ log write 5 cyclebreaker "Breaking cycle ($cprint) by splitting changeset [$bestnode str]"
set ID [$bestnode id]
Mark $dg -${ID}-before
set newcsets [$bestlink break]
$bestlink destroy
@@ -388,11 +386,11 @@
$dg node delete $n
foreach cset $replacements {
$dg node insert $cset
$dg node set $cset timerange [$cset timerange]
- $dg node set $cset label [ID $cset]
+ $dg node set $cset label [$cset str]
$dg node set $cset __id__ [$cset id]
}
foreach cset $replacements {
foreach succ [$cset successors] {
@@ -399,11 +397,11 @@
# The new changesets may have dependencies outside of
# the chosen set. These are ignored
if {![$dg node exists $succ]} continue
$dg arc insert $cset $succ
if {$succ eq $cset} {
- trouble internal "Self-referencing changeset <[$cset id]>"
+ trouble internal "Self-referencing changeset [$cset str]"
}
}
}
foreach cset $pre {
foreach succ [$cset successors] {
Modified tools/cvs2fossil/lib/c2f_pbreakacycle.tcl from [42309dffc2] to [c41eb33de6].
@@ -133,11 +133,11 @@
return
}
proc CheckAndBreakBackwardBranch {graph cset} {
while {[IsABackwardBranch $graph $cset]} {
- log write 5 breakacycle "Breaking backward branch changeset <[$cset id]>"
+ log write 5 breakacycle "Breaking backward branch changeset [$cset str]"
# Knowing that the branch is backward we now look at the
# individual revisions in the changeset and determine
# which of them are responsible for the overlap. This
# allows us to split them into two sets, one of
@@ -302,11 +302,20 @@
}
# # ## ### ##### ######## #############
- proc SaveOrder {graph cset pos} {
+ proc SaveOrder {graph at cset} {
+ set cid [$cset id]
+
+ log write 4 breakacycle "Comitting @ $at: [$cset str]"
+ state run {
+ INSERT INTO csorder (cid, pos)
+ VALUES ($cid, $at)
+ }
+ # MAYBE TODO: Write the project level changeset dependencies as well.
+ return
}
# # ## ### ##### ######## #############
proc BreakCycle {graph} {
Modified tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl from [956cfdff4d] to [e139c81d89].
@@ -104,16 +104,16 @@
proc IsByRevision {cset} { $cset byrevision }
proc SaveOrder {graph at cset} {
set cid [$cset id]
- log write 4 breakrcycle "Comitting @ $at: <$cid>"
+ log write 4 breakrcycle "Comitting @ $at: [$cset str]"
state run {
INSERT INTO csorder (cid, pos)
VALUES ($cid, $at)
}
- # TODO: Write the project level changeset dependencies as well.
+ # MAYBE TODO: Write the project level changeset dependencies as well.
return
}
# # ## ### ##### ######## #############
## Configuration
Modified tools/cvs2fossil/lib/c2f_prev.tcl from [d8c9727907] to [82795e9f92].
@@ -50,10 +50,12 @@
set myidmap($myid) $self
foreach r $revisions { lappend myrevmap($r) $self }
return
}
+ method str {} { return "<${myid}>" }
+
method id {} { return $myid }
method revisions {} { return $myrevisions }
method data {} { return [list $myproject $mytype $mysrcid] }
method bysymbol {} { return [expr {$mytype eq "sym"}] }
@@ -155,11 +157,11 @@
array set dependencies {}
PullInternalSuccessorRevisions dependencies $myrevisions
if {![array size dependencies]} {return 0} ; # Nothing to break.
- log write 6 csets ...<$myid>.......................................................
+ log write 6 csets ...[$self str].......................................................
# We have internal dependencies to break. We now iterate over
# all positions in the list (which is chronological, at least
# as far as the timestamps are correct and unique) and
# determine the best position for the break, by trying to
@@ -261,11 +263,11 @@
trouble internal "Bad fragment border <$laste | $s>, gap or overlap"
}
set new [$type %AUTO% $myproject $mytype $mysrcid [lrange $myrevisions $s $e]]
- log write 4 csets "Breaking <$myid> @ $laste, new <[$new id]>, cutting $breaks($laste)"
+ log write 4 csets "Breaking [$self str ] @ $laste, new [$new str], cutting $breaks($laste)"
set laste $e
}
if {$laste != ([llength $myrevisions]-1)} {
@@ -356,10 +358,16 @@
}
foreach c $newcsets { $c persist }
return $newcsets
}
+
+ typemethod strlist {changesets} {
+ return [join [struct::list map $changesets [myproc ID]]]
+ }
+
+ proc ID {cset} { $cset str }
# # ## ### ##### ######## #############
## State
variable myid {} ; # Id of the cset for the persistent
Modified tools/cvs2fossil/lib/c2f_prevlink.tcl from [b25fedd0c7] to [4abdaecd6f].
@@ -123,11 +123,11 @@
return 0 ; # Self is worse or equal, i.e. not better.
}
method break {} {
if {![$self breakable]} {
- trouble internal "Changeset <[$mycset id]> is not breakable."
+ trouble internal "Changeset [$mycset str] is not breakable."
}
# One thing to choose when splitting CSET is where the
# revision in categories 1 and 2 (none and passthrough
# respectively) are moved to. This is done using the counters.