revent 0.1 → 0.2

data/lib/revent/CallEvent.as

@@ -0,0 +1,25 @@
+package revent {
+	import flash.events.Event;
+
+	public class CallEvent extends Event {
+		// The connection has opened, communication is ready.
+		public static const CONNECT:String        = "CONNECT";
+		// The connection has closed, do not do any communication.
+		public static const CLOSE:String          = "CLOSE";
+		public static const IO_ERROR:String       = "IO_ERROR";
+		public static const SECURITY_ERROR:String = "SECURITY_ERROR";
+
+		public static const CALL:String   = "CALL";
+		public static const RESULT:String = "RESULT";
+		public static const ERROR:String  = "ERROR";
+
+		public var cmd:Object;
+		public var value:Object;
+
+		public function CallEvent(type:String, cmd:Object, value:Object):void {
+			this.cmd = cmd;
+			this.value = value;
+			super(type);
+		}
+	}
+}

data/lib/revent/Client.as

@@ -0,0 +1,95 @@
+package revent {
+	import flash.events.*;
+	import flash.net.Socket;
+	import flash.net.ObjectEncoding;
+
+	public class Client extends EventDispatcher {
+		private static const TYPE_CALL:int   = 0;
+		private static const TYPE_RESULT:int = 1;
+		private static const TYPE_ERROR:int  = 2;
+
+		private var _socket:Socket;
+
+		public function Client():void {
+			_socket = new Socket();
+			_socket.objectEncoding = ObjectEncoding.AMF3;
+			
+			_socket.addEventListener(Event.CONNECT, onConnect);
+			_socket.addEventListener(Event.CLOSE, onClose);
+			_socket.addEventListener(IOErrorEvent.IO_ERROR, onIOError);
+			_socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
+			_socket.addEventListener(ProgressEvent.SOCKET_DATA, onData);
+		}
+
+		public function connect(host:String, port:int):void {
+			_socket.connect(host, port);
+		}
+
+		public function close():void {
+			_socket.close();
+		}
+
+		public function get connected():Boolean {
+			return _socket.connected;
+		}
+
+		public function call(cmd:Object, value:Object):void {
+			_socket.writeObject([TYPE_CALL, cmd, value]);
+			_socket.flush();
+		}
+
+		public function result(cmd:Object, value:Object):void {
+			_socket.writeObject([TYPE_RESULT, cmd, value]);
+			_socket.flush();
+		}
+
+		public function error(cmd:Object, value:Object):void {
+			_socket.writeObject([TYPE_ERROR, cmd, value]);
+			_socket.flush();
+		}
+
+		// ---------------------------------------------------------------------------
+
+		private function onConnect(event:Event):void {
+			dispatchEvent(new CallEvent(CallEvent.CONNECT, null, null));
+		}
+
+		private function onClose(event:Event):void {
+			dispatchEvent(new CallEvent(CallEvent.CLOSE, null, null));
+		}
+
+		private function onIOError(event:IOErrorEvent):void {
+			dispatchEvent(new CallEvent(CallEvent.IO_ERROR, null, null));
+		}
+
+		private function onSecurityError(event:SecurityErrorEvent):void {
+			dispatchEvent(new CallEvent(CallEvent.SECURITY_ERROR, null, null));
+		}
+
+		private function onData(event:ProgressEvent):void {
+			try {
+				while (true) {
+					var o:Array = _socket.readObject();
+					var type:int     = o[0];
+					var cmd:Object   = o[1];
+					var value:Object = o[2];
+
+					var e:CallEvent;
+					switch (type) {
+					case TYPE_CALL:
+						e = new CallEvent(CallEvent.CALL, cmd, value);
+						break;
+					case TYPE_RESULT:
+						e = new CallEvent(CallEvent.RESULT, cmd, value);
+						break;
+					case TYPE_ERROR:
+						e = new CallEvent(CallEvent.ERROR, cmd, value);
+						break;
+					}
+					dispatchEvent(e);
+				}
+			} catch (e:Error) {
+			}
+		}
+	}
+}

data/lib/revent/amf3/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007 Aaron Smith (aaron@rubyamf.org)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+There is one exception to the above MIT license. WebORB may not use this code 
+base in any of their releases of WebORB for RoR.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/revent/amf3/README

@@ -0,0 +1,6 @@
+This is a stripped down version of RubyAMF trunk #1270.
+It only contains AMF serializing/deserializing code.
+
+See:
+http://www.rubyamf.org
+http://code.google.com/p/rubyamf

data/lib/revent/amf3/amf3.rb

@@ -0,0 +1,11 @@
+dir = File.dirname(__FILE__)
+
+# utils must be first
+require "#{dir}/util/string"
+require "#{dir}/util/vo_helper"
+
+require "#{dir}/app/fault_object"
+
+require 'kconv'  # For string.toutf8
+require "#{dir}/io/amf_deserializer"
+require "#{dir}/io/amf_serializer"

data/lib/revent/amf3/app/configuration.rb

@@ -0,0 +1,79 @@
+#This stores supporting configuration classes used in the config file to register class mappings and parameter mappings etc.
+
+require "#{File.dirname(__FILE__)}/../exception/rubyamf_exception"
+
+module RubyAMF
+  module Configuration
+    #ClassMappings configuration support class
+    class ClassMappings
+      
+      # these NEED to be outside the class << self to work
+      @ignore_fields = ['created_at','created_on','updated_at','updated_on']
+      @translate_case = false
+      @class_mappings_by_ruby_class = {}
+      @class_mappings_by_actionscript_class = {}
+      @scoped_class_mappings_by_ruby_class = {}
+      @attribute_names = {}
+      @hash_key_access = :symbol
+      @translate_case = false
+      @force_active_record_ids = true
+      @assume_types = false
+      @use_ruby_date_time = false
+      @use_array_collection = false
+      @check_for_associations = true
+      
+      # Aryk: I cleaned up how the class variables are called here. It doesnt matter if you use class variables or instance variables on the class level. Check out this simple tutorial
+      # - http://sporkmonger.com/2007/2/19/instance-variables-class-variables-and-inheritance-in-ruby      
+     
+      class << self           
+        include RubyAMF::Exceptions 
+        
+        attr_accessor :ignore_fields, :use_array_collection, :default_mapping_scope, :force_active_record_ids, :attribute_names, 
+          :use_ruby_date_time, :current_mapping_scope, :check_for_associations, :translate_case, :assume_types, :hash_key_access  #the rails parameter mapping type
+        
+        def register(mapping)  #register a value object map
+          #build out ignore field logic
+          hashed_ignores = {}
+          ClassMappings.ignore_fields.to_a.each{|k| hashed_ignores[k] = true} # strings and nils will be put into an array with to_a
+          mapping[:ignore_fields].to_a.each{|k| hashed_ignores[k] = true}
+          mapping[:ignore_fields] = hashed_ignores # overwrite the original ignore fields
+
+          # if they specify custom attributes, ensure that AR ids are being passed as well if they opt for it.
+          if force_active_record_ids && mapping[:attributes] && mapping[:type]=="active_record" && !mapping[:attributes].include?("id")
+            mapping[:attributes] << "id"
+          end
+          
+          # created caching hashes for mapping
+          @class_mappings_by_ruby_class[mapping[:ruby]] = mapping # for quick referencing purposes
+          @class_mappings_by_actionscript_class[mapping[:actionscript]] = mapping # for quick referencing purposes
+          @scoped_class_mappings_by_ruby_class[mapping[:ruby]] = {} # used later for caching based on scope (will get cached after the first run)
+          # for deserialization - looking up in a hash is faster than looking up in an array.
+          begin
+            if mapping[:type] == "active_record" 
+              @attribute_names[mapping[:ruby]] = (mapping[:ruby].constantize.new.attribute_names + ["id"]).inject({}){|hash, attr| hash[attr]=true ; hash} # include the id attribute
+            end
+          rescue ActiveRecord::StatementInvalid => e
+            # This error occurs during migrations, since the AR constructed above will check its columns, but the table won't exist yet.
+            # We'll ignore the error if we're migrating.
+            raise unless ARGV.include?("migrate") or ARGV.include?("db:migrate")
+          end
+        end
+        
+        def get_vo_mapping_for_ruby_class(ruby_class)
+          return unless scoped_class_mapping = @scoped_class_mappings_by_ruby_class[ruby_class] # just in case they didnt specify a ClassMapping for this Ruby Class
+          scoped_class_mapping[@current_mapping_scope] ||= (if vo_mapping = @class_mappings_by_ruby_class[ruby_class]
+              vo_mapping = vo_mapping.dup # need to duplicate it or else we will overwrite the keys from the original mappings
+              vo_mapping[:attributes]   = vo_mapping[:attributes][@current_mapping_scope]||[]   if vo_mapping[:attributes].is_a?(Hash)      # don't include any of these attributes if there is no scope
+              vo_mapping[:associations] = vo_mapping[:associations][@current_mapping_scope]||[] if vo_mapping[:associations].is_a?(Hash) # don't include any of these attributes
+              vo_mapping
+            end
+          )
+        end
+        
+        def get_vo_mapping_for_actionscript_class(actionscript_class)
+          @class_mappings_by_actionscript_class[actionscript_class]
+        end    
+      end
+    end
+  end
+end

