# File lib/bio/db/pdb/pdb.rb, line 286
      def self.continue?
        @cont
      end

# File lib/bio/db/pdb/pdb.rb, line 437
      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

# File lib/bio/db/pdb/pdb.rb, line 225
      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

# File lib/bio/db/pdb/pdb.rb, line 1388
      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

# File lib/bio/db/pdb/pdb.rb, line 256
      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

# File lib/bio/db/pdb/pdb.rb, line 243
      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

# File lib/bio/db/pdb/pdb.rb, line 279
      def self.symbols
        #p self
        @symbols
      end

# File lib/bio/db/pdb/pdb.rb, line 420
      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

# File lib/bio/db/pdb/pdb.rb, line 292
      def continue?
        self.class.continue?
      end

# File lib/bio/db/pdb/pdb.rb, line 340
      def do_parse
        return self if @parsed or !@str
        str = @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(str[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(str[r]) unless str[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
                r = ranges.first
                unless str[r].to_s.strip.empty?
                  #and concatenate the new data onto the old
                  v = klass.new(str[r])
                  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

# File lib/bio/db/pdb/pdb.rb, line 298
      def each_symbol
        self.class.symbols.each do |k, x|
          yield k, x[0], x[1]
        end
      end

# File lib/bio/db/pdb/pdb.rb, line 322
      def initialize_from_string(str)
        @str = str
        @record_name = fetch_record_name(str)
        @parsed = false
        self
      end

# File lib/bio/db/pdb/pdb.rb, line 455
      def inspect
        do_parse
        super
      end

# File lib/bio/db/pdb/pdb.rb, line 309
      def original_data
        if defined?(@cont_data) then
          [ @str, *@cont_data ]
        else
          [ @str ]
        end
      end

# File lib/bio/db/pdb/pdb.rb, line 407
      def record_name
        @record_name or self.class.to_s.split(/\:\:/)[-1].to_s.upcase
      end