[Gnash-commit] /srv/bzr/gnash/rtmp r9643: Add support for operator= for Elemenbt types, as the first byte is often an AMF type.

[rob]

------------------------------------------------------------
revno: 9643
committer: address@hidden
branch nick: rtmp
timestamp: Fri 2008-09-19 17:57:20 -0600
message:
  Add support for operator= for Elemenbt types, as the first byte is often an 
AMF type.
modified:
  libamf/amf.cpp
  libamf/amf.h
  libamf/buffer.cpp
  libamf/buffer.h
  libamf/element.cpp

=== modified file 'libamf/amf.cpp'
--- a/libamf/amf.cpp    2008-08-13 19:26:51 +0000
+++ b/libamf/amf.cpp    2008-09-19 23:57:20 +0000
@@ -21,8 +21,7 @@
 #include "gnashconfig.h"
 #endif
 
-#include "GnashException.h"
-
+#include <boost/shared_ptr.hpp>
 #include <string>
 #include <vector>
 
@@ -33,6 +32,7 @@
 #endif
 
 #include "log.h"
+#include "GnashException.h"
 #include "buffer.h"
 #include "amf.h"
 #include "network.h"
@@ -173,17 +173,19 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeNumber(double indata)
 {
 //    GNASH_REPORT_FUNCTION;
     double num;
     // Encode the data as a 64 bit, big-endian, numeric value
-    Buffer *buf = new Buffer(AMF0_NUMBER_SIZE + 1); // only one additional 
byte for the type
-    buf->append(Element::NUMBER_AMF0);
+    // only one additional byte for the type
+    boost::shared_ptr<Buffer> buf(new Buffer(AMF0_NUMBER_SIZE + 1));
+    *buf->reference() = Element::NUMBER_AMF0;
+    buf->operator += (Element::NUMBER_AMF0);
     num = indata;
     swapBytes(&num, AMF0_NUMBER_SIZE);
-    buf->append(num);
+    buf += num;
     
     return buf;
 }
