darcs-2.4.4: a distributed, interactive, smart revision control systemContentsIndex
Darcs.Patch.Prim
Synopsis
data Prim where
Move :: !FileName -> !FileName -> Prim
DP :: !FileName -> !DirPatchType -> Prim
FP :: !FileName -> !FilePatchType -> Prim
Split :: FL Prim -> Prim
Identity :: Prim
ChangePref :: !String -> !String -> !String -> Prim
data IsConflictedPrim where
IsC :: !ConflictState -> !Prim -> IsConflictedPrim
data ConflictState
= Okay
| Conflicted
| Duplicated
showPrim :: FileNameFormat -> Prim -> Doc
data DirPatchType
= RmDir
| AddDir
data FilePatchType
= RmFile
| AddFile
| Hunk !Int [ByteString] [ByteString]
| TokReplace !String !String !String
| Binary ByteString ByteString
type CommuteFunction = (Prim :< Prim) -> Perhaps (Prim :< Prim)
data Perhaps a
= Unknown
| Failed
| Succeeded a
null_patch :: Prim
nullP :: Prim -> EqCheck
isNullPatch :: Prim -> Bool
is_identity :: Prim -> EqCheck
formatFileName :: FileNameFormat -> FileName -> Doc
data FileNameFormat
= OldFormat
| NewFormat
adddir :: FilePath -> Prim
addfile :: FilePath -> Prim
binary :: FilePath -> ByteString -> ByteString -> Prim
changepref :: String -> String -> String -> Prim
hunk :: FilePath -> Int -> [ByteString] -> [ByteString] -> Prim
move :: FilePath -> FilePath -> Prim
rmdir :: FilePath -> Prim
rmfile :: FilePath -> Prim
tokreplace :: FilePath -> String -> String -> String -> Prim
primIsAddfile :: Prim -> Bool
primIsHunk :: Prim -> Bool
primIsBinary :: Prim -> Bool
primIsSetpref :: Prim -> Bool
isSimilar :: Prim -> Prim -> Bool
primIsAdddir :: Prim -> Bool
is_filepatch :: Prim -> Maybe FileName
canonize :: Prim -> FL Prim
tryToShrink :: FL Prim -> FL Prim
modernizePrim :: Prim -> FL Prim
subcommutes :: [(String, CommuteFunction)]
sortCoalesceFL :: FL Prim -> FL Prim
join :: (Prim :> Prim) -> Maybe Prim
canonizeFL :: FL Prim -> FL Prim
try_tok_internal :: String -> ByteString -> ByteString -> ByteString -> Maybe [ByteString]
try_shrinking_inverse :: FL Prim -> Maybe (FL Prim)
n_fn :: FilePath -> FilePath
class FromPrim p where
fromPrim :: Prim -> p
class FromPrims p where
fromPrims :: FL Prim -> p
joinPatches :: FL p -> p
class FromPrim p => ToFromPrim p where
toPrim :: p -> Maybe Prim
class (Invert p, Commute p, Effect p) => Conflict p where
listConflictedFiles :: p -> [FilePath]
resolveConflicts :: p -> [[Sealed (FL Prim)]]
commute_no_conflicts :: (p :> p) -> Maybe (p :> p)
conflictedEffect :: p -> [IsConflictedPrim]
class Effect p where
effect :: p -> FL Prim
effectRL :: p -> RL Prim
isHunk :: p -> Maybe Prim
commute_no_conflictsFL :: Conflict p => (p :> FL p) -> Maybe (FL p :> p)
commute_no_conflictsRL :: Conflict p => (RL p :> p) -> Maybe (p :> RL p)
Documentation
data Prim where
Constructors
Move :: !FileName -> !FileName -> Prim
DP :: !FileName -> !DirPatchType -> Prim
FP :: !FileName -> !FilePatchType -> Prim
Split :: FL Prim -> Prim
Identity :: Prim
ChangePref :: !String -> !String -> !String -> Prim
show/hide Instances
data IsConflictedPrim where
Constructors
IsC :: !ConflictState -> !Prim -> IsConflictedPrim
data ConflictState
Constructors
Okay
Conflicted
Duplicated
show/hide Instances
showPrim :: FileNameFormat -> Prim -> Doc
data DirPatchType
Constructors
RmDir
AddDir
show/hide Instances
data FilePatchType
Constructors
RmFile
AddFile
Hunk !Int [ByteString] [ByteString]
TokReplace !String !String !String
Binary ByteString ByteString
show/hide Instances
type CommuteFunction = (Prim :< Prim) -> Perhaps (Prim :< Prim)
data Perhaps a
Constructors
Unknown
Failed
Succeeded a
show/hide Instances
null_patch :: Prim
nullP :: Prim -> EqCheck
isNullPatch :: Prim -> Bool
is_identity :: Prim -> EqCheck
formatFileName :: FileNameFormat -> FileName -> Doc
data FileNameFormat
Constructors
OldFormat
NewFormat
adddir :: FilePath -> Prim
addfile :: FilePath -> Prim
binary :: FilePath -> ByteString -> ByteString -> Prim
changepref :: String -> String -> String -> Prim
hunk :: FilePath -> Int -> [ByteString] -> [ByteString] -> Prim
move :: FilePath -> FilePath -> Prim
rmdir :: FilePath -> Prim
rmfile :: FilePath -> Prim
tokreplace :: FilePath -> String -> String -> String -> Prim
primIsAddfile :: Prim -> Bool
primIsHunk :: Prim -> Bool
primIsBinary :: Prim -> Bool
primIsSetpref :: Prim -> Bool
isSimilar :: Prim -> Prim -> Bool
Tells you if two patches are in the same category, human-wise. Currently just returns true if they are filepatches on the same file.
primIsAdddir :: Prim -> Bool
is_filepatch :: Prim -> Maybe FileName
canonize :: Prim -> FL Prim
tryToShrink :: FL Prim -> FL Prim
modernizePrim :: Prim -> FL Prim
subcommutes :: [(String, CommuteFunction)]
sortCoalesceFL :: FL Prim -> FL Prim
sortCoalesceFL ps coalesces as many patches in ps as possible, sorting the results according to the scheme defined in comparePrim
join :: (Prim :> Prim) -> Maybe Prim
canonizeFL :: FL Prim -> FL Prim

