neerfri-ramf 0.1.0

data/lib/ramf/deserializer.rb

@@ -0,0 +1,9 @@
+
+require 'ramf/deserializer/base'
+require 'ramf/deserializer/amf0_reader'
+require 'ramf/deserializer/amf3_reader'
+
+module RAMF
+  module Deserializer 
+  end
+end

data/lib/ramf/extensions/class.rb

@@ -0,0 +1,139 @@
+class Class
+  
+  #returns the FlexClassTraits object of the class,
+  #if it doesn't exist, it will create one.
+  #
+  # class Car
+  #   @@my_flex_remoting = flex_remoting
+  #   #Why would you be doing that ???
+  # end
+  def flex_remoting
+    @flex_remoting ||= RAMF::FlexClassTraits.new(self, true, :transient=>[:flex_remoting])
+  end
+  
+  #This method defines members that are transient, which means
+  #they will not be sent by amf, and will be ignored if received from amf.
+  #For Exmple:
+  # class User
+  #   flex_remoting_transient :encrypted_password, :encription_salt
+  # end
+  #this will define <tt>:encrypted_password, :encription_salt</tt> not
+  #to be sent over amf.
+  #Make sure they are not important to represent the object when it comes from amf.
+  def flex_remoting_transient(*args)
+    flex_remoting.transient_members += args.map {|v| v.to_sym}
+  end
+  
+  #defines members for a specific scope.
+  #For exmple:
+  # class User
+  #   flex_remoting_scope :limited, :except=>[:phone,:email]
+  #   flex_remoting_scope :private, :only=>[:fullname, :nickname]
+  # end
+  #this will set :phone and :email attributes not to be sent
+  #when using <tt> render :amf=>@user, :scope=>:limited </tt>.
+  #
+  #it will also set only :fullname and :nickname to be sent when
+  #using <tt> render :amf=>@user_list, :scope=>:private </tt> 
+  #
+  #Each scope can only be set with either :except or :only, not both.
+  def flex_remoting_scope(scope, options)
+    raise "only & except" if options[:only] && options[:except]
+    flex_remoting.amf_scope_options[scope] = options
+  end
+  
+  #define the action script name of the class (or what they set 
+  #in RemoteAlias('') )
+  # class SomeRubyClass
+  #   flex_alias_name :SomeActionScriptClass
+  # end
+  #this will make the client side(flex) receive a class 
+  #named SomeActionScriptClass
+  def flex_alias(class_name)
+    flex_remoting.name = class_name.to_s
+  end
+  
+  #This method defines members that are fixed with the object, which means
+  #they will use to define the class's signature during serialization.
+  #For Exmple:
+  # class User
+  #   flex_remoting_members :great_attribute, :important_attribute
+  # end
+  #this will define <tt>:great_attribute, :important_attribute</tt> to 
+  #always be sent over amf.
+  #
+  #Note that some classes can use other mechanisms to find sealed members,
+  #this is the most simple way to do so.
+  
+  def flex_remoting_members(*members)
+    flex_remoting.defined_members = members
+  end
+  
+  #Defines dynamic members finder block.
+  #The block should return an array of symbols or nil(for empty array)
+  #each symbol in the array will represent a dynamic member to be serialized
+  #For example:
+  # class User
+  #   flex_dynamic_members_finder do |instance, scope|
+  #     instance.instance_variable_get("@dynamic") ? [:dynamic] : []
+  #   end
+  # end
+  #this will add :dynamic to the list of dynamic members if an instance variable named @dynamic exists.
+  def flex_dynamic_members_finder(&block)
+    flex_remoting.dynamic_members_finders.push(block)
+  end
+  
+  #defines a callback to set the value of the object's members.
+  #For example:
+  # class User
+  #   attr_accessor :my_other_data #this is a hash...
+  #   flex_members_reader do |obj, member, value|
+  #     obj.my_other_data.has_key?(member) ? obj.my_other_data[member]=value : obj.send(member.to_s+"=",value)
+  #   end
+  # end
+  #if the hash <tt>my_other_data</tt> has key <tt>member</tt> insert the value to the hash,
+  #otherwise use a setter method
+  def flex_members_writer(&block)
+    flex_remoting.members_writer = block
+  end
+  
+  #defines a callback to set the value of the object's dynamic members.
+  #For example:
+  # class User
+  #   attr_accessor :my_dynamic_members #this is a hash...
+  #   flex_dynamic_members_reader do |obj, member, value|
+  #     obj.my_dynamic_members[member] = value
+  #   end
+  # end
+  #this will set all dynamic members to the hash <tt>my_dynamic_members</tt>
+  def flex_dynamic_members_writer(&block)
+    flex_remoting.dynamic_members_writer = block
+  end
+  
+  #defines a callback to get the value of the object's members.
+  #For example:
+  # class User
+  #   attr_accessor :my_other_data #this is a hash...
+  #   flex_members_reader do |obj, member|
+  #     obj.my_other_data.has_key?(member) ? obj.my_other_data[member] : obj.send(member)
+  #   end
+  # end
+  #if the hash <tt>my_other_data</tt> has key <tt>member</tt> get it from the hash,
+  #otherwise get it from calling the appropriate method
+  def flex_members_reader(&block)
+    flex_remoting.members_reader = block
+  end
+  
+  #defines a callback to get the value of the object's dynamic members.
+  #For example:
+  # class User
+  #   attr_accessor :my_dynamic_members #this is a hash...
+  #   flex_dynamic_members_reader do |obj, member|
+  #     obj.my_dynamic_members[member]
+  #   end
+  # end
+  #this will get all dynamic members from the hash <tt>my_dynamic_members</tt>
+  def flex_dynamic_members_reader(&block)
+    flex_remoting.dynamic_members_reader = block
+  end
+end

