init( (object)arg1, (str)pdb_id, (int)start_pos [, (str)chain='_']) -> None : core/fragment/FragData.hh:202

C++ signature :
    void __init__(_object*,std::string,unsigned long [,char='_'])

init( (object)arg1, (AnnotatedFragData)) -> None : FragData that contains additional information

C++ signature :
    void __init__(_object*,core::fragment::AnnotatedFragData)

init( (object)arg1, (str)pdb_id, (int)start_pos, (FragData)frag [, (str)chain='_']) -> None : core/fragment/FragData.hh:207

C++ signature :
    void __init__(_object*,std::string,unsigned long,core::fragment::FragData [,char='_'])

apply( (AnnotatedFragData)arg1, (Pose), (Frame)) -> int : core/fragment/FragData.hh:73

C++ signature :
    unsigned long apply(core::fragment::AnnotatedFragData {lvalue},core::pose::Pose {lvalue},core::fragment::Frame)

apply( (AnnotatedFragData)arg1, (Pose), (Frame)) -> int :

C++ signature :
    unsigned long apply(AnnotatedFragData_exposer_callback {lvalue},core::pose::Pose {lvalue},core::fragment::Frame)

apply( (AnnotatedFragData)arg1, (MoveMap), (Pose), (int)start, (int)end) -> int : core/fragment/FragData.hh:69

C++ signature :
    unsigned long apply(core::fragment::AnnotatedFragData {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,unsigned long)

apply( (AnnotatedFragData)arg1, (MoveMap), (Pose), (int)start, (int)end) -> int :

C++ signature :
    unsigned long apply(AnnotatedFragData_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,unsigned long)

apply( (AnnotatedFragData)arg1, (MoveMap), (Pose), (Frame)) -> int : core/fragment/FragData.hh:70

C++ signature :
    unsigned long apply(core::fragment::AnnotatedFragData {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},core::fragment::Frame)

apply( (AnnotatedFragData)arg1, (MoveMap), (Pose), (Frame)) -> int :

C++ signature :
    unsigned long apply(AnnotatedFragData_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},core::fragment::Frame)

apply( (AnnotatedFragData)arg1, (Pose), (int)start, (int)end) -> int : core/fragment/FragData.hh:74

C++ signature :
    unsigned long apply(core::fragment::AnnotatedFragData {lvalue},core::pose::Pose {lvalue},unsigned long,unsigned long)

apply( (AnnotatedFragData)arg1, (Pose), (int)start, (int)end) -> int :

C++ signature :
    unsigned long apply(AnnotatedFragData_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long,unsigned long)

apply_ss( (AnnotatedFragData)arg1, (MoveMap), (str)ss, (Frame)) -> int : core/fragment/FragData.hh:77

C++ signature :
    unsigned long apply_ss(core::fragment::AnnotatedFragData {lvalue},core::kinematics::MoveMap,std::string {lvalue},core::fragment::Frame)

apply_ss( (AnnotatedFragData)arg1, (MoveMap), (str)ss, (Frame)) -> int :

C++ signature :
    unsigned long apply_ss(AnnotatedFragData_exposer_callback {lvalue},core::kinematics::MoveMap,std::string {lvalue},core::fragment::Frame)

chain( (AnnotatedFragData)arg1) -> str : core/fragment/FragData.hh:227

C++ signature :
    char chain(core::fragment::AnnotatedFragData {lvalue})

chain( (AnnotatedFragData)arg1) -> str :

C++ signature :
    char chain(AnnotatedFragData_exposer_callback {lvalue})

clone( (AnnotatedFragData)arg1) -> FragData : core/fragment/FragData.hh:212

C++ signature :
    boost::shared_ptr<core::fragment::FragData> clone(core::fragment::AnnotatedFragData {lvalue})

clone( (AnnotatedFragData)arg1) -> FragData :

C++ signature :
    boost::shared_ptr<core::fragment::FragData> clone(AnnotatedFragData_exposer_callback {lvalue})

copy( (AnnotatedFragData)arg1, (FragData)frag_data) -> None : core/fragment/FragData.hh:214

C++ signature :
    void copy(core::fragment::AnnotatedFragData {lvalue},core::fragment::FragData)

copy( (AnnotatedFragData)arg1, (FragData)frag_data) -> None :

C++ signature :
    void copy(AnnotatedFragData_exposer_callback {lvalue},core::fragment::FragData)

generate_sub_fragment( (AnnotatedFragData)arg1, (int)start, (int)stop) -> FragData : core/fragment/FragData.hh:217

C++ signature :
    boost::shared_ptr<core::fragment::FragData> generate_sub_fragment(core::fragment::AnnotatedFragData {lvalue},unsigned long,unsigned long)

generate_sub_fragment( (AnnotatedFragData)arg1, (int)start, (int)stop) -> FragData :

C++ signature :
    boost::shared_ptr<core::fragment::FragData> generate_sub_fragment(AnnotatedFragData_exposer_callback {lvalue},unsigned long,unsigned long)

is_applicable( (AnnotatedFragData)arg1, (MoveMap), (Frame)) -> int : core/fragment/FragData.hh:82

C++ signature :
    unsigned long is_applicable(core::fragment::AnnotatedFragData {lvalue},core::kinematics::MoveMap,core::fragment::Frame)

is_applicable( (AnnotatedFragData)arg1, (MoveMap), (Frame)) -> int :

C++ signature :
    unsigned long is_applicable(AnnotatedFragData_exposer_callback {lvalue},core::kinematics::MoveMap,core::fragment::Frame)

is_applicable( (AnnotatedFragData)arg1, (MoveMap), (int)start, (int)end) -> int : core/fragment/FragData.hh:81

C++ signature :
    unsigned long is_applicable(core::fragment::AnnotatedFragData {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long)

is_applicable( (AnnotatedFragData)arg1, (MoveMap), (int)start, (int)end) -> int :

C++ signature :
    unsigned long is_applicable(AnnotatedFragData_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long)

pdbid( (AnnotatedFragData)arg1) -> str : core/fragment/FragData.hh:219

C++ signature :
    std::string pdbid(core::fragment::AnnotatedFragData {lvalue})

pdbid( (AnnotatedFragData)arg1) -> str :

C++ signature :
    std::string pdbid(AnnotatedFragData_exposer_callback {lvalue})

pdbpos( (AnnotatedFragData)arg1) -> int : core/fragment/FragData.hh:223

C++ signature :
    unsigned long pdbpos(core::fragment::AnnotatedFragData {lvalue})

pdbpos( (AnnotatedFragData)arg1) -> int :

C++ signature :
    unsigned long pdbpos(AnnotatedFragData_exposer_callback {lvalue})

show( (AnnotatedFragData)arg1, (OStream)out) -> None : core/fragment/FragData.hh:148

C++ signature :
    void show(core::fragment::AnnotatedFragData {lvalue},std::ostream {lvalue})

show( (AnnotatedFragData)arg1, (OStream)out) -> None :

C++ signature :
    void show(AnnotatedFragData_exposer_callback {lvalue},std::ostream {lvalue})

show( (AnnotatedFragData)arg1, (OStream)out, (Frame)) -> None : core/fragment/FragData.hh:149

C++ signature :
    void show(core::fragment::AnnotatedFragData {lvalue},std::ostream {lvalue},core::fragment::Frame)

show( (AnnotatedFragData)arg1, (OStream)out, (Frame)) -> None :

C++ signature :
    void show(AnnotatedFragData_exposer_callback {lvalue},std::ostream {lvalue},core::fragment::Frame)

show_classic( (AnnotatedFragData)arg1, (OStream)out) -> None : core/fragment/FragData.hh:150

C++ signature :
    void show_classic(core::fragment::AnnotatedFragData {lvalue},std::ostream {lvalue})

show_classic( (AnnotatedFragData)arg1, (OStream)out) -> None :

C++ signature :
    void show_classic(AnnotatedFragData_exposer_callback {lvalue},std::ostream {lvalue})

steal( (AnnotatedFragData)arg1, (Pose), (int)start, (int)end) -> bool : core/fragment/FragData.hh:85

C++ signature :
    bool steal(core::fragment::AnnotatedFragData {lvalue},core::pose::Pose,unsigned long,unsigned long)

steal( (AnnotatedFragData)arg1, (Pose), (int)start, (int)end) -> bool :

C++ signature :
    bool steal(AnnotatedFragData_exposer_callback {lvalue},core::pose::Pose,unsigned long,unsigned long)

steal( (AnnotatedFragData)arg1, (Pose), (Frame)) -> bool : core/fragment/FragData.hh:86

C++ signature :
    bool steal(core::fragment::AnnotatedFragData {lvalue},core::pose::Pose,core::fragment::Frame)

steal( (AnnotatedFragData)arg1, (Pose), (Frame)) -> bool :

C++ signature :
    bool steal(AnnotatedFragData_exposer_callback {lvalue},core::pose::Pose,core::fragment::Frame)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AnnotatedFragDataAP)arg1) -> AnnotatedFragData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AnnotatedFragDataCAP)arg1) -> AnnotatedFragData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (BBTorsionAndAnglesSRFD)) -> None : core/fragment/BBTorsionAndAnglesSRFD.hh:50

C++ signature :
    void __init__(_object*,core::fragment::BBTorsionAndAnglesSRFD)

init( (object)arg1, (object)angles_in [, (int)nbb_in=3 [, (str)secstruct='X' [, (str)sequence='X']]]) -> None : core/fragment/BBTorsionAndAnglesSRFD.hh:57

C++ signature :
    void __init__(_object*,utility::vector1<std::pair<std::vector<unsigned long, std::allocator<unsigned long> >, double>, std::allocator<std::pair<std::vector<unsigned long, std::allocator<unsigned long> >, double> > > {lvalue} [,unsigned long=3 [,char='X' [,char='X']]])

apply( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)seq_pos) -> bool : core/fragment/BBTorsionAndAnglesSRFD.hh:72

C++ signature :
    bool apply(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)seq_pos) -> bool :

C++ signature :
    bool apply(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionAndAnglesSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)seqpos) -> bool : insert backbone torsions and angles into pose at position seqpos if all bb torsions are moveable in MoveMap True if all torsions and angles are inserted and superclass apply() is successful, otherwise False. @remarks This is currently all or nothing -- all torsions for seqpos must be moveable because it's not entirely clear what the behavior of partial angle insertion is. In addition, DOF_IDs are not made explicitly available within this class, meaning there is no way to look them up within the MoveMap; the implementation in this class must be changed if this is desired.

C++ signature :
    bool apply(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionAndAnglesSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)seqpos) -> bool :

C++ signature :
    bool apply(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos );

C++ signature :
    bool apply(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (BBTorsionAndAnglesSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)intra_frame_pos, (Frame)frame) -> bool : insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos ) for dofs that are allowed to move in the MoveMap

C++ signature :
    bool apply(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (BBTorsionAndAnglesSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)intra_frame_pos, (Frame)frame) -> bool :

