cds_objects.h

Go to the documentation of this file.

/*MT*
    
    MediaTomb - http://www.mediatomb.cc/
    
    cds_objects.h - this file is part of MediaTomb.
    
    Copyright (C) 2005 Gena Batyan <bgeradz@mediatomb.cc>,
                       Sergey 'Jin' Bostandzhyan <jin@mediatomb.cc>
    
    Copyright (C) 2006-2010 Gena Batyan <bgeradz@mediatomb.cc>,
                            Sergey 'Jin' Bostandzhyan <jin@mediatomb.cc>,
                            Leonhard Wimmer <leo@mediatomb.cc>
    
    MediaTomb is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 2
    as published by the Free Software Foundation.
    
    MediaTomb 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
    version 2 along with MediaTomb; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
    
    $Id: cds_objects.h 2081 2010-03-23 20:18:00Z lww $
*/

#ifndef __CDS_OBJECTS_H__
#define __CDS_OBJECTS_H__

#include "common.h"
#include "dictionary.h"
#include "cds_resource.h"

// ATTENTION: These values need to be changed in web/js/items.js too.
#define OBJECT_TYPE_CONTAINER           0x00000001
#define OBJECT_TYPE_ITEM                0x00000002
#define OBJECT_TYPE_ACTIVE_ITEM         0x00000004
#define OBJECT_TYPE_ITEM_EXTERNAL_URL   0x00000008
#define OBJECT_TYPE_ITEM_INTERNAL_URL   0x00000010

#define STRING_OBJECT_TYPE_CONTAINER    "container"
#define STRING_OBJECT_TYPE_ITEM         "item"
#define STRING_OBJECT_TYPE_ACTIVE_ITEM  "active_item"
#define STRING_OBJECT_TYPE_EXTERNAL_URL "external_url"
#define STRING_OBJECT_TYPE_INTERNAL_URL "internal_url"

#define IS_CDS_CONTAINER(type) (type & OBJECT_TYPE_CONTAINER)
#define IS_CDS_ITEM(type) (type & OBJECT_TYPE_ITEM)
#define IS_CDS_ACTIVE_ITEM(type) (type & OBJECT_TYPE_ACTIVE_ITEM)
#define IS_CDS_ITEM_EXTERNAL_URL(type) (type & OBJECT_TYPE_ITEM_EXTERNAL_URL)
#define IS_CDS_ITEM_INTERNAL_URL(type) (type & OBJECT_TYPE_ITEM_INTERNAL_URL)
#define IS_CDS_PURE_ITEM(type) (type == OBJECT_TYPE_ITEM)

#define OBJECT_FLAG_RESTRICTED            0x00000001
#define OBJECT_FLAG_SEARCHABLE            0x00000002
#define OBJECT_FLAG_USE_RESOURCE_REF      0x00000004
#define OBJECT_FLAG_PERSISTENT_CONTAINER  0x00000008
#define OBJECT_FLAG_PLAYLIST_REF          0x00000010
#define OBJECT_FLAG_PROXY_URL             0x00000020
#define OBJECT_FLAG_ONLINE_SERVICE        0x00000040
#define OBJECT_FLAG_OGG_THEORA            0x00000080
#define OBJECT_FLAG_DVD_IMAGE             0x00000100
#define OBJECT_FLAG_PLAYED                0x00000200

#define OBJECT_AUTOSCAN_NONE    0
#define OBJECT_AUTOSCAN_UI      1
#define OBJECT_AUTOSCAN_CFG     2

int CdsObjectTitleComparator(void *arg1, void *arg2);

class CdsObject : public zmm::Object
{
protected:
    int id;

    int refID;

    int parentID;

    zmm::String title;

    zmm::String upnpClass;

    zmm::String location;

    int virt;

    unsigned int objectType;

    unsigned int objectFlags; 

    int sortPriority;

    zmm::Ref<Dictionary> metadata;
    zmm::Ref<Dictionary> auxdata;
    zmm::Ref<zmm::Array<CdsResource> > resources;
    

public:
    CdsObject();

    inline void setID(int id) { this->id = id; }

    inline int getID() { return id; }

    inline void setRefID(int refID) { this->refID = refID; }

    inline int getRefID() { return refID; }

    inline void setParentID(int parentID) { this->parentID = parentID; }

    inline int getParentID() { return parentID; }

    inline void setRestricted(bool restricted) { changeFlag(OBJECT_FLAG_RESTRICTED, restricted); }

    inline bool isRestricted() { return getFlag(OBJECT_FLAG_RESTRICTED); }

    inline void setTitle(zmm::String title) { this->title = title; }

    inline zmm::String getTitle() { return title; }

    inline void setClass(zmm::String upnpClass) { this->upnpClass = upnpClass; }

    inline zmm::String getClass() { return upnpClass; }

    inline void setLocation(zmm::String location) { this->location = location; }

    inline zmm::String getLocation() { return location; }

    inline void setVirtual(bool virt) { this->virt = virt; }

    inline bool isVirtual() { return virt; }

    inline unsigned int getObjectType() { return objectType; }

    inline int getSortPriority() { return sortPriority; }

    inline void setSortPriority(int sortPriority) { this->sortPriority = sortPriority; }

    inline unsigned int getFlags() { return objectFlags; }
    
    inline unsigned int getFlag(unsigned int mask) { return objectFlags & mask; }

    inline void setFlags(unsigned int objectFlags) { this->objectFlags = objectFlags; }
    
    inline void setFlag(unsigned int mask) { objectFlags |= mask; }
    
    inline void changeFlag(unsigned int mask, bool value) { if (value) setFlag(mask); else clearFlag(mask); }
    
