Package rosetta :: Package core :: Package chemical :: Module _core_chemical_ :: Class Patch
[hide private]
[frames] | no frames]

Class Patch

 object --+    
          |    
??.instance --+
              |
             Patch

///////////////////////////////////////////////////////////////////////////////////// A class patching basic ResidueType to create variant types, containing multiple PatchCase

Instance Methods [hide private]
 
__init__(...)
__init__( (object)arg1) -> None :
 
__reduce__(...)
helper for pickle
 
applies_to(...)
applies_to( (Patch)arg1, (ResidueType)rsd) -> bool : can I operate on this residue type?
 
apply(...)
apply( (Patch)arg1, (ResidueType)rsd_type) -> ResidueType : returns patched residue, 0 if patch failed
 
name(...)
name( (Patch)arg1) -> str : unique name of this patch, eg Nter-simple, Cter-full, Phospho, ...
 
read_file(...)
read_file( (Patch)arg1, (str)filename) -> None : constructor from file
 
replaces(...)
replaces( (Patch)arg1, (ResidueType)rsd) -> bool : do I replace this residue type?
 
types(...)
types( (Patch)arg1) -> vector1_string : the variant types created by applying this patch

Inherited from unreachable.instance: __new__

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __str__, __subclasshook__

Class Variables [hide private]
  __instance_size__ = 32
Properties [hide private]

Inherited from object: __class__

Method Details [hide private]

__init__(...)
(Constructor)

 

__init__( (object)arg1) -> None :

    C++ signature :
        void __init__(_object*)

Overrides: object.__init__

__reduce__(...)

 

helper for pickle

Overrides: object.__reduce__
(inherited documentation)

applies_to(...)

 

applies_to( (Patch)arg1, (ResidueType)rsd) -> bool :
    can I operate on this residue type?
    

    C++ signature :
        bool applies_to(core::chemical::Patch {lvalue},core::chemical::ResidueType)

applies_to( (Patch)arg1, (ResidueType)rsd) -> bool :

    C++ signature :
        bool applies_to(Patch_exposer_callback {lvalue},core::chemical::ResidueType)

apply(...)

 

apply( (Patch)arg1, (ResidueType)rsd_type) -> ResidueType :
    returns patched residue, 0 if patch failed
    

    C++ signature :
        boost::shared_ptr<core::chemical::ResidueType> apply(core::chemical::Patch {lvalue},core::chemical::ResidueType)

apply( (Patch)arg1, (ResidueType)rsd_type) -> ResidueType :

    C++ signature :
        boost::shared_ptr<core::chemical::ResidueType> apply(Patch_exposer_callback {lvalue},core::chemical::ResidueType)

name(...)

 

name( (Patch)arg1) -> str :
    unique name of this patch, eg Nter-simple, Cter-full, Phospho, ... ?
    

    C++ signature :
        std::string name(core::chemical::Patch {lvalue})

name( (Patch)arg1) -> str :

    C++ signature :
        std::string name(Patch_exposer_callback {lvalue})

read_file(...)

 

read_file( (Patch)arg1, (str)filename) -> None :
    constructor from file
    

    C++ signature :
        void read_file(core::chemical::Patch {lvalue},std::string)

replaces(...)

 

replaces( (Patch)arg1, (ResidueType)rsd) -> bool :
    do I replace this residue type?
    

    C++ signature :
        bool replaces(core::chemical::Patch {lvalue},core::chemical::ResidueType)

replaces( (Patch)arg1, (ResidueType)rsd) -> bool :

    C++ signature :
        bool replaces(Patch_exposer_callback {lvalue},core::chemical::ResidueType)

types(...)

 

types( (Patch)arg1) -> vector1_string :
    the variant types created by applying this patch
    

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > types(core::chemical::Patch {lvalue})

types( (Patch)arg1) -> vector1_string :

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > types(Patch_exposer_callback {lvalue})