[Gnash-commit] /srv/bzr/gnash/rtmp r9635: Drop the Element::init() method, and improve allthe constructors instead.

[rob]

------------------------------------------------------------
revno: 9635
committer: address@hidden
branch nick: rtmp
timestamp: Wed 2008-09-17 21:41:34 -0600
message:
  Drop the Element::init() method, and improve allthe constructors instead.
  Properly build objects and arrays from a vector of elements.
modified:
  libamf/element.cpp
  libamf/element.h
  libcore/as_value.cpp
  libcore/asobj/SharedObject.cpp

=== modified file 'libamf/element.cpp'
--- a/libamf/element.cpp        2008-09-04 10:48:29 +0000
+++ b/libamf/element.cpp        2008-09-18 03:41:34 +0000
@@ -88,24 +88,24 @@
     delete[] _name;
 }
 
-
-Element::Element(Network::byte_t *indata) 
-    : _name(0),
-      _buffer(0),
-      _type(NOTYPE)
-{
-//    GNASH_REPORT_FUNCTION;
-    init(indata);
-}
-
+// Each Element has two main components, the optional name, and a value. All 
the properties
+// of an ActionScript class have the name set to a non null value, and without 
a name, the
+// Element just holds the lowest level AMF types.
 Element::Element(double indata)
     : _name(0),
       _buffer(0),
       _type(NOTYPE)
 {
 //    GNASH_REPORT_FUNCTION;
-    init(indata);
-}
+    makeNumber(indata);
+}
+
+Element::Element(const string &name, double num)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeNumber(name, num);
+}
+
 
 // Element(vector<double> &indata)
 // {
@@ -119,7 +119,16 @@
       _type(NOTYPE)
 {
 //    GNASH_REPORT_FUNCTION;
-    init(indata);
+    makeString(indata);
+}
+
+Element::Element(const char *indata)
+    : _name(0),
+      _buffer(0),
+      _type(NOTYPE)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeString(indata);
 }
 
 Element::Element(const string &name, const string &indata)
@@ -128,7 +137,16 @@
       _type(NOTYPE)
 {
 //    GNASH_REPORT_FUNCTION;
-    init(name, indata);
+    makeString(name, indata);
+}
+
+Element::Element(bool indata)
+    : _name(0),
+      _buffer(0),
+      _type(NOTYPE)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeBoolean(indata);
 }
 
 Element::Element(const string &name, bool indata)
@@ -137,16 +155,7 @@
       _type(NOTYPE)
 {
 //    GNASH_REPORT_FUNCTION;
-    init(name, indata);
-}
-
-Element::Element(bool indata)
-    : _name(0),
-      _buffer(0),
-      _type(NOTYPE)
-{
-//    GNASH_REPORT_FUNCTION;
-    init(indata);
+    makeBoolean(name, indata);
 }
 
 // Create a function block for AMF
@@ -157,9 +166,10 @@
       _type(NOTYPE)
 {
 //    GNASH_REPORT_FUNCTION;
-    init(flag, unknown1, unknown2, methodname);
+    log_unimpl("Can't create remote function calls yet");
 }
 
+#if 0
 Element &
 Element::init(bool flag, double unknown1, double unknown2,
              const string &methodname)
@@ -189,87 +199,13 @@
 //     memcpy(_data, &indata, _length);
     return *this;
 }