data/lib/ramf/extensions/exception.rb

@@ -0,0 +1,3 @@
+class Exception
+  flex_remoting_members :message, :backtrace
+end

data/lib/ramf/extensions/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  
+  flex_remoting.instance_variable_set("@name","")
+  
+  flex_dynamic_members_finder do |instance, scope|
+    instance.keys
+  end
+end

data/lib/ramf/extensions/object.rb

@@ -0,0 +1,44 @@
+class Object
+  
+  flex_dynamic_members_finder do |instance, scope|
+    instance.instance_variables.map{|v| v[1..-1].to_sym}
+  end
+  
+  flex_members_reader do |instance, member|
+    instance.send(member)
+  end
+  
+  flex_members_writer do |obj, key, value|
+    obj.respond_to?("#{key}=") ? obj.send("#{key}=",value) : obj.instance_variable_set("@#{key}",value)
+  end
+
+  flex_dynamic_members_reader do |instance, member|
+    case
+      when instance.respond_to?(member)
+        instance.send(member)
+      when instance.instance_variable_defined?("@#{member}")
+        instance.instance_variable_get("@#{member}")
+      when instance.respond_to?(:[])
+        instance[member]
+      else
+        begin
+          instance.send(member)
+        rescue NoMethodError=>e
+          warn("***Warning: Couldn't find value from dynamic member #{member} in object #{instance.class.name}!")
+          nil
+        end
+    end
+  end
+  
+  flex_dynamic_members_writer do |instance, member, value|
+    instance.send("#{member}=", value)
+  end
+  
+  unless defined?(returning)
+    def returning(value)
+      yield(value)
+      value
+    end
+  end
+  
+end