C++ signature :
    bool apply(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply_ss( (BBTorsionAndAnglesSRFD)arg1, (str), (int)seq_pos) -> bool : core/fragment/SecstructSRFD.hh:79

C++ signature :
    bool apply_ss(core::fragment::BBTorsionAndAnglesSRFD {lvalue},std::string {lvalue},unsigned long)

apply_ss( (BBTorsionAndAnglesSRFD)arg1, (str), (int)seq_pos) -> bool :

C++ signature :
    bool apply_ss(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long)

apply_ss( (BBTorsionAndAnglesSRFD)arg1, (str), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data sec-struct into ss-string at position seq_pos

C++ signature :
    bool apply_ss(core::fragment::BBTorsionAndAnglesSRFD {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

apply_ss( (BBTorsionAndAnglesSRFD)arg1, (str), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply_ss(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

clone( (BBTorsionAndAnglesSRFD)arg1) -> SingleResidueFragData : core/fragment/BBTorsionAndAnglesSRFD.hh:62

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(core::fragment::BBTorsionAndAnglesSRFD {lvalue})

clone( (BBTorsionAndAnglesSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(BBTorsionAndAnglesSRFD_exposer_callback {lvalue})

create( (BBTorsionAndAnglesSRFD)arg1) -> SingleResidueFragData : create a new instance of this object

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(core::fragment::BBTorsionAndAnglesSRFD {lvalue})

create( (BBTorsionAndAnglesSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(BBTorsionAndAnglesSRFD_exposer_callback {lvalue})

is_applicable( (BBTorsionAndAnglesSRFD)arg1, (MoveMap), (int)seq_pos) -> bool : core/fragment/BBTorsionAndAnglesSRFD.hh:88

C++ signature :
    bool is_applicable(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::kinematics::MoveMap,unsigned long)

is_applicable( (BBTorsionAndAnglesSRFD)arg1, (MoveMap), (int)seq_pos) -> bool :

C++ signature :
    bool is_applicable(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long)

is_applicable( (BBTorsionAndAnglesSRFD)arg1, (MoveMap), (int)intra_frame_pos, (Frame)) -> bool : check weather dofs can be moved

C++ signature :
    bool is_applicable(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_applicable( (BBTorsionAndAnglesSRFD)arg1, (MoveMap), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool is_applicable(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_compatible( (BBTorsionAndAnglesSRFD)arg1, (SingleResidueFragData)) -> bool : core/fragment/BBTorsionAndAnglesSRFD.hh:87

C++ signature :
    bool is_compatible(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::fragment::SingleResidueFragData)

is_compatible( (BBTorsionAndAnglesSRFD)arg1, (SingleResidueFragData)) -> bool :

C++ signature :
    bool is_compatible(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::fragment::SingleResidueFragData)

nangles( (BBTorsionAndAnglesSRFD)arg1) -> int : core/fragment/BBTorsionAndAnglesSRFD.hh:107

C++ signature : unsigned long nangles(core::fragment::BBTorsionAndAnglesSRFD {lvalue})

read( (BBTorsionAndAnglesSRFD)arg1, (std_istream)in) -> None : core/fragment/BBTorsionAndAnglesSRFD.hh:94

C++ signature :
    void read(core::fragment::BBTorsionAndAnglesSRFD {lvalue},std::istream {lvalue})

read( (BBTorsionAndAnglesSRFD)arg1, (std_istream)in) -> None :

C++ signature :
    void read(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},std::istream {lvalue})

read_data( (BBTorsionAndAnglesSRFD)arg1, (std_istream)in) -> None : core/fragment/BBTorsionSRFD.hh:146

C++ signature :
    void read_data(core::fragment::BBTorsionAndAnglesSRFD {lvalue},std::istream {lvalue})

read_data( (BBTorsionAndAnglesSRFD)arg1, (std_istream)in) -> None :

C++ signature :
    void read_data(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},std::istream {lvalue})

secstruct( (BBTorsionAndAnglesSRFD)arg1) -> str : get secstruct for this position

C++ signature :
    char secstruct(core::fragment::BBTorsionAndAnglesSRFD {lvalue})

secstruct( (BBTorsionAndAnglesSRFD)arg1) -> str :

C++ signature :
    char secstruct(BBTorsionAndAnglesSRFD_exposer_callback {lvalue})

show( (BBTorsionAndAnglesSRFD)arg1, (OStream)out) -> None : core/fragment/BBTorsionAndAnglesSRFD.hh:91

C++ signature :
    void show(core::fragment::BBTorsionAndAnglesSRFD {lvalue},std::ostream {lvalue})

show( (BBTorsionAndAnglesSRFD)arg1, (OStream)out) -> None :

C++ signature :
    void show(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},std::ostream {lvalue})

steal( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)seq_pos) -> bool : core/fragment/BBTorsionAndAnglesSRFD.hh:86

C++ signature :
    bool steal(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::pose::Pose,unsigned long)

steal( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)seq_pos) -> bool :

C++ signature :
    bool steal(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long)

steal( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data into pose at position seq_pos

C++ signature :
    bool steal(core::fragment::BBTorsionAndAnglesSRFD {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

steal( (BBTorsionAndAnglesSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool steal(BBTorsionAndAnglesSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

type( (BBTorsionAndAnglesSRFD)arg1) -> str : core/fragment/BBTorsionAndAnglesSRFD.hh:97

C++ signature :
    std::string type(core::fragment::BBTorsionAndAnglesSRFD {lvalue})

type( (BBTorsionAndAnglesSRFD)arg1) -> str :

C++ signature :
    std::string type(BBTorsionAndAnglesSRFD_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BBTorsionAndAnglesSRFDAP)arg1) -> BBTorsionAndAnglesSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BBTorsionAndAnglesSRFDCAP)arg1) -> BBTorsionAndAnglesSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1 [, (int)nbb_in=3 [, (str)secstruct='X' [, (str)sequence='X']]]) -> None : constructor

C++ signature :
    void __init__(_object* [,unsigned long=3 [,char='X' [,char='X']]])

init( (object)arg1, (BBTorsionSRFD)) -> None : core/fragment/BBTorsionSRFD.hh:43

C++ signature :
    void __init__(_object*,core::fragment::BBTorsionSRFD)

apply( (BBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool : insert all backbone torsions into pose at position seq_pos

C++ signature :
    bool apply(core::fragment::BBTorsionSRFD {lvalue},core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool :

C++ signature :
    bool apply(BBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)seqpos) -> bool : insert all backbone torsions into pose at position seq_pos [in] movemap This MoveMap will be ignored at the BBTorsionSRFD level, but will be passed to any superclass apply(). [in,out] pose The pose to modify. [in] seqpos Sequence position to modify. True if apply() successful, False otherwise. @warning MoveMap settings at the BBTorsionSRFD level are ignored. For speed, does not check to see whether or not all backbone torsions are moveable in MoveMap -- use is_applicable() for this purpose prior to calling apply().

C++ signature :
    bool apply(core::fragment::BBTorsionSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)seqpos) -> bool :

C++ signature :
    bool apply(BBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply( (BBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos );

C++ signature :
    bool apply(core::fragment::BBTorsionSRFD {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (BBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply(BBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (BBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)intra_frame_pos, (Frame)frame) -> bool : insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos ) for dofs that are allowed to move in the MoveMap

C++ signature :
    bool apply(core::fragment::BBTorsionSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (BBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)intra_frame_pos, (Frame)frame) -> bool :

C++ signature :
    bool apply(BBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply_ss( (BBTorsionSRFD)arg1, (str), (int)seq_pos) -> bool : core/fragment/SecstructSRFD.hh:79

C++ signature :
    bool apply_ss(core::fragment::BBTorsionSRFD {lvalue},std::string {lvalue},unsigned long)

apply_ss( (BBTorsionSRFD)arg1, (str), (int)seq_pos) -> bool :

C++ signature :
    bool apply_ss(BBTorsionSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long)

apply_ss( (BBTorsionSRFD)arg1, (str), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data sec-struct into ss-string at position seq_pos

C++ signature :
    bool apply_ss(core::fragment::BBTorsionSRFD {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

apply_ss( (BBTorsionSRFD)arg1, (str), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply_ss(BBTorsionSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

assign( (BBTorsionSRFD)arg1, (BBTorsionSRFD)rval) -> BBTorsionSRFD : copy assignment

C++ signature : core::fragment::BBTorsionSRFD {lvalue} assign(core::fragment::BBTorsionSRFD {lvalue},core::fragment::BBTorsionSRFD)

clone( (BBTorsionSRFD)arg1) -> SingleResidueFragData : clone this object

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(core::fragment::BBTorsionSRFD {lvalue})

clone( (BBTorsionSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(BBTorsionSRFD_exposer_callback {lvalue})

create( (BBTorsionSRFD)arg1) -> SingleResidueFragData : create a new instance of this object

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(core::fragment::BBTorsionSRFD {lvalue})

create( (BBTorsionSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(BBTorsionSRFD_exposer_callback {lvalue})

has_coordinates( (BBTorsionSRFD)arg1) -> bool : Returns true if this instance contains cartesian coordinates, false otherwise. Coordinates are available if the option is enabled in the new fragment picker and rosetta++ fragments are used.

C++ signature : bool has_coordinates(core::fragment::BBTorsionSRFD {lvalue})

is_applicable( (BBTorsionSRFD)arg1, (MoveMap), (int)seq_pos) -> bool : check if all backbone torsions at the sequence position moveable in the MoveMap True if all backbone torsions moveable and is_applicable() succeeded for superclass, otherwise False.

C++ signature :
    bool is_applicable(core::fragment::BBTorsionSRFD {lvalue},core::kinematics::MoveMap,unsigned long)

is_applicable( (BBTorsionSRFD)arg1, (MoveMap), (int)seq_pos) -> bool :

C++ signature :
    bool is_applicable(BBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long)

is_applicable( (BBTorsionSRFD)arg1, (MoveMap), (int)intra_frame_pos, (Frame)) -> bool : check weather dofs can be moved

C++ signature :
    bool is_applicable(core::fragment::BBTorsionSRFD {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_applicable( (BBTorsionSRFD)arg1, (MoveMap), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool is_applicable(BBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_compatible( (BBTorsionSRFD)arg1, (SingleResidueFragData)) -> bool : core/fragment/BBTorsionSRFD.hh:136

C++ signature :
    bool is_compatible(core::fragment::BBTorsionSRFD {lvalue},core::fragment::SingleResidueFragData)

is_compatible( (BBTorsionSRFD)arg1, (SingleResidueFragData)) -> bool :

C++ signature :
    bool is_compatible(BBTorsionSRFD_exposer_callback {lvalue},core::fragment::SingleResidueFragData)

nbb( (BBTorsionSRFD)arg1) -> int : number of backbone torsions described by this fragment

C++ signature : unsigned long nbb(core::fragment::BBTorsionSRFD {lvalue})

read_data( (BBTorsionSRFD)arg1, (std_istream)in) -> None : core/fragment/BBTorsionSRFD.hh:146

C++ signature :
    void read_data(core::fragment::BBTorsionSRFD {lvalue},std::istream {lvalue})

read_data( (BBTorsionSRFD)arg1, (std_istream)in) -> None :

C++ signature :
    void read_data(BBTorsionSRFD_exposer_callback {lvalue},std::istream {lvalue})

secstruct( (BBTorsionSRFD)arg1) -> str : get secstruct for this position

C++ signature :
    char secstruct(core::fragment::BBTorsionSRFD {lvalue})

secstruct( (BBTorsionSRFD)arg1) -> str :

C++ signature :
    char secstruct(BBTorsionSRFD_exposer_callback {lvalue})

set_coordinates( (BBTorsionSRFD)arg1, (float)x, (float)y, (float)z) -> None : Convenience method for setting this residue's CA coordinates all at once

C++ signature : void set_coordinates(core::fragment::BBTorsionSRFD {lvalue},double,double,double)

set_torsion( (BBTorsionSRFD)arg1, (int)tor, (float)setting) -> None : set value for specific torsion in this piece of fragment.

C++ signature : void set_torsion(core::fragment::BBTorsionSRFD {lvalue},unsigned long,double)

show( (BBTorsionSRFD)arg1, (OStream)out) -> None : core/fragment/BBTorsionSRFD.hh:144

C++ signature :
    void show(core::fragment::BBTorsionSRFD {lvalue},std::ostream {lvalue})

show( (BBTorsionSRFD)arg1, (OStream)out) -> None :

C++ signature :
    void show(BBTorsionSRFD_exposer_callback {lvalue},std::ostream {lvalue})

steal( (BBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool : core/fragment/BBTorsionSRFD.hh:135

C++ signature :
    bool steal(core::fragment::BBTorsionSRFD {lvalue},core::pose::Pose,unsigned long)

steal( (BBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool :

C++ signature :
    bool steal(BBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long)

steal( (BBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data into pose at position seq_pos

C++ signature :
    bool steal(core::fragment::BBTorsionSRFD {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

steal( (BBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool steal(BBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

torsion( (BBTorsionSRFD)arg1, (int)torsion_number) -> float : get the value for a specific torsion in this fragment

C++ signature : double torsion(core::fragment::BBTorsionSRFD {lvalue},unsigned long)

type( (BBTorsionSRFD)arg1) -> str : core/fragment/BBTorsionSRFD.hh:148

C++ signature :
    std::string type(core::fragment::BBTorsionSRFD {lvalue})

type( (BBTorsionSRFD)arg1) -> str :

C++ signature :
    std::string type(BBTorsionSRFD_exposer_callback {lvalue})

x( (BBTorsionSRFD)arg1) -> float : Returns the x coordinate of this residue's CA

C++ signature : double x(core::fragment::BBTorsionSRFD {lvalue})

y( (BBTorsionSRFD)arg1) -> float : Returns the y coordinate of this residue's CA

C++ signature : double y(core::fragment::BBTorsionSRFD {lvalue})

z( (BBTorsionSRFD)arg1) -> float : Returns the z coordinate of this residue's CA

C++ signature : double z(core::fragment::BBTorsionSRFD {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BBTorsionSRFDAP)arg1) -> BBTorsionSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BBTorsionSRFDCAP)arg1) -> BBTorsionSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

clone( (BaseCacheUnit)arg1) -> BaseCacheUnit : core/fragment/BaseCacheUnit.hh:46

C++ signature :
    boost::shared_ptr<core::fragment::BaseCacheUnit> clone(core::fragment::BaseCacheUnit {lvalue})

clone( (BaseCacheUnit)arg1) -> None :

C++ signature :
    void clone(boost::shared_ptr<BaseCacheUnit_exposer_callback> {lvalue})

remap_value( (BaseCacheUnit)arg1, (BaseCacheUnit)source, (int)source_id, (int)new_id) -> None : core/fragment/BaseCacheUnit.hh:47

C++ signature :
    void remap_value(core::fragment::BaseCacheUnit {lvalue},core::fragment::BaseCacheUnit,unsigned long,unsigned long)

remap_value( (BaseCacheUnit)arg1, (BaseCacheUnit)arg2, (int)arg3, (int)arg4) -> None :

C++ signature :
    void remap_value(boost::shared_ptr<BaseCacheUnit_exposer_callback> {lvalue},core::fragment::BaseCacheUnit,unsigned long,unsigned long)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BaseCacheUnitAP)arg1) -> BaseCacheUnit :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BaseCacheUnitCAP)arg1) -> BaseCacheUnit :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (FrameIteratorWorker_)it) -> None : core/fragment/FrameIterator.hh:66

C++ signature :
    void __init__(_object*,boost::shared_ptr<core::fragment::FrameIteratorWorker_>)

init( (object)arg1, (ConstFrameIterator)) -> None : core/fragment/FrameIterator.hh:62

C++ signature :
    void __init__(_object*,core::fragment::ConstFrameIterator)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

assign( (ConstFrameIterator)arg1, (ConstFrameIterator)itr) -> ConstFrameIterator : core/fragment/FrameIterator.hh:75

C++ signature : core::fragment::ConstFrameIterator assign(core::fragment::ConstFrameIterator {lvalue},core::fragment::ConstFrameIterator)

frame_ptr( (ConstFrameIterator)arg1) -> Frame : core/fragment/FrameIterator.hh:87

C++ signature : boost::shared_ptr frame_ptr(core::fragment::ConstFrameIterator {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConstFrameIteratorAP)arg1) -> ConstFrameIterator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConstFrameIteratorCAP)arg1) -> ConstFrameIterator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (int)frag_length) -> None : core/fragment/ConstantLengthFragSet.hh:71

C++ signature :
    void __init__(_object*,unsigned long)

init( (object)arg1, (ConstantLengthFragSet)) -> None : A set of fragments that contains fragments of a constant length read in from a fragment file. this object is a simple implementation of the FragSet for custom fragments, check out https://robetta.bakerlab.org/fragmentsubmit.jsp example: ninemers = ConstantLengthFragSet(9) ninemers.read_fragment_file("test9_fragments") See also: Pose ClassicFragmentMover

C++ signature :
    void __init__(_object*,core::fragment::ConstantLengthFragSet)

init( (object)arg1, (int)frag_length, (str)filename) -> None : core/fragment/ConstantLengthFragSet.hh:75

C++ signature :
    void __init__(_object*,unsigned long,std::string)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (FragSet)fragments) -> None : core/fragment/ConstantLengthFragSet.hh:81

C++ signature :
    void __init__(_object*,core::fragment::FragSet)

begin( (ConstantLengthFragSet)arg1) -> ConstFrameIterator : iterate over contents

C++ signature : core::fragment::ConstFrameIterator begin(core::fragment::ConstantLengthFragSet {lvalue})

clone( (ConstantLengthFragSet)arg1) -> FragSet : core/fragment/ConstantLengthFragSet.hh:83

C++ signature : boost::shared_ptr clone(core::fragment::ConstantLengthFragSet {lvalue})

empty( (ConstantLengthFragSet)arg1) -> bool : core/fragment/ConstantLengthFragSet.hh:146

C++ signature : bool empty(core::fragment::ConstantLengthFragSet {lvalue})

empty_clone( (ConstantLengthFragSet)arg1) -> FragSet : core/fragment/ConstantLengthFragSet.hh:88

C++ signature : boost::shared_ptr empty_clone(core::fragment::ConstantLengthFragSet {lvalue})

end( (ConstantLengthFragSet)arg1) -> ConstFrameIterator : core/fragment/ConstantLengthFragSet.hh:140

C++ signature : core::fragment::ConstFrameIterator end(core::fragment::ConstantLengthFragSet {lvalue})

nonconst_begin( (ConstantLengthFragSet)arg1) -> FrameIterator : core/fragment/ConstantLengthFragSet.hh:143

C++ signature : core::fragment::FrameIterator nonconst_begin(core::fragment::ConstantLengthFragSet {lvalue})

nonconst_end( (ConstantLengthFragSet)arg1) -> FrameIterator : core/fragment/ConstantLengthFragSet.hh:144

C++ signature : core::fragment::FrameIterator nonconst_end(core::fragment::ConstantLengthFragSet {lvalue})

overlapping_with_region( (ConstantLengthFragSet)arg1, (MoveMap)mm, (int)start, (int)end, (int)min_overlap, (int)min_length, (FrameList)frames) -> int : returns the number and list of all fragment alignment frames that somehow overlap with the given region (also allows those frames that start before the region and reach into it)

C++ signature : unsigned long overlapping_with_region(core::fragment::ConstantLengthFragSet {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long,unsigned long,unsigned long,core::fragment::FrameList {lvalue})

read_fragment_file( (ConstantLengthFragSet)arg1, (str)filename [, (int)top25=0 [, (int)ncopies=1 [, (bool)bAnnotation=False]]]) -> None : Loads the contents of into the ConstantLengthFragSet example: ninemers.read_fragment_file("test9_fragments") See also: ConstantLengthFragSet Pose Pose.omega Pose.phi Pose.psi ClassicFragmentMover

C++ signature : void read_fragment_file(core::fragment::ConstantLengthFragSet {lvalue},std::string [,unsigned long=0 [,unsigned long=1 [,bool=False]]])

read_fragment_stream( (ConstantLengthFragSet)arg1, (object)data [, (int)top25=0 [, (int)ncopies=1 [, (bool)bAnnotation=False]]]) -> None : core/fragment/ConstantLengthFragSet.hh:106

C++ signature : void read_fragment_stream(core::fragment::ConstantLengthFragSet {lvalue},utility::io::izstream {lvalue} [,unsigned long=0 [,unsigned long=1 [,bool=False]]])

region( (ConstantLengthFragSet)arg1, (MoveMap)mm, (int)start, (int)end, (int), (int), (FrameList)frames) -> int : there is only one Frame per position, end / max_overlap are ignored

C++ signature : unsigned long region(core::fragment::ConstantLengthFragSet {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long,unsigned long,unsigned long,core::fragment::FrameList {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConstantLengthFragSetAP)arg1) -> ConstantLengthFragSet :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConstantLengthFragSetCAP)arg1) -> ConstantLengthFragSet :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConstantLengthFragSetIterator_AP)arg1) -> ConstantLengthFragSetIterator_ :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConstantLengthFragSetIterator_CAP)arg1) -> ConstantLengthFragSetIterator_ :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1 [, (str)sequence='X']) -> None : core/fragment/JumpSRFD.hh:129

C++ signature :
    void __init__(_object* [,char='X'])

init( (object)arg1, (DownJumpSRFD)) -> None : core/fragment/JumpSRFD.hh:124

C++ signature :
    void __init__(_object*,core::fragment::DownJumpSRFD)

init( (object)arg1, (RT)rt, (vector1_string)downstream_stub_atoms, (vector1_string)upstream_stub_atoms, (str)sequence) -> None : core/fragment/JumpSRFD.hh:135

C++ signature :
    void __init__(_object*,core::kinematics::RT,utility::vector1<std::string, std::allocator<std::string> >,utility::vector1<std::string, std::allocator<std::string> >,char)

apply( (DownJumpSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool : the seq_pos is hijacked for the rt_nr

C++ signature :
    bool apply(core::fragment::DownJumpSRFD {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (DownJumpSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply(DownJumpSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (DownJumpSRFD)arg1, (MoveMap), (Pose), (int)intra_frame_pos, (Frame)) -> bool : core/fragment/JumpSRFD.hh:172

C++ signature :
    bool apply(core::fragment::DownJumpSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (DownJumpSRFD)arg1, (MoveMap), (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply(DownJumpSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (DownJumpSRFD)arg1, (Pose), (int)) -> bool : core/fragment/JumpSRFD.hh:182

C++ signature :
    bool apply(core::fragment::DownJumpSRFD {lvalue},core::pose::Pose {lvalue},unsigned long)

apply( (DownJumpSRFD)arg1, (Pose), (int)) -> bool :

C++ signature :
    bool apply(DownJumpSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long)

apply( (DownJumpSRFD)arg1, (MoveMap), (Pose), (int)) -> bool : for DownJumpSRFD this function should never be called, instead use Frame version always false @warning will trigger a false runtime assert

C++ signature :
    bool apply(core::fragment::DownJumpSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply( (DownJumpSRFD)arg1, (MoveMap), (Pose), (int)) -> bool :

C++ signature :
    bool apply(DownJumpSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply_ss( (DownJumpSRFD)arg1, (str), (int), (Frame)) -> bool : core/fragment/JumpSRFD.hh:173

C++ signature :
    bool apply_ss(core::fragment::DownJumpSRFD {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

apply_ss( (DownJumpSRFD)arg1, (str), (int), (Frame)) -> bool :

C++ signature :
    bool apply_ss(DownJumpSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

apply_ss( (DownJumpSRFD)arg1, (str), (int)) -> bool : core/fragment/JumpSRFD.hh:193

C++ signature :
    bool apply_ss(core::fragment::DownJumpSRFD {lvalue},std::string {lvalue},unsigned long)

apply_ss( (DownJumpSRFD)arg1, (str), (int)) -> bool :

C++ signature :
    bool apply_ss(DownJumpSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long)

clone( (DownJumpSRFD)arg1) -> SingleResidueFragData : clone

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(core::fragment::DownJumpSRFD {lvalue})

clone( (DownJumpSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(DownJumpSRFD_exposer_callback {lvalue})

create( (DownJumpSRFD)arg1) -> SingleResidueFragData : create a new instance of this object

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(core::fragment::DownJumpSRFD {lvalue})

create( (DownJumpSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(DownJumpSRFD_exposer_callback {lvalue})

is_applicable( (DownJumpSRFD)arg1, (MoveMap), (int)pos, (Frame)) -> bool : core/fragment/JumpSRFD.hh:177

C++ signature :
    bool is_applicable(core::fragment::DownJumpSRFD {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_applicable( (DownJumpSRFD)arg1, (MoveMap), (int)pos, (Frame)) -> bool :

C++ signature :
    bool is_applicable(DownJumpSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_applicable( (DownJumpSRFD)arg1, (MoveMap), (int)) -> bool : core/fragment/JumpSRFD.hh:206

C++ signature :
    bool is_applicable(core::fragment::DownJumpSRFD {lvalue},core::kinematics::MoveMap,unsigned long)

is_applicable( (DownJumpSRFD)arg1, (MoveMap), (int)) -> bool :

C++ signature :
    bool is_applicable(DownJumpSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long)

is_compatible( (DownJumpSRFD)arg1, (SingleResidueFragData)) -> bool : core/fragment/JumpSRFD.hh:176

C++ signature :
    bool is_compatible(core::fragment::DownJumpSRFD {lvalue},core::fragment::SingleResidueFragData)

is_compatible( (DownJumpSRFD)arg1, (SingleResidueFragData)) -> bool :

C++ signature :
    bool is_compatible(DownJumpSRFD_exposer_callback {lvalue},core::fragment::SingleResidueFragData)

read( (DownJumpSRFD)arg1, (std_istream)in) -> None : core/fragment/JumpSRFD.hh:231

C++ signature :
    void read(core::fragment::DownJumpSRFD {lvalue},std::istream {lvalue})

read( (DownJumpSRFD)arg1, (std_istream)in) -> None :

C++ signature :
    void read(DownJumpSRFD_exposer_callback {lvalue},std::istream {lvalue})

read_data( (DownJumpSRFD)arg1, (std_istream)) -> None : Default implementation: noop

C++ signature :
    void read_data(core::fragment::DownJumpSRFD {lvalue},std::istream {lvalue})

read_data( (DownJumpSRFD)arg1, (std_istream)) -> None :

C++ signature :
    void read_data(DownJumpSRFD_exposer_callback {lvalue},std::istream {lvalue})

secstruct( (DownJumpSRFD)arg1) -> str : core/fragment/SingleResidueFragData.hh:132

C++ signature :
    char secstruct(core::fragment::DownJumpSRFD {lvalue})

secstruct( (DownJumpSRFD)arg1) -> str :

C++ signature :
    char secstruct(DownJumpSRFD_exposer_callback {lvalue})

set_jump( (DownJumpSRFD)arg1, (RT)setting) -> None : set value of jump

C++ signature : void set_jump(core::fragment::DownJumpSRFD {lvalue},core::kinematics::RT)

set_standard_stub_atoms( (DownJumpSRFD)arg1) -> None : core/fragment/JumpSRFD.hh:167

C++ signature : void set_standard_stub_atoms(core::fragment::DownJumpSRFD {lvalue})

set_stub_atoms( (DownJumpSRFD)arg1, (vector1_string)downstream, (vector1_string)upstream) -> None : core/fragment/JumpSRFD.hh:163

C++ signature : void set_stub_atoms(core::fragment::DownJumpSRFD {lvalue},utility::vector1 >,utility::vector1 >)

show( (DownJumpSRFD)arg1, (OStream)out) -> None : core/fragment/JumpSRFD.hh:228

C++ signature :
    void show(core::fragment::DownJumpSRFD {lvalue},std::ostream {lvalue})

show( (DownJumpSRFD)arg1, (OStream)out) -> None :

C++ signature :
    void show(DownJumpSRFD_exposer_callback {lvalue},std::ostream {lvalue})

steal( (DownJumpSRFD)arg1, (Pose), (int)pos, (Frame)) -> bool : core/fragment/JumpSRFD.hh:175

C++ signature :
    bool steal(core::fragment::DownJumpSRFD {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

steal( (DownJumpSRFD)arg1, (Pose), (int)pos, (Frame)) -> bool :

C++ signature :
    bool steal(DownJumpSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

steal( (DownJumpSRFD)arg1, (Pose), (int)) -> bool : core/fragment/JumpSRFD.hh:199

C++ signature :
    bool steal(core::fragment::DownJumpSRFD {lvalue},core::pose::Pose,unsigned long)

steal( (DownJumpSRFD)arg1, (Pose), (int)) -> bool :

C++ signature :
    bool steal(DownJumpSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long)

type( (DownJumpSRFD)arg1) -> str : core/fragment/JumpSRFD.hh:219

C++ signature :
    std::string type(core::fragment::DownJumpSRFD {lvalue})

type( (DownJumpSRFD)arg1) -> str :

C++ signature :
    std::string type(DownJumpSRFD_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DownJumpSRFDAP)arg1) -> DownJumpSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DownJumpSRFDCAP)arg1) -> DownJumpSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (FragData)) -> None : core/fragment/FragData.hh:46

C++ signature :
    void __init__(_object*,core::fragment::FragData)

init( (object)arg1, (CPP_SingleResidueFragData), (int)n) -> None : core/fragment/FragData.hh:54

C++ signature :
    void __init__(_object*,boost::shared_ptr<core::fragment::SingleResidueFragData>,unsigned long)

add_residue( (FragData)arg1, (CPP_SingleResidueFragData)res) -> None : core/fragment/FragData.hh:137

C++ signature : void add_residue(core::fragment::FragData {lvalue},boost::shared_ptr)

apply( (FragData)arg1, (MoveMap), (Pose), (int)start, (int)end) -> int : core/fragment/FragData.hh:69

C++ signature :
    unsigned long apply(core::fragment::FragData {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,unsigned long)

apply( (FragData)arg1, (MoveMap), (Pose), (int)start, (int)end) -> int :

C++ signature :
    unsigned long apply(FragData_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,unsigned long)

apply( (FragData)arg1, (MoveMap), (Pose), (Frame)) -> int : core/fragment/FragData.hh:70

C++ signature :
    unsigned long apply(core::fragment::FragData {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},core::fragment::Frame)

apply( (FragData)arg1, (MoveMap), (Pose), (Frame)) -> int :

C++ signature :
    unsigned long apply(FragData_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},core::fragment::Frame)

apply( (FragData)arg1, (Pose), (Frame)) -> int : core/fragment/FragData.hh:73

C++ signature :
    unsigned long apply(core::fragment::FragData {lvalue},core::pose::Pose {lvalue},core::fragment::Frame)

apply( (FragData)arg1, (Pose), (Frame)) -> int :

C++ signature :
    unsigned long apply(FragData_exposer_callback {lvalue},core::pose::Pose {lvalue},core::fragment::Frame)

apply( (FragData)arg1, (Pose), (int)start, (int)end) -> int : core/fragment/FragData.hh:74

C++ signature :
    unsigned long apply(core::fragment::FragData {lvalue},core::pose::Pose {lvalue},unsigned long,unsigned long)

apply( (FragData)arg1, (Pose), (int)start, (int)end) -> int :

C++ signature :
    unsigned long apply(FragData_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long,unsigned long)

apply_ss( (FragData)arg1, (MoveMap), (str)ss, (Frame)) -> int : core/fragment/FragData.hh:77

C++ signature :
    unsigned long apply_ss(core::fragment::FragData {lvalue},core::kinematics::MoveMap,std::string {lvalue},core::fragment::Frame)

apply_ss( (FragData)arg1, (MoveMap), (str)ss, (Frame)) -> int :

C++ signature :
    unsigned long apply_ss(FragData_exposer_callback {lvalue},core::kinematics::MoveMap,std::string {lvalue},core::fragment::Frame)

chain( (FragData)arg1) -> str : Returns the chain if it has been specified, '_' otherwise.

C++ signature :
    char chain(core::fragment::FragData {lvalue})

chain( (FragData)arg1) -> str :

C++ signature :
    char chain(FragData_exposer_callback {lvalue})

clone( (FragData)arg1) -> FragData : core/fragment/FragData.hh:60

C++ signature :
    boost::shared_ptr<core::fragment::FragData> clone(core::fragment::FragData {lvalue})

clone( (FragData)arg1) -> FragData :

C++ signature :
    boost::shared_ptr<core::fragment::FragData> clone(FragData_exposer_callback {lvalue})

copy( (FragData)arg1, (FragData)frag_data) -> None : core/fragment/FragData.hh:89

C++ signature :
    void copy(core::fragment::FragData {lvalue},core::fragment::FragData)

copy( (FragData)arg1, (FragData)frag_data) -> None :

C++ signature :
    void copy(FragData_exposer_callback {lvalue},core::fragment::FragData)

generate_sub_fragment( (FragData)arg1, (int)start, (int)stop) -> FragData : core/fragment/FragData.hh:146

C++ signature :
    boost::shared_ptr<core::fragment::FragData> generate_sub_fragment(core::fragment::FragData {lvalue},unsigned long,unsigned long)

generate_sub_fragment( (FragData)arg1, (int)start, (int)stop) -> FragData :

C++ signature :
    boost::shared_ptr<core::fragment::FragData> generate_sub_fragment(FragData_exposer_callback {lvalue},unsigned long,unsigned long)

get_residue( (FragData)arg1, (int)pos) -> SingleResidueFragData : core/fragment/FragData.hh:141

C++ signature : boost::shared_ptr get_residue(core::fragment::FragData {lvalue},unsigned long)

get_self_ptr( (FragData)arg1) -> FragData : self pointers

C++ signature :
    boost::shared_ptr<core::fragment::FragData const> get_self_ptr(core::fragment::FragData {lvalue})

get_self_ptr( (FragData)arg1) -> FragData : core/fragment/FragData.hh:64

C++ signature :
    boost::shared_ptr<core::fragment::FragData> get_self_ptr(core::fragment::FragData {lvalue})

is_applicable( (FragData)arg1, (MoveMap), (int)start, (int)end) -> int : core/fragment/FragData.hh:81

C++ signature :
    unsigned long is_applicable(core::fragment::FragData {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long)

is_applicable( (FragData)arg1, (MoveMap), (int)start, (int)end) -> int :

C++ signature :
    unsigned long is_applicable(FragData_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long)

is_applicable( (FragData)arg1, (MoveMap), (Frame)) -> int : core/fragment/FragData.hh:82

C++ signature :
    unsigned long is_applicable(core::fragment::FragData {lvalue},core::kinematics::MoveMap,core::fragment::Frame)

is_applicable( (FragData)arg1, (MoveMap), (Frame)) -> int :

C++ signature :
    unsigned long is_applicable(FragData_exposer_callback {lvalue},core::kinematics::MoveMap,core::fragment::Frame)

is_compatible( (FragData)arg1, (FragData)frag_data) -> bool : core/fragment/FragData.hh:92

C++ signature : bool is_compatible(core::fragment::FragData {lvalue},core::fragment::FragData)

is_valid( (FragData)arg1) -> bool : core/fragment/FragData.hh:94

C++ signature : bool is_valid(core::fragment::FragData {lvalue})

pdbid( (FragData)arg1) -> str : Returns the PDB identifier if it has been specified, "no_pdb" otherwise.

C++ signature :
    std::string pdbid(core::fragment::FragData {lvalue})

pdbid( (FragData)arg1) -> str :

C++ signature :
    std::string pdbid(FragData_exposer_callback {lvalue})

pdbpos( (FragData)arg1) -> int : core/fragment/FragData.hh:169

C++ signature :
    unsigned long pdbpos(core::fragment::FragData {lvalue})

pdbpos( (FragData)arg1) -> int :

C++ signature :
    unsigned long pdbpos(FragData_exposer_callback {lvalue})

score( (FragData)arg1) -> float : Returns the score for this fragment

C++ signature : double score(core::fragment::FragData {lvalue})

secstruct( (FragData)arg1, (int)pos) -> str : core/fragment/FragData.hh:102

C++ signature :
    char secstruct(core::fragment::FragData {lvalue},unsigned long)

secstruct( (FragData)arg1) -> str : core/fragment/FragData.hh:110

C++ signature :
    std::string secstruct(core::fragment::FragData {lvalue})

sequence( (FragData)arg1, (int)pos) -> str : core/fragment/FragData.hh:106

C++ signature :
    char sequence(core::fragment::FragData {lvalue},unsigned long)

sequence( (FragData)arg1) -> str : core/fragment/FragData.hh:118

C++ signature :
    std::string sequence(core::fragment::FragData {lvalue})

set_residue( (FragData)arg1, (int)pos, (CPP_SingleResidueFragData)res) -> None : core/fragment/FragData.hh:130

C++ signature : void set_residue(core::fragment::FragData {lvalue},unsigned long,boost::shared_ptr)

set_score( (FragData)arg1, (float)score) -> None : Set a score value for this fragment

C++ signature : void set_score(core::fragment::FragData {lvalue},double)

set_sequence( (FragData)arg1, (int)pos, (str)setting) -> None : core/fragment/FragData.hh:126

C++ signature : void set_sequence(core::fragment::FragData {lvalue},unsigned long,char)

set_valid( (FragData)arg1 [, (bool)setting=True]) -> None : core/fragment/FragData.hh:154

C++ signature : void set_valid(core::fragment::FragData {lvalue} [,bool=True])

show( (FragData)arg1, (OStream)out) -> None : core/fragment/FragData.hh:148

C++ signature :
    void show(core::fragment::FragData {lvalue},std::ostream {lvalue})

show( (FragData)arg1, (OStream)out) -> None :

C++ signature :
    void show(FragData_exposer_callback {lvalue},std::ostream {lvalue})

show( (FragData)arg1, (OStream)out, (Frame)) -> None : core/fragment/FragData.hh:149

C++ signature :
    void show(core::fragment::FragData {lvalue},std::ostream {lvalue},core::fragment::Frame)

show( (FragData)arg1, (OStream)out, (Frame)) -> None :

C++ signature :
    void show(FragData_exposer_callback {lvalue},std::ostream {lvalue},core::fragment::Frame)

show_classic( (FragData)arg1, (OStream)out) -> None : core/fragment/FragData.hh:150

C++ signature :
    void show_classic(core::fragment::FragData {lvalue},std::ostream {lvalue})

show_classic( (FragData)arg1, (OStream)out) -> None :

C++ signature :
    void show_classic(FragData_exposer_callback {lvalue},std::ostream {lvalue})

size( (FragData)arg1) -> int : core/fragment/FragData.hh:98

C++ signature : unsigned long size(core::fragment::FragData {lvalue})

steal( (FragData)arg1, (Pose), (int)start, (int)end) -> bool : core/fragment/FragData.hh:85

C++ signature :
    bool steal(core::fragment::FragData {lvalue},core::pose::Pose,unsigned long,unsigned long)

steal( (FragData)arg1, (Pose), (int)start, (int)end) -> bool :

C++ signature :
    bool steal(FragData_exposer_callback {lvalue},core::pose::Pose,unsigned long,unsigned long)

steal( (FragData)arg1, (Pose), (Frame)) -> bool : core/fragment/FragData.hh:86

C++ signature :
    bool steal(core::fragment::FragData {lvalue},core::pose::Pose,core::fragment::Frame)

steal( (FragData)arg1, (Pose), (Frame)) -> bool :

C++ signature :
    bool steal(FragData_exposer_callback {lvalue},core::pose::Pose,core::fragment::Frame)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragDataAP)arg1) -> FragData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragDataCAP)arg1) -> FragData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (FragFactory)) -> None : core/fragment/FragmentIO.hh:34

C++ signature :
    void __init__(_object*,core::fragment::FragFactory)

add_frag_type( (FragFactory)arg1, (str)type_name, (CPP_SingleResidueFragData)frag_type) -> None : core/fragment/FragmentIO.hh:42

C++ signature : void add_frag_type(core::fragment::FragFactory {lvalue},std::string,boost::shared_ptr)

add_frame_type( (FragFactory)arg1, (str)type_name, (CPP_Frame)new_frag) -> None : core/fragment/FragmentIO.hh:44

C++ signature : void add_frame_type(core::fragment::FragFactory {lvalue},std::string,boost::shared_ptr)

frag_type( (FragFactory)arg1, (str)frag_name) -> SingleResidueFragData : core/fragment/FragmentIO.hh:47

C++ signature : boost::shared_ptr frag_type(core::fragment::FragFactory {lvalue},std::string)

frame( (FragFactory)arg1, (str)frame_name) -> Frame : core/fragment/FragmentIO.hh:46

C++ signature : boost::shared_ptr frame(core::fragment::FragFactory {lvalue},std::string)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragFactoryAP)arg1) -> FragFactory :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragFactoryCAP)arg1) -> FragFactory :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (CPP_Frame)frame, (int)frag_id) -> None : core/fragment/FragID.hh:47

C++ signature :
    void __init__(_object*,boost::shared_ptr<core::fragment::Frame const>,unsigned long)

init( (object)arg1, (FragID)) -> None : core/fragment/FragID.hh:48

C++ signature :
    void __init__(_object*,core::fragment::FragID)

apply( (FragID)arg1, (MoveMap)mm, (Pose)pose) -> int : core/fragment/FragID.hh:58

C++ signature :
    unsigned long apply(core::fragment::FragID {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue})

apply( (FragID)arg1, (Pose)pose) -> int : core/fragment/FragID.hh:59

C++ signature :
    unsigned long apply(core::fragment::FragID {lvalue},core::pose::Pose {lvalue})

apply_ss( (FragID)arg1, (MoveMap)mm, (str)ss) -> int : core/fragment/FragID.hh:63

C++ signature : unsigned long apply_ss(core::fragment::FragID {lvalue},core::kinematics::MoveMap,std::string {lvalue})

assign( (FragID)arg1, (FragID)rhs) -> FragID : core/fragment/FragID.hh:50

C++ signature : core::fragment::FragID assign(core::fragment::FragID {lvalue},core::fragment::FragID)

fragment( (FragID)arg1) -> FragData : core/fragment/FragID.hh:56

C++ signature : core::fragment::FragData fragment(core::fragment::FragID {lvalue})

fragment_ptr( (FragID)arg1) -> FragData : core/fragment/FragID.hh:57

C++ signature : boost::shared_ptr fragment_ptr(core::fragment::FragID {lvalue})

frame( (FragID)arg1) -> Frame : core/fragment/FragID.hh:53

C++ signature : core::fragment::Frame frame(core::fragment::FragID {lvalue})

frame_ptr( (FragID)arg1) -> Frame : core/fragment/FragID.hh:52

C++ signature : boost::shared_ptr frame_ptr(core::fragment::FragID {lvalue})

id( (FragID)arg1) -> int : core/fragment/FragID.hh:55

C++ signature : unsigned long id(core::fragment::FragID {lvalue})

is_valid( (FragID)arg1) -> bool : core/fragment/FragID.hh:62

C++ signature : bool is_valid(core::fragment::FragID {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragIDAP)arg1) -> FragID :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragIDCAP)arg1) -> FragID :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (ConstFrameIterator)it) -> None : core/fragment/FragID_Iterator.hh:49

C++ signature :
    void __init__(_object*,core::fragment::ConstFrameIterator)

init( (object)arg1, (FragID_Iterator)) -> None : core/fragment/FragID_Iterator.hh:47

C++ signature :
    void __init__(_object*,core::fragment::FragID_Iterator)

init( (object)arg1, (FrameIterator)it) -> None : core/fragment/FragID_Iterator.hh:50

C++ signature :
    void __init__(_object*,core::fragment::FrameIterator)

init( (object)arg1, (FrameIteratorWorker_)it) -> None : core/fragment/FragID_Iterator.hh:51

C++ signature :
    void __init__(_object*,boost::shared_ptr<core::fragment::FrameIteratorWorker_>)

init( (object)arg1, (object)it) -> None : core/fragment/FragID_Iterator.hh:52

C++ signature :
    void __init__(_object*,__gnu_cxx::__normal_iterator<boost::shared_ptr<core::fragment::Frame>*, std::vector<boost::shared_ptr<core::fragment::Frame>, std::allocator<boost::shared_ptr<core::fragment::Frame> > > >)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

assign( (FragID_Iterator)arg1, (FragID_Iterator)itr) -> FragID_Iterator : core/fragment/FragID_Iterator.hh:65

C++ signature : core::fragment::FragID_Iterator {lvalue} assign(core::fragment::FragID_Iterator {lvalue},core::fragment::FragID_Iterator)

frag_id( (FragID_Iterator)arg1) -> FragID : core/fragment/FragID_Iterator.hh:67

C++ signature : core::fragment::FragID frag_id(core::fragment::FragID_Iterator {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragID_IteratorAP)arg1) -> FragID_Iterator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragID_IteratorCAP)arg1) -> FragID_Iterator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

add( (FragSet)arg1, (CPP_Frame)aFrame) -> None : add a single frame. if compatible frame is already in set the frames will be merged

C++ signature :
    void add(core::fragment::FragSet {lvalue},boost::shared_ptr<core::fragment::Frame const>)

add( (FragSet)arg1, (FrameList)frames) -> None : add all Frames in list

C++ signature :
    void add(core::fragment::FragSet {lvalue},core::fragment::FrameList)

add( (FragSet)arg1, (FragSet)frames) -> None : add all Frames in FragSet

C++ signature :
    void add(core::fragment::FragSet {lvalue},core::fragment::FragSet)

add( (FragSet)arg1, (FragID)) -> None : add single fragment

C++ signature :
    void add(core::fragment::FragSet {lvalue},core::fragment::FragID)

add( (FragSet)arg1, (object)list) -> None : core/fragment/FragSet.hh:167

C++ signature :
    void add(core::fragment::FragSet {lvalue},utility::vector1<core::fragment::FragID, std::allocator<core::fragment::FragID> > {lvalue})

begin( (FragSet)arg1) -> ConstFrameIterator : iterate over contents

C++ signature :
    core::fragment::ConstFrameIterator begin(core::fragment::FragSet {lvalue})

begin( (FragSet)arg1) -> None :

C++ signature :
    void begin(boost::shared_ptr<core::fragment::FragSet> {lvalue})

clone( (FragSet)arg1) -> FragSet : clone and copy the pointer of all Frames (Frames will not be copied)

C++ signature :
    boost::shared_ptr<core::fragment::FragSet> clone(core::fragment::FragSet {lvalue})

clone( (FragSet)arg1) -> None :

C++ signature :
    void clone(boost::shared_ptr<core::fragment::FragSet> {lvalue})

clone_shifted( (FragSet)arg1, (int)) -> FragSet : core/fragment/FragSet.hh:195

C++ signature : boost::shared_ptr clone_shifted(core::fragment::FragSet {lvalue},int)

empty( (FragSet)arg1) -> bool : core/fragment/FragSet.hh:180

C++ signature :
    bool empty(core::fragment::FragSet {lvalue})

empty( (FragSet)arg1) -> None :

C++ signature :
    void empty(boost::shared_ptr<core::fragment::FragSet> {lvalue})

empty_clone( (FragSet)arg1) -> FragSet : create an empty clone

C++ signature :
    boost::shared_ptr<core::fragment::FragSet> empty_clone(core::fragment::FragSet {lvalue})

empty_clone( (FragSet)arg1) -> None :

C++ signature :
    void empty_clone(boost::shared_ptr<core::fragment::FragSet> {lvalue})

end( (FragSet)arg1) -> ConstFrameIterator : core/fragment/FragSet.hh:85

C++ signature :
    core::fragment::ConstFrameIterator end(core::fragment::FragSet {lvalue})

end( (FragSet)arg1) -> None :

C++ signature :
    void end(boost::shared_ptr<core::fragment::FragSet> {lvalue})

frames( (FragSet)arg1, (int)pos, (FrameList)frames) -> int : appends frames at sequence position pos to frames, returns nr of frames added

C++ signature : unsigned long frames(core::fragment::FragSet {lvalue},unsigned long,core::fragment::FrameList {lvalue})

generate_insert_map( (FragSet)arg1, (MoveMap)mm, (vector1_Size)insert_map, (vector1_Size)insert_size) -> None : InsertMap and InsertSize gives quick overview which residues can be affected by fragments. insert_map --- list of start-positions, insert_size corresponding list of longest fragment at position x

C++ signature : void generate_insert_map(core::fragment::FragSet {lvalue},core::kinematics::MoveMap,utility::vector1 > {lvalue},utility::vector1 > {lvalue})

global_offset( (FragSet)arg1) -> int : core/fragment/FragSet.hh:187

C++ signature :
    int global_offset(core::fragment::FragSet {lvalue})

global_offset( (FragSet)arg1, (int)) -> None : resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to

C++ signature :
    void global_offset(core::fragment::FragSet {lvalue},int)

insert_fragID_list( (FragSet)arg1, (object)list) -> None : add all fragments in FragID_List

C++ signature : void insert_fragID_list(core::fragment::FragSet {lvalue},utility::vector1 > {lvalue})

max_frag_length( (FragSet)arg1) -> int : returns the longest fragment stored in this FragSet.

C++ signature : unsigned long max_frag_length(core::fragment::FragSet {lvalue})

max_pos( (FragSet)arg1) -> int : returns the maximal sequence position that can be affected by fragments in this set

C++ signature : unsigned long max_pos(core::fragment::FragSet {lvalue})

min_pos( (FragSet)arg1) -> int : returns the first sequence position that can be affected by fragments in this set

C++ signature : unsigned long min_pos(core::fragment::FragSet {lvalue})

nonconst_begin( (FragSet)arg1) -> FrameIterator : iterate over contents

C++ signature :
    core::fragment::FrameIterator nonconst_begin(core::fragment::FragSet {lvalue})

nonconst_begin( (FragSet)arg1) -> None :

C++ signature :
    void nonconst_begin(boost::shared_ptr<core::fragment::FragSet> {lvalue})

nonconst_end( (FragSet)arg1) -> FrameIterator : core/fragment/FragSet.hh:89

C++ signature :
    core::fragment::FrameIterator nonconst_end(core::fragment::FragSet {lvalue})

nonconst_end( (FragSet)arg1) -> None :

C++ signature :
    void nonconst_end(boost::shared_ptr<core::fragment::FragSet> {lvalue})

nr_frames( (FragSet)arg1) -> int : counts number of frames ( slow! - it really counts )

C++ signature : unsigned long nr_frames(core::fragment::FragSet {lvalue})

overlapping_with_region( (FragSet)arg1, (MoveMap)mm, (int)start, (int)end, (int)min_overlap, (int)min_length, (FrameList)frames) -> int : returns the number and list of all fragment alignment frames that somehow overlap with the given region (also allows those frames that start before the region and reach into it)

C++ signature : unsigned long overlapping_with_region(core::fragment::FragSet {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long,unsigned long,unsigned long,core::fragment::FrameList {lvalue})

region( (FragSet)arg1, (MoveMap)move_map, (int)start, (int)end, (int)min_overlap, (int)min_length, (FrameList)frames) -> int : the region thing has to be thought-over. How do we really want to sample fragments? for now, we ignore everything in this call and just return frags that have "start" as there specified start() entry.

C++ signature :
    unsigned long region(core::fragment::FragSet {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long,unsigned long,unsigned long,core::fragment::FrameList {lvalue})

region( (FragSet)arg1, (MoveMap)arg2, (int)arg3, (int)arg4, (int)arg5, (int)arg6, (FrameList)arg7) -> None :

C++ signature :
    void region(boost::shared_ptr<core::fragment::FragSet> {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long,unsigned long,unsigned long,core::fragment::FrameList {lvalue})

region_all( (FragSet)arg1, (int)start, (int)end, (int)min_overlap, (int)min_length, (FrameList)frames) -> int : return a list of frames that all sample the specified region, assume all motions are allowed

C++ signature : unsigned long region_all(core::fragment::FragSet {lvalue},unsigned long,unsigned long,unsigned long,unsigned long,core::fragment::FrameList {lvalue})

region_simple( (FragSet)arg1, (int)start, (int)end, (FrameList)frames) -> int : returns fragments that exactly span seq_pos start...end

C++ signature : unsigned long region_simple(core::fragment::FragSet {lvalue},unsigned long,unsigned long,core::fragment::FrameList {lvalue})

shift_by( (FragSet)arg1, (int)offset) -> None : shift all frames in FragSet by offset

C++ signature : void shift_by(core::fragment::FragSet {lvalue},int)

size( (FragSet)arg1) -> int : returns total size--> counts together all frags in each frame

C++ signature : unsigned long size(core::fragment::FragSet {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragSetAP)arg1) -> FragSet :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragSetCAP)arg1) -> FragSet :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (FragSetCollection)) -> None : core/fragment/FragSetCollection.hh:56

C++ signature :
    void __init__(_object*,core::fragment::FragSetCollection)

add_fragset( (FragSetCollection)arg1, (FragSet)fragset) -> None : core/fragment/FragSetCollection.hh:61

C++ signature : void add_fragset(core::fragment::FragSetCollection {lvalue},boost::shared_ptr)

begin( (FragSetCollection)arg1) -> ConstFrameIterator : core/fragment/FragSetCollection.hh:72

C++ signature : core::fragment::ConstFrameIterator begin(core::fragment::FragSetCollection {lvalue})

clone( (FragSetCollection)arg1) -> FragSet : core/fragment/FragSetCollection.hh:58

C++ signature : boost::shared_ptr clone(core::fragment::FragSetCollection {lvalue})

empty( (FragSetCollection)arg1) -> bool : core/fragment/FragSetCollection.hh:78

C++ signature : bool empty(core::fragment::FragSetCollection {lvalue})

empty_clone( (FragSetCollection)arg1) -> FragSet : core/fragment/FragSetCollection.hh:59

C++ signature : boost::shared_ptr empty_clone(core::fragment::FragSetCollection {lvalue})

end( (FragSetCollection)arg1) -> ConstFrameIterator : core/fragment/FragSetCollection.hh:73

C++ signature : core::fragment::ConstFrameIterator end(core::fragment::FragSetCollection {lvalue})

nonconst_begin( (FragSetCollection)arg1) -> FrameIterator : core/fragment/FragSetCollection.hh:75

C++ signature : core::fragment::FrameIterator nonconst_begin(core::fragment::FragSetCollection {lvalue})

nonconst_end( (FragSetCollection)arg1) -> FrameIterator : core/fragment/FragSetCollection.hh:76

C++ signature : core::fragment::FrameIterator nonconst_end(core::fragment::FragSetCollection {lvalue})

region( (FragSetCollection)arg1, (MoveMap)move_map, (int)start, (int)end, (int)min_overlap, (int)min_length, (FrameList)frames) -> int : core/fragment/FragSetCollection.hh:70

C++ signature : unsigned long region(core::fragment::FragSetCollection {lvalue},core::kinematics::MoveMap,unsigned long,unsigned long,unsigned long,unsigned long,core::fragment::FrameList {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragSetCollectionAP)arg1) -> FragSetCollection :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragSetCollectionCAP)arg1) -> FragSetCollection :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (FragmentIO)) -> None : core/fragment/FragmentIO.hh:55

C++ signature :
    void __init__(_object*,core::fragment::FragmentIO)

init( (object)arg1, (int)top [, (int)ncopies=1 [, (bool)bAnnotate=True]]) -> None : core/fragment/FragmentIO.hh:60

C++ signature :
    void __init__(_object*,unsigned long [,unsigned long=1 [,bool=True]])

clean_frag_cache( (FragmentIO)arg1) -> None : remove all FragSets that are not referenced outside the cache.

C++ signature : void clean_frag_cache(core::fragment::FragmentIO {lvalue})

get_frag_factory( (FragmentIO)arg1) -> FragFactory : core/fragment/FragmentIO.hh:78

C++ signature : core::fragment::FragFactory {lvalue} get_frag_factory(core::fragment::FragmentIO {lvalue})

read_data( (FragmentIO)arg1, (str)filename) -> FragSet : read a FragSet... note that this function caches the fragment set. i.e., if you read the same set from multiple positions in the code you get the same set. if you read a new file ... we'll check the cache for stale references and delete them...

C++ signature :
    boost::shared_ptr<core::fragment::FragSet> read_data(core::fragment::FragmentIO {lvalue},std::string)

read_data( (FragmentIO)arg1, (str)filename, (FrameList)) -> None : core/fragment/FragmentIO.hh:72

C++ signature :
    void read_data(core::fragment::FragmentIO {lvalue},std::string,core::fragment::FrameList {lvalue})

read_data( (FragmentIO)arg1, (std_istream)data, (FrameList)) -> None : core/fragment/FragmentIO.hh:74

C++ signature :
    void read_data(core::fragment::FragmentIO {lvalue},std::istream {lvalue},core::fragment::FrameList {lvalue})

set_ncopies( (FragmentIO)arg1, (int)setting) -> None : Updates the number of copies of each fragment to keep (default 1)

C++ signature : void set_ncopies(core::fragment::FragmentIO {lvalue},unsigned long)

set_read_annotation( (FragmentIO)arg1 [, (bool)setting=True]) -> None : Toggles between reading annotated (true) and non-annotated (false)

C++ signature : void set_read_annotation(core::fragment::FragmentIO {lvalue} [,bool=True])

set_top_frag_num( (FragmentIO)arg1, (int)setting) -> None : Updates the number of distinct fragments to keep

C++ signature : void set_top_frag_num(core::fragment::FragmentIO {lvalue},unsigned long)

write_data( (FragmentIO)arg1, (str)file, (FragSet)frags) -> None : core/fragment/FragmentIO.hh:76

C++ signature : void write_data(core::fragment::FragmentIO {lvalue},std::string,core::fragment::FragSet)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragmentIOAP)arg1) -> FragmentIO :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragmentIOCAP)arg1) -> FragmentIO :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (FragSet)fragments) -> None : core/fragment/FragmentRmsd.hh:41

C++ signature :
    void __init__(_object*,boost::shared_ptr<core::fragment::FragSet const>)

init( (object)arg1, (FragmentRmsd)) -> None : core/fragment/FragmentRmsd.hh:35

C++ signature :
    void __init__(_object*,core::fragment::FragmentRmsd)

fragment( (FragmentRmsd)arg1, (int)position, (int)k) -> FragData : Returns the kth fragment at the specified position in the fragment library.

C++ signature : boost::shared_ptr fragment(core::fragment::FragmentRmsd {lvalue},unsigned long,unsigned long)

rmsd( (FragmentRmsd)arg1, (int)position, (int)k, (Pose)reference) -> float : Returns the RMSD of the kth fragment at the specified position in the fragment library and pose.

C++ signature : double rmsd(core::fragment::FragmentRmsd {lvalue},unsigned long,unsigned long,core::pose::Pose)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragmentRmsdAP)arg1) -> FragmentRmsd :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FragmentRmsdCAP)arg1) -> FragmentRmsd :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (Frame)) -> None : Frame couples a list of FragData-instances to a certain alignment frame, i.e., position in sequence space @detail A frame may be continous, i.e., its fragment data will be applied to all residues between start() and end() or ( in a specialized version inheriting this interface) may contain a loose list of sequence positions. Instances of FragData (e.g., the Torsion-Angles of a specific Fragment) can be added and deleted via add_- or delete_fragment() methods. a fragment is inserted into the structure via the apply() method and the steal() method is its inverse: an instance of FragData is created from the structure of the pose at the dof's specified in the other FragData's of the Frame. The new FragData is added as last fragment to the frame. accessors to underlying FragData-instances are available as fragment() or fragment_ptr(). Frame supports the FragCache --> see FragCache for documentation. MoveMaps: It should be possible to specify which dofs can be moved. In this case fragment-insertions should a) only be allowed if all dofs affected are moveable or b) only change those dofs that are moveable. this information could be handled by an extended version of the kinematics::movemap. The movemap would then have to functions: 1) which dofs are changed by a certain FragData/Frame 2) which dofs are moveable comparison of movemaps, i.e., M1 <= M2 could tell us if dofs tagged in M1 are also tagged in M2: i.e., the M_fragdata<= M_pose would tell us that the fragment is applicable to the Pose.

C++ signature :
    void __init__(_object*,core::fragment::Frame)

init( (object)arg1, (int)begin, (int)end, (int)nr_res) -> None : core/fragment/Frame.hh:110

C++ signature :
    void __init__(_object*,unsigned long,unsigned long,unsigned long)

init( (object)arg1, (int)start, (int)length) -> None : core/fragment/Frame.hh:112

C++ signature :
    void __init__(_object*,unsigned long,unsigned long)

init( (object)arg1, (int)start) -> None : core/fragment/Frame.hh:114

C++ signature :
    void __init__(_object*,unsigned long)

init( (object)arg1, (int)start, (CPP_FragData)frag1) -> None : core/fragment/Frame.hh:116

C++ signature :
    void __init__(_object*,unsigned long,boost::shared_ptr<core::fragment::FragData const>)

init( (object)arg1, (int)start, (int)length, (CPP_SingleResidueFragData)srfd) -> None : core/fragment/Frame.hh:118

C++ signature :
    void __init__(_object*,unsigned long,unsigned long,boost::shared_ptr<core::fragment::SingleResidueFragData>)

add_fragment( (Frame)arg1, (CPP_FragData)new_frag) -> int : add a fragment .. return new frag_nr

C++ signature :
    unsigned long add_fragment(core::fragment::Frame {lvalue},boost::shared_ptr<core::fragment::FragData const>)

add_fragment( (Frame)arg1, (object)new_frags) -> bool : add all fragments in list

C++ signature :
    bool add_fragment(core::fragment::Frame {lvalue},utility::vector1<boost::shared_ptr<core::fragment::FragData const>, std::allocator<boost::shared_ptr<core::fragment::FragData const> > >)

align( (Frame)arg1, (SequenceMapping)map) -> bool : change frames residue numbers accoriding to map

C++ signature :
    bool align(core::fragment::Frame {lvalue},core::id::SequenceMapping)

align( (Frame)arg1, (SequenceMapping)map) -> bool :

C++ signature :
    bool align(Frame_exposer_callback {lvalue},core::id::SequenceMapping)

apply( (Frame)arg1, (MoveMap), (int)frag_num, (Pose)pose) -> int : insert fragment frag_num into pose

C++ signature :
    unsigned long apply(core::fragment::Frame {lvalue},core::kinematics::MoveMap,unsigned long,core::pose::Pose {lvalue})

apply( (Frame)arg1, (int)frag_num, (Pose)pose) -> int : insert fragment frag_num into pose --- ignore movemap

C++ signature :
    unsigned long apply(core::fragment::Frame {lvalue},unsigned long,core::pose::Pose {lvalue})

apply_ss( (Frame)arg1, (MoveMap), (int)frag_num, (str)ss) -> int : change ss-string according to sec-struct info in fragments

C++ signature : unsigned long apply_ss(core::fragment::Frame {lvalue},core::kinematics::MoveMap,unsigned long,std::string {lvalue})

cache( (Frame)arg1, (str)tag, (CPP_BaseCacheUnit)new_cache) -> BaseCacheUnit : return handle to cached data stored under "tag" shouldn't be called directly

C++ signature : core::fragment::BaseCacheUnit {lvalue} cache(core::fragment::Frame {lvalue},std::string,boost::shared_ptr)

clear( (Frame)arg1) -> None : remove all valid fragments, a template fragment will be left over

C++ signature : void clear(core::fragment::Frame {lvalue})

clone( (Frame)arg1) -> Frame : clone method, new frame with same alignment position, fragments are not copied!

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone(core::fragment::Frame {lvalue})

clone( (Frame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone(Frame_exposer_callback {lvalue})

clone_cache_data( (Frame)arg1, (Frame)source, (int)sid, (int)nid) -> None : copies all entries in the Frame-Cache for fragment "sid" of Frame "source" to fragment "nid" of "this" frame

C++ signature : void clone_cache_data(core::fragment::Frame {lvalue},core::fragment::Frame,unsigned long,unsigned long)

clone_with_frags( (Frame)arg1) -> Frame : clone method, new frame with same alignment position, fragments are not copied!

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_frags(core::fragment::Frame {lvalue})

clone_with_frags( (Frame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_frags(Frame_exposer_callback {lvalue})

clone_with_template( (Frame)arg1) -> Frame : clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false )

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_template(core::fragment::Frame {lvalue})

clone_with_template( (Frame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_template(Frame_exposer_callback {lvalue})

contains_seqpos( (Frame)arg1, (int)seqpos) -> bool : whether this fragment contains a certain position

C++ signature : bool contains_seqpos(core::fragment::Frame {lvalue},unsigned long)

end( (Frame)arg1) -> int : last sequence position affected by this frame

C++ signature : unsigned long end(core::fragment::Frame {lvalue})

frag_id( (Frame)arg1, (int)frag_num) -> int : a unique id for every fragment in the list. his is silly, but would enable later on to avoid cache_clearence on deletion of FragData entries in this case, we would require that the ID of a certain fragment never changes, even if the position in FragList changes

C++ signature : unsigned long frag_id(core::fragment::Frame {lvalue},unsigned long)

fragment( (Frame)arg1, (int)frag_num) -> FragData : accesors for underlying FragData

C++ signature : core::fragment::FragData fragment(core::fragment::Frame {lvalue},unsigned long)

fragment_as_pose( (Frame)arg1, (int)frag_num, (Pose)pose, (ResidueTypeSetCAP)restype_set) -> None : returns a (small) pose with fragment ( continous from seqpos 1 ... nr_res_affected() )

C++ signature : void fragment_as_pose(core::fragment::Frame {lvalue},unsigned long,core::pose::Pose {lvalue},boost::weak_ptr)

fragment_ptr( (Frame)arg1, (int)frag_num) -> FragData : accessor for underlying FragData as owning ptr

C++ signature : boost::shared_ptr fragment_ptr(core::fragment::Frame {lvalue},unsigned long)

generate_sub_frame( (Frame)arg1, (int)length [, (int)start=1]) -> Frame : generate_sub_frame of length from start ( internal numbers )

C++ signature : boost::shared_ptr generate_sub_frame(core::fragment::Frame {lvalue},unsigned long [,unsigned long=1])

is_applicable( (Frame)arg1, (MoveMap)) -> int : is the Frame applicable to the pose with the given movemap?

C++ signature : unsigned long is_applicable(core::fragment::Frame {lvalue},core::kinematics::MoveMap)

is_continuous( (Frame)arg1) -> bool : /////// properties of the Frame/////////////////// true if frame is continuous (always true for base class)

C++ signature :
    bool is_continuous(core::fragment::Frame {lvalue})

is_continuous( (Frame)arg1) -> bool :

C++ signature :
    bool is_continuous(Frame_exposer_callback {lvalue})

is_mergeable( (Frame)arg1, (Frame)other) -> bool : core/fragment/Frame.hh:263

C++ signature : bool is_mergeable(core::fragment::Frame {lvalue},core::fragment::Frame)

is_valid( (Frame)arg1) -> bool : a frame is considered valid if at least one fragment is contained and this fragment is also valid (not an empty template fragment)

C++ signature : bool is_valid(core::fragment::Frame {lvalue})

length( (Frame)arg1) -> int : number of residues in this frame ( for continuous frames it is the same as end()-start() + 1 )

C++ signature : unsigned long length(core::fragment::Frame {lvalue})

merge( (Frame)arg1, (Frame)other) -> bool : core/fragment/Frame.hh:265

C++ signature : bool merge(core::fragment::Frame {lvalue},core::fragment::Frame)

moves_residue( (Frame)arg1, (int)pos) -> bool : core/fragment/Frame.hh:232

C++ signature :
    bool moves_residue(core::fragment::Frame {lvalue},unsigned long)

moves_residue( (Frame)arg1, (int)pos) -> bool :

C++ signature :
    bool moves_residue(Frame_exposer_callback {lvalue},unsigned long)

nr_frags( (Frame)arg1) -> int : number of fragments attached to this frame

C++ signature : unsigned long nr_frags(core::fragment::Frame {lvalue})

nr_res_affected( (Frame)arg1, (MoveMap)mm) -> int : number of residues affected by this frame

C++ signature : unsigned long nr_res_affected(core::fragment::Frame {lvalue},core::kinematics::MoveMap)

read( (Frame)arg1, (std_istream)in) -> None : core/fragment/Frame.hh:261

C++ signature :
    void read(core::fragment::Frame {lvalue},std::istream {lvalue})

read( (Frame)arg1, (std_istream)in) -> None :

C++ signature :
    void read(Frame_exposer_callback {lvalue},std::istream {lvalue})

seqpos( (Frame)arg1, (int)intra_pos) -> int : translate intra-frame position into sequence position. (trivial for base-class)

C++ signature :
    unsigned long seqpos(core::fragment::Frame {lvalue},unsigned long)

seqpos( (Frame)arg1, (int)intra_pos) -> int :

C++ signature :
    unsigned long seqpos(Frame_exposer_callback {lvalue},unsigned long)

shift_by( (Frame)arg1, (int)offset) -> None : shift frame by offset relative to current start position ( change end accordingly )

C++ signature :
    void shift_by(core::fragment::Frame {lvalue},int)

shift_by( (Frame)arg1, (int)offset) -> None :

C++ signature :
    void shift_by(Frame_exposer_callback {lvalue},int)

shift_to( (Frame)arg1, (int)setting) -> None : shift to new start position ( change end accordingly )

C++ signature :
    void shift_to(core::fragment::Frame {lvalue},unsigned long)

shift_to( (Frame)arg1, (int)setting) -> None :

C++ signature :
    void shift_to(Frame_exposer_callback {lvalue},unsigned long)

show( (Frame)arg1, (OStream)out) -> None : core/fragment/Frame.hh:255

C++ signature :
    void show(core::fragment::Frame {lvalue},std::ostream {lvalue})

show( (Frame)arg1, (OStream)out) -> None :

C++ signature :
    void show(Frame_exposer_callback {lvalue},std::ostream {lvalue})

show_classic( (Frame)arg1, (OStream)out) -> None : core/fragment/Frame.hh:251

C++ signature :
    void show_classic(core::fragment::Frame {lvalue},std::ostream {lvalue})

show_classic( (Frame)arg1, (OStream)out) -> None :

C++ signature :
    void show_classic(Frame_exposer_callback {lvalue},std::ostream {lvalue})

show_header( (Frame)arg1, (OStream)out) -> None : core/fragment/Frame.hh:258

C++ signature :
    void show_header(core::fragment::Frame {lvalue},std::ostream {lvalue})

show_header( (Frame)arg1, (OStream)out) -> None :

C++ signature :
    void show_header(Frame_exposer_callback {lvalue},std::ostream {lvalue})

start( (Frame)arg1) -> int : first seqpos of this frame

C++ signature : unsigned long start(core::fragment::Frame {lvalue})

steal( (Frame)arg1, (Pose)pose) -> bool : obtain fragment from pose at frame position

C++ signature : bool steal(core::fragment::Frame {lvalue},core::pose::Pose)

stop( (Frame)arg1) -> int : last sequence position affected by this frame

C++ signature : unsigned long stop(core::fragment::Frame {lvalue})

type( (Frame)arg1) -> str : type() is specifying the output name of the Frame in FragmentIO ("FRAME", "JUMPFRAME", etc)

C++ signature :
    std::string type(core::fragment::Frame {lvalue})

type( (Frame)arg1) -> str :

C++ signature :
    std::string type(Frame_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameAP)arg1) -> Frame :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameCAP)arg1) -> Frame :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (FrameIteratorWorker_)it) -> None : core/fragment/FrameIterator.hh:98

C++ signature :
    void __init__(_object*,boost::shared_ptr<core::fragment::FrameIteratorWorker_>)

init( (object)arg1, (FrameIterator)) -> None : core/fragment/FrameIterator.hh:94

C++ signature :
    void __init__(_object*,core::fragment::FrameIterator)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

assign( (FrameIterator)arg1, (FrameIterator)itr) -> FrameIterator : core/fragment/FrameIterator.hh:108

C++ signature : core::fragment::FrameIterator assign(core::fragment::FrameIterator {lvalue},core::fragment::FrameIterator)

frame_ptr( (FrameIterator)arg1) -> Frame : core/fragment/FrameIterator.hh:118

C++ signature : boost::shared_ptr frame_ptr(core::fragment::FrameIterator {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameIteratorAP)arg1) -> FrameIterator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameIteratorCAP)arg1) -> FrameIterator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameIteratorWorker_AP)arg1) -> FrameIteratorWorker_ :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameIteratorWorker_CAP)arg1) -> FrameIteratorWorker_ :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

flat_size( (FrameList)arg1) -> int : core/fragment/FrameList.hh:43

C++ signature : unsigned long flat_size(core::fragment::FrameList {lvalue})

fragID( (FrameList)arg1, (int)flat_nr) -> FragID : core/fragment/FrameList.hh:42

C++ signature : core::fragment::FragID fragID(core::fragment::FrameList {lvalue},unsigned long)

frame_vector( (FrameList)arg1) -> vector1_FrameOP : core/fragment/FrameList.hh:45

C++ signature : utility::vector1, std::allocator > > frame_vector(core::fragment::FrameList {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameListAP)arg1) -> FrameList :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameListCAP)arg1) -> FrameList :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameListIterator_AP)arg1) -> FrameListIterator_ :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FrameListIterator_CAP)arg1) -> FrameListIterator_ :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (int)n_bbtorsions, (str)secstruct, (str)sequence) -> None : constructor [in] n_bbtorsions Number of backbone torsions. [in] secstruct The single character secondary structure type. [in] sequence The single character sequence type.

