property_intf.h

Go to the documentation of this file.

 
#pragma once
#include "rawmemory_intf.h"
#include "string_intf.h"
#include <adtfucom3/adtf_ucom3.h>
 
namespace adtf
{
namespace base
{
namespace ant
{
 
    class IRawValue
    {
    protected:
        virtual ~IRawValue() = default;
 
    public:
        virtual tResult FromRaw(const IRawMemory& oRawValue) = 0;
        virtual tResult ToRaw(IRawMemory&& oRawValue) const = 0;
    };
    class IPropertyValue : public IRawValue
    {
        public:
            ~IPropertyValue() = default;
 
        public:
            virtual tResult GetType(IString&& strType) const = 0;
            virtual tResult Set(const IPropertyValue& oValue) = 0;
            virtual tResult FromString(const IString& strValueAsString) = 0;
 
            virtual tResult ToString(IString&& strIToString) const = 0;
    };
 
    class IProperties;
 
    class IProperty
    {
    public: 
        virtual ~IProperty() = default;
 
    public:
        virtual const IPropertyValue* GetValue() const = 0;
        virtual IPropertyValue* GetValue() = 0;
        virtual tResult SetValue(const IPropertyValue& oValue) = 0;
 
        virtual tResult GetName(IString&& strName) const = 0;
        virtual tResult SetName(const IString& strName) = 0;
 
        virtual tResult Set(const IProperty& oProp) = 0;
 
        virtual bool   HasProperties() const = 0;
        virtual bool   HasAttachedProperties() const = 0;
 
        virtual tResult SetProperties(const IProperties& pProperties) = 0;
        virtual tResult AttachProperties(const ucom::ant::iobject_ptr<IProperties>& pProperties) = 0;
        virtual tResult GetAttachedProperties(IProperty& pProperty) const = 0;
        virtual tResult DetachProperties() = 0;
 
        virtual tResult GetProperties(ucom::ant::iobject_ptr<IProperties>& pSubProperties) = 0;
        virtual tResult GetProperties(ucom::ant::iobject_ptr<const IProperties>& pProperties) const = 0;
    };
 
    bool operator==(const IProperty& oPropertyLeft, const IProperty& oPropertyRight);
 
    bool operator!=(const IProperty& oPropertyLeft, const IProperty& oPropertyRight);
 
    class IPropertyObserver
    {
        protected:
            ~IPropertyObserver() = default;
        public:
            virtual void Notify(const IProperty& oProperty) = 0;
    };
 
    class IProperties : public ucom::ant::IObject
    {
    public:
        ADTF_IID(IProperties, "properties.ant.base.adtf.iid");
 
    protected:
        ~IProperties() = default;
 
    public:
        virtual bool   Exists(const char* strName) const = 0;
 
        virtual tResult Get(IProperties& pProperties) const = 0;
 
        virtual tResult Set(const IProperties& pProperties) = 0;
 
        virtual size_t   GetSize() const = 0;
                
        virtual tResult GetProperty(const char* strName, IProperty& pProperty) const = 0;
        virtual tResult SetProperty(const IProperty& pProperty) = 0;
        virtual tResult SetPropertyByPath(const char* strParentPath, const IProperty& pProperty) = 0;
 
        virtual tResult RemoveProperty(const char* strName) = 0;
 
        virtual tResult RegisterPropertyObserver(const char* strPropertyName,
                                                 IPropertyObserver& oObserver) = 0;
        virtual tResult UnregisterPropertyObserver(IPropertyObserver& oObserver) = 0;
    };
 
    bool operator==(const IProperties& oPropertiesLeft, const IProperties& oPropertiesRight);
 
    bool operator!=(const IProperties& oPropertiesLeft, const IProperties& oPropertiesRight);
 
} //namespace ant
 
namespace spider
{
 
tResult is_equal(const ant::IProperties& oLeftProperties, const ant::IProperties& oRightProperties);
 
tResult is_equal(const ant::IProperty& oLeftProperty, const ant::IProperty& oRightProperty);
 
}
 
using ant::IPropertyObserver;
using ant::IPropertyValue;
using ant::IProperties;
using ant::IProperty;
using spider::is_equal;
 
} //namespace base
} //namespace adtf