data/lib/ramf/flex_class_traits.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+module RAMF
+  #The term 'traits' is used to describe the defining characteristics of a class. (amf3 spec document section 3.12)
+  class FlexClassTraits
+    
+    KNOWN_CLASSES = {}
+    
+    def self.find_ruby_class(name)
+#      RAILS_DEFAULT_LOGGER.info "name: #{name.to_s.inspect}"
+#      RAILS_DEFAULT_LOGGER.info "KNOWN_CLASSES[name]:#{KNOWN_CLASSES[name.to_s].inspect}"
+#      RAILS_DEFAULT_LOGGER.info "KNOWN_CLASSES:\n#{KNOWN_CLASSES.inspect}"
+      Object.module_eval(KNOWN_CLASSES[name.to_s]) rescue nil
+    end
+    
+    attr_reader :klass, :members, :name
+    attr_accessor :transient_members, :amf_scope_options, :is_dynamic
+    attr_accessor :dynamic_members_writer, :members_writer
+    attr_accessor :dynamic_members_reader, :members_reader
+    
+    def initialize(klass,is_dynamic, options = {})
+      @klass = klass
+      @amf_scope_options = get_duplicate_from_super({}, :amf_scope_options)
+      @members = {}
+      self.name= klass.name
+      @is_dynamic = is_dynamic
+      @defined_members = []
+      @transient_members = options[:transient] || []
+      [:dynamic_members_writer, :members_writer, :dynamic_members_reader, :members_reader].each do |a|
+        default = Proc.new{raise "No #{a} defined for #{klass}"}
+        instance_variable_set("@#{a}", get_attribute_from_super(default, a))
+      end
+    end
+    
+    def name=(new_name)
+      new_name = new_name.to_s
+      if KNOWN_CLASSES[new_name] && KNOWN_CLASSES[new_name]!=klass.name
+        raise("An ActionScript class named '#{new_name}' already exists.")
+      end
+      KNOWN_CLASSES.delete(@name)
+      @name = new_name
+      KNOWN_CLASSES[new_name] = klass.name
+    end
+    
+    def transient_members
+      (@transient_members + get_attribute_from_super([], :transient_members)).uniq
+    end
+    
+    def members(scope = RAMF::Configuration::DEFAULT_SCOPE)
+      @members[scope] ||= find_members(scope)
+    end
+    
+    def defined_members=(members)
+      @defined_members = members.flatten.map {|v| v.to_sym}
+    end
+    
+    def dynamic_members_finders
+      @dynamic_members_finders ||= get_duplicate_from_super([], :dynamic_members_finders)
+    end
+    
+    def dynamic_members(instance, scope = RAMF::Configuration::DEFAULT_SCOPE)
+      members = dynamic_members_finders.map{|b| b.call(instance, scope)}.flatten.uniq
+      members -= members(scope)
+      members -= transient_members
+      scope_opt = amf_scope_options[scope]
+      except = scope_opt && scope_opt[:except] ? scope_opt[:except] : []
+      members -= except
+      members.inject({}) do |hash,member|
+        hash[member] = dynamic_members_reader.call(instance,member)
+        hash
+      end
+    end
+    
+    ##############################################################
+    private
+        
+    def find_members(scope)
+      if (amf_scope_options[scope] && amf_scope_options[scope][:only])
+        members = amf_scope_options[scope][:only]
+      else
+        members = get_duplicate_from_super([], :members, scope) + @defined_members
+        members += klass.flex_members if klass.respond_to?(:flex_members)
+        members -= transient_members
+        members -= amf_scope_options[scope][:except] if amf_scope_options[scope]
+      end
+      members
+    end
+    
+    def get_duplicate_from_super(default, attribute, *args)
+      get_attribute_from_super(default, attribute, *args).dup
+    end
+    
+    
+    def get_attribute_from_super(default, attribute, *args)
+      klass.superclass ? klass.superclass.flex_remoting.send(attribute,*args) : default
+    end
+    
+  end
+end

data/lib/ramf/flex_objects/acknowledge_message.rb

@@ -0,0 +1,31 @@
+module RAMF
+  module FlexObjects
+    class AcknowledgeMessage
+      flex_alias 'flex.messaging.messages.AcknowledgeMessage'
+      MEMBERS = [:messageId, :clientId, :destination, :body, :timeToLive, :timestamp, :headers, :correlationId]
+      
+      flex_remoting_members MEMBERS 
+      attr_accessor *MEMBERS
+      
+      def initialize(options={})
+        @messageId = rand_uuid
+        @clientId = options[:clientId] ||rand_uuid
+        @destination = nil
+        @body = options[:body] || nil
+        @timeToLive = 0
+        @timestamp = Time.now.to_i * 100
+        @headers = {}
+        @correlationId = options[:correlationId]
+      end
+      
+      def rand_uuid
+        [8,4,4,4,12].map {|n| rand_hex_3(n)}.join('-').to_s
+      end
+      
+      def rand_hex_3(l)
+        "%0#{l}x" % rand(1 << l*4)
+      end
+      
+    end    
+  end
+end

data/lib/ramf/flex_objects/byte_array.rb

@@ -0,0 +1,9 @@
+require 'tempfile'
+
+class RAMF::FlexObjects::ByteArray < Tempfile
+  def initialize(content)
+    super("RAMFTemp")
+    self.write content
+    self.rewind
+  end
+end

data/lib/ramf/flex_objects/command_message.rb

