Actions

Copy link

Feature #1436

closed

Please consider this addition to resolv.rb which adds methods for resolving LOC resources

Feature #1436: Please consider this addition to resolv.rb which adds methods for resolving LOC resources

Added by jabo (JB Smith) over 16 years ago. Updated over 12 years ago.

Status:

Closed

Assignee:

akr (Akira Tanaka)

Target version:

2.6

[ruby-core:23361]

Description

=begin
Please consider this diff which would add support to resolv.rb to permit parsing of LOC resources.
I would welcome any criticism or guidance that would make this more suitable for inclusion.
Regards,

JB Smith

Index: lib/resolv.rb¶

--- lib/resolv.rb (revision 23349)
+++ lib/resolv.rb (working copy)
@@ -1835,6 +1835,97 @@
end

##

```
 # Location resource
```
```
 class LOC < Resource
```
```
   TypeValue = 29 # :nodoc:
```

   def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude)

```
     @version    = version
```

     @ssize      = Resolv::LOC::Size.create(ssize)

     @hprecision = Resolv::LOC::Size.create(hprecision)

     @vprecision = Resolv::LOC::Size.create(vprecision)

     @latitude   = Resolv::LOC::Coord.create(latitude)

     @longitude  = Resolv::LOC::Coord.create(longitude)

     @altitude   = Resolv::LOC::Alt.create(altitude)

```
   end
```
```
   ##
```

   # Returns the version value for this LOC record which should always be 00

```
   attr_reader :version
```
```
   ##
```
```
   # The spherical size of this LOC
```

   # in meters using scientific notation as 2 integers of XeY

```
   attr_reader :ssize
```
```
   ##
```

   # The horizontal precision using ssize type values

   # in meters using scientific notation as 2 integers of XeY

   # for precision use value/2 e.g. 2m = +/-1m

```
   attr_reader :hprecision
```
```
   ##
```

   # The vertical precision using ssize type values

   # in meters using scientific notation as 2 integers of XeY

   # for precision use value/2 e.g. 2m = +/-1m

```
   attr_reader :vprecision
```
```
   ##
```

   # The latitude for this LOC where 2**31 is the equator

   # in thousandths of an arc second as an unsigned 32bit integer

```
   attr_reader :latitude
```
```
   ##
```

   # The longitude for this LOC where 2**31 is the prime meridian

   # in thousandths of an arc second as an unsigned 32bit integer

```
   attr_reader :longitude
```
```
   ##
```

   # The altitude of the LOC above a reference sphere whose surface sits 100km below the WGS84 spheroid

   # in centimeters as an unsigned 32bit integer

```
   attr_reader :altitude
```
```
   def encode_rdata(msg) # :nodoc:
```
```
     msg.put_bytes(@version)
```
```
     msg.put_bytes(@ssize.scalar)
```
```
     msg.put_bytes(@hprecision.scalar)
```
```
     msg.put_bytes(@vprecision.scalar)
```

     msg.put_bytes(@latitude.coordinates)

     msg.put_bytes(@longitude.coordinates)

```
     msg.put_bytes(@altitude.altitude)
```
```
   end
```

   def self.decode_rdata(msg) # :nodoc:

```
     version    = msg.get_bytes(1)
```
```
     ssize      = msg.get_bytes(1)
```
```
     hprecision = msg.get_bytes(1)
```
```
     vprecision = msg.get_bytes(1)
```
```
     latitude   = msg.get_bytes(4)
```
```
     longitude  = msg.get_bytes(4)
```
```
     altitude   = msg.get_bytes(4)
```
```
     return self.new(
```
```
       version, 
```
```
       Resolv::LOC::Size.new(ssize), 
```

       Resolv::LOC::Size.new(hprecision),

       Resolv::LOC::Size.new(vprecision),

       Resolv::LOC::Coord.new(latitude,"lat"),

       Resolv::LOC::Coord.new(longitude,"lon"),

```
       Resolv::LOC::Alt.new(altitude)
```
```
     )
```
```
   end
```
```
 end
```

 ##
 # A Query type requesting any RR.

 class ANY < Query

@@ -1842,7 +1933,7 @@
end

    ClassInsensitiveTypes = [ # :nodoc:

   NS, CNAME, SOA, PTR, HINFO, MINFO, MX, TXT, ANY

   NS, CNAME, SOA, PTR, HINFO, MINFO, MX, TXT, LOC, ANY
 ]

 ##

@@ -2260,6 +2351,223 @@
end
end

module LOC
A Resolv::LOC::Size¶
class Size
```
 Regex = /^(\d+\.*\d*)[m]$/
```
```
 ##
```

 # Creates a new LOC::Size from +arg+ which may be:

