amf0.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <initializer_list>
#include <utility>
#include <promeki/namespace.h>
#include <promeki/pair.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/sharedptr.h>
#include <promeki/error.h>
#include <promeki/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Buffer;
class BufferView;
 
class Amf0Value {
        public:
                using List = promeki::List<Amf0Value>;
 
                using Field = promeki::Pair<promeki::String, Amf0Value>;
 
                using FieldList = promeki::List<Field>;
 
                enum Type {
                        Null,         
                        Undefined,    
                        Boolean,      
                        Number,       
                        String,       
                        Object,       
                        EcmaArray,    
                        StrictArray,  
                        Date,         
                        XmlDocument,  
                        TypedObject,  
                        Reference,    
                        Unsupported   
                };
 
                enum Marker : uint8_t {
                        MarkerNumber        = 0x00,
                        MarkerBoolean       = 0x01,
                        MarkerString        = 0x02,
                        MarkerObject        = 0x03,
                        MarkerMovieClip     = 0x04, 
                        MarkerNull          = 0x05,
                        MarkerUndefined     = 0x06,
                        MarkerReference     = 0x07,
                        MarkerEcmaArray     = 0x08,
                        MarkerObjectEnd     = 0x09, 
                        MarkerStrictArray   = 0x0A,
                        MarkerDate          = 0x0B,
                        MarkerLongString    = 0x0C, 
                        MarkerUnsupported   = 0x0D,
                        MarkerRecordSet     = 0x0E, 
                        MarkerXmlDocument   = 0x0F,
                        MarkerTypedObject   = 0x10,
                        MarkerAvmPlusObject = 0x11  
                };
 
                Amf0Value();
                Amf0Value(bool b);
                Amf0Value(double d);
                Amf0Value(int i);
                Amf0Value(int64_t i);
                Amf0Value(const promeki::String &s);
                Amf0Value(const char *s);
 
                Amf0Value(const Amf0Value &);
                Amf0Value(Amf0Value &&) noexcept;
                Amf0Value &operator=(const Amf0Value &);
                Amf0Value &operator=(Amf0Value &&) noexcept;
                ~Amf0Value();
 
                static Amf0Value undefined();
 
                static Amf0Value unsupported();
 
                static Amf0Value reference(uint16_t index);
 
                static Amf0Value object(std::initializer_list<Field> kv = {});
 
                static Amf0Value ecmaArray(std::initializer_list<Field> kv = {}, uint32_t countHint = 0);
 
                static Amf0Value strictArray(std::initializer_list<Amf0Value> items = {});
 
                static Amf0Value date(double msSinceEpoch, int16_t timezone = 0);
 
                static Amf0Value xmlDocument(const promeki::String &xml);
 
                static Amf0Value typedObject(const promeki::String &className,
                                             std::initializer_list<Field> kv = {});
 
                Type type() const;
 
                bool isNull() const { return type() == Null; }
                bool isUndefined() const { return type() == Undefined; }
                bool isBoolean() const { return type() == Boolean; }
                bool isNumber() const { return type() == Number; }
                bool isString() const { return type() == String; }
                bool isObject() const { return type() == Object; }
                bool isEcmaArray() const { return type() == EcmaArray; }
                bool isStrictArray() const { return type() == StrictArray; }
                bool isDate() const { return type() == Date; }
                bool isXmlDocument() const { return type() == XmlDocument; }
                bool isTypedObject() const { return type() == TypedObject; }
                bool isReference() const { return type() == Reference; }
                bool isUnsupportedMarker() const { return type() == Unsupported; }
 
                bool asBool(bool def = false) const;
                double asNumber(double def = 0.0) const;
                promeki::String asString(const promeki::String &def = promeki::String()) const;
 
                double dateMs() const;
                int16_t dateTimezone() const;
 
                uint16_t referenceIndex() const;
 
                const promeki::String &className() const;
 
                const FieldList &fields() const;
 
                FieldList &fields();
 
                const Amf0Value *find(const promeki::String &key) const;
 
                Amf0Value *find(const promeki::String &key);
 
                bool contains(const promeki::String &key) const;
 
                void setField(const promeki::String &key, Amf0Value value);
 
                uint32_t ecmaCountHint() const;
 
                void setEcmaCountHint(uint32_t count);
 
                const List &items() const;
 
                List &items();
 
                Error serialize(Buffer &out) const;
 
                promeki::String toDebugString(unsigned int indent = 0) const;
 
                bool operator==(const Amf0Value &other) const;
                bool operator!=(const Amf0Value &other) const { return !(*this == other); }
 
        private:
                struct Amf0Data;
                SharedPtr<Amf0Data> _d;
 
                // Out-of-line so the SharedPtr<Amf0Data> temporary destructor
                // only instantiates inside amf0.cpp (where Amf0Data is fully
                // defined) rather than at every include site.
                explicit Amf0Value(SharedPtr<Amf0Data> d);
};
 
class Amf0Reader {
        public:
                static Result<Amf0Value::List> read(const BufferView &view);
 
                static Result<Amf0Value::List> read(const uint8_t *data, size_t len);
 
                static Error readOne(const uint8_t *data, size_t len, size_t &offset, Amf0Value &out);
};
 
class Amf0Writer {
        public:
                explicit Amf0Writer(Buffer &out);
 
                Error writeNumber(double v);
                Error writeBoolean(bool v);
                Error writeString(const promeki::String &s);
                Error writeNull();
                Error writeUndefined();
                Error writeDate(double msSinceEpoch, int16_t timezone = 0);
                Error writeStrictArray(const Amf0Value::List &items);
                Error writeObject(const Amf0Value::FieldList &fields);
                Error writeEcmaArray(const Amf0Value::FieldList &fields, uint32_t countHint = 0);
                Error writeTypedObject(const promeki::String &className,
                                       const Amf0Value::FieldList &fields);
                Error writeXmlDocument(const promeki::String &xml);
                Error writeValue(const Amf0Value &v);
 
                size_t bytesWritten() const { return _bytesWritten; }
 
        private:
                Buffer &_out;
                size_t  _bytesWritten = 0;
 
                Error appendBytes(const void *bytes, size_t len);
                Error appendByte(uint8_t b);
                Error appendU16BE(uint16_t v);
                Error appendU32BE(uint32_t v);
                Error appendDoubleBE(double v);
                Error appendShortString(const promeki::String &s);   // 16-bit length prefix
                Error appendLongString(const promeki::String &s);    // 32-bit length prefix
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV