Fixed small bug which leads to an empty TV folder

1 files changed, 1576 insertions, 0 deletions

diff --git a/inc/object.h b/inc/object.h
new file mode 100644
index 0000000..bceb3f1
--- /dev/null
+++ b/inc/object.h
@@ -0,0 +1,1576 @@
+/* 
+ * File:   object.h
+ * Author: savop
+ *
+ * Created on 11. September 2009, 20:39
+ */
+
+#ifndef _OBJECT_H
+#define	_OBJECT_H
+
+#include "database.h"
+#include "../common.h"
+#include "util.h"
+#include <string.h>
+#include <vdr/tools.h>
+#include <map>
+#include <vector>
+#include <upnp/ixml.h>
+
+/**
+ * UPnP Object ID
+ *
+ * This is a UPnP Object ID representation.
+ */
+struct cUPnPObjectID {
+    int _ID;                    ///< The UPnP Object ID
+    /**
+     * Constructor
+     *
+     * Creates invalid ID
+     */
+    cUPnPObjectID():_ID(-1){}
+    /**
+     * Constructor
+     *
+     * Creates from long integer
+     */
+    cUPnPObjectID(
+        long ID         ///< new ID
+    ){ _ID = (int)ID; }
+    /**
+     * Constructor
+     *
+     * Creates from integer
+     */
+    cUPnPObjectID(
+        int ID          ///< new ID
+    ){ _ID = ID; }
+    /** Set the object ID */
+    cUPnPObjectID &operator=(
+        long ID         ///< new ID
+    ){ _ID = ID; return *this; }
+    /** @overload cUPnPObjectID &operator=(long ID) */
+    cUPnPObjectID &operator=(
+        int ID          ///< new ID
+    ){ _ID = ID; return *this; }
+    /** @overload cUPnPObjectID &operator=(long ID) */
+    cUPnPObjectID &operator=(
+        const cUPnPObjectID& ID     ///< new ID
+    ){ if(this != &ID){ _ID = ID._ID; } return *this; }
+    /** Pre increment the ID */
+    cUPnPObjectID &operator++(){ _ID++; return *this; }
+    /** Post increment the ID */
+    cUPnPObjectID operator++(int){ cUPnPObjectID old = *this; _ID++; return old; }
+    /** Post decrement the ID */
+    cUPnPObjectID operator--(int){ cUPnPObjectID old = *this; _ID--; return old; }
+    /** Pre decrement the ID */
+    cUPnPObjectID &operator--(){ _ID--; return *this; }
+    /** Not equal */
+    bool operator!=(
+        long ID         ///< compare with this ID
+    ){ return _ID != ID; }
+    /** Equal */
+    bool operator==(
+        long ID         ///< compare with this ID
+    ){ return _ID == ID; }
+    /** @overload bool operator!=(long ID) */
+    bool operator!=(
+        int ID          ///< compare with this ID
+    ){ return _ID != ID; }
+    /** @overload bool operator==(long ID) */
+    bool operator==(
+        int ID          ///< compare with this ID
+    ){ return _ID == ID; }
+    /** @overload bool operator!=(long ID) */
+    bool operator!=(
+        const cUPnPObjectID& ID ///< compare with this ID
+    ){ return *this == ID; }
+    /** @overload bool operator==(long ID) */
+    bool operator==(
+        const cUPnPObjectID& ID ///< compare with this ID
+    ){ return *this == ID; }
+    /** Casts to unsigned int */
+    operator unsigned int(){ return (unsigned int)_ID; }
+    /** Casts to int */
+    operator int(){ return _ID; }
+    /** Casts to long */
+    operator long(){ return (long)_ID; }
+    /** Casts to string */
+    const char* operator*(){ char* buf; return asprintf(&buf,"%d",_ID)?buf:NULL; }
+};
+
+/**
+ * Structure of a UPnP Class
+ *
+ * This represents a UPnP Class
+ */
+struct cClass {
+    cString ID;             ///< The upnp class ID
+    bool includeDerived;    ///< flag, to indicate if derived classes are allowed
+    /**
+     * Compares two classes
+     *
+     * @param cmp the other class to compare with
+     */
+    bool operator==(const cClass &cmp){ return (!strcasecmp(cmp.ID,ID) && includeDerived==cmp.includeDerived); }
+    /*! @copydoc operator==(const cClass &cmp) */
+    bool operator!=(const cClass &cmp){ return !(*this==cmp); }
+};
+
+class cUPnPClassObject;
+class cUPnPObjectMediator;
+class cUPnPContainerMediator;
+class cUPnPClassContainer;
+class cUPnPResource;
+
+/**
+ * List of UPnP Objects
+ *
+ * This is a cList of UPnP Objects
+ * The list can be sorted by using a specific property
+ */
+class cUPnPObjects : public cList<cUPnPClassObject> {
+public:
+    cUPnPObjects();
+    virtual ~cUPnPObjects();
+    /**
+     * Sorts the list
+     *
+     * This sorts the list by a specific property and a certain direction
+     */
+    void SortBy(
+        const char* Property,       ///< the property used for sorting
+        bool Descending = false     ///< the direction of the sort
+    );
+};
+
+/**
+ * The UPnP class Object
+ *
+ * This is a UPnP class Object representation with all its properties.
+ */
+class cUPnPClassObject : public cListObject {
+    friend class cMediaDatabase;
+    friend class cUPnPObjectMediator;
+    friend class cUPnPClassContainer;
+private:
+    cUPnPObjectID           mLastID;
+    bool                    mDeleted;                   // is this Objected marked as deleted, NOT used yet.
+protected:
+    time_t                  mLastModified;              ///< The last modification of this property
+    cUPnPObjectID           mID;                        ///< The object ID
+    cUPnPClassObject*       mParent;                    ///< The parent object
+    cString                 mClass;                     ///< Class (Who am I?)
+    cString                 mTitle;                     ///< Object title
+    cString                 mCreator;                   ///< Creator of this object
+    bool                    mRestricted;                ///< Ability of changing metadata?
+    int                     mWriteStatus;               ///< Ability of writing resources?
+    cList<cUPnPResource>*   mResources;                 ///< The resources of this object
+    cHash<cUPnPResource>*   mResourcesID;               ///< The resources of this object as hashmap
+    IXML_Document*          mDIDLFragment;              ///< The DIDL fragment of the object
+    cString                 mSortCriteria;              ///< The sort criteria to sort with
+    bool                    mSortDescending;            ///< The direction of the sort
+    cUPnPClassObject();
+    /**
+     * Set the Object ID
+     *
+     * This is only allowed by mediators and the media database. Manually editing
+     * the object ID may result in unpredictable behavior.
+     *
+     * @param ID the ObjectID of this object
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     */
+    int setID(cUPnPObjectID ID);
+    /**
+     * Set the Parent Object
+     *
+     * This is only allowed by mediators and the media database. Manually editing
+     * the parent may result in unpredictable behavior.
+     *
+     * @param Parent the parent of this object
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     */
+    int setParent(cUPnPClassContainer* Parent);
+    /**
+     * Set the object class
+     *
+     * This is only allowed by mediators and the media database. Manually editing
+     * the object class may result in unpredictable behavior.
+     *
+     * @param Class the class of this object
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     */
+    int setClass(const char* Class);
+    /**
+     * Set the modification time
+     *
+     * This sets the last modification time to the current timestamp. This is
+     * used to indicate when the object was updated the last time.
+     */
+    void setModified(void){ this->mLastModified = time(NULL); }
+public:
+    /**
+     * Last modified
+     *
+     * Returns when the object was modified the last time.
+     *
+     * @return last modification timestamp
+     */
+    time_t  modified() const { return this->mLastModified; }
+    virtual ~cUPnPClassObject();
+    /**
+     * Compares a object
+     *
+     * This compares a given object with this object
+     * It uses the SortCriteria to compare them.
+     *
+     * @return returns
+     * - \bc >0, if the object comes after this one
+     * - \bc 0, if the objects have the same property
+     * - \bc <0, if the object comes before this one
+     * @param ListObject the object to compare with
+     */
+    virtual int Compare(const cListObject& ListObject) const;
+    /**
+     * Get the properties of the object
+     *
+     * This returns a property list with all the properties which can be obtained
+     * or set with \c getProperty or \c setProperty.
+     *
+     * @return a stringlist with the properties
+     */
+    virtual cStringList* getPropertyList();
+    /**
+     * Gets a property
+     *
+     * Returns the value of a specified property. The value is converted into a
+     * string.
+     *
+     * @return returns
+     * - \bc true, if the property exists
+     * - \bc false, otherwise
+     * @param Property the property which should be returned
+     * @param Value the value of that property
+     */
+    virtual bool getProperty(const char* Property, char** Value) const ;
+    /**
+     * Sets a property
+     *
+     * Sets the value of a specified property. The value is converted from string
+     * into the propper data type
+     *
+     * @return returns
+     * - \bc true, if the property exists
+     * - \bc false, otherwise
+     * @param Property the property which should be set
+     * @param Value the value of that property
+     */
+    virtual bool setProperty(const char* Property, const char* Value);
+    /**
+     * Converts to container
+     *
+     * This will convert the object into a container if it is one. If not, it
+     * returns \bc NULL.
+     *
+     * @return returns
+     * - \bc NULL, if it is not a container
+     * - a container representation of this object
+     */
+    virtual cUPnPClassContainer* getContainer(){ return NULL; }
+    /**
+     * Create the DIDL fragment
+     *
+     * This creates the DIDL-Lite fragment of the object. The DIDL is written to the
+     * specified \em IXML document. The details of the output can be controlled via
+     * the filter stringlist
+     *
+     * @return the DIDL fragment of the object
+     * @param Document the IXML document where to write the contents
+     * @param Filter the string list with the filter criteria
+     */
+    virtual IXML_Node* createDIDLFragment(IXML_Document* Document, cStringList* Filter) = 0;
+    /**
+     * Is this a container?
+     *
+     * Returns if this object is a container or not
+     *
+     * @return returns
+     * - \bc true, if it is a container
+     * - \bc false, otherwise
+     */
+    bool isContainer(){ return this->getContainer()==NULL?false:true; }
+    /**
+     * Set the sort criteria
+     *
+     * This sets a certain criteria which the object can be compared with.
+     *
+     * @param Property the property to sort after
+     * @param Descending sort the objects in descending order
+     */
+    void setSortCriteria(const char* Property, bool Descending = false);
+    /**
+     * Clears the sort criteria
+     *
+     * Clears the property of the sort criteria and sets the descending flag to
+     * false.
+     */
+    void clearSortCriteria();
+    /******* Setter *******/
+    /**
+     * Set the title
+     *
+     * This sets the title of the object. It is a required metadata information.
+     * It must not be \bc NULL or an empty string.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Title the title of the object
+     */
+    int setTitle(const char* Title);
+    /**
+     * Set the creator
+     *
+     * The creator of an object is primarily the creator or owner of the object
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Creator the creator of the object
+     */
+    int setCreator(const char* Creator);
+    /**
+     * Set the restriction
+     *
+     * This sets the restriction flag. If the object is restricted, no modifications
+     * to its metadata by the user are allowed.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Restricted \bc true, to disallow modification, \bc false to allow it
+     */
+    int setRestricted(bool Restricted);
+    /**
+     * Set the write status
+     *
+     * This sets the write status of a resource. With this indicator, you can set
+     * the modifiabilty of resources by a control point.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Status the write status
+     */
+    int setWriteStatus(int Status);
+    /**
+     * Set the resources
+     *
+     * This sets the list of resources of an object. The list usally contain a
+     * single resource. However, multiple resources a also very common.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Resources the resource list of this object
+     */
+    int setResources(cList<cUPnPResource>* Resources);
+    /**
+     * Add resource to list
+     *
+     * This adds the specified resource to the resource list of the object
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Resource the resource to be added
+     */
+    int addResource(cUPnPResource* Resource);
+    /**
+     * Remove resource from list
+     *
+     * This removes the specified resource from the resource list of the object
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Resource the resource to be removed
+     */
+    int removeResource(cUPnPResource* Resource);
+    /******* Getter *******/
+    /**
+     * Get the object ID
+     *
+     * This returns the object ID of the object.
+     *
+     * @return the object ID
+     */
+    cUPnPObjectID getID() const { return this->mID; }
+    /**
+     * Get the parent ID
+     *
+     * This returns the ID of the parent container object, associated with this object.
+     * It is \bc -1, if the object is the root object.
+     *
+     * @return the parent ID
+     */
+    cUPnPObjectID getParentID() const { return this->mParent?this->mParent->getID():cUPnPObjectID(-1); }
+    /**
+     * Get the parent object
+     *
+     * This returns the parent container object, associated with this object. It is
+     * \bc NULL, if the object is the root object.
+     *
+     * @return the parent object
+     */
+    cUPnPClassContainer* getParent() const { return (cUPnPClassContainer*)this->mParent; }
+    /**
+     * Get the title
+     *
+     * This returns the title of the object. This may be the title of an item or
+     * the folder name in case of a container.
+     *
+     * @return the title of the object
+     */
+    const char* getTitle() const { return this->mTitle; }
+    /**
+     * Get the object class
+     *
+     * This returns the object class of the object. The classes are defined by
+     * the UPnP Working Committee. However, custom classes which are derived from
+     * a standardized class are also possible.
+     *
+     * @return the class of the object
+     */
+    const char* getClass() const { return this->mClass; }
+    /**
+     * Get the creator
+     *
+     * This returns the creator of the object. Usually, this is the primary
+     * content creator or the owner of the object
+     *
+     * @return the creator of the object
+     */
+    const char* getCreator() const { return this->mCreator; }
+    /**
+     * Is the resource restricted?
+     *
+     * Returns \bc true, if the object is restricted or \bc false, otherwise.
+     * When the object is restricted, then modifications to the metadata of the
+     * object are disallowed.
+     *
+     * @return returns
+     * - \bc true, if the object is restricted
+     * - \bc false, otherwise
+     */
+    bool        isRestricted() const { return this->mRestricted; }
+    /**
+     * Get write status
+     *
+     * This returns the write status of the object. It gives information, if the
+     * resource is modifiable.
+     *
+     * @return the write status
+     */
+    int getWriteStatus() const { return this->mWriteStatus; }
+    /**
+     * Get a resource by its ID
+     *
+     * Returns the resource with the specified resource ID.
+     *
+     * @return the resource by ID
+     * @param ResourceID the resource ID of the demanded resource
+     */
+    cUPnPResource* getResource(unsigned int ResourceID) const { return this->mResourcesID->Get(ResourceID); }
+    /**
+     * Get the resources
+     *
+     * This returns a list with resources associated with this object.
+     *
+     * @return the resources of this object
+     */
+    cList<cUPnPResource>* getResources() const { return this->mResources; }
+};
+
+/**
+ * The UPnP class Item
+ *
+ * This is a UPnP class Item representation with all its properties.
+ */
+class cUPnPClassItem : public cUPnPClassObject {
+    friend class cMediaDatabase;
+    friend class cUPnPObjectMediator;
+    friend class cUPnPItemMediator;
+protected:
+//    cUPnPObjectID             mReferenceID;
+    cUPnPClassItem*           mReference;                                       ///< The reference item
+    /**
+     * Constructor of an item
+     *
+     * This creates a new instance of an item
+     */
+    cUPnPClassItem();
+public:
+    virtual ~cUPnPClassItem(){};
+    virtual cStringList* getPropertyList();
+    virtual IXML_Node* createDIDLFragment(IXML_Document* Document, cStringList* Filter);
+    virtual bool setProperty(const char* Property, const char* Value);
+    virtual bool getProperty(const char* Property, char** Value) const;
+    /******** Setter ********/
+    /**
+     * Set a reference item
+     *
+     * This sets a reference item. Its comparable with symlinks in *nix systems
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Reference the reference item
+     */
+    int setReference(cUPnPClassItem* Reference);
+    /******** Getter ********/
+    /**
+     * Get the referenced item
+     *
+     * This returns the referenced item of this item
+     *
+     * @return the referenced item
+     */
+    cUPnPClassItem* getReference() const { return this->mReference; }
+    /**
+     * Get the reference ID
+     *
+     * This returns the object ID of the referenced item or \b -1, if
+     * no reference exists.
+     *
+     * @return the reference ID
+     */
+    cUPnPObjectID   getReferenceID() const { return this->mReference?this->mReference->getID():cUPnPObjectID(-1); }
+};
+
+typedef std::vector<cClass> tClassVector;
+
+/**
+ * The UPnP class Container
+ *
+ * This is a UPnP class Container representation with all its properties.
+ */
+class cUPnPClassContainer : public cUPnPClassObject {
+    friend class cMediaDatabase;
+    friend class cUPnPObjectMediator;
+    friend class cUPnPContainerMediator;
+protected:
+    cString                     mContainerType;                                 ///< DLNA container type
+    tClassVector                mSearchClasses;                                 ///< Classes which are searchable
+    tClassVector                mCreateClasses;                                 ///< Classes which are creatable
+    bool                        mSearchable;                                    ///< Is the Container searchable?
+    unsigned int                mUpdateID;                                      ///< The containerUpdateID
+    cUPnPObjects*               mChildren;                                      ///< List of children
+    cHash<cUPnPClassObject>*    mChildrenID;                                    ///< List of children as hash map
+    /**
+     * Update the container
+     *
+     * This performs an update, which acutally increases the containerUpdateID.
+     */
+    void update();
+    /**
+     * Sets the containerUpdateID
+     *
+     * This method should only be used when the containerUpdateID is loaded from
+     * the database.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param UID the containerUpdateID
+     */
+    int setUpdateID(unsigned int UID);
+    /**
+     * Constructor of a container
+     *
+     * This creates a new instance of a container
+     */
+    cUPnPClassContainer();
+public:
+    virtual ~cUPnPClassContainer();
+    virtual cStringList* getPropertyList();
+    virtual IXML_Node* createDIDLFragment(IXML_Document* Document, cStringList* Filter);
+    virtual bool setProperty(const char* Property, const char* Value);
+    virtual bool getProperty(const char* Property, char** Value) const;
+    virtual cUPnPClassContainer* getContainer(){ return this; }
+    /**
+     * Add a child
+     *
+     * This adds the specified child to this container. The parent container of the
+     * child will be set to this container.
+     *
+     * @param Object the child to be added
+     */
+    void addObject(cUPnPClassObject* Object);
+    /**
+     * Remove a child
+     *
+     * This removes the specified child from the list of children. The child will
+     * also loose its parent container, so that there is no link between left.
+     *
+     * @param Object the child to be removed
+     */
+    void removeObject(cUPnPClassObject* Object);
+    /**
+     * Get a child by ID
+     *
+     * Returns the child, which is specified by the \c ObjectID.
+     *
+     * @return the child with the specified ID
+     * @param ID the \c ObjectID of the child
+     */
+    cUPnPClassObject* getObject(cUPnPObjectID ID) const;
+    /**
+     * Get the list of children
+     *
+     * This returns a list of the children of the container.
+     *
+     * @return the list of children
+     */
+    cUPnPObjects* getObjectList() const { return this->mChildren; }
+    /**
+     * Add a search class
+     *
+     * This adds a search class to the search classes vector
+     *
+     * @return returns
+     * - \bc 0, if adding was successful
+     * - \bc <0, otherwise
+     * @param SearchClass the new class to be added
+     */
+    int addSearchClass(cClass SearchClass);
+    /**
+     * Remove a search class
+     *
+     * This removes a search class from the search classes vector
+     *
+     * @return returns
+     * - \bc 0, if deleting was successful
+     * - \bc <0, otherwise
+     * @param SearchClass the class to be deleted
+     */
+    int delSearchClass(cClass SearchClass);
+    /**
+     * Add a create class
+     *
+     * This adds a create class to the create classes vector
+     *
+     * @return returns
+     * - \bc 0, if adding was successful
+     * - \bc <0, otherwise
+     * @param CreateClass the new class to be added
+     */
+    int addCreateClass(cClass CreateClass);
+    /**
+     * Remove a create class
+     *
+     * This removes a create class from the create classes vector
+     *
+     * @return returns
+     * - \bc 0, if deleting was successful
+     * - \bc <0, otherwise
+     * @param CreateClass the class to be deleted
+     */
+    int delCreateClass(cClass CreateClass);
+    /******** Setter ********/
+    /**
+     * Set the DLNA container type
+     *
+     * This sets the DLNA container type. It must be a valid container type value.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Type the DLNA container type
+     */
+    int setContainerType(const char* Type);
+    /**
+     * Sets the search classes
+     *
+     * This sets the search classes, which allows the user to search only for
+     * these classes in the current container and its children. If the vector
+     * is empty the search can return any match. If the additional flag \bc
+     * derived is set, then also any derived classes are matched.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param SearchClasses a vector container the allowed search classes
+     */
+    int setSearchClasses(std::vector<cClass> SearchClasses);
+    /**
+     * Sets the create classes
+     *
+     * This sets the create classes, which allows the user to create new objects
+     * in this container, if \em restricted is \bc false.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param CreateClasses a vector containing the create classes
+     */
+    int setCreateClasses(std::vector<cClass> CreateClasses);
+    /**
+     * Sets the searchable flag
+     *
+     * This sets the searchable flag, which allows or disallows search on this
+     * container.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Searchable \bc true, to enable or \bc false, to disable searching
+     */
+    int setSearchable(bool Searchable);
+    /******** Getter ********/
+    /**
+     * Get the DLNA container type
+     *
+     * This returns the DLNA container type. Currently there are only these possible
+     * values beside \bc NULL:
+     * - \bc TUNER_1_0
+     *
+     * @return the DLNA container type
+     */
+    const char*   getContainerType() const { return this->mContainerType; }
+    /**
+     * Get the search classes
+     *
+     * This returns a vector container all possible search classes. This are classes,
+     * which can be used for searching in this container.
+     *
+     * @return a vector with all search classes
+     */
+    const std::vector<cClass>* getSearchClasses() const { return &(this->mSearchClasses); }
+    /**
+     * Get the create classes
+     *
+     * This returns a vector containing all possible create classes. This are classes,
+     * which can be created in this container. For instance a TV container can only create
+     * items of the class VideoBroadcast. The vector is empty when creation of new items
+     * by the user is not allowed.
+     *
+     * @return a vector with create classes
+     */
+    const std::vector<cClass>* getCreateClasses() const { return &(this->mCreateClasses); }
+    /**
+     * Is this container searchable
+     *
+     * This returns \bc true, if the container can be search via \em Search or
+     * \bc false, otherwise.
+     *
+     * @return returns
+     * - \bc true, if the container is searchable
+     * - \bc false, otherwise
+     */
+    bool          isSearchable() const { return this->mSearchable; }
+    /**
+     * Get the number of children
+     *
+     * This returns the total number of children of this container
+     *
+     * @return the number of childen
+     */
+    unsigned int getChildCount() const { return this->mChildren->Count(); }
+    /**
+     * Get the containerUpdateID
+     *
+     * This returns the containerUpdateID
+     *
+     * @return the containerUpdateID of this container
+     */
+    unsigned int getUpdateID() const { return this->mUpdateID; }
+    /**
+     * Has the container been updated?
+     *
+     * This returns \bc true, if the container was recently updated or
+     * \bc false, otherwise
+     *
+     * @return returns
+     * - \bc true, if the container was updated
+     * - \bc false, otherwise
+     */
+    bool         isUpdated();
+};
+
+/**
+ * The UPnP class VideoItem
+ *
+ * This is a UPnP class VideoItem representation with all its properties.
+ */
+class cUPnPClassVideoItem : public cUPnPClassItem {
+    friend class cMediaDatabase;
+    friend class cUPnPObjectMediator;
+    friend class cUPnPVideoItemMediator;
+protected:
+    cString             mGenre;                                                 ///< Genre of the video
+    cString             mDescription;                                           ///< Description
+    cString             mLongDescription;                                       ///< a longer description
+    cString             mPublishers;                                            ///< CSV of Publishers
+    cString             mLanguage;                                              ///< RFC 1766 Language code
+    cString             mRelations;                                             ///< Relation to other contents
+    cString             mProducers;                                             ///< CSV of Producers
+    cString             mRating;                                                ///< Rating (for parential control)
+    cString             mActors;                                                ///< CSV of Actors
+    cString             mDirectors;                                             ///< CSV of Directors
+    /**
+     * Constructor of a video item
+     *
+     * This creates a new instance of a video item
+     */
+    cUPnPClassVideoItem();
+public:
+    virtual ~cUPnPClassVideoItem();
+    //virtual cString createDIDLFragment(cStringList* Filter);
+    virtual cStringList* getPropertyList();
+    virtual bool setProperty(const char* Property, const char* Value);
+    virtual bool getProperty(const char* Property, char** Value) const;
+    /******** Setter ********/
+    /**
+     * Set a long description
+     *
+     * A long description may hold information about the content or the story
+     * of a video
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param LongDescription the content or story of a video
+     */
+    int setLongDescription(const char* LongDescription);
+    /**
+     * Set a description
+     *
+     * A description may hold short information about the content or the story
+     * of a video. Unlike a long description, this contains just a very short
+     * brief like a subtitle or the episode title.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Description the description of a video
+     */
+    int setDescription(const char* Description);
+    /**
+     * Set the publishers
+     *
+     * This is a CSV list of publishers, who distributes the video.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Publishers a CSV list of publishers
+     */
+    int setPublishers(const char* Publishers);
+    /**
+     * Set a genre
+     *
+     * This is a CSV list of genre of a video. This may be something like
+     * "Western" or "SciFi". Actually, there is no standardized rule for
+     * a genre name, which results in an ambiguous definition of certain
+     * genre, like Thriller and Horror.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Genre a CSV list of genre
+     */
+    int setGenre(const char* Genre);
+    /**
+     * Set the language
+     *
+     * This sets the language of a video. It is defined by RFC 1766.
+     * A valid language definition is \em "de-DE" or \em "en-US".
+     *
+     * @see http://www.ietf.org/rfc/rfc1766.txt
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Language the language (RFC 1766)
+     */
+    int setLanguage(const char* Language);
+    /**
+     * Sets a relation URL
+     *
+     * This sets a CSV list of relation URLs, where to find additional
+     * information about the movie. The URLs may not contain commas and they
+     * must be properly escaped as in RFC 2396
+     *
+     * @see http://www.ietf.org/rfc/rfc2396.txt
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Relations a CSV list with relations
+     */
+    int setRelations(const char* Relations);
+    /**
+     * Sets the directors
+     *
+     * This sets a CSV list of directors.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Directors a CSV list of directors
+     */
+    int setDirectors(const char* Directors);
+    /**
+     * Sets the actors
+     *
+     * This sets a CSV list of actors in a video. This usually contain the main actors.
+     * However, also other actors appearing in the video can be mentioned here.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Actors a CSV list of actors
+     */
+    int setActors(const char* Actors);
+    /**
+     * Sets the producers
+     *
+     * This sets a CSV list of producers of a video. These are the people who are
+     * involed in the production of a video
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Producers a CSV list of producers
+     */
+    int setProducers(const char* Producers);
+    /**
+     * Sets the rating
+     *
+     * This is a rating, which can be used for parential control issues.
+     *
+     * @see http://en.wikipedia.org/wiki/Motion_picture_rating_system
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Rating the rating of a video
+     */
+    int setRating(const char* Rating);
+    /******** Getter ********/
+    /**
+     * Get the genres
+     *
+     * This returns a CSV list of genre
+     *
+     * @return the genre of a video
+     */
+    const char* getGenre() const { return this->mGenre; }
+    /**
+     * Get the long description
+     *
+     * This returns the long description of a video
+     *
+     * @return the long description of a video
+     */
+    const char* getLongDescription() const { return this->mLongDescription; }
+    /**
+     * Get the description
+     *
+     * This returns the description of a video
+     *
+     * @return the description of a video
+     */
+    const char* getDescription() const { return this->mDescription; }
+    /**
+     * Get the publishers
+     *
+     * This returns a CSV list of publishers of the video
+     *
+     * @return a CSV list of publishers
+     */
+    const char* getPublishers() const { return this->mPublishers; }
+    /**
+     * Get the language
+     *
+     * This returns the language of the video
+     *
+     * @return the language
+     */
+    const char* getLanguage() const { return this->mLanguage; }
+    /**
+     * Get the relations
+     *
+     * This returns a CSV list of relation URLs.
+     *
+     * @return a CSV list of relation URLs
+     */
+    const char* getRelations() const { return this->mRelations; }
+    /**
+     * Get the actors
+     *
+     * This returns a CSV list of actors in the video
+     *
+     * @return a CSV list of actors
+     */
+    const char* getActors() const { return this->mActors; }
+    /**
+     * Get the producers
+     *
+     * This returns a CSV list of producers of a video
+     *
+     * @return a CSV list of producers
+     */
+    const char* getProducers() const { return this->mProducers; }
+    /**
+     * Get the directors
+     *
+     * This returns a CSV list of directors
+     *
+     * @return a CSV list of directors
+     */
+    const char* getDirectors() const { return this->mDirectors; }
+    /**
+     * Get the rating
+     *
+     * This returns the rating used for parental control.
+     *
+     * @return the rating of a video
+     */
+    const char* getRating() const { return this->mRating; }
+};
+
+/**
+ * The UPnP class Movie
+ *
+ * This is a UPnP class Movie representation with all its properties.
+ */
+class cUPnPClassMovie : public cUPnPClassVideoItem {
+    friend class cMediaDatabase;
+    friend class cUPnPObjectMediator;
+    friend class cUPnPMovieMediator;
+protected:
+    int          mDVDRegionCode;                ///< The Region code of the movie (0 - 8)
+    cString      mStorageMedium;                ///< The storage medium where the movie is stored
+    /**
+     * Constructor of a movie
+     *
+     * This creates a new instance of a movie
+     */
+    cUPnPClassMovie();
+public:
+    virtual ~cUPnPClassMovie();
+    //virtual cString createDIDLFragment(cStringList* Filter);
+    virtual cStringList* getPropertyList();
+    virtual bool setProperty(const char* Property, const char* Value);
+    virtual bool getProperty(const char* Property, char** Value) const;
+    /******** Setter ********/
+    /**
+     * Sets the DVD region code
+     * 
+     * For more information on this, see http://en.wikipedia.org/wiki/DVD_region_code
+     * 
+     * The integer representation for \em ALL is 9.
+     *
+     * @see http://en.wikipedia.org/wiki/DVD_region_code
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param RegionCode the region code of this movie
+     */
+    int setDVDRegionCode(int RegionCode);
+    /**
+     * Sets the storage medium
+     *
+     * This will set the storage medium, where the movie resides. Valid media
+     * are defined in \link common.h \endlink
+     *
+     * @see common.h
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param StorageMedium the medium where the movie is located
+     */
+    int setStorageMedium(const char* StorageMedium);
+    /******** Getter ********/
+    /**
+     * Get the DVD region code
+     *
+     * This returns the DVD region code. For more information,
+     * see http://en.wikipedia.org/wiki/DVD_region_code
+     *
+     * The integer representation for \em ALL is 9.
+     *
+     * @see http://en.wikipedia.org/wiki/DVD_region_code
+     * @return the DVD region code
+     */
+    int getDVDRegionCode() const { return this->mDVDRegionCode; }
+    /**
+     * Get the storage medium
+     *
+     * This returns the storage medium, where the movie resides.
+     *
+     * @return the storage medium
+     */
+    const char* getStorageMedium() const { return this->mStorageMedium; }
+};
+
+/**
+ * The UPnP class VideoBroadcast
+ *
+ * This is a UPnP class VideoBroadcast representation with all its properties.
+ */
+class cUPnPClassVideoBroadcast : public cUPnPClassVideoItem {
+    friend class cMediaDatabase;
+    friend class cUPnPObjectMediator;
+    friend class cUPnPVideoBroadcastMediator;
+protected:
+    cString             mIcon;                  ///< The channel icon of the channel
+    cString             mRegion;                ///< The region where the channel can be received
+    int                 mChannelNr;             ///< The channel number
+    cString             mChannelName;           ///< The channel name or provider name
+    /**
+     * Constructor of a video broadcast
+     *
+     * This creates a new instance of a video broadcast
+     */
+    cUPnPClassVideoBroadcast();
+public:
+    virtual ~cUPnPClassVideoBroadcast();
+    //virtual cString createDIDLFragment(cStringList* Filter);
+    virtual cStringList* getPropertyList();
+    virtual bool setProperty(const char* Property, const char* Value);
+    virtual bool getProperty(const char* Property, char** Value) const;
+    /******** Setter ********/
+    /**
+     * Set the channel icon
+     *
+     * This sets the channel icon of this channel. The resource must be a valid
+     * URI which can be obtained via the internal webserver
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param IconURI the URI to the icon file
+     */
+    int setIcon(const char* IconURI);
+    /**
+     * Set the channel region
+     *
+     * This sets the region of a channel, where it can be received
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param Region the location where the channel can be received
+     */
+    int setRegion(const char* Region);
+    /**
+     * Set channel number
+     *
+     * This sets the channel number, so that it can be used for directly navigation
+     * or channel up and down navigation respectively.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param ChannelNr the channel number
+     */
+    int setChannelNr(int ChannelNr);
+    /**
+     * Set the channel name
+     *
+     * This sets the channel name or the provider of the channel.
+     *
+     * @return returns
+     * - \bc 0, if setting was successful
+     * - \bc <0, otherwise
+     * @param ChannelName the channel name
+     */
+    int setChannelName(const char* ChannelName);
+    /******** Getter ********/
+    /**
+     * Get the channel icon
+     *
+     * This returns the channel icon of the channel.
+     *
+     * @return the channel icon
+     */
+    const char* getIcon() const { return this->mIcon; }
+    /**
+     * Get the region
+     *
+     * This returns the region, where the channel can be received
+     *
+     * @return the channel region
+     */
+    const char* getRegion() const { return this->mRegion; }
+    /**
+     * Get the channel number
+     *
+     * This returns the channel number
+     *
+     * @return the channel number
+     */
+    int getChannelNr() const { return this->mChannelNr; }
+    /**
+     * Get the channel name
+     *
+     * This returns the channel name or provider name respectively
+     *
+     * @return the channel name
+     */
+    const char* getChannelName() const { return this->mChannelName; }
+};
+
+/**
+ * Mediator interface
+ *
+ * This is an interface for mediators used to communicate with the database.
+ * A mediator is applied to get, create, save or delete an UPnP object.
+ */
+class cMediatorInterface {
+public:
+    virtual ~cMediatorInterface(){};
+    /**
+     * Creates an object
+     *
+     * This creates a new UPnP object with the specific title and the restriction.
+     *
+     * @return the newly created object
+     * @param Title the title of that object
+     * @param Restricted the restriction of the object
+     */
+    virtual cUPnPClassObject* createObject(const char* Title, bool Restricted) = 0;
+    /**
+     * Get an object
+     *
+     * Retrieves a UPnP object from the database and stores its information in the
+     * object. The object is obtained via its object ID.
+     *
+     * @return the object, found in the database
+     * @param ID the object ID
+     */
+    virtual cUPnPClassObject* getObject(cUPnPObjectID ID) = 0;
+    /**
+     * Saves the object
+     *
+     * This saves the object in the database by updating the values in the database
+     * with those in the object.
+     *
+     * @return returns
+     * - \bc <0, in case of an error
+     * - \bc 0, otherwise
+     * @param Object the object to be saved
+     */
+    virtual int saveObject(cUPnPClassObject* Object) = 0;
+    /**
+     * Deletes the object
+     *
+     * This deletes the object in the database by removing all its children and then
+     * deleting the contents from the database
+     *
+     * @return returns
+     * - \bc <0, in case of an error
+     * - \bc 0, otherwise
+     * @param Object the object to be deleted
+     */
+    virtual int deleteObject(cUPnPClassObject* Object) = 0;
+    /**
+     * Clears the object
+     *
+     * This clears the object, i.e. all its children will be removed and deleted
+     * from the database
+     *
+     * @return returns
+     * - \bc <0, in case of an error
+     * - \bc 0, otherwise
+     * @param Object the object to be cleared
+     */
+    virtual int clearObject(cUPnPClassObject* Object) = 0;
+};
+
+typedef std::map<const char*, cMediatorInterface*, strCmp> tMediatorMap;
+
+/**
+ * The object factory
+ *
+ * This factory can create, delete, clear or save UPnP objects. It uses mediators
+ * to communicate with the persistance database to load or persist the objects.
+ *
+ * If a new type of object shall be stored in the database an according mediator
+ * is needed, which knows the internal database structure. It must implement the
+ * cMediatorInterface class to work with this factory.
+ */
+class cUPnPObjectFactory {
+private:
+    static cUPnPObjectFactory*            mInstance;
+    cSQLiteDatabase*                      mDatabase;
+    tMediatorMap                          mMediators;
+    cMediatorInterface* findMediatorByID(cUPnPObjectID ID);
+    cMediatorInterface* findMediatorByClass(const char* Class);
+    cUPnPObjectFactory();
+public:
+    /**
+     * Return the instance of the factory
+     *
+     * This returns the instance of the factory. When the media database is
+     * initialized successfully, it usally has all known mediators already
+     * registered.
+     *
+     * @return the instance of the factory
+     */
+    static cUPnPObjectFactory* getInstance();
+    /**
+     * Register a mediator
+     *
+     * This registers a new mediator by the associated class. The mediator
+     * must implement the cMediatorInterface class to be used with this
+     * factory.
+     *
+     * @param UPnPClass the class of which the mediator is associated to
+     * @param Mediator the mediator itself
+     */
+    void registerMediator(const char* UPnPClass, cMediatorInterface* Mediator);
+    /**
+     * Unregisters a mediator
+     *
+     * This unregisters a mediator if it is not needed anylonger. If the optional
+     * parameter \c freeMediator is set, the object instance will be free'd after
+     * removing it from the list.
+     *
+     * @param UPnPClass the class of the associated mediator
+     * @param freeMediator flag to indicate if the mediator shall be free'd after removing
+     */
+    void unregisterMediator(const char* UPnPClass, bool freeMediator=true);
+    /**
+     * @copydoc cMediatorInterface::createObject(const char* Title, bool Restricted)
+     *
+     * @param UPnPClass the class of the new object
+     */
+    cUPnPClassObject* createObject(const char* UPnPClass, const char* Title, bool Restricted=true);
+    /*! @copydoc cMediatorInterface::getObject(cUPnPObjectID ID) */
+    cUPnPClassObject* getObject(cUPnPObjectID ID);
+    /*! @copydoc cMediatorInterface::saveObject(cUPnPClassObject* Object) */
+    int saveObject(cUPnPClassObject* Object);
+    /*! @copydoc cMediatorInterface::deleteObject(cUPnPClassObject* Object) */
+    int deleteObject(cUPnPClassObject* Object);
+    /*! @copydoc cMediatorInterface::clearObject(cUPnPClassObject* Object) */
+    int clearObject(cUPnPClassObject* Object);
+};
+
+class cMediaDatabase;
+
+/**
+ * Object Mediator
+ *
+ * This is the interface between the objects and the database. It is possible to
+ * create new objects, stores objects in the database as well as removing them from
+ * it.
+ */
+class cUPnPObjectMediator : public cMediatorInterface {
+protected:
+    cSQLiteDatabase*        mDatabase;                  ///< the SQLite 3 database wrapper
+    cMediaDatabase*         mMediaDatabase;             ///< the media database
+    /**
+     * Constructor of object mediator
+     *
+     * This constructs a new object mediator. This is actually not allowed because
+     * it is prohibited to create instances of the UPnP class Object
+     */
+    cUPnPObjectMediator(
+        cMediaDatabase* MediaDatabase                   ///< the media database
+    );
+    /**
+     * Initializes an object
+     *
+     * This initializes an object, which means, that it will be created in the database with
+     * the required details.
+     *
+     * @return returns
+     * - \bc <0, in case of an error
+     * - \bc 0, otherwise
+     */
+    virtual int initializeObject(
+        cUPnPClassObject* Object,                       ///< the object to be initialized
+        const char* Class,                              ///< the class of the object
+        const char* Title,                              ///< the title of the object
+        bool Restricted                                 ///< restriction of the object
+    );
+    /**
+     * Store the object in the database
+     *
+     * This stores the information of an object in the database
+     *
+     * @return returns
+     * - \bc <0, in case of an error
+     * - \bc 0, otherwise
+     * @param Object the object to be saved
+     */
+    virtual int objectToDatabase(cUPnPClassObject* Object);
+    /**
+     * Loads an object from database
+     *
+     * This loads an object from the database
+     *
+     * @return returns
+     * - \bc <0, in case of an error
+     * - \bc 0, otherwise
+     * @param Object the object to be loaded
+     * @param ID the object ID of that object
+     */
+    virtual int databaseToObject(cUPnPClassObject* Object, cUPnPObjectID ID);
+public:
+    virtual ~cUPnPObjectMediator();
+    /*! @copydoc cMediatorInterface::createObject(const char* Title, bool Restricted) */
+    virtual cUPnPClassObject* createObject(const char* Title, bool Restricted);
+    /*! @copydoc cMediatorInterface::getObject(cUPnPObjectID ID) */
+    virtual cUPnPClassObject* getObject(cUPnPObjectID ID);
+    /*! @copydoc cMediatorInterface::saveObject(cUPnPClassObject* Object) */
+    virtual int saveObject(cUPnPClassObject* Object);
+    /*! @copydoc cMediatorInterface::deleteObject(cUPnPClassObject* Object) */
+    virtual int deleteObject(cUPnPClassObject* Object);
+    /*! @copydoc cMediatorInterface::clearObject(cUPnPClassObject* Object) */
+    virtual int clearObject(cUPnPClassObject* Object);
+};
+
+/**
+ * Item Mediator
+ *
+ * This is the interface between the objects and the database. It is possible to
+ * create new objects, stores objects in the database as well as removing them from
+ * it.
+ */
+class cUPnPItemMediator : public cUPnPObjectMediator {
+protected:
+    /*! @copydoc cUPnPObjectMediator::objectToDatabase(cUPnPClassObject* Object) */
+    virtual int objectToDatabase(cUPnPClassObject* Object);
+    /*! @copydoc cUPnPObjectMediator::databaseToObject(cUPnPClassObject* Object, cUPnPObjectID ID) */
+    virtual int databaseToObject(cUPnPClassObject* Object, cUPnPObjectID ID);
+public:
+    /**
+     * Constructor of item mediator
+     *
+     * This creates a new item mediator with which it is possible to create new
+     * instances of Item objects.
+     *
+     * @param MediaDatabase the media database
+     */
+    cUPnPItemMediator(cMediaDatabase* MediaDatabase);
+    virtual ~cUPnPItemMediator(){};
+    /*! @copydoc cUPnPObjectMediator::createObject(const char* Title, bool Restricted) */
+    virtual cUPnPClassItem* createObject(const char* Title, bool Restricted);
+    /*! @copydoc cUPnPObjectMediator::getObject(cUPnPObjectID ID) */
+    virtual cUPnPClassItem* getObject(cUPnPObjectID ID);
+};
+
+/**
+ * VideoItem Mediator
+ *
+ * This is the interface between the objects and the database. It is possible to
+ * create new objects, stores objects in the database as well as removing them from
+ * it.
+ */
+class cUPnPVideoItemMediator : public cUPnPItemMediator {
+protected:
+    virtual int objectToDatabase(cUPnPClassObject* Object);
+    virtual int databaseToObject(cUPnPClassObject* Object, cUPnPObjectID ID);
+public:
+    /**
+     * Constructor of videoitem mediator
+     *
+     * This creates a new videoitem mediator with which it is possible to create new
+     * instances of VideoItem objects.
+     *
+     * @param MediaDatabase the media database
+     */
+    cUPnPVideoItemMediator(cMediaDatabase* MediaDatabase);
+    virtual ~cUPnPVideoItemMediator(){};
+    virtual cUPnPClassVideoItem* createObject(const char* Title, bool Restricted);
+    virtual cUPnPClassVideoItem* getObject(cUPnPObjectID ID);
+};
+
+/**
+ * VideoBroadcast Mediator
+ *
+ * This is the interface between the objects and the database. It is possible to
+ * create new objects, stores objects in the database as well as removing them from
+ * it.
+ */
+class cUPnPVideoBroadcastMediator : public cUPnPVideoItemMediator {
+protected:
+    virtual int objectToDatabase(cUPnPClassObject* Object);
+    virtual int databaseToObject(cUPnPClassObject* Object, cUPnPObjectID ID);
+public:
+    /**
+     * Constructor of video broadcast mediator
+     *
+     * This creates a new video broadcast mediator with which it is possible to create new
+     * instances of VideoBroadcast objects.
+     *
+     * @param MediaDatabase the media database
+     */
+    cUPnPVideoBroadcastMediator(cMediaDatabase* MediaDatabase);
+    virtual ~cUPnPVideoBroadcastMediator(){};
+    virtual cUPnPClassVideoBroadcast* createObject(const char* Title, bool Restricted);
+    virtual cUPnPClassVideoBroadcast* getObject(cUPnPObjectID ID);
+};
+
+/**
+ * Movie Mediator
+ *
+ * This is the interface between the objects and the database. It is possible to
+ * create new objects, stores objects in the database as well as removing them from
+ * it.
+ */
+class cUPnPMovieMediator : public cUPnPVideoItemMediator {
+protected:
+    virtual int objectToDatabase(cUPnPClassObject* Object);
+    virtual int databaseToObject(cUPnPClassObject* Object, cUPnPObjectID ID);
+public:
+    /**
+     * Constructor of movie mediator
+     *
+     * This creates a new movie mediator with which it is possible to create new
+     * instances of Movie objects.
+     *
+     * @param MediaDatabase the media database
+     */
+    cUPnPMovieMediator(cMediaDatabase* MediaDatabase);
+    virtual ~cUPnPMovieMediator(){};
+    virtual cUPnPClassMovie* createObject(const char* Title, bool Restricted);
+    virtual cUPnPClassMovie* getObject(cUPnPObjectID ID);
+};
+
+/**
+ * Container Mediator
+ *
+ * This is the interface between the objects and the database. It is possible to
+ * create new objects, stores objects in the database as well as removing them from
+ * it.
+ */
+class cUPnPContainerMediator : public cUPnPObjectMediator {
+protected:
+    virtual int objectToDatabase(cUPnPClassObject* Object);
+    virtual int databaseToObject(cUPnPClassObject* Object, cUPnPObjectID ID);
+public:
+    /**
+     * Constructor of container mediator
+     *
+     * This creates a new container mediator with which it is possible to create new
+     * instances of Container objects.
+     *
+     * @param MediaDatabase the media database
+     */
+    cUPnPContainerMediator(cMediaDatabase* MediaDatabase);
+    virtual ~cUPnPContainerMediator(){};
+    virtual cUPnPClassContainer* createObject(const char* Title, bool Restricted);
+    virtual cUPnPClassContainer* getObject(cUPnPObjectID ID);
+};
+
+#endif	/* _OBJECT_H */
+