-
-Element &
-Element::init(double indata)
-{
-//    GNASH_REPORT_FUNCTION;
-    return init("", indata);
-}
-
-Element &
-Element::init(const string &name, double num)
-{
-//    GNASH_REPORT_FUNCTION;
-    _type = Element::NUMBER_AMF0;
-    if (name.size()) {
-        setName(name);
-    }
-    if (_buffer == 0) {
-       _buffer = new Buffer(AMF0_NUMBER_SIZE);
-    } else {
-       _buffer->resize(AMF0_NUMBER_SIZE);
-    }
-    _buffer->copy(num);
-    
-    return *this;
-}
-
-Element &
-Element::init(const string &indata)
-{
-//    GNASH_REPORT_FUNCTION;
-    return init("", indata);
-}
-
-Element &
-Element::init(const string &name, const string &str)
-{
-//    GNASH_REPORT_FUNCTION;
-    _type = Element::STRING_AMF0;
-    if (name.size()) {
-        setName(name);
-    }
-    if (_buffer == 0) {
-       _buffer = new Buffer(str.size());
-    } else {
-       _buffer->resize(str.size());
-    }
-    _buffer->copy(str);
-    
-    return *this;
-}
-
-Element &
-Element::init(bool indata)
-{
-//    GNASH_REPORT_FUNCTION;
-    return init("", indata);
-}
-
-Element &
-Element::init(const string &name, bool flag)
-{
-//    GNASH_REPORT_FUNCTION;
-    _type = Element::BOOLEAN_AMF0;
-    if (name.size()) {
-        setName(name);
-    }
-    if (_buffer == 0) {
-       _buffer = new Buffer(sizeof(bool));
-    } else {
-       _buffer->resize(sizeof(bool));
-    }
-    _buffer->append(flag);
-    
-    return *this;
-}
+#endif
 
 void
 Element::clear()
 {
 //    GNASH_REPORT_FUNCTION;
-       delete [] _name;
+       delete[] _name;
        _name = 0;
        delete _buffer;
        _buffer = 0;
@@ -312,7 +248,14 @@
 //    GNASH_REPORT_FUNCTION;
     if (_buffer) {
        if (_buffer->size() > 0) {
+#if 0
+           char *foo = new char[_buffer->size() + 1];
+           memset(foo, 0, _buffer->size() + 1);
+           memcpy(foo, _buffer->reference(), _buffer->size());
+           return foo;
+#else
            return reinterpret_cast<const char *>(_buffer->reference());
+#endif
        }
        return "NULL";
     }
@@ -396,6 +339,7 @@
     return false;
 };
 
+
 Buffer *
 Element::encode()
 {
@@ -479,6 +423,24 @@
     return *this;
 }
 
+Element &
+Element::operator=(double num)
+{
+    return makeNumber(num);
+}
+
+Element &
+Element::operator=(const string &str)
+{
+    return makeString(str);
+}
+
+Element &
+Element::operator=(bool flag)
+{
+    return makeBoolean(flag);
+}
+
 /// \brief Fill an element with data
 ///
 /// All Numbers are 64 bit, big-endian (network byte order) entities.
@@ -582,7 +544,10 @@
     if (name.size()) {
         setName(name);
     }
-    return makeNumber(num);
+    _type = Element::NUMBER_AMF0;
+//    check_buffer(AMF0_NUMBER_SIZE);
+//     _buffer->copy(num);
+    return *this;
 }
 
 Element &
@@ -680,17 +645,56 @@
     if (name.size()) {
         setName(name);
     }
+    return makeObject();
+}
+
+Element &
+Element::makeObject(const std::string &name, std::vector<Element *> &data)
+{
+//    GNASH_REPORT_FUNCTION;
     _type = OBJECT_AMF0;
-    return *this;
+    if (name.size()) {
+        setName(name);
+    }
+    return makeObject(data);
 }
 
 Element &
-Element::makeObject(Network::byte_t *indata, size_t size)
+Element::makeObject(std::vector<Element *> &data)
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::OBJECT_AMF0;
-    check_buffer(size);
-    _buffer->copy(indata, size);
+    vector<amf::Element *>::const_iterator ait;
+    for (ait = data.begin(); ait != data.end(); ait++) {
+       amf::Element *el = (*(ait));
+       addProperty(el);
+//     el->dump(os);
+    }
+}
+
+Element &
+Element::makeXMLObject()
+{
+//    GNASH_REPORT_FUNCTION;
+    _type = Element::XML_OBJECT_AMF0;
+    return *this;
+}
+
+Element &
+Element::makeXMLObject(const string &data)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeString(data);
+    _type = Element::XML_OBJECT_AMF0;
+    return *this;
+}
+
+Element &
+Element::makeXMLObject(const string &name, const string &data)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeXMLObject(name, data);
+    _type = Element::XML_OBJECT_AMF0;
     return *this;
 }
 
@@ -702,27 +706,6 @@
     return *this;
 }
 
-Element &
-Element::makeXMLObject(const std::string &name)
-{
-//    GNASH_REPORT_FUNCTION;
-    _type = Element::XML_OBJECT_AMF0;
-    if (name.size()) {
-        setName(name);
-    }
-    return *this;
-}
-
-Element &
-Element::makeXMLObject(Network::byte_t *indata, size_t size)
-{
-//    GNASH_REPORT_FUNCTION;
-    _type = Element::XML_OBJECT_AMF0;
-    check_buffer(size);
-    _buffer->copy(indata, size);
-    
-    return *this;
-}
 
 Element &
 Element::makeTypedObject(const std::string &name)
@@ -790,13 +773,68 @@
 }
 
 Element &
-Element::makeECMAArray(Network::byte_t *indata, size_t size)
-{
-//    GNASH_REPORT_FUNCTION;
-    _type = Element::ECMA_ARRAY_AMF0;
-    check_buffer(size);
-    _buffer->copy(indata, size);
-    return *this;    
+Element::makeECMAArray(const std::string &name)
+{
+//    GNASH_REPORT_FUNCTION;
+    if (name.size()) {
+        setName(name);
+    }
+    return makeECMAArray();
+}
+
+Element &
+Element::makeECMAArray(const std::string &name, std::vector<Element *> &data)
+{
+//    GNASH_REPORT_FUNCTION;
+    _type = Element::ECMA_ARRAY_AMF0;
+    makeObject(name, data);
+    _type = Element::ECMA_ARRAY_AMF0;
+    return *this;
+}
+
+Element &
+Element::makeECMAArray(std::vector<Element *> &data)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeObject(data);
+    _type = Element::ECMA_ARRAY_AMF0;
+    return *this;
+}
+
+Element &
+Element::makeStrictArray()
+{
+//    GNASH_REPORT_FUNCTION;
+    _type = Element::STRICT_ARRAY_AMF0;
+    return *this;
+}
+
+Element &
+Element::makeStrictArray(const std::string &name)
+{
+//    GNASH_REPORT_FUNCTION;
+    if (name.size()) {
+        setName(name);
+    }
+    return makeStrictArray();
+}
+
+Element &
+Element::makeStrictArray(const std::string &name, std::vector<Element *> &data)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeObject(name, data);
+    _type = Element::STRICT_ARRAY_AMF0;
+    return *this;
+}
+
+Element &
+Element::makeStrictArray(std::vector<Element *> &data)
+{
+//    GNASH_REPORT_FUNCTION;
+    makeObject(data);
+    _type = Element::STRICT_ARRAY_AMF0;
+    return *this;
 }
 
 Element &
@@ -854,23 +892,6 @@
     return makeNumber(date);
 }
 
-Element &
-Element::makeStrictArray()
-{
-//    GNASH_REPORT_FUNCTION;
-    _type = Element::STRICT_ARRAY_AMF0;
-    return *this;
-}
-
-Element &
-Element::makeStrictArray(Network::byte_t *indata, size_t size)
-{
-//    GNASH_REPORT_FUNCTION;    
-    _type = Element::STRICT_ARRAY_AMF0;
-    check_buffer(size);
-    _buffer->copy(indata, size);
-    return *this;
-}
 
 size_t
 Element::getNameSize()
@@ -882,6 +903,8 @@
     return 0;
 }
 
+// The name is for properties, which in AMF land is a string, followed by the 
AMF
+// element.
 void
 Element::setName(const string &str)
 {
@@ -909,7 +932,7 @@
            std::copy(name, name+size, _name);
            *(_name + size) = 0;
        } else {
-           log_debug("Got unprintable characters for the element name!");
+           log_error("Got unprintable characters for the element name!");
        }
     }
 }

=== modified file 'libamf/element.h'
--- a/libamf/element.h  2008-09-04 10:48:29 +0000
+++ b/libamf/element.h  2008-09-18 03:41:34 +0000
@@ -80,59 +80,104 @@
         BYTES_AMF3=0x0c,
     } amf3_type_e;
     Element();
-    Element(gnash::Network::byte_t *data);
+//    Element(gnash::Network::byte_t *data);
+    // Construct a Number
     Element(double data);
-    Element(std::vector<double> &data);
+    Element(const std::string &name, double data);
+    // Construct a String
+    Element(const char *data);
     Element(const std::string &data);
     Element(const std::string &name, const std::string &data);
+    // Construct a Boolean
     Element(bool data);
     Element(const std::string &name, bool data);
+
+    //.Construct a strict array, where each item is the same type
+    Element(std::vector<double> &data);
+    Element(std::vector<std::string> &data);
+
+    // Construct an ECMA array, which can contain any type
+    Element(std::vector<Element > &data);
+    
     // Create a function block for AMF
     Element(bool, double, double, const std::string &str);
+    
     ~Element();
     void clear();
-    Element &init(const std::string &name, double data);
-    Element &init(double data);
-    Element &init(std::vector<double> &data);
-    Element &init(const std::string &name, const std::string &data);
-    Element &init(const std::string &data);
-    Element &init(const std::string &name, bool data);
-    Element &init(bool data);
+#if 0
     // Create a function block for AMF
     Element &init(bool, double, double, const std::string &str);
+#endif
+    
+    // Make ourselves be the same as another Element.
+    Element &operator=(Element &);
+    Element &operator=(Element *);
 
+    // Make ourselves be the same as other commonly used data types. Note
+    // that this can;t be used for properties unless you call setName() later.
+    Element &operator=(double num);
+    Element &operator=(const std::string &str);
+    Element &operator=(bool flag);
+    
     // These create the other "special" AMF types.
-    Element &makeNullString(); 
-    Element &makeString(const char *str, size_t size); 
-    Element &makeString(gnash::Network::byte_t *data, size_t size); 
-    Element &makeString(const std::string &data); 
+
+    // A Null String is a string with a length of zero
+    Element &makeNullString();
+
+    // Make a string element
+    Element &makeString(const char *str, size_t size);
+    Element &makeString(gnash::Network::byte_t *data, size_t size);
+    Element &makeString(const std::string &data);
     Element &makeString(const std::string &name, const std::string &data);
-    
+
+    // Make a number element
     Element &makeNumber(double num); 
     Element &makeNumber(amf::Buffer *buf); 
-    Element &makeNumber(gnash::Network::byte_t *data); 
-    Element &makeNumber(const std::string &name, double num);
-    Element &makeNumber(const std::string &name, gnash::Network::byte_t 
*data); 
-    
-    Element &makeBoolean(gnash::Network::byte_t *data); 
-    Element &makeBoolean(bool data); 
+    Element &makeNumber(gnash::Network::byte_t *data);
+    Element &makeNumber(const std::string &name, double num) ;
+    Element &makeNumber(const std::string &name, gnash::Network::byte_t *data);
+
+    // Make a boolean element
+    Element &makeBoolean(gnash::Network::byte_t *data);
+    Element &makeBoolean(bool data);
     Element &makeBoolean(const std::string &name, bool data);
-    
+
+    // Make an undefined element
     Element &makeUndefined();
     Element &makeUndefined(const std::string &name);
-    
+
+    // Make a Null element, which is often used as a placeholder
     Element &makeNull();
     Element &makeNull(const std::string &name);
 
+    // Tterminate an object
     Element &makeObjectEnd();
 
+    // Make an AMF Object. This is an AMF type that support having properties.
     Element &makeObject();
     Element &makeObject(const std::string &name);
-    Element &makeObject(gnash::Network::byte_t *data, size_t size);
+    Element &makeObject(std::vector<Element *> &data);
+    Element &makeObject(const std::string &name, std::vector<Element *> &data);
     