```
 #
```
```
 # LOC::Size:: returns +arg+.
```

 # String:: +arg+ must match the LOC::Size::Regex constant

```
 def self.create(arg)
```
```
   case arg
```
```
   when Size
```
```
     return arg
```
```
   when String
```
```
     scalar = ''
```
```
     if Regex =~ arg
```

       scalar = [(($1.to_f*(1e2)).to_i.to_s[0].to_i*(2**4)+(($1.to_f*(1e2)).to_i.to_s.length-1))].pack("C")

```
     else
```

       raise ArgumentError.new("not a properly formed Size string: " + arg)

```
     end
```
```
     return Size.new(scalar) 
```
```
   else
```

     raise ArgumentError.new("cannot interpret as Size: #{arg.inspect}")

```
   end
```
```
 end
```
```
 def initialize(scalar)
```
```
   @scalar = scalar
```
```
 end
```
```
 ##
```
```
 # The raw size
```
```
 attr_reader :scalar
```
```
 def to_s # :nodoc:
```
```
   s = @scalar.unpack("H2").join.to_s
```

   return ((s[0].to_i)*(10**(s[1].to_i-2))).to_s << "m"

```
 end
```
```
 def inspect # :nodoc:
```

   return "#<#{self.class} #{self.to_s}>"

```
 end
```
```
 def ==(other) # :nodoc:
```
```
   return @scalar == other.scalar
```
```
 end
```
```
 def eql?(other) # :nodoc:
```
```
   return self == other
```
```
 end
```
```
 def hash # :nodoc:
```
```
   return @scalar.hash
```
```
 end
```
end
A Resolv::LOC::Coord¶
class Coord

 Regex = /^(\d+)\s(\d+)\s(\d+\.\d+)\s([NESW])$/

```
 ##
```

 # Creates a new LOC::Coord from +arg+ which may be:

```
 #
```
```
 # LOC::Coord:: returns +arg+.
```

 # String:: +arg+ must match the LOC::Coord::Regex constant

```
 def self.create(arg)
```
```
   case arg
```
```
   when Coord
```
```
     return arg
```
```
   when String
```
```
     coordinates = ''
```
```
     if Regex =~ arg &&  $1<180
```

       hemi = ($4[/([NE])/,1]) || ($4[/([SW])/,1]) ? 1 : -1

       coordinates = [(($1.to_i*(36e5))+($2.to_i*(6e4))+($3.to_f*(1e3)))*hemi+(2**31)].pack("N")

       (orientation ||= '') << $4[[/NS/],1] ? 'lat' : 'lon'

```
     else
```

       raise ArgumentError.new("not a properly formed Coord string: " + arg)

```
     end
```

     return Coord.new(coordinates,orientation)

```
   else
```

     raise ArgumentError.new("cannot interpret as Coord: #{arg.inspect}")

```
   end
```
```
 end
```

 def initialize(coordinates,orientation)

```
   unless coordinates.kind_of?(String)
```

     raise ArgumentError.new("Coord must be a 32bit unsigned integer in hex format: #{coordinates.inspect}")

```
   end
```

   unless orientation.kind_of?(String) && orientation[/^lon$|^lat$/]

     raise ArgumentError.new('Coord expects orientation to be a String argument of "lat" or "lon"')

```
   end  
```
```
   @coordinates = coordinates
```
```
   @orientation = orientation
```
```
 end
```
```
 ##
```
```
 # The raw coordinates
```
```
 attr_reader :coordinates
```

 ## The orientation of the hemisphere as 'lat' or 'lon'

```
 attr_reader :orientation
```
```
 def to_s # :nodoc:
```

     c = @coordinates.unpack("N").join.to_i

```
     val      = (c - (2**31)).abs
```
```
     fracsecs = (val % 1e3).to_i.to_s 
```
```
     val      = val / 1e3
```
```
     secs     = (val % 60).to_i.to_s 
```
```
     val      = val / 60
```
```
     mins     = (val % 60).to_i.to_s 
```
```
     degs     = (val / 60).to_i.to_s
```
```
     posi = (c >= 2**31)
```
```
     case posi
```
```
     when true
```

       hemi = @orientation[/^lat$/] ? "N" : "E"

```
     else
```

       hemi = @orientation[/^lon$/] ? "W" : "S"

```
     end
```

     return degs << " " << mins << " " << secs << "." << fracsecs << " " << hemi

```
 end
```
```
 def inspect # :nodoc:
```

   return "#<#{self.class} #{self.to_s}>"

```
 end
```
```
 def ==(other) # :nodoc:
```

   return @coordinates == other.coordinates

