public:

using ObjectVector = std::vector<CefRefPtr<CefXmlObject>>;

using AttributeMap = std::map<CefString, CefString>;

///

/// Create a new object with the specified name. An object name must always be

/// at least one character long.

///

explicit CefXmlObject(const CefString& name);

CefXmlObject(const CefXmlObject&) = delete;

CefXmlObject& operator=(const CefXmlObject&) = delete;

///

/// Load the contents of the specified XML stream into this object. The

/// existing children and attributes, if any, will first be cleared.

///

bool Load(CefRefPtr<CefStreamReader> stream,

CefXmlReader::EncodingType encodingType,

const CefString& URI,

CefString* loadError);

///

/// Set the name, children and attributes of this object to a duplicate of the

/// specified object's contents. The existing children and attributes, if any,

/// will first be cleared.

///

void Set(CefRefPtr<CefXmlObject> object);

///

/// Append a duplicate of the children and attributes of the specified object

/// to this object. If |overwriteAttributes| is true then any attributes in

/// this object that also exist in the specified object will be overwritten

/// with the new values. The name of this object is not changed.

///

void Append(CefRefPtr<CefXmlObject> object, bool overwriteAttributes);

///

/// Return a new object with the same name, children and attributes as this

/// object. The parent of the new object will be NULL.

///

CefRefPtr<CefXmlObject> Duplicate();

///

/// Clears this object's children and attributes. The name and parenting of

/// this object are not changed.

///

void Clear();

///

/// Access the object's name. An object name must always be at least one

/// character long.

///

CefString GetName();

bool SetName(const CefString& name);

///

/// Access the object's parent. The parent can be NULL if this object has not

/// been added as the child on another object.

///

bool HasParent();

CefRefPtr<CefXmlObject> GetParent();

///

/// Access the object's value. An object cannot have a value if it also has

/// children. Attempting to set the value while children exist will fail.

///

bool HasValue();

CefString GetValue();

bool SetValue(const CefString& value);

///

/// Access the object's attributes. Attributes must have unique names.

///

bool HasAttributes();

size_t GetAttributeCount();

bool HasAttribute(const CefString& name);

CefString GetAttributeValue(const CefString& name);

bool SetAttributeValue(const CefString& name, const CefString& value);

size_t GetAttributes(AttributeMap& attributes);

void ClearAttributes();

///

/// Access the object's children. Each object can only have one parent so

/// attempting to add an object that already has a parent will fail. Removing

/// a child will set the child's parent to NULL. Adding a child will set the

/// child's parent to this object. This object's value, if any, will be

/// cleared if a child is added.

///

bool HasChildren();

size_t GetChildCount();

bool HasChild(CefRefPtr<CefXmlObject> child);

bool AddChild(CefRefPtr<CefXmlObject> child);

bool RemoveChild(CefRefPtr<CefXmlObject> child);

size_t GetChildren(ObjectVector& children);

void ClearChildren();

///

/// Find the first child with the specified name.

///

CefRefPtr<CefXmlObject> FindChild(const CefString& name);

///

/// Find all children with the specified name.

///

size_t FindChildren(const CefString& name, ObjectVector& children);

private:

// Protect against accidental deletion of this object.

friend class base::RefCountedThreadSafe<CefXmlObject>;

~CefXmlObject();

void SetParent(CefXmlObject* parent);

CefString name_;

CefXmlObject* parent_ = nullptr;

CefString value_;

AttributeMap attributes_;

ObjectVector children_;

base::Lock lock_;