+    // Make an XML Object. This is like a string object, but the type is 
different.
+    Element &makeXMLObject();
     Element &makeXMLObject(const std::string &name);
-    Element &makeXMLObject(gnash::Network::byte_t *data, size_t size);
-    
+    Element &makeXMLObject(const std::string &name, const std::string &data);
+
+    // Make an ECMA array. This is a mixed array of any AMF types. These are 
stored
+    // the same as an object, but with a different type.
+    Element &makeECMAArray();
+    Element &makeECMAArray(const std::string &name);
+    Element &makeECMAArray(std::vector<Element *> &data);
+    Element &makeECMAArray(const std::string &name, std::vector<Element *> 
&data);
+
+    // Make a Strict array. This is an array of a single AMF type. These are 
stored
+    // the same as an object, but with a different type.
+    Element &makeStrictArray();
+    Element &makeStrictArray(const std::string &name);
+    Element &makeStrictArray(std::vector<Element *> &data);
+    Element &makeStrictArray(const std::string &name, std::vector<Element *> 
&data);
+
     Element &makeTypedObject(const std::string &name);
     Element &makeTypedObject(gnash::Network::byte_t *data, size_t size);
     
@@ -142,9 +187,6 @@
     Element &makeMovieClip();
     Element &makeMovieClip(gnash::Network::byte_t *data, size_t size);
 
-    Element &makeECMAArray();
-    Element &makeECMAArray(gnash::Network::byte_t *data, size_t size);
-    
     Element &makeLongString();
     Element &makeLongString(gnash::Network::byte_t *data, size_t size);
     
@@ -157,8 +199,6 @@
     Element &makeUnsupported();
     Element &makeUnsupported(gnash::Network::byte_t *data, size_t size);
     
-    Element &makeStrictArray();
-    Element &makeStrictArray(gnash::Network::byte_t *data, size_t size);
 //    Element &makeArray();
 
 //    Element &makeConnect();
@@ -168,10 +208,6 @@
     bool operator==(Element *);
     bool operator==(bool x);
 
-    // Make ourselves be the same as another Element.
-    Element &operator=(Element &);
-    Element &operator=(Element *);
-    
     Element *operator[](size_t x);
 
     gnash::Network::byte_t *getData() const;

=== modified file 'libcore/as_value.cpp'
--- a/libcore/as_value.cpp      2008-09-17 07:27:11 +0000
+++ b/libcore/as_value.cpp      2008-09-18 03:41:34 +0000
@@ -144,13 +144,11 @@
                 if (!val.is_undefined()) {
                     str = val.to_string();
                 }
-                el = new amf::Element;
-                el->init(name, str);
+                el = new amf::Element(name, str);
             }
             if (val.is_bool()) {
                 bool flag = val.to_bool();
-                el = new amf::Element;
-                el->init(name, flag);
+                el = new amf::Element(name, flag);
             }
             if (val.is_number()) { 
                 double dub;
@@ -159,8 +157,7 @@
                 } else {
                     dub = val.to_number();
                 }
-                el = new amf::Element;
-                el->init(name, dub);
+                el = new amf::Element(name, dub);
             }
            
             if (el) {

=== modified file 'libcore/asobj/SharedObject.cpp'
--- a/libcore/asobj/SharedObject.cpp    2008-09-13 08:04:24 +0000
+++ b/libcore/asobj/SharedObject.cpp    2008-09-18 03:41:34 +0000
@@ -105,13 +105,11 @@
                 if (!val.is_undefined()) {
                     str = val.to_string();
                 }
-                el = new amf::Element;
-                el->init(name, str);
+                el = new amf::Element(name, str);
             }
             if (val.is_bool()) {
                 bool flag = val.to_bool();
-                el = new amf::Element;
-                el->init(name, flag);
+                el = new amf::Element(name, flag);
             }
             if (val.is_number()) { 
                 double dub;
@@ -120,8 +118,7 @@
                 } else {
                     dub = val.to_number();
                 }
-                el = new amf::Element;
-                el->init(name, dub);
+                el = new amf::Element(name, dub);
             }
 
             if (el) {