edlproperty.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */

 
#ifndef EDLPROPERTY_H
#define EDLPROPERTY_H
 
#include <edl/edlqname.h>
#include <edl/edltypes.h>
#include <edl/edltime.h>
#include <edl/iedlobject.h>
#include <edl/edlstring.h>
#include <edl/edlerrors.h>
 
_BEGIN_EDL_NAMESPACE

 
class PValue
{
public:
    PValue () { zero(); };
    PValue(int32 i, const int variant = 0) {zero(); m_type = T_INT; m_variant = variant; m_simpleValue.integer = i;}
    PValue(uint32 ui, const int variant = 0) {zero(); m_type = T_INT; m_variant = variant; m_simpleValue.integer = ui;}
    PValue(const EDLString &s, const int variant = 0) {zero(); setString(s, variant);}
    PValue(const EDLSysString &s, const int variant = 0) {zero(); setString(EDLSysStringToEDLString(s), variant);}
    explicit PValue(const wchar_t *s, const int variant = 0) {zero(); setString(s, variant);}
    explicit PValue(const char *s, const int variant = 0) {zero(); setString(s, variant);}
    PValue(const CEDLStringVect &v, const int variant = 0) {zero(); setStringVector(v, variant);}
    PValue(const CEDLSysStringVect &v, const int variant = 0) {zero(); setSysStringVector(v, variant);}
    PValue(void *p, const int variant = 0) {zero(); m_type = T_POINTER; m_variant = variant; m_simpleValue.pointer = p;}
    PValue(const IEDLTimePtr &ptrTime, const int variant = 0) {zero(); m_type = T_TIME; m_variant = variant; m_timePtr = ptrTime;}
    PValue(const EDLQName &qn, const int variant = 0) {zero(); setName(qn, variant);}
    PValue(const IRCObjectPtr &object, const int variant = 0) {zero(); m_type = T_OBJECT; m_variant = variant; m_rcObjectPtr = object;}
    PValue(double d, const int variant = 0) {zero(); m_type = T_DECIMAL; m_variant = variant; m_simpleValue.decimalVal = d;}
    PValue(bool b, const int variant = 0) {zero(); m_type = T_BOOL; m_variant = variant; m_simpleValue.boolean = b;}
    PValue(const PValue &another)
    {
        zero();
        assign(another);
    }
 
    ~PValue()
    {
        clean();
    }

    enum PValueType
    {
        T_UNASSIGNED,       
        T_BOOL,             
        T_INT,              
        T_DECIMAL,          
        T_STRING,           
        T_POINTER,          
        T_TIME,             
        T_QNAME,            
        T_OBJECT,           
        T_STRINGVECT        
    };
 
    enum PValueType getType() const
    {
        return m_type;
    }
 
    int getVariant() const
    {
        return m_variant;
    }
 
    const PValue & operator =(const PValue &another)
    {
        assign(another);
        return *this;
    }
 
    bool isEmpty () const
    {
        return (T_UNASSIGNED == m_type);
    }
 
    EDLString getString() const
    {
        return (m_type == T_STRING && m_simpleValue.stringVal) ? *m_simpleValue.stringVal : EDLString();
    }
 
    EDLSysString getSysString() const
    {
        return (m_type == T_STRING && m_simpleValue.stringVal) ? EDL::EDLStringToEDLSysString (*m_simpleValue.stringVal) : EDLSysString();
    }
 
    CEDLStringVect getStringVect() const
    {
        return (m_type == T_STRINGVECT && m_simpleValue.stringVect) ? *m_simpleValue.stringVect : CEDLStringVect();
    }
 
    CEDLSysStringVect getSysStringVect () const
    {
        CEDLStringVect      edlStrVect = getStringVect ();
        CEDLSysStringVect   edlSysStrVect;
 
        edlSysStrVect.resize (edlStrVect.size ());
        for (uint32 i = 0; i < edlStrVect.size (); i++)
        {
            edlSysStrVect [i] = EDLStringToEDLSysString (edlStrVect [i]);
        }
        return edlSysStrVect;
    }
 
    bool getBool() const
    {
        return (m_type == T_BOOL) ? m_simpleValue.boolean : false;
    }
    int32 getInt32() const
    {
        return (m_type == T_INT) ? m_simpleValue.integer : 0;
    }
    double getDecimal() const
    {
        return (m_type == T_DECIMAL) ? m_simpleValue.decimalVal : 0.0;
    }
    void * getPointer() const
    {
        return (m_type == T_POINTER) ? m_simpleValue.pointer : NULL;
    }
    IEDLTimePtr getTime() const
    {
        return (m_type == T_TIME) ? m_timePtr : IEDLTimePtr(NULL);
    }
    EDLQName getQName() const
    {
        return (m_type == T_QNAME && m_simpleValue.qname) ? *m_simpleValue.qname : EDLQName();
    }
    IEDLObjectPtr getObject() const
    {
        return IEDLObjectPtr(dynamic_cast<IEDLObject *>((IRCObject *) getRCObject()), true);
    }
    IRCObjectPtr getRCObject() const
    {
        return (m_type == T_OBJECT) ? m_rcObjectPtr : IRCObjectPtr(NULL);
    }
 