@@ -193,12 +195,12 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeBoolean(bool flag)
 {
 //    GNASH_REPORT_FUNCTION;
     // Encode a boolean value. 0 for false, 1 for true
-    Buffer *buf = new Buffer(2);
+    boost::shared_ptr<Buffer>buf = new Buffer(2);
     buf->append(Element::BOOLEAN_AMF0);
     buf->append(flag);
     
@@ -210,11 +212,11 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeObjectEnd()
 {
 //    GNASH_REPORT_FUNCTION;
-    Buffer *buf = new Buffer(1);
+    boost::shared_ptr<Buffer>buf = new Buffer(1);
     buf->append(TERMINATOR);
 
     return buf;
@@ -226,17 +228,17 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeObject(Element *el)
 {
     GNASH_REPORT_FUNCTION;
 //    AMF amf_obj;
     
     for (size_t i=0; i< el->propertiesSize(); i++) {
-//     Buffer *var = amf_obj.encodeProperty();
+//     boost::shared_ptr<Buffer>var = amf_obj.encodeProperty();
 //     Element *child = el[i];
 #if 0
-       Buffer *buf = new Buffer(AMF_HEADER_SIZE + size);
+       boost::shared_ptr<Buffer>buf = new Buffer(AMF_HEADER_SIZE + size);
        buf->append(Element::OBJECT);
        boost::uint32_t num = size;
        swapBytes(&num, 4);
@@ -256,11 +258,11 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeUndefined()
 {
 //    GNASH_REPORT_FUNCTION;
-    Buffer *buf = new Buffer(AMF_HEADER_SIZE);
+    boost::shared_ptr<Buffer>buf = new Buffer(AMF_HEADER_SIZE);
     buf->append(Element::UNDEFINED_AMF0);
     
     return buf;
@@ -271,11 +273,11 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeUnsupported()
 {
 //    GNASH_REPORT_FUNCTION;
-    Buffer *buf = new Buffer(AMF_HEADER_SIZE);
+    boost::shared_ptr<Buffer>buf = new Buffer(AMF_HEADER_SIZE);
     buf->append(Element::UNSUPPORTED_AMF0);
     
     return buf;
@@ -286,11 +288,11 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeDate(Network::byte_t *data)
 {
 //    GNASH_REPORT_FUNCTION;
-    Buffer *buf = new Buffer(AMF_HEADER_SIZE);
+    boost::shared_ptr<Buffer>buf = new Buffer(AMF_HEADER_SIZE);
     buf->append(Element::DATE_AMF0);
     double num = *reinterpret_cast<const double*>(data);
     swapBytes(&num, 8);
@@ -303,12 +305,12 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeNull()
 {
 //    GNASH_REPORT_FUNCTION;
 
-    Buffer *buf = new Buffer(1);
+    boost::shared_ptr<Buffer>buf = new Buffer(1);
     buf->append(Element::NULL_AMF0);
     
     return buf;
@@ -319,7 +321,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeXMLObject(Network::byte_t * /*data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -333,7 +335,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeTypedObject(Network::byte_t * /* data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -347,7 +349,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeReference(Network::byte_t * /* data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -361,7 +363,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeMovieClip(Network::byte_t * /*data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -375,7 +377,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeECMAArray(Network::byte_t * /*data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -389,7 +391,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeLongString(Network::byte_t * /* data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -403,7 +405,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeRecordSet(Network::byte_t * /* data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -417,7 +419,7 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeStrictArray(Network::byte_t * /* data */, size_t /* size */)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -431,20 +433,20 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeString(const string &str)
 {
     Network::byte_t *ptr = const_cast<Network::byte_t 
*>(reinterpret_cast<const Network::byte_t *>(str.c_str()));
     return encodeString(ptr, str.size());
 }
 
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeString(Network::byte_t *data, size_t size)
 {
 //    GNASH_REPORT_FUNCTION;
     boost::uint16_t length;
     
-    Buffer *buf = new Buffer(size + AMF_HEADER_SIZE);
+    boost::shared_ptr<Buffer>buf = new Buffer(size + AMF_HEADER_SIZE);
     buf->append(Element::STRING_AMF0);
     // when a string is stored in an element, we add a NULL terminator so
     // it can be printed by to_string() efficiently. The NULL terminator
@@ -464,13 +466,13 @@
 /// @return a binary AMF packet in big endian format (header,data) which
 /// needs to be deleted[] after being used.
 ///
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeNullString()
 {
 //    GNASH_REPORT_FUNCTION;
     boost::uint16_t length;
     
-    Buffer *buf = new Buffer(AMF_HEADER_SIZE);
+    boost::shared_ptr<Buffer>buf = new Buffer(AMF_HEADER_SIZE);
     buf->append(Element::STRING_AMF0);
     // when a string is stored in an element, we add a NULL terminator so
     // it can be printed by to_string() efficiently. The NULL terminator
@@ -499,12 +501,12 @@
 /// normal ASCII. It may be that these need to be converted to wide
 /// characters, but for now we just leave them as standard multibyte
 /// characters.
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeElement(Element *el)
 {
 //    GNASH_REPORT_FUNCTION;
-    Buffer *buf = 0;
-    Buffer *tmp = 0;
+    boost::shared_ptr<Buffer>buf = 0;
+    boost::shared_ptr<Buffer>tmp = 0;
     
     size_t outsize;
     if (el->getType() == Element::BOOLEAN_AMF0) {
@@ -611,7 +613,7 @@
     return buf;
 }
 
-Buffer *
+boost::shared_ptr<Buffer>
 AMF::encodeProperty(amf::Element *el)
 {
 //    GNASH_REPORT_FUNCTION;
@@ -619,7 +621,7 @@
     
     outsize = el->getNameSize() + el->getLength() + AMF_VAR_HEADER_SIZE;
 
-    Buffer *buf = new Buffer(outsize);
+    boost::shared_ptr<Buffer>buf = new Buffer(outsize);
     _totalsize += outsize;
 
     // Add the length of the string for the name of the variable
@@ -663,7 +665,7 @@
 }
 
 Element *
-AMF::extractAMF(Buffer *buf)
+AMF::extractAMF(boost::shared_ptr<Buffer>buf)
 {
 //    GNASH_REPORT_FUNCTION;
     Network::byte_t* start = buf->reference();
@@ -836,7 +838,7 @@
 }
 
 Element *
-AMF::extractProperty(Buffer *buf)
+AMF::extractProperty(boost::shared_ptr<Buffer> buf)
 {
 //    GNASH_REPORT_FUNCTION;
 

=== modified file 'libamf/amf.h'
--- a/libamf/amf.h      2008-08-04 08:29:21 +0000
+++ b/libamf/amf.h      2008-09-19 23:57:20 +0000
@@ -35,6 +35,7 @@
 #include <cstring>
 #include <map>
 #include <boost/cstdint.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include "network.h"
 #include "element.h"
@@ -115,108 +116,108 @@
 
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeString(const std::string &str);
-    static Buffer *encodeString(gnash::Network::byte_t *data, size_t size);
+    static boost::shared_ptr<Buffer> encodeString(const std::string &str);
+    static boost::shared_ptr<Buffer> encodeString(gnash::Network::byte_t 
*data, size_t size);
 
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeNullString();
+    static boost::shared_ptr<Buffer> encodeNullString();
 
     /// Encode a Boolean object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeBoolean(bool flag);
+    static boost::shared_ptr<Buffer> encodeBoolean(bool flag);
 
     /// Encode an "Undefined" object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeUndefined();
+    static boost::shared_ptr<Buffer> encodeUndefined();
 
     /// Encode a "NULL" object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeNull();
+    static boost::shared_ptr<Buffer> encodeNull();
 
     /// Encode a "Unsupported" object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static  Buffer *encodeUnsupported();
+    static  boost::shared_ptr<Buffer> encodeUnsupported();
 
     /// Encode an XML object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeXMLObject(gnash::Network::byte_t *data, size_t size);
+    static boost::shared_ptr<Buffer> encodeXMLObject(gnash::Network::byte_t 
*data, size_t size);
 
     /// Encode a Typed Object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeTypedObject(gnash::Network::byte_t *data, size_t 
size);
+    static boost::shared_ptr<Buffer> encodeTypedObject(gnash::Network::byte_t 
*data, size_t size);
 
     /// Encode a Reference to an object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeReference(gnash::Network::byte_t *data, size_t size);
+    static boost::shared_ptr<Buffer> encodeReference(gnash::Network::byte_t 
*data, size_t size);
 
     /// Encode a Movie Clip
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeMovieClip(gnash::Network::byte_t *data, size_t size);
+    static boost::shared_ptr<Buffer> encodeMovieClip(gnash::Network::byte_t 
*data, size_t size);
 
     /// Encode an ECMA Array
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeECMAArray(gnash::Network::byte_t *data, size_t size);
+    static boost::shared_ptr<Buffer> encodeECMAArray(gnash::Network::byte_t 
*data, size_t size);
 
     /// Encode a long string
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeLongString(gnash::Network::byte_t *data, size_t size);
+    static boost::shared_ptr<Buffer> encodeLongString(gnash::Network::byte_t 
*data, size_t size);
 
     /// Encode a Record Set
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeRecordSet(gnash::Network::byte_t *data, size_t size);
+    static boost::shared_ptr<Buffer> encodeRecordSet(gnash::Network::byte_t 
*data, size_t size);
 
     /// Encode a Date
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeDate(gnash::Network::byte_t *data);
+    static boost::shared_ptr<Buffer> encodeDate(gnash::Network::byte_t *data);
 
     /// Encode a Strict Array
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeStrictArray(gnash::Network::byte_t *data, size_t 
size);
+    static boost::shared_ptr<Buffer> encodeStrictArray(gnash::Network::byte_t 
*data, size_t size);
     
     /// Encode an object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeObject(Element *el);
+    static boost::shared_ptr<Buffer> encodeObject(Element *el);
 
     /// Encode the end of an object
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeObjectEnd();
+    static boost::shared_ptr<Buffer> encodeObjectEnd();
 
     /// Encode a 64 bit number
     ///
     /// @return a binary AMF packet in big endian format (header,data)
     ///
-    static Buffer *encodeNumber(double num);
+    static boost::shared_ptr<Buffer> encodeNumber(double num);
 
     /// Encode a element. 
     ///
@@ -225,7 +226,7 @@
     /// @return a newly allocated byte array.
     /// to be deleted by caller using delete [] operator, or NULL
     ///
-    static Buffer *encodeElement(amf::Element *el);
+    static boost::shared_ptr<Buffer> encodeElement(amf::Element *el);
 
     /// Encode a variable. 
     //
@@ -237,8 +238,8 @@
     ///         in form of a newly allocated byte array.
     ///         to be deleted by caller using delete [] operator, or NULL
     ///
-    Buffer *encodeProperty(amf::Element *el);
-    static Buffer *encodeVariableHeader(const std::string &name);
+    boost::shared_ptr<Buffer> encodeProperty(amf::Element *el);
+    static boost::shared_ptr<Buffer> encodeVariableHeader(const std::string 
&name);
     
     //
     // Methods for extracting data from big endian formatted raw AMF data.
@@ -266,7 +267,7 @@
     amf::Element *extractAMF(gnash::Network::byte_t *in, 
gnash::Network::byte_t* tooFar);
 
     /// Extract an AMF object. These have no name like the variables do.
-    amf::Element *extractAMF(Buffer *buf);
+    amf::Element *extractAMF(boost::shared_ptr<Buffer>buf);
     
     /// \brief
     /// Extract an AMF "variable", which is a standard AMF object preceeded by
@@ -286,7 +287,7 @@
     /// \brief
     /// Extract an AMF "variable", which is a standard AMF object preceeded by
     /// just a length and a name field.
-    amf::Element *extractProperty(Buffer *buf);
+    amf::Element *extractProperty(boost::shared_ptr<Buffer> buf);
 
     size_t totalsize() { return _totalsize; }
     

=== modified file 'libamf/buffer.cpp'
--- a/libamf/buffer.cpp 2008-09-19 22:11:12 +0000
+++ b/libamf/buffer.cpp 2008-09-19 23:57:20 +0000
@@ -160,166 +160,6 @@
     return *this;
 }
 
-#if 0
-void
-Buffer::copy(const string &str)
-{    
-//    GNASH_REPORT_FUNCTION;
-    std::copy(str.begin(), str.end(), _ptr);
-    _seekptr = _ptr + str.size();
-}
-
-void
-Buffer::copy(boost::uint16_t length)
-{
-    Network::byte_t *data = reinterpret_cast<Network::byte_t *>(&length);
-    std::copy(data, data + sizeof(boost::uint16_t), _ptr);
-    _seekptr = _ptr + sizeof(boost::uint16_t);
-}
-
-void
-Buffer::copy(double num)
-{
-//    GNASH_REPORT_FUNCTION;
-    Network::byte_t *ptr = reinterpret_cast<Network::byte_t *>(&num);
-    std::copy(ptr, ptr + amf::AMF0_NUMBER_SIZE, _ptr);
-    _seekptr = _ptr + amf::AMF0_NUMBER_SIZE;
-}
-
-void
-Buffer::copy(Network::byte_t val)
-{
-    GNASH_REPORT_FUNCTION;
-    *_ptr = val;
-    _seekptr = _ptr + sizeof(bool);
-}
-#endif
-
-#if 0
-void
-Buffer::copy(bool val)
-{
-    GNASH_REPORT_FUNCTION;
-    return copy(static_cast<Network::byte_t>(val));
-}
-#endif
-
-#if 0
-Network::byte_t *
-Buffer::append(boost::uint16_t length)
-{
-//    GNASH_REPORT_FUNCTION;
-    
-    if ((_seekptr + sizeof(boost::uint16_t)) <= (_ptr + _nbytes)) {
-       Network::byte_t *data = reinterpret_cast<Network::byte_t *>(&length);
-       std::copy(data, data + sizeof(boost::uint16_t), _seekptr);
-       std::copy(data, data + sizeof(boost::uint16_t), _data.get());
-       _seekptr += sizeof(boost::uint16_t);
-       return _seekptr;
-    }
-    return 0;
-}
-
-Network::byte_t *
-Buffer::append(gnash::Network::byte_t *data, size_t nbytes)
-{
-//    GNASH_REPORT_FUNCTION;
-
-    if ((_seekptr + nbytes) <= (_ptr + _nbytes)) {
-       std::copy(data, data + nbytes, _seekptr);
-       _seekptr += nbytes;
-       return _seekptr;
-    }
-    return 0;
-}
-
-Network::byte_t *
-Buffer::append(double num)
-{
-//    GNASH_REPORT_FUNCTION;
-    if ((_seekptr + sizeof(double)) <= (_ptr + _nbytes)) {
-       Network::byte_t *ptr = reinterpret_cast<Network::byte_t *>(&num);
-       std::copy(ptr, ptr + amf::AMF0_NUMBER_SIZE, _seekptr);
-       _seekptr += amf::AMF0_NUMBER_SIZE;
-       return _seekptr;
-    }
-    return 0;
-}
-
-Network::byte_t *
-Buffer::append(bool val)
-{
-//    GNASH_REPORT_FUNCTION;
-    if ((_seekptr + sizeof(bool)) <= (_ptr + _nbytes)) {
-       *_seekptr = val;
-       _seekptr += sizeof(bool);
-       return _seekptr;
-    }
-    return 0;
-}
-
-Network::byte_t *
-Buffer::append(boost::uint32_t num)
-{
-//    GNASH_REPORT_FUNCTION;
-    Network::byte_t *ptr = reinterpret_cast< Network::byte_t *>(&num);    
-    return append(ptr, sizeof(boost::uint32_t));
-}
-
-Network::byte_t *
-Buffer::append(Network::byte_t byte)
-{
-//    GNASH_REPORT_FUNCTION;
-    if ((_seekptr + sizeof(gnash::Network::byte_t)) <= (_ptr + _nbytes)) {
-       *_seekptr = byte;
-       _seekptr += sizeof(gnash::Network::byte_t);
-       return _seekptr;
-    }
-    return 0;
-}
-
-Network::byte_t *
-Buffer::append(const std::string &str)
-{
-//    GNASH_REPORT_FUNCTION;
-    if ((_seekptr + str.size()) <= (_ptr + _nbytes)) {
-       std::copy(str.begin(), str.end(), _seekptr);    
-       _seekptr += str.size();
-       return _seekptr;
-    }
-    return 0;
-}
-
-Network::byte_t *
-Buffer::append(amf::Element::amf0_type_e type)
-{
-    return append(static_cast<Network::byte_t>(type));
-}
-
-Network::byte_t *
-Buffer::append(Buffer &buf)
-{
-//    GNASH_REPORT_FUNCTION;
-    return append(&buf);
-}
-
-Network::byte_t *
-Buffer::append(Buffer *buf)
-{
-//    GNASH_REPORT_FUNCTION;
-    size_t diff = _seekptr - _ptr;
-    
-    if (buf->size() > (_nbytes - diff)) {
-         resize(buf->size() + diff);
-    }
-    
-    std::copy(buf->begin(), buf->end(), _seekptr);
-    _seekptr += buf->size();
-
-    return _seekptr;
-}
-#endif
-
 // make ourselves be able to appended too. If the source
 // buffer is larger than the current buffer has room for,
 // resize ourselves (which copies the data too) to make
@@ -376,6 +216,7 @@
     return append(ptr, sizeof(boost::uint16_t));
 }
 
+
 Buffer &
 Buffer::operator=(Buffer &buf)
 {
@@ -413,6 +254,13 @@
 }
 
 Buffer &
+Buffer::operator=(amf::Element::amf0_type_e type)
+{
+    Network::byte_t nb = static_cast<Network::byte_t>(type);
+    return operator+=(nb);
+}
+
+Buffer &
 Buffer::operator=(gnash::Network::byte_t byte)
 {
 //    GNASH_REPORT_FUNCTION;

=== modified file 'libamf/buffer.h'
--- a/libamf/buffer.h   2008-09-19 22:11:12 +0000
+++ b/libamf/buffer.h   2008-09-19 23:57:20 +0000
@@ -60,7 +60,8 @@
     Buffer &operator=(double num);
     Buffer &operator=(boost::uint16_t length);
     Buffer &operator=(gnash::Network::byte_t byte);
-    Buffer &operator=(gnash::Network::byte_t *data);    
+    Buffer &operator=(gnash::Network::byte_t *data);
+    Buffer &operator=(amf::Element::amf0_type_e type);
     
     Buffer &operator+=(Buffer &buf);
     Buffer &operator+=(const std::string &str);
@@ -111,8 +112,7 @@
 #endif
   private:
     // Initialize a block of memory for this buffer
-    Buffer &init(size_t nbytes);
-    
+    Buffer &init(size_t nbytes);    
     gnash::Network::byte_t hex2digit (gnash::Network::byte_t digit);
 };
 

=== modified file 'libamf/element.cpp'
--- a/libamf/element.cpp        2008-09-18 04:05:29 +0000
+++ b/libamf/element.cpp        2008-09-19 23:57:20 +0000
@@ -544,10 +544,7 @@
     if (name.size()) {
         setName(name);
     }
-    _type = Element::NUMBER_AMF0;
-    check_buffer(AMF0_NUMBER_SIZE);
-    _buffer->copy(num);
-    return *this;
+    return makeNumber(num);
 }
 
 Element &