element.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
//   Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_ELEMENT_H
#define GNASH_ELEMENT_H

#include <vector>
#include <string>
#include <cstring>
#include <iostream> // for output operator
#include <boost/cstdint.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>

//#include "network.h"
#include "dsodefs.h" // DSOEXPORT

namespace cygnal
{

// Forward decleration
class Buffer;

class DSOEXPORT Element {
public:
    typedef enum {
        NOTYPE            = -1,
        NUMBER_AMF0       = 0x00,
        BOOLEAN_AMF0      = 0x01,
        STRING_AMF0       = 0x02,
        OBJECT_AMF0       = 0x03,
        MOVIECLIP_AMF0    = 0x04,
        NULL_AMF0         = 0x05,
        UNDEFINED_AMF0    = 0x06,
        REFERENCE_AMF0    = 0x07,
        ECMA_ARRAY_AMF0   = 0x08,
        OBJECT_END_AMF0   = 0x09,
        STRICT_ARRAY_AMF0 = 0x0a,
        DATE_AMF0         = 0x0b,
        LONG_STRING_AMF0  = 0x0c,
        UNSUPPORTED_AMF0  = 0x0d,
        RECORD_SET_AMF0   = 0x0e,
        XML_OBJECT_AMF0   = 0x0f,
        TYPED_OBJECT_AMF0 = 0x10,
        AMF3_DATA         = 0x11,
//      // these aren't part of the AMF spec, they're used internally
        RTMP_HEADER       = 0x20
//      FUNCTION=0x12
    } amf0_type_e;
    
    typedef enum {
        UNDEFINED_AMF3 = 0x00,
        NULL_AMF3    = 0x01,
        FALSE_AMF3   = 0x02,
        TRUE_AMF3    = 0x03,
        INTEGER_AMF3 = 0x04,
        DOUBLE_AMF3  = 0x05,
        STRING_AMF3  = 0x06,
        XMLDOC_AMF3  = 0x07,
        DATE_AMF3    = 0x08,
        ARRAY_AMF3   = 0x09,
        OBJECT_AMF3  = 0x0a,
        XML_AMF3     = 0x0b,
        BYTES_AMF3   = 0x0c
    } amf3_type_e;

    Element();

    ~Element();

    Element(double data);

    Element(const std::string &name, double num);
    
    Element(const char *data);
    Element(const std::string &data);
    
    Element(const std::string &name, const std::string &data);
    
    Element(bool data);

    Element(const std::string &name, bool data);
    
    Element(std::vector<double> &data);

    Element(std::vector<std::string> &data);

    Element(std::vector<Element > &data);

    void clear();
    
#if 0
    // Create a function block for AMF
    Element(bool, double, double, const std::string &str);

    // Create a function block for AMF
    Element &init(bool, double, double, const std::string &str);
#endif
    
    Element &operator=(Element &el);
//    Element &operator=(boost::shared_ptr<Element>);

    Element &operator=(double num);
    
    Element &operator=(const std::string &str);

    Element &operator=(bool flag);

    Element &makeNullString();

    Element &makeString(const char *str, size_t size);
    Element &makeString(boost::uint8_t *data, size_t size);

    Element &makeString(const std::string &data);
    
    Element &makeString(const std::string &name, const std::string &str);

    Element &makeNumber(double num); 

    Element &makeNumber(boost::shared_ptr<cygnal::Buffer> buf); 

    Element &makeNumber(boost::uint8_t *data);
    
    Element &makeNumber(const std::string &name, double num) ;
    Element &makeNumber(const std::string &name, boost::uint8_t *data);

    Element &makeBoolean(boost::uint8_t *data);

    Element &makeBoolean(bool data);

    Element &makeBoolean(const std::string &name, bool data);
    
    Element &makeUndefined();

    Element &makeUndefined(const std::string &name);

    Element &makeNull();
    
    Element &makeNull(const std::string &name);

    Element &makeObjectEnd();

    Element &makeObject();

    Element &makeObject(const std::string &name);

    Element &makeObject(std::vector<boost::shared_ptr<cygnal::Element> > &data);
    