C++ signature :
    void __init__(_object*,unsigned long,char,char)

init( (object)arg1, (IndependentBBTorsionSRFD)rval) -> None : copy constructor

C++ signature :
    void __init__(_object*,core::fragment::IndependentBBTorsionSRFD)

apply( (IndependentBBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)seqpos) -> bool : apply only torsions in this fragment marked as moveable in the given MoveMap [in] movemap Check for moveable torsions in this MoveMap. [in,out] pose The Pose to modify. [in] seqpos Insert at this sequence position. True if at least one torsion inserted and second level superclass SecstructSRFD::apply() succeeded, otherwise false.

C++ signature :
    bool apply(core::fragment::IndependentBBTorsionSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply( (IndependentBBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)seqpos) -> bool :

C++ signature :
    bool apply(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long)

apply( (IndependentBBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos );

C++ signature :
    bool apply(core::fragment::IndependentBBTorsionSRFD {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (IndependentBBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (IndependentBBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)intra_frame_pos, (Frame)frame) -> bool : insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos ) for dofs that are allowed to move in the MoveMap

C++ signature :
    bool apply(core::fragment::IndependentBBTorsionSRFD {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (IndependentBBTorsionSRFD)arg1, (MoveMap)movemap, (Pose)pose, (int)intra_frame_pos, (Frame)frame) -> bool :

C++ signature :
    bool apply(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,core::pose::Pose {lvalue},unsigned long,core::fragment::Frame)

apply( (IndependentBBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool : insert all backbone torsions into pose at position seq_pos

C++ signature :
    bool apply(core::fragment::IndependentBBTorsionSRFD {lvalue},core::pose::Pose {lvalue},unsigned long)

apply( (IndependentBBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool :

C++ signature :
    bool apply(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose {lvalue},unsigned long)

apply_ss( (IndependentBBTorsionSRFD)arg1, (str), (int)seq_pos) -> bool : core/fragment/SecstructSRFD.hh:79

C++ signature :
    bool apply_ss(core::fragment::IndependentBBTorsionSRFD {lvalue},std::string {lvalue},unsigned long)

apply_ss( (IndependentBBTorsionSRFD)arg1, (str), (int)seq_pos) -> bool :

C++ signature :
    bool apply_ss(IndependentBBTorsionSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long)

apply_ss( (IndependentBBTorsionSRFD)arg1, (str), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data sec-struct into ss-string at position seq_pos

C++ signature :
    bool apply_ss(core::fragment::IndependentBBTorsionSRFD {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

apply_ss( (IndependentBBTorsionSRFD)arg1, (str), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool apply_ss(IndependentBBTorsionSRFD_exposer_callback {lvalue},std::string {lvalue},unsigned long,core::fragment::Frame)

assign( (IndependentBBTorsionSRFD)arg1, (IndependentBBTorsionSRFD)rval) -> IndependentBBTorsionSRFD : copy assignment

C++ signature : core::fragment::IndependentBBTorsionSRFD {lvalue} assign(core::fragment::IndependentBBTorsionSRFD {lvalue},core::fragment::IndependentBBTorsionSRFD)

clone( (IndependentBBTorsionSRFD)arg1) -> SingleResidueFragData : clone this object

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(core::fragment::IndependentBBTorsionSRFD {lvalue})

clone( (IndependentBBTorsionSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> clone(IndependentBBTorsionSRFD_exposer_callback {lvalue})

create( (IndependentBBTorsionSRFD)arg1) -> SingleResidueFragData : create a new instance of this object

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(core::fragment::IndependentBBTorsionSRFD {lvalue})

create( (IndependentBBTorsionSRFD)arg1) -> SingleResidueFragData :

C++ signature :
    boost::shared_ptr<core::fragment::SingleResidueFragData> create(IndependentBBTorsionSRFD_exposer_callback {lvalue})

is_applicable( (IndependentBBTorsionSRFD)arg1, (MoveMap)movemap, (int)seqpos) -> bool : is at least one torsion marked as moveable in the given MoveMap? [in] movemap Check for moveable torsions in this MoveMap. [in] seqpos Check at this sequence position. True if at least one torsion moveable and second level superclass SecstructSRFD::is_applicable(), otherwise False.

C++ signature :
    bool is_applicable(core::fragment::IndependentBBTorsionSRFD {lvalue},core::kinematics::MoveMap,unsigned long)

is_applicable( (IndependentBBTorsionSRFD)arg1, (MoveMap)movemap, (int)seqpos) -> bool :

C++ signature :
    bool is_applicable(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long)

is_applicable( (IndependentBBTorsionSRFD)arg1, (MoveMap), (int)intra_frame_pos, (Frame)) -> bool : check weather dofs can be moved

C++ signature :
    bool is_applicable(core::fragment::IndependentBBTorsionSRFD {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_applicable( (IndependentBBTorsionSRFD)arg1, (MoveMap), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool is_applicable(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::kinematics::MoveMap,unsigned long,core::fragment::Frame)

is_compatible( (IndependentBBTorsionSRFD)arg1, (SingleResidueFragData)) -> bool : core/fragment/BBTorsionSRFD.hh:136

C++ signature :
    bool is_compatible(core::fragment::IndependentBBTorsionSRFD {lvalue},core::fragment::SingleResidueFragData)

is_compatible( (IndependentBBTorsionSRFD)arg1, (SingleResidueFragData)) -> bool :

C++ signature :
    bool is_compatible(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::fragment::SingleResidueFragData)

read_data( (IndependentBBTorsionSRFD)arg1, (std_istream)in) -> None : core/fragment/BBTorsionSRFD.hh:146

C++ signature :
    void read_data(core::fragment::IndependentBBTorsionSRFD {lvalue},std::istream {lvalue})

read_data( (IndependentBBTorsionSRFD)arg1, (std_istream)in) -> None :

C++ signature :
    void read_data(IndependentBBTorsionSRFD_exposer_callback {lvalue},std::istream {lvalue})

secstruct( (IndependentBBTorsionSRFD)arg1) -> str : get secstruct for this position

C++ signature :
    char secstruct(core::fragment::IndependentBBTorsionSRFD {lvalue})

secstruct( (IndependentBBTorsionSRFD)arg1) -> str :

C++ signature :
    char secstruct(IndependentBBTorsionSRFD_exposer_callback {lvalue})

show( (IndependentBBTorsionSRFD)arg1, (OStream)out) -> None : core/fragment/BBTorsionSRFD.hh:144

C++ signature :
    void show(core::fragment::IndependentBBTorsionSRFD {lvalue},std::ostream {lvalue})

show( (IndependentBBTorsionSRFD)arg1, (OStream)out) -> None :

C++ signature :
    void show(IndependentBBTorsionSRFD_exposer_callback {lvalue},std::ostream {lvalue})

steal( (IndependentBBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool : core/fragment/BBTorsionSRFD.hh:135

C++ signature :
    bool steal(core::fragment::IndependentBBTorsionSRFD {lvalue},core::pose::Pose,unsigned long)

steal( (IndependentBBTorsionSRFD)arg1, (Pose), (int)seq_pos) -> bool :

C++ signature :
    bool steal(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long)

steal( (IndependentBBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool : insert fragment_data into pose at position seq_pos

C++ signature :
    bool steal(core::fragment::IndependentBBTorsionSRFD {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

steal( (IndependentBBTorsionSRFD)arg1, (Pose), (int)intra_frame_pos, (Frame)) -> bool :

C++ signature :
    bool steal(IndependentBBTorsionSRFD_exposer_callback {lvalue},core::pose::Pose,unsigned long,core::fragment::Frame)

type( (IndependentBBTorsionSRFD)arg1) -> str : core/fragment/BBTorsionSRFD.hh:148

C++ signature :
    std::string type(core::fragment::IndependentBBTorsionSRFD {lvalue})

type( (IndependentBBTorsionSRFD)arg1) -> str :

C++ signature :
    std::string type(IndependentBBTorsionSRFD_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (IndependentBBTorsionSRFDAP)arg1) -> IndependentBBTorsionSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (IndependentBBTorsionSRFDCAP)arg1) -> IndependentBBTorsionSRFD :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (JumpingFrame)) -> None : JumpingFrame, so far there is nothing special about JumpingFrames. but I think we might want to have additionally information like the start and end residues that belong to a certain jump_nr.! okay: right now I require that the creator of a JumpingFrame sets start to the start-residue of the jump

C++ signature :
    void __init__(_object*,core::fragment::JumpingFrame)

init( (object)arg1, (int)start, (int)end, (int)length) -> None : core/fragment/JumpingFrame.hh:128

C++ signature :
    void __init__(_object*,unsigned long,unsigned long,unsigned long)

align( (JumpingFrame)arg1, (SequenceMapping)map) -> bool : core/fragment/JumpingFrame.hh:106

C++ signature :
    bool align(core::fragment::JumpingFrame {lvalue},core::id::SequenceMapping)

align( (JumpingFrame)arg1, (SequenceMapping)map) -> bool :

C++ signature :
    bool align(JumpingFrame_exposer_callback {lvalue},core::id::SequenceMapping)

clone( (JumpingFrame)arg1) -> Frame : convience --- generate a matching FragData object dofs are unitialized! clone method, new frame with same alignment position, fragments are not copied!

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone(core::fragment::JumpingFrame {lvalue})

clone( (JumpingFrame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone(JumpingFrame_exposer_callback {lvalue})

clone_with_frags( (JumpingFrame)arg1) -> Frame : clone method, new frame with same alignment position, fragments are not copied!

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_frags(core::fragment::JumpingFrame {lvalue})

clone_with_frags( (JumpingFrame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_frags(JumpingFrame_exposer_callback {lvalue})

clone_with_template( (JumpingFrame)arg1) -> Frame : clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false )

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_template(core::fragment::JumpingFrame {lvalue})

clone_with_template( (JumpingFrame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_template(JumpingFrame_exposer_callback {lvalue})

is_continuous( (JumpingFrame)arg1) -> bool : true if frame is continuous

C++ signature :
    bool is_continuous(core::fragment::JumpingFrame {lvalue})

is_continuous( (JumpingFrame)arg1) -> bool :

C++ signature :
    bool is_continuous(JumpingFrame_exposer_callback {lvalue})

moves_residue( (JumpingFrame)arg1, (int)pos) -> bool : core/fragment/JumpingFrame.hh:82

C++ signature :
    bool moves_residue(core::fragment::JumpingFrame {lvalue},unsigned long)

moves_residue( (JumpingFrame)arg1, (int)pos) -> bool :

C++ signature :
    bool moves_residue(JumpingFrame_exposer_callback {lvalue},unsigned long)

read( (JumpingFrame)arg1, (std_istream)) -> None : core/fragment/JumpingFrame.hh:104

C++ signature :
    void read(core::fragment::JumpingFrame {lvalue},std::istream {lvalue})

read( (JumpingFrame)arg1, (std_istream)) -> None :

C++ signature :
    void read(JumpingFrame_exposer_callback {lvalue},std::istream {lvalue})

seqpos( (JumpingFrame)arg1, (int)intra_pos) -> int : translate intra-frame position into sequence position. (trivial for base-class)

C++ signature :
    unsigned long seqpos(core::fragment::JumpingFrame {lvalue},unsigned long)

seqpos( (JumpingFrame)arg1, (int)intra_pos) -> int :

C++ signature :
    unsigned long seqpos(JumpingFrame_exposer_callback {lvalue},unsigned long)

shift_by( (JumpingFrame)arg1, (int)offset) -> None : shift frame by offset relative to current start position ( change end accordingly )

C++ signature :
    void shift_by(core::fragment::JumpingFrame {lvalue},int)

shift_by( (JumpingFrame)arg1, (int)offset) -> None :

C++ signature :
    void shift_by(JumpingFrame_exposer_callback {lvalue},int)

shift_to( (JumpingFrame)arg1, (int)setting) -> None : shift to new start position ( change end accordingly )

C++ signature :
    void shift_to(core::fragment::JumpingFrame {lvalue},unsigned long)

shift_to( (JumpingFrame)arg1, (int)setting) -> None :

C++ signature :
    void shift_to(JumpingFrame_exposer_callback {lvalue},unsigned long)

show( (JumpingFrame)arg1, (OStream)) -> None : core/fragment/JumpingFrame.hh:103

C++ signature :
    void show(core::fragment::JumpingFrame {lvalue},std::ostream {lvalue})

show( (JumpingFrame)arg1, (OStream)) -> None :

C++ signature :
    void show(JumpingFrame_exposer_callback {lvalue},std::ostream {lvalue})

show_classic( (JumpingFrame)arg1, (OStream)out) -> None : core/fragment/Frame.hh:251

C++ signature :
    void show_classic(core::fragment::JumpingFrame {lvalue},std::ostream {lvalue})

show_classic( (JumpingFrame)arg1, (OStream)out) -> None :

C++ signature :
    void show_classic(JumpingFrame_exposer_callback {lvalue},std::ostream {lvalue})

show_header( (JumpingFrame)arg1, (OStream)out) -> None : core/fragment/Frame.hh:258

C++ signature :
    void show_header(core::fragment::JumpingFrame {lvalue},std::ostream {lvalue})

show_header( (JumpingFrame)arg1, (OStream)out) -> None :

C++ signature :
    void show_header(JumpingFrame_exposer_callback {lvalue},std::ostream {lvalue})

type( (JumpingFrame)arg1) -> str : core/fragment/JumpingFrame.hh:145

C++ signature :
    std::string type(core::fragment::JumpingFrame {lvalue})

type( (JumpingFrame)arg1) -> str :

C++ signature :
    std::string type(JumpingFrame_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (JumpingFrameAP)arg1) -> JumpingFrame :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (JumpingFrameCAP)arg1) -> JumpingFrame :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (int)start, (int)end, (int)length) -> None : core/fragment/JumpingFrame.hh:60

C++ signature :
    void __init__(_object*,unsigned long,unsigned long,unsigned long)

init( (object)arg1, (NonContinuousFrame)) -> None : JumpingFrame is a discontinuous frame i.e, the SRFDs stored in the FragData objects can be applied to residues anywhere a 5 7 9 Frame of a FragData containing three BBTorsionSRFDs would change torsions of 5 7 9 a 5 32 2 Frame of a FragData containing two BBTorsionSRFD and on JumpSRFD would change torsions of 5 and 32 and the RT of jump_nr 2 note that in the latter case the 2 is not coding for a residue number! what is meaning of start() and end() ? If some of the positions are actually jump_nr should we ignore them for the start() / end() question ? or should we store which positions are jumps and translate into residue numbers from jump_nr ? could a MixedFrame contain Frames MixedFrame -- > non-cont-Frame, JumpFrame

C++ signature :
    void __init__(_object*,core::fragment::NonContinuousFrame)

align( (NonContinuousFrame)arg1, (SequenceMapping)map) -> bool : core/fragment/JumpingFrame.hh:106

C++ signature :
    bool align(core::fragment::NonContinuousFrame {lvalue},core::id::SequenceMapping)

align( (NonContinuousFrame)arg1, (SequenceMapping)map) -> bool :

C++ signature :
    bool align(NonContinuousFrame_exposer_callback {lvalue},core::id::SequenceMapping)

clone( (NonContinuousFrame)arg1) -> Frame : clone method, new frame with same alignment position, fragments are not copied!

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone(core::fragment::NonContinuousFrame {lvalue})

clone( (NonContinuousFrame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone(NonContinuousFrame_exposer_callback {lvalue})

clone_with_frags( (NonContinuousFrame)arg1) -> Frame : clone method, new frame with same alignment position, fragments are not copied!

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_frags(core::fragment::NonContinuousFrame {lvalue})

clone_with_frags( (NonContinuousFrame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_frags(NonContinuousFrame_exposer_callback {lvalue})

clone_with_template( (NonContinuousFrame)arg1) -> Frame : clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false )

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_template(core::fragment::NonContinuousFrame {lvalue})

clone_with_template( (NonContinuousFrame)arg1) -> Frame :

C++ signature :
    boost::shared_ptr<core::fragment::Frame> clone_with_template(NonContinuousFrame_exposer_callback {lvalue})

is_continuous( (NonContinuousFrame)arg1) -> bool : true if frame is continuous

C++ signature :
    bool is_continuous(core::fragment::NonContinuousFrame {lvalue})

is_continuous( (NonContinuousFrame)arg1) -> bool :

C++ signature :
    bool is_continuous(NonContinuousFrame_exposer_callback {lvalue})

moves_residue( (NonContinuousFrame)arg1, (int)pos) -> bool : core/fragment/JumpingFrame.hh:82

C++ signature :
    bool moves_residue(core::fragment::NonContinuousFrame {lvalue},unsigned long)

moves_residue( (NonContinuousFrame)arg1, (int)pos) -> bool :

C++ signature :
    bool moves_residue(NonContinuousFrame_exposer_callback {lvalue},unsigned long)

read( (NonContinuousFrame)arg1, (std_istream)) -> None : core/fragment/JumpingFrame.hh:104

C++ signature :
    void read(core::fragment::NonContinuousFrame {lvalue},std::istream {lvalue})

read( (NonContinuousFrame)arg1, (std_istream)) -> None :

C++ signature :
    void read(NonContinuousFrame_exposer_callback {lvalue},std::istream {lvalue})

seqpos( (NonContinuousFrame)arg1, (int)intra_pos) -> int : translate intra-frame position into sequence position. (trivial for base-class)

C++ signature :
    unsigned long seqpos(core::fragment::NonContinuousFrame {lvalue},unsigned long)

seqpos( (NonContinuousFrame)arg1, (int)intra_pos) -> int :

C++ signature :
    unsigned long seqpos(NonContinuousFrame_exposer_callback {lvalue},unsigned long)

set_pos( (NonContinuousFrame)arg1, (int)intra_pos, (int)setting) -> None : assign sequence position or jump_nr to internal position pos

C++ signature : void set_pos(core::fragment::NonContinuousFrame {lvalue},unsigned long,unsigned long)

shift_by( (NonContinuousFrame)arg1, (int)offset) -> None : shift frame by offset relative to current start position ( change end accordingly )

C++ signature :
    void shift_by(core::fragment::NonContinuousFrame {lvalue},int)

shift_by( (NonContinuousFrame)arg1, (int)offset) -> None :

C++ signature :
    void shift_by(NonContinuousFrame_exposer_callback {lvalue},int)

shift_to( (NonContinuousFrame)arg1, (int)setting) -> None : shift to new start position ( change end accordingly )

C++ signature :
    void shift_to(core::fragment::NonContinuousFrame {lvalue},unsigned long)

shift_to( (NonContinuousFrame)arg1, (int)setting) -> None :

C++ signature :
    void shift_to(NonContinuousFrame_exposer_callback {lvalue},unsigned long)

show( (NonContinuousFrame)arg1, (OStream)) -> None : core/fragment/JumpingFrame.hh:103

C++ signature :
    void show(core::fragment::NonContinuousFrame {lvalue},std::ostream {lvalue})

show( (NonContinuousFrame)arg1, (OStream)) -> None :

C++ signature :
    void show(NonContinuousFrame_exposer_callback {lvalue},std::ostream {lvalue})

show_classic( (NonContinuousFrame)arg1, (OStream)out) -> None : core/fragment/Frame.hh:251

C++ signature :
    void show_classic(core::fragment::NonContinuousFrame {lvalue},std::ostream {lvalue})

show_classic( (NonContinuousFrame)arg1, (OStream)out) -> None :

C++ signature :
    void show_classic(NonContinuousFrame_exposer_callback {lvalue},std::ostream {lvalue})

show_header( (NonContinuousFrame)arg1, (OStream)out) -> None : core/fragment/Frame.hh:258

C++ signature :
    void show_header(core::fragment::NonContinuousFrame {lvalue},std::ostream {lvalue})

show_header( (NonContinuousFrame)arg1, (OStream)out) -> None :

C++ signature :
    void show_header(NonContinuousFrame_exposer_callback {lvalue},std::ostream {lvalue})

type( (NonContinuousFrame)arg1) -> str : type() is specifying the output name of the Frame in FragmentIO ("FRAME", "JUMPFRAME", etc)

C++ signature :
    std::string type(core::fragment::NonContinuousFrame {lvalue})

type( (NonContinuousFrame)arg1) -> str :

C++ signature :
    std::string type(NonContinuousFrame_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)