Add recursive copy for structures (#56)

* Add recursive copy for structures

Certain methods, like `applytransform!`, exist only in mutating form.
Rather than adding a non-mutating version for every potential mutating
function, we can simply copy the structure, apply the transformation,
and return the new structure.

* Fix parenting

* disordered copy (smoke test)

* Fix

Author: timholy

src/model.jl

@@ -113,12 +113,14 @@ struct Atom <: AbstractAtom
     charge::String
     residue::StructuralElement
 end
+Atom(a::Atom, r::StructuralElement) = Atom(a.serial, a.name, a.alt_loc_id, copy(a.coords), a.occupancy, a.temp_factor, a.element, a.charge, r)
 
 "A container to hold different locations of the same atom."
 struct DisorderedAtom <: AbstractAtom
     alt_loc_ids::Dict{Char, Atom}
     default::Char
 end
+DisorderedAtom(da::DisorderedAtom, r::StructuralElement) = DisorderedAtom(Dict(k => Atom(a, r) for (k, a) in da.alt_loc_ids), da.default)
 
 """
 A residue (amino acid) or other molecule - either a `Residue` or a
@@ -137,6 +139,14 @@ mutable struct Residue <: AbstractResidue
     chain::StructuralElement
     ss_code::Char
 end
+function Residue(r::Residue, chain::StructuralElement)
+    atoms = Dict{String, AbstractAtom}()
+    rnew = Residue(r.name, r.number, r.ins_code, r.het_res, [name for name in r.atom_list], atoms, chain, r.ss_code)
+    for (name, atom) in r.atoms
+        atoms[name] = isa(atom, Atom) ? Atom(atom, rnew) : DisorderedAtom(atom, rnew)
+    end
+    return rnew
+end
 
 """
 A container to hold different versions of the same residue (point
@@ -146,6 +156,7 @@ struct DisorderedResidue <: AbstractResidue
     names::Dict{String, Residue}
     default::String
 end
+DisorderedResidue(dr::DisorderedResidue, chain::StructuralElement) = DisorderedResidue(Dict(k => Residue(r, chain) for (k, r) in dr.names), dr.default)
 
 "A chain (molecule) from a macromolecular structure."
 mutable struct Chain <: StructuralElement
@@ -154,13 +165,29 @@ mutable struct Chain <: StructuralElement
     residues::Dict{String, AbstractResidue}
     model::StructuralElement
 end
+function Chain(c::Chain, model::StructuralElement)
+    residues = Dict{String, AbstractResidue}()
+    cnew = Chain(c.id, [id for id in c.res_list], residues, model)
+    for (id, res) in c.residues
+        residues[id] = isa(res, Residue) ? Residue(res, cnew) : DisorderedResidue(res, cnew)
+    end
+    return cnew
+end
 
 "A conformation of a macromolecular structure."
 struct Model <: StructuralElement
     number::Int
     chains::Dict{String, Chain}
     structure::StructuralElement
 end
+function Model(m::Model, structure::StructuralElement)
+    chains = Dict{String, Chain}()
+    mnew = Model(m.number, chains, structure)
+    for (id, ch) in m.chains
+        chains[id] = Chain(ch, mnew)
+    end
+    return mnew
+end
 
 """
 A container for multiple `Model`s that represents a Protein Data Bank (PDB)
@@ -170,6 +197,14 @@ struct MolecularStructure <: StructuralElement
     name::String
     models::Dict{Int, Model}
 end
+function MolecularStructure(s::MolecularStructure)
+    models = Dict{Int, Model}()
+    snew = MolecularStructure(s.name, models)
+    for (number, mo) in s.models
+        models[number] = Model(mo, snew)
+    end
+    return snew
+end
 
 """
 A record for a single atom, e.g. as represented in a Protein Data Bank
@@ -338,6 +373,15 @@ end
 Base.firstindex(struc::MolecularStructure) = first(modelnumbers(struc))
 Base.lastindex(struc::MolecularStructure) = last(modelnumbers(struc))
 
+# recursive copy methods. If we copy a subelement (anything below MolecularStructure), it shares the parent element
+Base.copy(a::Atom) = Atom(a, a.residue)
+Base.copy(da::DisorderedAtom) = DisorderedAtom(da, only(unique(a -> a.residue, values(da.alt_loc_ids))).residue)
+Base.copy(r::Residue) = Residue(r, r.chain)
+Base.copy(dr::DisorderedResidue) = DisorderedResidue(dr, only(unique(r -> r.chain, values(dr.names))).chain)
+Base.copy(c::Chain) = Chain(c, c.model)
+Base.copy(m::Model) = Model(m, m.structure)
+Base.copy(s::MolecularStructure) = MolecularStructure(s)
+
 # Check if an atom name exists in a residue as a whitespace-padded version
 function findatombyname(res::Residue, atom_name::AbstractString)
     # Look for atom name directly

test/runtests.jl

@@ -85,6 +85,33 @@ function countlines_gzip(filename::AbstractString; gzip=false)
     end
 end
 
+getparent(a::Atom) = a.residue
+getparent(r::Residue) = r.chain
+getparent(c::Chain) = c.model
+getparent(m::Model) = m.structure
+getchildren(::Atom) = ()
+getchildren(r::Residue) = values(r.atoms)
+getchildren(c::Chain) = values(c.residues)
+getchildren(m::Model) = values(m.chains)
+getchildren(s::MolecularStructure) = values(s.models)
+function testparent(children, parent)
+    for child in children
+        if isa(child, DisorderedAtom)
+            for a in values(child.alt_loc_ids)
+                @test getparent(a) === parent
+            end
+        elseif isa(child, DisorderedResidue)
+            for r in values(child.names)
+                @test getparent(r) === parent
+                testparent(getchildren(r), r)
+            end
+        else
+            @test getparent(child) === parent
+            testparent(getchildren(child), child)
+        end
+    end
+end
+
 Aqua.test_all(BioStructures; ambiguities=(recursive=false))
 
 # This is the only test set that requires an internet connection
@@ -198,8 +225,8 @@ end
     ), " VA")
     dis_res = struc['A']["H_20A"]
     @test isa(dis_res, DisorderedResidue)