@@ -0,0 +1,86 @@
+class RAMF::FlexObjects::CommandMessage
+  flex_alias "flex.messaging.messages.CommandMessage"
+  flex_remoting_members :operation, :correlationId, :clientId, 
+                        :messageId, :body, :timestamp, :timeToLive, 
+                        :destination, :headers
+                        
+  attr_accessor :operation, :correlationId, :clientId, 
+                :messageId, :body, :timestamp, :timeToLive, 
+                :destination, :headers
+                        
+  ######################################OPERATION TYPES###############################3
+  #holdes the operations names for easier debugging and exception reporting
+  OPERATION_NAMES = {}  
+
+  #This operation is used to subscribe to a remote destination.
+  SUBSCRIBE_OPERATION = 0; OPERATION_NAMES[0] = "SUBSCRIBE_OPERATION"
+
+  #This operation is used to unsubscribe from a remote destination.
+  UNSUBSCRIBE_OPERATION = 1; OPERATION_NAMES[1] = "UNSUBSCRIBE_OPERATION"
+
+  #This operation is used to poll a remote destination for pending, undelivered messages.
+  POLL_OPERATION = 2; OPERATION_NAMES[2] = "POLL_OPERATION"
+
+  #This operation is used by a remote destination to sync missed or cached messages 
+  #back to a client as a result of a client issued poll command.
+  CLIENT_SYNC_OPERATION = 4; OPERATION_NAMES[4] = "CLIENT_SYNC_OPERATION"
+
+  #This operation is used to test connectivity over the current channel to
+  #the remote endpoint.
+  CLIENT_PING_OPERATION = 5; OPERATION_NAMES[5] = "CLIENT_PING_OPERATION"
+  
+  #This operation is used to request a list of failover endpoint URIs
+  #for the remote destination based on cluster membership.
+  CLUSTER_REQUEST_OPERATION = 7; OPERATION_NAMES[7] = "CLUSTER_REQUEST_OPERATION"
+  
+  #This operation is used to send credentials to the endpoint so that
+  #the user can be logged in over the current channel.  
+  #The credentials need to be Base64 encoded and stored in the <code>body</code>
+  #of the message.
+  LOGIN_OPERATION = 8; OPERATION_NAMES[8] = "LOGIN_OPERATION"
+    
+  #This operation is used to log the user out of the current channel, and 
+  #will invalidate the server session if the channel is HTTP based.
+  LOGOUT_OPERATION = 9; OPERATION_NAMES[9] = "LOGOUT_OPERATION"
+
+  #This operation is used to indicate that the client's subscription with a
+  #remote destination has timed out.
+  SUBSCRIPTION_INVALIDATE_OPERATION = 10; OPERATION_NAMES[10] = "SUBSCRIPTION_INVALIDATE_OPERATION"
+
+  #Used by the MultiTopicConsumer to subscribe/unsubscribe for more
+  #than one topic in the same message.
+  MULTI_SUBSCRIBE_OPERATION = 11; OPERATION_NAMES[11] = "MULTI_SUBSCRIBE_OPERATION"
+    
+  #This operation is used to indicate that a channel has disconnected.
+  DISCONNECT_OPERATION = 12; OPERATION_NAMES[12] = "DISCONNECT_OPERATION"
+  
+  #This is the default operation for new CommandMessage instances.
+  UNKNOWN_OPERATION = 10000; OPERATION_NAMES[10000] = "UNKNOWN_OPERATION"
+
+######################################HEADER VALUES###############################
+
+  #Endpoints can imply what features they support by reporting the
+  #latest version of messaging they are capable of during the handshake of
+  #the initial ping CommandMessage.
+  MESSAGING_VERSION = "DSMessagingVersion"
+  
+  def credentials_for_login_operation
+    RAMF::Util.extract_credentials(body.to_s) || {:userid => nil, :password => nil}
+  end
+  
+  #construct an Operation object from the command message <tt>message</tt>
+  def to_operation
+    case operation
+      when CLIENT_PING_OPERATION
+        RAMF::OperationRequest.new :operation => operation, 
+                                   :messageId=>messageId
+      when LOGIN_OPERATION
+        RAMF::OperationRequest.new :operation => operation, 
+                                   :credentials => credentials_for_login_operation,
+                                   :messageId=>messageId
+    else
+      raise "Unimplemented Operation: #{operation} - #{OPERATION_NAMES[operation]}"
+    end
+  end
+    
+end

data/lib/ramf/flex_objects/error_message.rb

@@ -0,0 +1,14 @@
+class RAMF::FlexObjects::ErrorMessage < RAMF::FlexObjects::AcknowledgeMessage
+  flex_alias "flex.messaging.messages.ErrorMessage"
+  flex_remoting_members :extendedData, :faultCode, :faultDetail, :faultString, :rootCause
+                        
+  attr_accessor :extendedData, :faultCode, :faultDetail, :faultString, :rootCause
+  
+  def initialize(options = {})
+    super(options)
+    self.extendedData = options[:exception]
+    self.faultDetail = options[:exception].message if options[:exception]
+    self.faultString = options[:exception].message if options[:exception]
+  end
+  
+end

data/lib/ramf/flex_objects/flex_anonymous_object.rb

@@ -0,0 +1,37 @@
+module RAMF
+  module FlexObjects
+    
+    #This class is used to create objects that are anonymous flex objects.
+    #these objects are very much like a ruby hash but their attributes can be accessed
+    #via methods as well.
+    #
+    # some_object = RAMF::FlexObjects::FlexAnonymousObject.new
+    # => {}
+    # some_object.my_attribute = "Wow !"
+    # => "Wow !"
+    # some_object
+    # => {:my_attribute=>"Wow !"}
+    # some_object.my_attribute == some_object[:my_attribute]
+    # => true
+    #
+    class FlexAnonymousObject < Hash
+      
+      flex_alias ""
+      
+      def method_missing(method_name,*args,&block)
+        method_name = method_name.to_s 
+        if method_name[method_name.length-1,1] == "="
+          self["#{method_name[0,method_name.length-1]}".to_sym] = args.first
+        else
+          self["#{method_name}".to_sym]
+        end
+      end
+      
+      
+#      def flex_dynamic_members(scope = :default)
+#        self.keys.inject({}) {|mem, key| mem[key.to_s] = self[key]; mem}
+#      end
+      
+    end
+  end
+end

data/lib/ramf/flex_objects/flex_object.rb

@@ -0,0 +1,13 @@
+module RAMF
+  module FlexObjects
+    class FlexObject < FlexAnonymousObject
+  
+      attr_reader :_explicitType
+
+      def initialize(_explicitType)
+        super
+        @_explicitType = _explicitType
+      end
+    end
+  end
+end

data/lib/ramf/flex_objects/remoting_message.rb

@@ -0,0 +1,26 @@
+require 'base64'
+
+class RAMF::FlexObjects::RemotingMessage
+  flex_alias 'flex.messaging.messages.RemotingMessage'
+  flex_remoting_members :operation, :source, :correlationId, :clientId, 
+                        :messageId, :body, :timestamp, :timeToLive, 
+                        :destination, :headers
+                        
+  attr_accessor :operation, :source, :correlationId, :clientId, 
+                :messageId, :body, :timestamp, :timeToLive, 
+                :destination, :headers
+                
+  def credentials_header
+    RAMF::Util.extract_credentials(headers[:DSRemoteCredentials].to_s) || {:userid => nil, :password => nil}
+  end
+  
+  #construct an Operation object from the remoting message <tt>message</tt>
+  def to_operation
+    RAMF::OperationRequest.new :service => RAMF::Util.service_name(destination.to_s),
+                               :method => RAMF::Util.method_name(operation.to_s),
+                               :args => body,
+                               :credentials => credentials_header,
+                               :messageId=>messageId
+  end
+  
+end

data/lib/ramf/io/common_read_write.rb

@@ -0,0 +1,73 @@
+module RAMF
+  module IO
+    module CommonReadWrite
+      BigEndian = :BigEndian
+      LittleEndian = :LittleEndian
+      @@BYTE_ORDER = nil
+      
+      #examines the locale byte order on the running machine
+      def byte_order
+        if @@BYTE_ORDER.nil?
+          @@BYTE_ORDER = ([0x12345678].pack("L") == "\x12\x34\x56\x78") ? :BigEndian : :LittleEndian  
+        end
+      end
+    
+      def byte_order_little?
+        (byte_order == :LittleEndian)
+      end
+    
+      def byte_order_big?
+        (byte_order == :BigEndian)
+      end
+      
+      def readU8(stream)
+        stream.read(1).unpack('C').first
+      end
+      
+      def readU16(stream)
+        stream.read(2).unpack('n').first
+      end
+      
+      def readU32(stream)
+        stream.read(4).unpack('N').first
+      end
+      
+      def read_double(stream)
+        stream.read(8).unpack('G').first
+      end
+      
+      def readUTF8(stream)
+        length = readU16(stream)
+        stream.read(length)
+      end
+      
+      def writeU8(val, stream)
+        stream.write [val].pack('C')
+      end
+      
+      def writeU16(val,stream)
+        stream.write [val].pack('n')
+      end
+      
+      #write an unsigned 32-bit integer in network (big-endian) byte order
+      def writeU32(val,stream)
+        stream.write [val].pack('N')
+      end
+      
+      def writeUTF8(string,stream)
+        writeU16(string.length,stream) 
+        stream.write string
+      end
+      
+      def writeUTF8Long(string,stream)
+        writeU32(string.length, stream)
+        stream.write string
+      end
+      
+      def write_double(val,stream)
+        stream.write( @double_mappings[val] ||= [val].pack('G'))
+      end
+      
+    end
+  end
+end