data/lib/revent/amf3/app/fault_object.rb

@@ -0,0 +1,13 @@
+#This is a helper to return FaultObjects. Often times there are sitiuations with database logic that requires an "error state"
+#to be set in Flash / Flex, but returning false isn't the best because it still get's mapped to the onResult handler, even returning a 
+#generic object with some specific keys set, such as ({error:'someError', code:3}). That is still a pain because it gets mapped to
+#the onResult function still. So return one of these objects to RubyAMF and it will auto generate a faultObject to return to flash
+#so that it maps correctly to the onFault handler.
+class FaultObject < Hash
+  def initialize(message = '')
+    self['faultCode'] = 1
+    self['code'] = 1
+    self['message'] = message
+    self['faultString'] = message
+  end
+end

data/lib/revent/amf3/exception/rubyamf_exception.rb

@@ -0,0 +1,95 @@
+module RubyAMF
+module Exceptions
+
+#Encompasses all rubyamf specific exceptions that occur
+class RUBYAMFException < Exception
+  
+  #when version is not 0 or 3
+  @VERSION_ERROR = 'RUBYAMF_AMF_VERSION_ERROR'
+  
+  #when translating the target_uri of a body, there isn't a .(period) to map the service / method name
+  @SERVICE_TRANSLATION_ERROR = 'RUBYAMF_SERVICE_TRANSLATION_ERROR'
+  
+  #when an authentication error occurs
+  @AUTHENTICATION_ERROR = 'RUBYAMF_ATUHENTICATION_ERROR'
+  
+  #when a method is called, but the method is either private or doesn't exist
+  @METHOD_ACCESS_ERROR = 'RUBYAMF_METHOD_ACCESS_ERROR'
+  
+  #when a mehod is undefined
+  @METHOD_UNDEFINED_METHOD_ERROR = 'RUBYAMF_UNDECLARED_METHOD_ERROR'
+  
+  #when there is an error with session implementation
+  @SESSION_ERROR = 'RUBYAMF_SESSION_ERROR'
+  
+  #when a general user error has occured
+  @USER_ERROR = 'RUBYAMF_USER_ERROR'
+  
+  #when parsing AMF3, an undefined object reference
+  @UNDEFINED_OBJECT_REFERENCE_ERROR = 'RUBYAMF_UNDEFINED_OBJECT_REFERENCE_ERROR'
+  
+  #when parsing AMF3, an undefined class definition
+  @UNDEFINED_DEFINITION_REFERENCE_ERROR = 'RUBYAMF_UNDEFINED_DEFINIITON_REFERENCE_ERROR'
+  
+  #when parsing amf3, an undefined string reference
+  @UNDEFINED_STRING_REFERENCE_ERROR = 'RUBYAMF_UNDEFINED_STRING_REFERENCE_ERROR'
+  
+  #unsupported AMF0 type
+  @UNSUPPORTED_AMF0_TYPE = 'UNSUPPORTED_AMF0_TYPE'
+  
+  #when the Rails ActionController Filter chain haults
+  @FILTER_CHAIN_HAULTED = 'RAILS_ACTION_CONTROLLER_FILTER_CHAIN_HAULTED'
+  
+  #when active record errors
+  @ACTIVE_RECORD_ERRORS = 'ACTIVE_RECORD_ERRORS'
+  
+  #whan amf data is incomplete or incorrect
+  @AMF_ERROR = 'AMF_ERROR'
+  
+  #vo errors
+  @VO_ERROR = 'VO_ERROR'
+  
+  #when a parameter mapping error occurs
+  @PARAMETER_MAPPING_ERROR = "PARAMETER_MAPPING_ERROR"
+  
+  attr_accessor :message
+  attr_accessor :etype
+  attr_accessor :ebacktrace
+  
+  #static accessors
+  class << self
+    attr_accessor :VERSION_ERROR
+    attr_accessor :SERVICE_TRANSLATION_ERROR
+    attr_accessor :AUTHENTICATION_ERROR
+    attr_accessor :METHOD_ACCESS_ERROR
+    attr_accessor :METHOD_UNDEFINED_METHOD_ERROR
+    attr_accessor :SESSION_ERROR
+    attr_accessor :USER_ERROR
+    attr_accessor :UNDEFINED_OBJECT_REFERENCE_ERROR
+    attr_accessor :UNDEFINED_DEFINITION_REFERENCE_ERROR
+    attr_accessor :UNDEFINED_STRING_REFERENCE_ERROR
+    attr_accessor :UNSUPPORTED_TYPE
+    attr_accessor :ADAPTER_ERROR
+    attr_accessor :INTERNAL_ERROR
+    attr_accessor :UNSUPPORTED_AMF0_TYPE
+    attr_accessor :FILTER_CHAIN_HAULTED
+    attr_accessor :ACTIVE_RECORD_ERRORS
+    attr_accessor :VO_ERROR
+    attr_accessor :AMF_ERROR
+    attr_accessor :PARAMETER_MAPPING_ERROR
+  end
+  
+  def initialize(type,msg)
+    super(msg)
+    @message = msg
+    @etype = type
+  end
+  
+  # stringify the message
+  def to_s
+    @msg
+  end
+  
+end
+end
+end