```
 end
```
```
 def eql?(other) # :nodoc:
```
```
   return self == other
```
```
 end
```
```
 def hash # :nodoc:
```
```
   return @coordinates.hash
```
```
 end
```
end
A Resolv::LOC::Alt¶
class Alt
```
 Regex = /^([+-]*\d+\.*\d*)[m]$/
```
```
 ##
```

 # Creates a new LOC::Alt from +arg+ which may be:

```
 #
```
```
 # LOC::Alt:: returns +arg+.
```

 # String:: +arg+ must match the LOC::Alt::Regex constant

```
 def self.create(arg)
```
```
   case arg
```
```
   when Alt
```
```
     return arg
```
```
   when String
```
```
     altitude = ''
```
```
     if Regex =~ arg
```

       altitude = [($1.to_f*(1e2))+(1e7)].pack("N")

```
     else
```

       raise ArgumentError.new("not a properly formed Alt string: " + arg)

```
     end
```
```
     return Alt.new(altitude) 
```
```
   else
```

     raise ArgumentError.new("cannot interpret as Alt: #{arg.inspect}")

```
   end
```
```
 end
```
```
 def initialize(altitude)
```
```
   @altitude = altitude
```
```
 end
```
```
 ##
```
```
 # The raw altitude
```
```
 attr_reader :altitude
```
```
 def to_s # :nodoc:
```
```
   a = @altitude.unpack("N").join.to_i
```

   return ((a.to_f/1e2)-1e5).to_s + "m"

```
 end
```
```
 def inspect # :nodoc:
```

   return "#<#{self.class} #{self.to_s}>"

```
 end
```
```
 def ==(other) # :nodoc:
```
```
   return @altitude == other.altitude
```
```
 end
```
```
 def eql?(other) # :nodoc:
```
```
   return self == other
```
```
 end
```
```
 def hash # :nodoc:
```
```
   return @altitude.hash
```
```
 end
```
end
end
Default resolver to use for Resolv class methods.¶

=end

Actions

Copy link

Also available in: PDF Atom

Project

General

Profile

Ruby

Tags

Custom queries

Feature #1436

Please consider this addition to resolv.rb which adds methods for resolving LOC resources

Index: lib/resolv.rb¶

A Resolv::LOC::Size¶

A Resolv::LOC::Coord¶

A Resolv::LOC::Alt¶

Default resolver to use for Resolv class methods.¶

Updated by akr (Akira Tanaka) over 16 years ago Actions
Copy link
#1

Updated by yugui (Yuki Sonoda) over 16 years ago Actions
Copy link
#2

Updated by mame (Yusuke Endoh) over 15 years ago Actions
Copy link
#3

Updated by shyouhei (Shyouhei Urabe) about 15 years ago Actions
Copy link
#4

Updated by mame (Yusuke Endoh) over 13 years ago Actions
Copy link
#5 [ruby-core:42551]

Updated by akr (Akira Tanaka) almost 13 years ago Actions
Copy link
#6 [ruby-core:48519]

Updated by akr (Akira Tanaka) over 12 years ago Actions
Copy link
#7

Project

General

Profile

Ruby

Tags

Custom queries

Feature #1436

Please consider this addition to resolv.rb which adds methods for resolving LOC resources

Index: lib/resolv.rb¶

A Resolv::LOC::Size¶

A Resolv::LOC::Coord¶

A Resolv::LOC::Alt¶

Default resolver to use for Resolv class methods.¶

Updated by akr (Akira Tanaka) over 16 years ago ActionsCopy link #1

Updated by yugui (Yuki Sonoda) over 16 years ago ActionsCopy link #2

Updated by mame (Yusuke Endoh) over 15 years ago ActionsCopy link #3

Updated by shyouhei (Shyouhei Urabe) about 15 years ago ActionsCopy link #4

Updated by mame (Yusuke Endoh) over 13 years ago ActionsCopy link #5 [ruby-core:42551]

Updated by akr (Akira Tanaka) almost 13 years ago ActionsCopy link #6 [ruby-core:48519]

Updated by akr (Akira Tanaka) over 12 years ago ActionsCopy link #7

Updated by akr (Akira Tanaka) over 16 years ago Actions
Copy link
#1

Updated by yugui (Yuki Sonoda) over 16 years ago Actions
Copy link
#2

Updated by mame (Yusuke Endoh) over 15 years ago Actions
Copy link
#3

Updated by shyouhei (Shyouhei Urabe) about 15 years ago Actions
Copy link
#4

Updated by mame (Yusuke Endoh) over 13 years ago Actions
Copy link
#5 [ruby-core:42551]

Updated by akr (Akira Tanaka) almost 13 years ago Actions
Copy link
#6 [ruby-core:48519]

Updated by akr (Akira Tanaka) over 12 years ago Actions
Copy link
#7