    Element &makeObject(const std::string &name, std::vector<boost::shared_ptr<cygnal::Element> > &data);
    
    Element &makeXMLObject();
    
    Element &makeXMLObject(const std::string &name);

    Element &makeXMLObject(const std::string &name, const std::string &data);
    Element &makeXMLObject(boost::uint8_t *data);

    Element &makeECMAArray();

    Element &makeECMAArray(const std::string &name);

    Element &makeECMAArray(std::vector<boost::shared_ptr<cygnal::Element> > &data);

    Element &makeECMAArray(const std::string &name, std::vector<boost::shared_ptr<cygnal::Element> > &data);

    Element &makeStrictArray();

    Element &makeStrictArray(const std::string &name);

    Element &makeStrictArray(std::vector<boost::shared_ptr<cygnal::Element> > &data);

    Element &makeStrictArray(const std::string &name, std::vector<boost::shared_ptr<cygnal::Element> > &data);

    Element &makeTypedObject();
    Element &makeTypedObject(const std::string &name);

    Element &makeTypedObject(boost::uint8_t *data);
    
    Element &makeReference();
    Element &makeReference(boost::uint16_t index);

    Element &makeReference(boost::uint8_t *data, size_t size);
    
    Element &makeMovieClip();

    Element &makeMovieClip(boost::uint8_t *data, size_t size);

    Element &makeLongString();
    
    Element &makeLongString(boost::uint8_t *data);
    
    Element &makeRecordSet();

    Element &makeRecordSet(boost::uint8_t *data);
    
    Element &makeDate();

    Element &makeDate(boost::uint8_t *data);
    Element &makeDate(double data);
    
    Element &makeUnsupported();

    Element &makeUnsupported(boost::uint8_t *data);
    
    bool operator==(Element &);
    
    bool operator==(boost::shared_ptr<cygnal::Element> );
    
    bool operator==(bool x);

    boost::shared_ptr<cygnal::Element> operator[](size_t index);

    size_t getDataSize() const;
    
    amf0_type_e getType() const { return _type; };
    
    void setType(amf0_type_e type) { _type = type; };
//    void setData(Buffer *buf) { _buffer = buf; };

    bool to_bool() const;
    
    double to_number() const;

    boost::uint16_t to_short() const;

    boost::uint32_t to_integer() const;

    const char *to_string() const;

    boost::uint8_t *to_reference();
    const boost::uint8_t *to_reference() const;

    // Manipulate the name of a property

    size_t getNameSize() const;
    
    char *getName() const { return _name; };

    void setName(const std::string &name);
    void setName(const char *name, size_t x);

    void setName(boost::uint8_t *name, size_t size);

    // Manipulate the children Elements of an object

    boost::shared_ptr<Element> findProperty(const std::string &name);

    boost::shared_ptr<Element> getProperty(size_t index) const { return _properties[index]; };

    void addProperty(boost::shared_ptr<Element> el) { _properties.push_back(el); };

    void clearProperties() { return _properties.clear(); };

    boost::shared_ptr<Element> popProperty()
                        { return _properties.front(); };

    size_t propertySize() const
                        { return _properties.size(); };

    boost::shared_ptr<Buffer> encode();
    boost::shared_ptr<Buffer> encode(bool notobject);

    std::vector<boost::shared_ptr<Element> > getProperties() const
                        { return _properties; };

    size_t calculateSize();
    size_t calculateSize(cygnal::Element &el) const;

    void dump() const { dump(std::cerr); }
    void dump(std::ostream& os) const;
    
private:
    void check_buffer(size_t size);

    char                *_name;
    
    boost::shared_ptr<cygnal::Buffer> _buffer;

    amf0_type_e         _type;

    std::vector<boost::shared_ptr<Element> > _properties;
};                              // end of class definition


inline std::ostream& operator << (std::ostream& os, const Element& el)
{
        el.dump(os);
        return os;
}


} // end of amf namespace

// end of _ELEMENT_H_
#endif

// local Variables:
// mode: C++
// indent-tabs-mode: nil
// End: