Struct
The ancestor of every single PDB record class. It inherits Struct class. Basically, each line of a PDB file corresponds to an instance of each corresponding child class. If continuation exists, multiple lines may correspond to single instance.
ANISOU record class
ATOM record class
AUTHOR record class
CAVEAT record class
CISPEP record class
COMPND record class
CONECT record class
CRYST1 record class
DBREF record class
default (or unknown) record class
definitions (hash)
ENDMDL record class
EXPDTA record class
END record class.
Because END is a reserved word of Ruby, it is separately added to the hash
FORMUL record class
HEADER record class
HELIX record class
HET record class
HETATM record class
HETNAM record class
HETSYN record class
HYDBND record class
‘JRNL’ is defined below
KEYWDS record class
LINK record class
MASTER record class
MODEL record class
MODRS record class
MTRIX1 record class
MTRIXn n=1,2, or 3
MTRIX2 record class
MTRIX3 record class
OBSLTE record class
ORIGX1 record class
ORIGXn n=1, 2, or 3
ORIGX2 record class
ORIGX3 record class
‘REMARK’ is defined below
REVDAT record class
SCALE1 record class
SCALEn n=1, 2, or 3
SCALE2 record class
SCALE3 record class
SEQADV record class
SEQRES record class
SHEET record class
SIGATM record class
SIGUIJ record class
SITE record class
SLTBRG record class
SOURCE record class
SPRSDE record class
SSBOND record class
TER record class
TITLE record class
TURN record class
TVECT record class
Returns true if this record has a field type which allows continuations.
# File lib/bio/db/pdb/pdb.rb, line 287 def self.continue? @cont end
creates definition hash from current classes constants
# File lib/bio/db/pdb/pdb.rb, line 438 def self.create_definition_hash hash = {} constants.each do |x| x = x.intern # keep compatibility both Ruby 1.8 and 1.9 hash[x] = const_get(x) if /\A[A-Z][A-Z0-9]+\z/ =~ x.to_s end if x = const_get(:Default) then hash.default = x end hash end
Creates new class by given field definition The difference from new_direct() is the class created by the method does lazy evaluation.
Internal use only.
# File lib/bio/db/pdb/pdb.rb, line 226 def self.def_rec(*ary) symbolhash, symbolary, cont = parse_field_definitions(ary) klass = Class.new(self.new(*symbolary)) klass.module_eval { @definition = ary @symbols = symbolhash @cont = cont } klass.module_eval { symbolary.each do |x| define_method(x) { do_parse; super() } end } klass end
Basically just look up the class in Definition hash do some munging for JRNL and REMARK
# File lib/bio/db/pdb/pdb.rb, line 1389 def self.get_record_class(str) t = fetch_record_name(str) t = t.intern unless t.empty? if d = Definition[t] then return d end case t when :JRNL ts = str[12..15].to_s.strip ts = ts.intern unless ts.empty? d = Jrnl::Definition[ts] when :REMARK case str[7..9].to_i when 1 ts = str[12..15].to_s.strip ts = ts.intern unless ts.empty? d = Remark1::Definition[ts] when 2 if str[28..37] == 'ANGSTROMS.' then d = Remark2::ANGSTROMS elsif str[22..37] == ' NOT APPLICABLE.' then d = Remark2::NOT_APPLICABLE else d = Remark2::Default end else d = RemarkN end else # unknown field d = Default end return d end
Creates new class by given field definition.
Internal use only.
# File lib/bio/db/pdb/pdb.rb, line 257 def self.new_direct(*ary) symbolhash, symbolary, cont = parse_field_definitions(ary) if cont raise 'continuation not allowed. please use def_rec instead' end klass = Class.new(self.new(*symbolary)) klass.module_eval { @definition = ary @symbols = symbolhash @cont = cont } klass.module_eval { define_method(:initialize_from_string) { |str| r = super(str) do_parse r } } klass end
creates new class which inherits given class.
# File lib/bio/db/pdb/pdb.rb, line 244 def self.new_inherit(klass) newklass = Class.new(klass) newklass.module_eval { @definition = klass.module_eval { @definition } @symbols = klass.module_eval { @symbols } @cont = klass.module_eval { @cont } } newklass end
Internal use only.
Adds continuation data to the record from str if str is really the continuation of current record. Returns self (= not nil) if str is the continuation. Otherwaise, returns false.
# File lib/bio/db/pdb/pdb.rb, line 421 def add_continuation(str) #Check that this record can continue #and that str has the same type and definition return false unless self.continue? return false unless fetch_record_name(str) == @record_name return false unless self.class.get_record_class(str) == self.class return false unless fetch_cont(str) >= 2 #If all this is OK then add onto @cont_data unless defined?(@cont_data) @cont_data = [] end @cont_data << str # Returns self (= not nil) if succeeded. self end
Returns true if this record has a field type which allows continuations.
# File lib/bio/db/pdb/pdb.rb, line 293 def continue? self.class.continue? end
In order to speeding up processing of PDB file format, fields have not been parsed before calling this method.
Normally, it is automatically called and you don’t explicitly need to call it .
# File lib/bio/db/pdb/pdb.rb, line 341 def do_parse return self if @parsed or !@str str0 = @str each_symbol do |key, klass, ranges| #If we only have one range then pull that out #and store it in the hash if ranges.size <= 1 then self[key] = klass.new(str0[ranges.first]) else #Go through each range and add the string to an array #set the hash key to point to that array ary = [] ranges.each do |r| ary << klass.new(str0[r]) unless str0[r].to_s.strip.empty? end self[key] = ary end end #each_symbol #If we have continuations then for each line of extra data... if defined?(@cont_data) then @cont_data.each do |str| #Get the symbol, type and range array each_symbol do |key, klass, ranges| #If there's one range then grab that range if ranges.size <= 1 then r1 = ranges.first unless str[r1].to_s.strip.empty? #and concatenate the new data onto the old v = klass.new(str[r1]) self[key].concat(v) if self[key] != v end else #If there's more than one range then add to the array ary = self[key] ranges.each do |r| ary << klass.new(str[r]) unless str[r].to_s.strip.empty? end end end end end @parsed = true self end
yields the symbol(k), type(x) and array of ranges of each symbol.
# File lib/bio/db/pdb/pdb.rb, line 299 def each_symbol self.class.symbols.each do |k, x| yield k, x[0], x[1] end end
initialize this record from the given string. str must be a line (in PDB format).
You can add continuation lines later using add_continuation method.
# File lib/bio/db/pdb/pdb.rb, line 323 def initialize_from_string(str) @str = str @record_name = fetch_record_name(str) @parsed = false self end
Return original string (except that “n” are truncated) for this record (usually just @str, but sometimes add on the continuation data from other lines. Returns an array of string.
# File lib/bio/db/pdb/pdb.rb, line 310 def original_data if defined?(@cont_data) then [ @str, *@cont_data ] else [ @str ] end end
Record name of this record, e.g. "HEADER", "ATOM".
# File lib/bio/db/pdb/pdb.rb, line 408 def record_name @record_name or self.class.to_s.split(/\:\:/)[-1].to_s.upcase end
Generated with the Darkfish Rdoc Generator 2.