-    struc['A'][10][" CA "] = Atom(
-        100, " CA ", ' ', [1.0, 2.0, 3.0], 1.0, 10.0, " C", "  ", res)
+    a = Atom(100, " CA ", ' ', [1.0, 2.0, 3.0], 1.0, 10.0, " C", "  ", res)
+    struc['A'][10][" CA "] = a
     at = struc['A'][10]["CA"]
     @test isa(at, Atom)
     struc['A'][10][" CB "] = DisorderedAtom(Dict(
@@ -214,6 +241,27 @@ end
         400, " O  ", ' ', [1.0, 2.0, 3.0], 1.0, 10.0, " O", "  ", disorderedres(dis_res, "ILE"))
     fixlists!(struc)
 
+    # copy doesn't share memory
+    testparent(getchildren(struc), struc)
+    struc_copy = copy(struc)
+    testparent(getchildren(struc_copy), struc_copy)
+    struc_copy['A'][10]["CA"].coords[2] = 100
+    @test struc_copy['A'][10]["CA"].coords[2] == 100
+    @test a.coords[2] == 2
+    @test struc['A'][10]["CA"].coords[2] == 2
+    # intermediate copies preserve parenting up to the node of the copy
+    testparent(getchildren(mo), mo)
+    mo_copy = copy(mo)
+    testparent(getchildren(mo_copy), mo_copy)
+    testparent(getchildren(ch), ch)
+    ch_copy = copy(ch)
+    testparent(getchildren(ch_copy), ch_copy)
+    testparent(getchildren(res), res)
+    res_copy = copy(res)
+    testparent(getchildren(res_copy), res_copy)
+    @test copy(dis_res) isa DisorderedResidue
+    @test copy(dis_at) isa DisorderedAtom
+
     # Test alternate constructors
     MolecularStructure("struc", Dict(1 => Model()))
     MolecularStructure()