data/lib/revent/amf3/io/amf_deserializer.rb

@@ -0,0 +1,315 @@
+module RubyAMF
+  module IO
+    class AMFDeserializer
+
+      require "#{File.dirname(__FILE__)}/read_write"
+
+      include RubyAMF::Configuration
+      include RubyAMF::Exceptions
+      include RubyAMF::IO::BinaryReader
+      include RubyAMF::IO::Constants
+      include RubyAMF::VoHelper
+
+      attr_accessor :stream
+      attr_accessor :stream_position
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @stream = ''
+        @stream_position = 0
+        reset_referencables
+      end
+
+      def reset_referencables
+        @stored_strings = []
+        @stored_objects = []
+        @stored_defs = []
+      end
+
+      def read_amf3
+        type = read_word8
+        case type
+        when AMF3_UNDEFINED
+          nil
+        when AMF3_NULL
+          nil
+        when AMF3_FALSE
+          false
+        when AMF3_TRUE
+          true
+        when AMF3_INTEGER
+          read_amf3_integer
+        when AMF3_NUMBER
+          read_amf3_number
+        when AMF3_STRING 
+          read_amf3_string
+        when AMF3_XML
+          read_amf3_xml_string
+        when AMF3_DATE
+          read_amf3_date
+        when AMF3_ARRAY
+          read_amf3_array
+        when AMF3_OBJECT
+          read_amf3_object
+        when AMF3_XML_STRING
+          read_amf3_xml
+        when AMF3_BYTE_ARRAY
+          read_amf3_byte_array
+        end
+      end
+
+      def read_amf3_integer
+        n = 0
+        b = read_word8||0
+        result = 0
+
+        while ((b & 0x80) != 0 && n < 3)
+          result = result << 7
+          result = result | (b & 0x7f)
+          b = read_word8||0
+          n = n + 1
+        end
+
+        if (n < 3)
+          result = result << 7
+          result = result | b
+        else
+          #Use all 8 bits from the 4th byte
+          result = result << 8
+          result = result | b
+    	
+          #Check if the integer should be negative
+          if (result > AMF3_INTEGER_MAX)
+            result -= (1 << 29)
+          end
+        end
+        return result
+      end
+
+      def read_amf3_string
+        type = read_amf3_integer
+        isReference = (type & 0x01) == 0
+        if isReference
+          reference = type >> 1
+          if reference < @stored_strings.length
+            if @stored_strings[reference] == nil
+              raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Reference to non existant string at index #{reference}, please tell aaron@rubyamf.org"))
+            end
+            return @stored_strings[reference]
+          else
+            raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_STRING_REFERENCE_ERROR, "Reference to non existant string at index #{reference}, please tell aaron@rubyamf.org") )
+          end
+        else
+
+          length = type >> 1
+
+          #Note that we have to read the string into a byte buffer and then
+          #convert to a UTF-8 string, because for standard readUTF() it
+          #reads an unsigned short to get the string length.
+          #A string isn't stored as a reference if it is the empty string
+          #thanks Karl von Randow for this
+          if length > 0
+            str = String.new(readn(length)) #specifically cast as string, as we're reading verbatim from the stream
+            str.toutf8 #convert to utf8
+            @stored_strings << str
+          end
+          return str
+        end
+      end
+
+      def read_amf3_xml
+        type = read_amf3_integer
+        length = type >> 1
+        readn(length)
+      end
+
+      def read_amf3_date
+        type = read_amf3_integer
+        isReference = (type & 0x01) == 0
+        if isReference
+          reference = type >> 1
+          if reference < @stored_objects.length
+            if @stored_objects[reference] == nil
+              
+              raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Reference to non existant date at index #{reference}, please tell aaron@rubyamf.org"))
+            end
+            return @stored_objects[reference]
+          else
+            raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Undefined date object reference when deserialing AMF3: #{reference}") )
+          end
+        else
+          seconds = read_double.to_f/1000
+          time = if (seconds < 0) || ClassMappings.use_ruby_date_time # we can't use Time if its a negative second value
+            DateTime.strptime(seconds.to_s, "%s")
+          else 
+            Time.at(seconds)
+          end
+          @stored_objects << time
+          time
+        end
+      end
+
+      def read_amf3_array
+        type = read_amf3_integer
+        isReference = (type & 0x01) == 0
+
+        if isReference
+          reference = type >> 1
+          if reference < @stored_objects.length
+            if @stored_objects[reference] == nil
+              raise(RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Reference to non existant array at index #{reference}, please tell aaron@rubyamf.org"))
+            end
+            return @stored_objects[reference]
+          else
+            raise Exception.new("Reference to non-existent array at index #{reference}, please tell aaron@rubyamf.org")
+          end
+        else
+          length = type >> 1
+          propertyName = read_amf3_string
+          if propertyName != nil
+            array = {}
+            @stored_objects << array
+            begin
+              while(propertyName.length)
+                value = read_amf3
+                array[propertyName] = value
+                propertyName = read_amf3_string
+              end
+            rescue Exception => e #end of object exception, because propertyName.length will be non existent
+            end
+            0.upto(length - 1) do |i|
+              array["" + i.to_s] = read_amf3
+            end
+          else
+            array = []
+            @stored_objects << array
+            0.upto(length - 1) do
+              array << read_amf3
+            end
+          end
+          array
+        end
+      end
+
+      def read_amf3_object
+        type = read_amf3_integer
+        isReference = (type & 0x01) == 0
+
+        if isReference
+          reference = type >> 1
+          if reference < @stored_objects.length
+            if @stored_objects[reference] == nil
+              raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Reference to non existant object at index #{reference}, please tell aaron@rubyamf.org."))
+            end
+            return @stored_objects[reference]
+          else
+            raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Reference to non existant object #{reference}"))
+          end
+        else
+
+          class_type = type >> 1
+          class_is_reference = (class_type & 0x01) == 0
+
+          if class_is_reference
+            class_reference = class_type >> 1
+            if class_reference < @stored_defs.length
+              class_definition = @stored_defs[class_reference]
+            else
+              raise RUBYAMFException.new(RUBYAMFException.UNDEFINED_DEFINITION_REFERENCE_ERROR, "Reference to non existant class definition #{class_reference}")
+            end
+          else
+            actionscript_class_name = read_amf3_string
+            externalizable = (class_type & 0x02) != 0
+            dynamic = (class_type & 0x04) != 0
+            attribute_count = class_type >> 3
+
+            class_attributes = []
+            attribute_count.times{class_attributes << read_amf3_string} # Read class members
+
+            class_definition = {"as_class_name" => actionscript_class_name, "members" => class_attributes, "externalizable" => externalizable, "dynamic" => dynamic}
+            @stored_defs << class_definition
+          end
+          action_class_name = class_definition['as_class_name'] #get the className according to type
+
+          # check to see if its the first main amf object or a flex message obj, because then we need a _explicitType field type and skip some things
+          skip_mapping = if action_class_name && action_class_name.include?("flex.messaging")
+            obj = VoHash.new # initialize an empty VoHash value holder    
+            obj._explicitType = action_class_name
+            true
+          else # otherwise just use a normal hash
+            obj = {}
+            false
+          end
+
+          obj_position = @stored_objects.size # need to replace the object later for referencing (MUST be before inserting the object into stored_objs)
+          @stored_objects << obj
+
+          if class_definition['externalizable']
+            if ['flex.messaging.io.ObjectProxy','flex.messaging.io.ArrayCollection'].include?(action_class_name)
+              obj = read_amf3
+            else
+              raise( RUBYAMFException.new(RUBYAMFException.USER_ERROR, "Unable to read externalizable data type #{type}"))
+            end            
+          else            
+            translate_case = !skip_mapping&&ClassMappings.translate_case  # remove the need for a method call / also, don't want to convert on main remoting object
+            class_definition['members'].each do |key|
+              value = read_amf3
+              #if (value)&& value != 'NaN'# have to read key to move the reader ahead in the stream
+              key.to_snake! if translate_case   
+              obj[key] = value
+              #end
+            end
+
+            if class_definition['dynamic']
+              while (key = read_amf3_string) && key.length != 0  do # read next key
+                value = read_amf3
+                #if (value) && value != 'NaN'
+                key.to_snake! if translate_case  
+                obj[key] = value
+                #end
+              end
+            end
+            obj = VoUtil.get_vo_for_incoming(obj,action_class_name) unless skip_mapping
+          end
+          @stored_objects[obj_position] = obj # put the new object into the same position as the original object since it was worked on
+          obj
+        end
+      end
+
+      def read_amf3_byte_array # according to the charles amf3 deserializer, they store byte array
+        type = read_amf3_integer
+        isReference = (type & 0x01) == 0
+        if isReference
+          reference = type >> 1
+          if reference < @stored_objects.length
+            if @stored_objects[reference] == nil
+              raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Reference to non existant byteArray at index #{reference}, please tell aaron@rubyamf.org"))
+            end
+            return @stored_objects[reference]
+          else
+            raise( RUBYAMFException.new(RUBYAMFException.UNDEFINED_OBJECT_REFERENCE_ERROR, "Reference to non existant byteArray #{reference}"))
+          end
+        else
+          length = type >> 1
+          begin # first assume its gzipped and rescue an exception if its not
+            inflated_stream = Zlib::Inflate.inflate( self.stream[self.stream_position,length] )
+            arr = inflated_stream.unpack('c'*inflated_stream.length) 
+          rescue Exception => e
+            arr = self.stream[self.stream_position,length].unpack('c'*length)
+          end      
+          self.stream_position += length
+          @stored_objects << arr
+          arr
+        end
+      end
+
+      def read_amf3_number
+        res = read_double
+        res.is_a?(Float)&&res.nan? ? nil : res # check for NaN and convert them to nil
+      end
+    end
+  end
+end