    inline void clearFlag(unsigned int mask) { objectFlags &= ~mask; }
    
    inline zmm::String getMetadata(zmm::String key)
    { return metadata->get(key); }

    inline zmm::Ref<Dictionary> getMetadata() { return metadata; }
    
    inline void setMetadata(zmm::Ref<Dictionary> metadata)
    { this->metadata = metadata; }

    inline void setMetadata(zmm::String key, zmm::String value)
    { metadata->put(key, value); }

    inline void removeMetadata(zmm::String key)
    { metadata->remove(key); }
    

    inline zmm::String getAuxData(zmm::String key)
    { return auxdata->get(key); }

    inline zmm::Ref<Dictionary> getAuxData() { return auxdata; }

    inline void setAuxData(zmm::String key, zmm::String value)
    { auxdata->put(key, value); }
    
    inline void setAuxData(zmm::Ref<Dictionary> auxdata)
    { this->auxdata = auxdata; }

    inline void removeAuxData(zmm::String key)
    { auxdata->remove(key); }
    
    
    inline int getResourceCount() { return resources->size(); }

    inline zmm::Ref<zmm::Array<CdsResource> > getResources()
    { return resources; }
 
    inline void setResources(zmm::Ref<zmm::Array<CdsResource> > res) 
    { resources = res; }
    
    inline zmm::Ref<CdsResource> getResource(int index)
    { return resources->get(index); }
    
    inline void addResource(zmm::Ref<CdsResource> resource)
    { resources->append(resource); } 
  
    inline void insertResource(int index, zmm::Ref<CdsResource> resource)
    { resources->insert(index, resource); }

    virtual void copyTo(zmm::Ref<CdsObject> obj);
    
    virtual int equals(zmm::Ref<CdsObject> obj, bool exactly=false);
    
    int resourcesEqual(zmm::Ref<CdsObject> obj);
    
    virtual void validate();
    
    void optimize();
    
    static zmm::Ref<CdsObject> createObject(unsigned int objectType);

    virtual zmm::String getVirtualPath() = 0; 
    
    static zmm::String mapObjectType(int objectType);
    static int remapObjectType(zmm::String objectType);
    
    friend int CdsObjectTitleComparator(void *arg1, void *arg2);
};

class CdsItem : public CdsObject
{
protected:
    zmm::String mimeType;

    int trackNumber;
    
    zmm::String serviceID;

public:
    CdsItem();

    inline void setMimeType(zmm::String mimeType) { this->mimeType = mimeType; }

    inline zmm::String getMimeType() { return mimeType; }

    inline void setTrackNumber(int trackNumber) { this->trackNumber = trackNumber; }
    
    inline int getTrackNumber() { return trackNumber; }
    virtual void copyTo(zmm::Ref<CdsObject> obj);

    virtual int equals(zmm::Ref<CdsObject> obj, bool exactly=false);

    virtual void validate();

    virtual zmm::String getVirtualPath();
    
    inline void setServiceID(zmm::String serviceID) { this->serviceID = serviceID; }
    
    inline zmm::String getServiceID() { return serviceID; }
};

class CdsActiveItem : public CdsItem
{
protected:
    zmm::String action;

    zmm::String state;
public:

    CdsActiveItem();

    inline void setAction(zmm::String action) { this->action = action; }

    inline zmm::String getAction() { return action; }

    inline void setState(zmm::String state) { this->state = state; }

    inline zmm::String getState() { return state; }

    virtual void copyTo(zmm::Ref<CdsObject> obj);

    virtual int equals(zmm::Ref<CdsObject> obj, bool exactly=false);

    virtual void validate();
};

class CdsItemExternalURL : public CdsItem
{
public:

    CdsItemExternalURL();

    inline void setURL(zmm::String URL) { this->location = URL; }

    inline zmm::String getURL() { return location; }
    //virtual void copyTo(zmm::Ref<CdsObject> obj);

    //virtual int equals(zmm::Ref<CdsObject> obj, bool exactly=false);

    virtual void validate();
};

class CdsItemInternalURL : public CdsItemExternalURL
{
public:

    CdsItemInternalURL();

    virtual void validate();
};

/*
class CdsDynamicItem : public CdsItem
{
protected:
    zmm::String ;

    zmm::String properties;
public:

    CdsActiveItem();

    void setAction(zmm::String action);

    zmm::String getAction();

    void setState(zmm::String state);

    zmm::String getState();

    virtual void copyTo(zmm::Ref<CdsObject> obj);

    virtual int equals(zmm::Ref<CdsObject> obj, bool exactly=false);

    virtual void validate();
};

*/

class CdsContainer : public CdsObject
{
protected:
    int updateID;

    int childCount;
    
    int autoscanType;
    
public:
    CdsContainer();

    inline void setSearchable(bool searchable) { changeFlag(OBJECT_FLAG_SEARCHABLE, searchable); }

    inline int isSearchable() { return getFlag(OBJECT_FLAG_SEARCHABLE); }

    inline void setUpdateID(int updateID) { this->updateID = updateID; }

    inline int getUpdateID() { return updateID; }

    inline void setChildCount(int childCount) { this->childCount = childCount; }

    inline int getChildCount() { return childCount; }
    
    inline int getAutoscanType() { return autoscanType; }
    
    inline void setAutoscanType(int type) { autoscanType = type; }
    
    virtual void copyTo(zmm::Ref<CdsObject> obj);

    virtual int equals(zmm::Ref<CdsObject> obj, bool exactly=false);

    virtual void validate();
    
    virtual zmm::String getVirtualPath();
};

#endif // __CDS_OBJECTS_H__

---