data/lib/ramf/io/constants.rb

@@ -0,0 +1,79 @@
+module RAMF
+  module IO
+    module Constants
+      #AMF0
+      AMF0_NUMBER = 0x00
+      AMF0_BOOLEAN = 0x01
+      AMF0_STRING = 0x02
+      AMF0_OBJECT = 0x03
+      AMF0_MOVIE_CLIP = 0x04
+      AMF0_NULL = 0x05
+      AMF0_UNDEFINED = 0x06
+      AMF0_REFERENCE = 0x07
+      AMF0_MIXED_ARRAY = 0x08
+      AMF0_EOO = 0x09
+      AMF0_ARRAY = 0x0A
+      AMF0_DATE = 0x0B
+      AMF0_LONG_STRING = 0x0C
+      AMF0_UNSUPPORTED = 0x0D
+      AMF0_RECORDSET = 0x0E
+      AMF0_XML = 0x0F
+      AMF0_TYPED_OBJECT = 0x10
+      
+      #AMF0 MARKERS
+      AMF0_NUMBER_MARKER = "\000"
+      AMF0_BOOLEAN_MARKER = "\001"
+      AMF0_STRING_MARKER = "\002"
+      AMF0_OBJECT_MARKER = "\003"
+      AMF0_MOVIE_CLIP_MARKER = "\004"
+      AMF0_NULL_MARKER = "\005"
+      AMF0_UNDEFINED_MARKER = "\006"
+      AMF0_REFERENCE_MARKER = "\007"
+      AMF0_ECMA_ARRAY_MARKER = "\010"
+      AMF0_OBJECT_END_MARKER = "\011"
+      AMF0_ARRAY_MARKER = "\012"
+      AMF0_DATE_MARKER = "\013"
+      AMF0_LONG_STRING_MARKER = "\014"
+      AMF0_UNSUPPORTED_MARKER = "\015"
+      AMF0_RECORDSET_MARKER = "\016"
+      AMF0_XML_MARKER = "\017"
+      AMF0_TYPED_OBJECT_MARKER = "\020"
+    
+      #AMF3
+      AMF3_TYPE         = 0x11
+      AMF3_UNDEFINED    = 0x00
+      AMF3_NULL         = 0x01
+      AMF3_FALSE        = 0x02
+      AMF3_TRUE         = 0x03
+      AMF3_INTEGER      = 0x04
+      AMF3_DOUBLE       = 0x05
+      AMF3_STRING       = 0x06
+      AMF3_XML_DOC      = 0x07
+      AMF3_DATE         = 0x08
+      AMF3_ARRAY        = 0x09
+      AMF3_OBJECT       = 0x0A
+      AMF3_XML          = 0x0B
+      AMF3_BYTE_ARRAY   = 0x0C
+      AMF3_INTEGER_MAX  = 268435455
+      AMF3_INTEGER_MIN  = -268435456
+      
+      #AMF3 Markers
+      AMF3_TYPE_MARKER         = "\021"
+      AMF3_UNDEFINED_MARKER    = "\000"
+      AMF3_NULL_MARKER         = "\001"
+      AMF3_FALSE_MARKER        = "\002"
+      AMF3_TRUE_MARKER         = "\003"
+      AMF3_INTEGER_MARKER      = "\004"
+      AMF3_DOUBLE_MARKER       = "\005"
+      AMF3_STRING_MARKER       = "\006"
+      AMF3_XML_DOC_MARKER      = "\007"
+      AMF3_DATE_MARKER         = "\010"
+      AMF3_ARRAY_MARKER        = "\011"
+      AMF3_OBJECT_MARKER       = "\012"
+      AMF3_XML_STRING_MARKER   = "\013"
+      AMF3_BYTE_ARRAY_MARKER   = "\014"
+      
+      AMF3_EMPTY_STRING = "\001"
+    end
+  end
+end