Module _utility_

ReadFromFileOrDie( (str)filename, (str)contents) -> None :
    Reads the contents of <filename> into <contents>, preserving newline
    characters. Aborts if an error is encoutered.
    

    C++ signature :
        void ReadFromFileOrDie(std::string,std::string*)

add_spaces_left_align( (str)st, (int)newlen) -> None :
    adds spaces to a left aligned string until a given length is reached
    

    C++ signature :
        void add_spaces_left_align(std::string {lvalue},unsigned long)

add_spaces_right_align( (str)st, (int)newlen) -> None :
    adds spaces to a right aligned string until a given length is reached
    

    C++ signature :
        void add_spaces_right_align(std::string {lvalue},unsigned long)

code_from_6bit( (int)_8bit) -> int :
    utility/Binary_Util.hh:51

    C++ signature :
        unsigned char code_from_6bit(unsigned char)

code_to_6bit( (int)_6bit) -> int :
    ///////////////////////
    
      uuencode
    
    

    C++ signature :
        unsigned char code_to_6bit(unsigned char)

copysign( (float)x, (float)y) -> float :
    utility/numbers.hh:77

    C++ signature :
        double copysign(double,double)

decode6bit( (int)memory, (str)jar) -> int :
    utility/Binary_Util.hh:98

    C++ signature :
        int decode6bit(unsigned char*,std::string)

decode_32_to_24( (int)i0, (int)i1, (int)i2, (int)i3, (int)o0, (int)o1, (int)o2) -> None :
    utility/Binary_Util.hh:84

    C++ signature :
        void decode_32_to_24(unsigned char,unsigned char,unsigned char,unsigned char,unsigned char {lvalue},unsigned char {lvalue},unsigned char {lvalue})

encode6bit( (int)memory, (int)length, (str)jar) -> None :
    utility/Binary_Util.hh:95

    C++ signature :
        void encode6bit(unsigned char const*,unsigned int,std::string {lvalue})

encode_24_to_32( (int)i0, (int)i1, (int)i2, (int)o0, (int)o1, (int)o2, (int)o3) -> None :
    utility/Binary_Util.hh:68

    C++ signature :
        void encode_24_to_32(unsigned char,unsigned char,unsigned char,unsigned char {lvalue},unsigned char {lvalue},unsigned char {lvalue},unsigned char {lvalue})

endswith( (str)haystack, (str)needle) -> bool :
    True iff haystack ends with needle
    

    C++ signature :
        bool endswith(std::string,std::string)

file_basename( (str)full_path) -> str :
    utility/string_util.hh:148

    C++ signature :
        std::string file_basename(std::string)

file_contents( (str)file_name) -> str :
    Read the entire contents of a file into a string.  All end-of-line characters are replaced
    by "\n".  Throws a utility::excn::EXCN_msg_exception if the file cannot be opened.
    

    C++ signature :
        std::string file_contents(std::string)

filename( (str)path) -> str :
    utility/string_util.hh:152

    C++ signature :
        std::string filename(std::string)

get_num_digits( (int)value) -> int :
    utility/string_util.hh:307

    C++ signature :
        unsigned long get_num_digits(unsigned long)

get_resnum_and_chain( (str)s, (bool)string_is_ok) -> object :
    converts string like "1-3 20-22" or "A:1-5 B:20-22" to vectors containing resnums and chains.
    

    C++ signature :
        std::pair<std::vector<int, std::allocator<int> >, std::vector<char, std::allocator<char> > > get_resnum_and_chain(std::string,bool {lvalue})

get_resnum_and_chain_from_one_tag( (str)tag, (std_vector_int)resnum, (std_vector_char)chains) -> bool :
    helper function for get_resnum_and_chain
    

    C++ signature :
        bool get_resnum_and_chain_from_one_tag(std::string,std::vector<int, std::allocator<int> > {lvalue},std::vector<char, std::allocator<char> > {lvalue})

    Get a numeric value for Real that represents an "undefined" value
    

    C++ signature :
        double get_undefined_real()

Returns: float :

    Get a numeric value for Size that represents an "undefined" value
    

    C++ signature :
        unsigned long get_undefined_size()

Returns: int :

is_false_string( (str)value_str) -> bool :
    String accepted as a false value?
    

    C++ signature :
        bool is_false_string(std::string)

is_inf( (float)val) -> bool :
    utility/numbers.hh:67

    C++ signature :
        bool is_inf(double)

is_nan( (float)val) -> bool :
    utility/numbers.hh:62

    C++ signature :
        bool is_nan(double)

is_string_numeric( (str)input) -> bool :
    utility/string_util.hh:142

    C++ signature :
        bool is_string_numeric(std::string)

is_true_string( (str)value_str) -> bool :
    String accepted as a true value?
    

    C++ signature :
        bool is_true_string(std::string)

is_undefined( (float)val) -> bool :
    Check if a Real is undefined (i.e has the same value as utility::get_undefined_real() )
    

    C++ signature :
        bool is_undefined(double)

is_undefined( (int)val) -> bool :
    Check if a Size is undefined (i.e has the same value as utility::get_undefined_size() )
    

    C++ signature :
        bool is_undefined(unsigned long)

join( (str)string_w_spaces, (str)connector) -> str :
    join space separations in a string with a connector such as '_'
    

    C++ signature :
        std::string join(std::string,std::string)

join( (std_vector_string)s, (str)connector) -> str :
    combine strings with anything
    

    C++ signature :
        std::string join(std::vector<std::string, std::allocator<std::string> >,std::string)

join( (vector1_string)s, (str)connector) -> str :
    combine strings with anything
    

    C++ signature :
        std::string join(utility::vector1<std::string, std::allocator<std::string> >,std::string)

make_tag( (vector1_int)res_vector) -> str :
    utility/string_util.hh:293

    C++ signature :
        std::string make_tag(utility::vector1<int, std::allocator<int> >)

make_tag_with_dashes( (vector1_int)res_vector, (vector1_char)chain_vector [, (str)delimiter=' ']) -> str :
    utility/string_util.hh:290

    C++ signature :
        std::string make_tag_with_dashes(utility::vector1<int, std::allocator<int> >,utility::vector1<char, std::allocator<char> > [,char=' '])

make_tag_with_dashes( (vector1_int)res_vector [, (str)delimiter=' ']) -> str :
    Compactifies vectors of ints:  1 2 3 9 10 11 to "1-3 9-11"
    

    C++ signature :
        std::string make_tag_with_dashes(utility::vector1<int, std::allocator<int> > [,char=' '])

max( (float)a, (float)b) -> float :
    max( long double, long double )
    

    C++ signature :
        long double max(long double,long double)

max( (float)a, (float)b) -> float :
    max( double, double )
    

    C++ signature :
        double max(double,double)

max( (float)a, (float)b) -> float :
    max( float, float )
    

    C++ signature :
        float max(float,float)

max( (int)a, (int)b) -> int :
    max( unsigned long int, unsigned long int )
    

    C++ signature :
        unsigned long max(unsigned long,unsigned long)

max( (int)a, (int)b) -> int :
    max( unsigned int, unsigned int )
    

    C++ signature :
        unsigned int max(unsigned int,unsigned int)

max( (int)a, (int)b) -> int :
    max( unsigned short int, unsigned short int )
    

    C++ signature :
        unsigned short max(unsigned short,unsigned short)

max( (int)a, (int)b) -> int :
    max( long int, long int )
    

    C++ signature :
        long max(long,long)

max( (int)a, (int)b) -> int :
    max( int, int )
    

    C++ signature :
        int max(int,int)

max( (int)a, (int)b) -> int :
    max( short int, short int )
    

    C++ signature :
        short max(short,short)

min( (float)a, (float)b) -> float :
    min( long double, long double )
    

    C++ signature :
        long double min(long double,long double)

min( (float)a, (float)b) -> float :
    min( double, double )
    

    C++ signature :
        double min(double,double)

min( (float)a, (float)b) -> float :
    min( float, float )
    

    C++ signature :
        float min(float,float)

min( (int)a, (int)b) -> int :
    min( unsigned long int, unsigned long int )
    

    C++ signature :
        unsigned long min(unsigned long,unsigned long)

min( (int)a, (int)b) -> int :
    min( unsigned int, unsigned int )
    

    C++ signature :
        unsigned int min(unsigned int,unsigned int)

min( (int)a, (int)b) -> int :
    min( unsigned short int, unsigned short int )
    

    C++ signature :
        unsigned short min(unsigned short,unsigned short)

min( (int)a, (int)b) -> int :
    min( long int, long int )
    

    C++ signature :
        long min(long,long)

min( (int)a, (int)b) -> int :
    min( int, int )
    

    C++ signature :
        int min(int,int)

min( (int)a, (int)b) -> int :
    min( short int, short int )
    

    C++ signature :
        short min(short,short)

    utility/mpi_util.hh:35

    C++ signature :
        int mpi_nprocs()

Returns: int :

    utility/mpi_util.hh:32

    C++ signature :
        int mpi_rank()

Returns: int :

pathname( (str)path) -> str :
    utility/string_util.hh:155

    C++ signature :
        std::string pathname(std::string)

py_xdec_ref( (object)arg1) -> None :

    C++ signature :
        void py_xdec_ref(_object*)

py_xinc_ref( (object)arg1) -> None :

    C++ signature :
        void py_xinc_ref(_object*)

    utility/basic_sys_util.hh:34

    C++ signature :
        void rand_sleep()

Returns: None :

receive_char_from_node( (int)source) -> str :
    Use MPI to receive a single char from a particular node.
    

    C++ signature :
        char receive_char_from_node(int)

receive_double_from_node( (int)source) -> float :
    Use MPI to receive a single double from a particular node.
    

    C++ signature :
        double receive_double_from_node(int)

receive_doubles_from_node( (int)source) -> vector1_Real :
    Use MPI to receive a vector of doubles from a particular node.
    

    C++ signature :
        utility::vector1<double, std::allocator<double> > receive_doubles_from_node(int)

    Use MPI to wait until some node sends an integer -- usually its own mpi_rank
    so that it can send further messages.
    

    C++ signature :
        int receive_integer_from_anyone()

Returns: int :

receive_integer_from_node( (int)source) -> int :
    Use MPI to receive a single integer from a particular node.
    

    C++ signature :
        int receive_integer_from_node(int)

receive_integers_from_node( (int)source) -> vector1_int :
    Use MPI to receive a vector of integers from a particular node.
    

    C++ signature :
        utility::vector1<int, std::allocator<int> > receive_integers_from_node(int)

receive_string_from_node( (int)source) -> str :
    Use MPI to receive a string from a particular node.
    

    C++ signature :
        std::string receive_string_from_node(int)

replace_environment_variables( (str)input) -> str :
    find all environment variables with the form ${VARIABLE}
    and replace with the contents of that environment variable.
    if the environment variable does not exist, return string::npos
    

    C++ signature :
        std::string replace_environment_variables(std::string)

replace_in( (str)name_in, (str)find_string, (str)replace_string) -> str :
    find/replace strings within input string.
    

    C++ signature :
        std::string replace_in(std::string,std::string,std::string)

replace_in( (str)s, (str)from, (str)to) -> None :
    utility/string_util.hh:178

    C++ signature :
        void replace_in(std::string {lvalue},char,char const*)

round( (float)val) -> float :
    utility/numbers.hh:72

    C++ signature :
        double round(double)

same_ignoring_spaces( (str)s1, (str)s2) -> bool :
    Compares two strings, ignoring spaces.  Useful for comparing atom
    name strings which have pdb-alignment built into them.  Slightly dangerous
    if you consider the fact that atom names in the PDB are different for
    different indentation rules: ' CA ' is c-alpha.  'CA  ' is calcium.
    

    C++ signature :
        bool same_ignoring_spaces(std::string,std::string)

send_char_to_node( (int)destination, (str)message) -> None :
    utility/mpi_util.hh:54

    C++ signature :
        void send_char_to_node(int,char)

send_double_to_node( (int)destination, (float)message) -> None :
    utility/mpi_util.hh:75

    C++ signature :
        void send_double_to_node(int,double)

send_doubles_to_node( (int)destination, (vector1_Real)message) -> None :
    utility/mpi_util.hh:82

    C++ signature :
        void send_doubles_to_node(int,utility::vector1<double, std::allocator<double> >)

send_integer_to_node( (int)destination, (int)message) -> None :
    utility/mpi_util.hh:61

    C++ signature :
        void send_integer_to_node(int,int)

send_integers_to_node( (int)destination, (vector1_int)message) -> None :
    utility/mpi_util.hh:68

    C++ signature :
        void send_integers_to_node(int,utility::vector1<int, std::allocator<int> >)

send_string_to_node( (int)source, (str)message) -> None :
    utility/mpi_util.hh:47

    C++ signature :
        void send_string_to_node(int,std::string)

    C++ signature :
        void set_pyexit_callback()