    bool operator ==(const PValue &another)
    {
        if (this == &another)
            return true;
 
        if (m_type != another.m_type)
            return false;
 
        switch(m_type)
        {
        case T_UNASSIGNED:
            return true;
        case T_BOOL:
            return (getBool() == another.getBool());
        case T_INT:
            return (getInt32() == another.getInt32());
        case T_DECIMAL:
            return (getDecimal() == another.getDecimal());
        case T_STRING:
            return (getString() == another.getString());
        case T_STRINGVECT:
            if (m_simpleValue.stringVect && another.m_simpleValue.stringVect)
            {
                uint32 n = m_simpleValue.stringVect->size();
 
                if (n != another.m_simpleValue.stringVect->size())
                    return false;
 
                for (uint32 j = 0; j < n; j++)
                {
                    if ((*m_simpleValue.stringVect)[j] != (*another.m_simpleValue.stringVect)[j])
                        return false;
                }
                return true;
            }
            return false;
        case T_POINTER:
            return (getPointer() == another.getPointer());
        case T_QNAME:
            return (getQName() == another.getQName());
         case T_OBJECT:
            return (getObject() == another.getObject());
        case T_TIME:
            return (getTime() == another.getTime());
        default:
            break;
        }
        return false;
    }
 
    bool operator !=(const PValue &another)
    {
        return !operator ==(another);
    }
 
private:
    void zero()
    {
        m_type = T_UNASSIGNED;
        m_variant = 0;
        memset(&m_simpleValue, 0, sizeof(m_simpleValue));
        m_rcObjectPtr = NULL;
    }
 
    void clean()
    {
        switch (m_type)
        {
            case T_STRING:
                if (m_simpleValue.stringVal)
                {
                    delete m_simpleValue.stringVal;
                }
                break;
            case T_QNAME:
                if (m_simpleValue.qname)
                {
                    delete m_simpleValue.qname;
                }
                break;
            case T_STRINGVECT:
                if (m_simpleValue.stringVect)
                {
                    m_simpleValue.stringVect->clear ();
                    delete m_simpleValue.stringVect;
                }
                break;
            default:
                break;
        }
 
        zero();
    }
 
    void assign(const PValue &another)
    {
        if (this != &another)
        {
            clean();
 
            m_variant = another.m_variant;
            m_type = another.m_type;
            switch(m_type)
            {
                case T_BOOL:
                case T_INT:
                case T_DECIMAL:
                case T_POINTER:
                    memcpy(&m_simpleValue, &another.m_simpleValue, sizeof(m_simpleValue));
                    break;
 
                case T_STRING:
                    if (!another.m_simpleValue.stringVal)
                    {
                        throwEDLError(EDL_ERR_UNDEFINED);
                    }
                    setString(*another.m_simpleValue.stringVal, another.m_variant);
                    break;
 
                case T_STRINGVECT:
                    if (!another.m_simpleValue.stringVect)
                    {
                        throwEDLError(EDL_ERR_UNDEFINED);
                    }
                    setStringVector (*another.m_simpleValue.stringVect, another.m_variant);
                    break;
 
                case T_QNAME:
                    if (!another.m_simpleValue.qname)
                    {
                        throwEDLError(EDL_ERR_UNDEFINED);
                    }
                    setName(*another.m_simpleValue.qname);
                    break;
                case T_OBJECT:
                    m_rcObjectPtr = another.m_rcObjectPtr;
                    break;
                case T_TIME:
                    m_timePtr = another.m_timePtr;
                    break;
                default:
                    break;
            }
        }
    }
 
    void setString(const EDLString &stringVal, const int variant = 0)
    {
        clean();
        m_type = T_STRING;
        m_variant = variant;
        m_simpleValue.stringVal = new EDLString();
        *m_simpleValue.stringVal = stringVal;
    }
 
    void setString(const wchar_t *s, const int variant = 0)
    {
        EDLString stringVal (s);
        setString (stringVal, variant);
    }
 
    void setString(const char *s, const int variant = 0)
    {
        EDLSysString sysStr (s);
        EDLString stringVal = EDLSysStringToEDLString (sysStr);
        setString (stringVal, variant);
    }
 
    void setStringVector(const CEDLStringVect &stringVect, const int variant = 0)
    {
        clean();
        m_type = T_STRINGVECT;
        m_variant = variant;
        m_simpleValue.stringVect = new CEDLStringVect ();
        m_simpleValue.stringVect->resize (stringVect.size());
        for (uint32 j = 0; j < stringVect.size(); j++)
            (*m_simpleValue.stringVect)[j] = stringVect[j];
    }
 
    void setSysStringVector(const CEDLSysStringVect &sysStringVect, const int variant = 0)
    {
        clean();
        m_type = T_STRINGVECT;
        m_variant = variant;
        m_simpleValue.stringVect = new CEDLStringVect ();
        m_simpleValue.stringVect->resize (sysStringVect.size());
        for (uint32 j = 0; j < sysStringVect.size(); j++)
            (*m_simpleValue.stringVect)[j] = EDLSysStringToEDLString (sysStringVect[j]);
    }
 
    void setName(const EDLQName &name, const int variant = 0)
    {
        clean();
        m_type = T_QNAME;
        m_variant = variant;
        m_simpleValue.qname = new EDLQName();
        *m_simpleValue.qname = name;
    }
 
private:
    enum PValueType m_type;
 
    union
    {
        bool            boolean;
        int32           integer;
        double          decimalVal;
        void           *pointer;
        EDLString      *stringVal;
        CEDLStringVect *stringVect;
        EDLQName       *qname;
    } m_simpleValue;
 
    IEDLTimePtr     m_timePtr;
    IRCObjectPtr    m_rcObjectPtr;
    int             m_variant;
};
 
_END_EDL_NAMESPACE
 
#endif /* EDLPROPERTY_H */