canonizeFL ps puts a sequence of primitive patches into canonical form. Even if the patches are just hunk patches, this is not necessarily the same set of results as you would get if you applied the sequence to a specific tree and recalculated a diff.

Note that this process does not preserve the commutation behaviour of the patches and is therefore not appropriate for use when working with already recorded patches (unless doing amend-record or the like).

try_tok_internal :: String -> ByteString -> ByteString -> ByteString -> Maybe [ByteString]
try_shrinking_inverse :: FL Prim -> Maybe (FL Prim)
n_fn :: FilePath -> FilePath
class FromPrim p where
Methods
fromPrim :: Prim -> p
show/hide Instances
class FromPrims p where
Methods
fromPrims :: FL Prim -> p
joinPatches :: FL p -> p
show/hide Instances
class FromPrim p => ToFromPrim p where
Methods
toPrim :: p -> Maybe Prim
show/hide Instances
class (Invert p, Commute p, Effect p) => Conflict p where
Methods
listConflictedFiles :: p -> [FilePath]
resolveConflicts :: p -> [[Sealed (FL Prim)]]
commute_no_conflicts :: (p :> p) -> Maybe (p :> p)

If commute_no_conflicts x :> y succeeds, we know that that x commutes past y without any conflicts. This function is useful for patch types for which commute is defined to always succeed; so we need some way to pick out the specific cases where commutation succeeds without any conflicts.

Consider the commute square with patch names written in capital letters and repository states written in small letters.

          X
       o-->--a
       |     |
    Y' v     v Y
       |     |
       z-->--b
          X'

The default definition of this function checks that we can mirror the commutation with patch inverses (written with the negative sign)

         -X     X
       a-->--o-->--a
       |     |     |
   Y'' v  Y' v     v Y
       |     |     |
       b-->--z-->--b
         (-X)'  X'

We check that commuting X and Y succeeds, as does commuting -X and Y'. It also checks that Y'' == Y and that -(X') is the same as (-X)'

conflictedEffect :: p -> [IsConflictedPrim]
show/hide Instances
class Effect p where

Patches whose concrete effect which can be expressed as a list of primitive patches.

A minimal definition would be either of effect or effectRL.

Methods
effect :: p -> FL Prim
effectRL :: p -> RL Prim
isHunk :: p -> Maybe Prim
show/hide Instances
commute_no_conflictsFL :: Conflict p => (p :> FL p) -> Maybe (FL p :> p)
commute_no_conflictsRL :: Conflict p => (RL p :> p) -> Maybe (p :> RL p)
Produced by Haddock version 2.6.0