Returns: None :

slurp( (std_istream)in, (str)out) -> None :
    utility/string_util.hh:123

    C++ signature :
        void slurp(std::istream {lvalue},std::string {lvalue})

split( (str)s) -> vector1_string :
    split given std::string using ' ' symbol.
    

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > split(std::string)

split_to_list( (str)s) -> object :
    split given std::string using ' ' symbol.
    

    C++ signature :
        std::list<std::string, std::allocator<std::string> > split_to_list(std::string)

split_to_set( (str)s) -> set_string :
    split given std::string to a set using ' ' symbol.
    

    C++ signature :
        std::set<std::string, std::less<std::string>, std::allocator<std::string> > split_to_set(std::string)

split_whitespace( (str)s) -> vector1_string :
    split given std::string using whitespace as a separator.
    Unlike string_split_multi_delim(), any group of mixed whitespace counts only as a single seperator.
    

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > split_whitespace(std::string)

startswith( (str)haystack, (str)needle) -> bool :
    True iff haystack starts with needle
    

    C++ signature :
        bool startswith(std::string,std::string)

string2Real( (str)st) -> float :
    convert a string to a Real, returns numeric::get_undefined_real() on failure
    

    C++ signature :
        double string2Real(std::string)

string2Size( (str)st) -> int :
    convert a string to a Size, returns numeric::get_undefined_size() on failure
    

    C++ signature :
        unsigned long string2Size(std::string)

string2float( (str)st) -> float :
    convert a string to a float, returns -1 on failure
    

    C++ signature :
        float string2float(std::string)

string2int( (str)st) -> int :
    convert a string to an int, returns -1 on failure
    

    C++ signature :
        int string2int(std::string)

string2uint( (str)x, (int)y) -> None :
    utility/string_util.hh:115

    C++ signature :
        void string2uint(std::string,unsigned int*)

string_split( (str)in [, (str)splitchar=' ']) -> vector1_string :
    split to vector1< std::string > using arbitrary split character
    

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > string_split(std::string [,char=' '])

string_split_multi_delim( (str)in [, (str)splitchars=' \t']) -> vector1_string :
    split to vector< std::string > using any of arbitrary split characters
    

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > string_split_multi_delim(std::string [,std::string=' \t'])

string_split_simple( (str)in [, (str)splitchar=' ']) -> vector1_string :
    split to vector1< std::string > using arbitrary split character, but no empty strings (closer to python string::split)
    

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > string_split_simple(std::string [,char=' '])

string_to_sha1( (str)input_string) -> str :
    utility/string_util.hh:175

    C++ signature :
        std::string string_to_sha1(std::string)

swap4_aligned( (object)v, (int)ndata) -> None :
    ////////////////////////////////
    

    C++ signature :
        void swap4_aligned(void*,long)

sys_sleep( (float)seconds) -> None :
    Sleep for a specified number of seconds
    

    C++ signature :
        void sys_sleep(double)

    Generate timestamp string
    

    C++ signature :
        std::string timestamp()

Returns: str :

    Generate timestamp string, short format
    

    C++ signature :
        std::string timestamp_short()

Returns: str :

trim( (str)s [, (str)drop=' ']) -> str :
    create a new string that drops all the unwanted substrings of
    the original string.
    

    C++ signature :
        std::string trim(std::string [,std::string=' '])

trim( (str)s [, (str)drop=' ']) -> None :
    utility/string_util.hh:125

    C++ signature :
        void trim(std::string {lvalue} [,std::string=' '])

trimmed_compare( (str)s1, (str)s2) -> bool :
    compares two strings ignoring leading and trailing spaces
    

    C++ signature :
        bool trimmed_compare(std::string,std::string)

smpi_char

Value:

rosetta.utility._utility_.simulate_mpi_message_type.smpi_char

smpi_double

Value:

rosetta.utility._utility_.simulate_mpi_message_type.smpi_double

smpi_doubles

Value:

rosetta.utility._utility_.simulate_mpi_message_type.smpi_doubles

smpi_integer

Value:

rosetta.utility._utility_.simulate_mpi_message_type.smpi_integer

smpi_integers

Value:

rosetta.utility._utility_.simulate_mpi_message_type.smpi_integers

smpi_string

Value:

rosetta.utility._utility_.simulate_mpi_message_type.smpi_string