Class: Palm::PDB

Inherits:
Object
  • Object
show all
Defined in:
lib/palm/pdb.rb

Overview

PDB handles reading and writing raw Palm PDB records and resources. For most cases, users will probably want to extend this class class, overriding pack_entry and unpack_entry to support their record types.

Records are simply stored as an array in data, so polish up on your enumerable tricks. The created_at, modified_at, and backed_up_at attributes are all stored as Times. Note that modified_at is not automatically updated.

Direct Known Subclasses

WabaDB

Constant Summary collapse

HEADER_LENGTH =

Size of database header

32+2+2+(9*4)
RECORD_INDEX_HEADER_LEN =

Size of record index header

6
INDEX_RECORD_LENGTH =

Length of record index entry

8
INDEX_RESOURCE_LENGTH =

Length of resource index entry

10
ATTRIBUTE_CODES = 
{
  "resource" =>      0x0001,
  "read-only" =>     0x0002,
  "AppInfo dirty" => 0x0004,
  "backup" =>        0x0008,
  "OK newer" =>      0x0010,
  "reset"   =>          0x0020,
  "launchable" =>    0x0200,
  "open" =>          0x8000,
  
  # PalmOS 5.0 attribute names

  "ResDB" =>           0x0001,
  "ReadOnly" =>          0x0002,
  "AppInfoDirty" =>      0x0004,
  "Backup" =>          0x0008,
  "OKToInstallNewer" =>  0x0010,
  "ResetAfterInstall"=> 0x0020,
  "LaunchableData" =>  0x0200,
  "Recyclable" =>      0x0400,
  "Bundle" =>          0x0800,
  "Open" =>            0x8000,
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(from = nil) ⇒ PDB

Creates a new PDB. If from is passed a String, a file will be loaded from that path (see load_file). If a IO object is passed in, then it will be used to load the palm data (see load).



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/palm/pdb.rb', line 68

def initialize(from = nil)
  @attributes = {}
  @data = []
  @appinfo_block = nil
  @sort_block = nil
  @backed_up_at = @created_at = @modified_at = Time.now
  
  case from
  when NilClass
    now = Time.now
    @created_at   = now
    @modified_at  = now
    @version  = 0
    @modnum   = 0
    @type   = "\0\0\0\0"
    @creator  = "\0\0\0\0"
    @unique_id_seed = 0
  when String
    load(open(from))
  when IO
    load(from)
  else
    raise ArgumentError.new("Unknown value to load from #{from.inspect}.  Use a String or IO object.")
  end
end

Instance Attribute Details

#attributes ⇒ Object

Returns the value of attribute attributes.



31
32
33
 
# File 'lib/palm/pdb.rb', line 31

def attributes
  @attributes
end

#backed_up_at ⇒ Object

Returns the value of attribute backed_up_at.



32
33
34
 
# File 'lib/palm/pdb.rb', line 32

def backed_up_at
  @backed_up_at
end

#created_at ⇒ Object

Returns the value of attribute created_at.



32
33
34
 
# File 'lib/palm/pdb.rb', line 32

def created_at
  @created_at
end

#creator ⇒ Object

Returns the value of attribute creator.



33
34
35
 
# File 'lib/palm/pdb.rb', line 33

def creator
  @creator
end

#data ⇒ Object

Returns the value of attribute data.



35
36
37
 
# File 'lib/palm/pdb.rb', line 35

def data
  @data
end

#modified_at ⇒ Object

Returns the value of attribute modified_at.



32
33
34
 
# File 'lib/palm/pdb.rb', line 32

def modified_at
  @modified_at
end

#modnum ⇒ Object

Returns the value of attribute modnum.



33
34
35
 
# File 'lib/palm/pdb.rb', line 33

def modnum
  @modnum
end

#name ⇒ Object

Returns the value of attribute name.



31
32
33
 
# File 'lib/palm/pdb.rb', line 31

def name
  @name
end

#type ⇒ Object

Returns the value of attribute type.



33
34
35
 
# File 'lib/palm/pdb.rb', line 33

def type
  @type
end

#unique_id_seed ⇒ Object

Returns the value of attribute unique_id_seed.



34
35
36
 
# File 'lib/palm/pdb.rb', line 34

def unique_id_seed
  @unique_id_seed
end

#version ⇒ Object

Returns the value of attribute version.



31
32
33
 
# File 'lib/palm/pdb.rb', line 31

def version
  @version
end

Instance Method Details

#load(io) ⇒ Object

Loads the PDB from the given IO source.



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/palm/pdb.rb', line 107

def load(io)
  # Set to binary mode for windows environment

  io.binmode if io.respond_to? :binmode
  
  start_postion = io.pos
  io.seek(0, IO::SEEK_END)
  io_size = io.pos
  io.seek(start_postion)
  
  appinfo_offset, sort_offset = unpack_header(io.read(HEADER_LENGTH))
  
  # parse the record index

  record_index = io.read(RECORD_INDEX_HEADER_LEN)
  next_index, record_count = record_index.unpack("N n")
  
  # load the indexes, gather information about offsets and

  # record lengths

  indexes = nil
  if resource?
    indexes = load_resource_index(io, next_index, record_count)
  else
    indexes = load_record_index(io, next_index, record_count)
  end
  # Add the final offset as a Datablock for the end of the file

  indexes << DataBlock.new(io_size, 0)
  # Fill in the lengths for each of these index entries 

  indexes.each_cons(2){|starts, ends| starts.record_length = ends.offset - starts.offset }
  # Calculate where the data starts (or end of file if empty)

  data_offset = indexes.first.offset
  
  # Pop the last entry back off.  We pushed it on make it easier to calculate the lengths

  # of each entry.

  indexes.pop
  
  # Load optional chunks

  load_appinfo_block(io, appinfo_offset, sort_offset, data_offset) if appinfo_offset > 0
  load_sort_block(io, sort_offset, data_offset) if sort_offset > 0
  
  # Load data

  load_data(io, indexes)
  io.close
end

#load_file(path) ⇒ Object

Loads the PDB from a file path



100
101
102
103
104
 
# File 'lib/palm/pdb.rb', line 100

def load_file(path)
  open path, "r" do |io|
    load io
  end
end

#resource? ⇒ Boolean

Returns true if the PDB is a set of resources, false if it is a set of records

Returns:

  • (Boolean) 


95
96
97
 
# File 'lib/palm/pdb.rb', line 95

def resource?
  @attributes['resource'] || @attributes['ResDB']
end

#write(io) ⇒ Object

Writes PDB to an IO object



270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
# File 'lib/palm/pdb.rb', line 270

def write(io)   
  io.binmode if io.respond_to? :binmode
  
  # Track the current offset for each section

  offset_position = HEADER_LENGTH + 2 #(2: Index Header length)

  
  index_length = RECORD_INDEX_HEADER_LEN + 
    @data.length * (resource? ? INDEX_RESOURCE_LENGTH : INDEX_RECORD_LENGTH )
  
  offset_position += index_length  # Advance for the index

  
  packed_entries = @data.map{|e| pack_entry(e)}
  
  packed_app_info = pack_app_info_block()
  packed_sort =    pack_sort_block()
  
  # Calculate AppInfo block offset

  app_info_offset = 0
  if packed_app_info and !packed_app_info.empty?
    app_info_offset = offset_position
    offset_position += packed_app_info.length # Advance for the app_info_block

  end
  
  # Calculate sort block offset

  sort_offset = 0
  if packed_sort and !packed_sort.empty?
    sort_offset = offset_position
    offset_position += packed_sort.length # Advance for the sort_block

  end
  
  packed_header = pack_header(app_info_offset, sort_offset)
  
  index_header = [0, @data.length ].pack "N n"

  packed_index = @data.zip(packed_entries).map do |entry, packed|
    index = nil
    if resource?
      index = [entry.record_type, entry.record_id, offset_position].pack "a4 n N"
    else
      index = [
        offset_position, entry.packed_attributes,
        (entry.record_id >> 16) & 0xff,
        (entry.record_id >> 8) & 0xff,
        entry.record_id & 0xff
      ].pack "N C C3"
    end
    offset_position += packed.length
    index
  end
  
  # Write to IO stream

  io << packed_header
  io << index_header
  io << packed_index.join
  io << "\0\0" # 2 null byte separator

  io << @app_info_block unless app_info_offset == 0
  io << @sort_block unless sort_offset == 0
  io << packed_entries.join
end

#write_file(path) ⇒ Object

Writes to the given path



263
264
265
266
267
 
# File 'lib/palm/pdb.rb', line 263

def write_file(path)
  open(path, "w") do |io| 
    write io
  end
end