BaseAttribute.h

// BaseAttribute.h:
// ----------------
//

#ifndef __IPSDKBASEPROCESSING_BASEATTRIBUTE_H__
#define __IPSDKBASEPROCESSING_BASEATTRIBUTE_H__

// suppression warnings
// warning C4251: 'boost::enable_shared_from_this<T>::weak_this_' : class 'boost::weak_ptr<T>' needs to have dll-interface to be used by clients of class 'boost::enable_shared_from_this<T>'
// warning C4275: non dll-interface class 'ipsdk::BaseIOData' used as base for dll-interface class 'ipsdk::processor::BaseAttribute'
#pragma warning (push)
#pragma warning (disable : 4251 4275)

#include <IPSDKBaseProcessing/IPSDKBaseProcessingExports.h>
#include <IPSDKBaseData/ToolTip/BaseToolTip.h>
#include <IPSDKBaseData/DataStatus/BaseIOData.h>
#include <IPSDKBaseData/DataStatus/BaseOptData.h>
#include <IPSDKBaseProcessing/Rule/RuleTypes.h>
#include <IPSDKBaseProcessing/Attribute/Base/AttributeTypes.h>
#include <IPSDKSerialization/Engine/BaseObjectWithSkeleton.h>
#include <IPSDKUtil/Tools/ProcessingResult.h>
#include <boost/enable_shared_from_this.hpp>

namespace ipsdk {
namespace processor {

class BaseProcessor;
class AttributeFactory;


class IPSDKBASEPROCESSING_API BaseAttribute : public BaseObjectWithSkeleton,
                                              public BaseToolTip,
                                              public BaseIOData,
                                              public BaseOptData,
                                              public boost::enable_shared_from_this<BaseAttribute>
{
    // declare serial class
    IPSDK_DECLARE_ABSTRACT_SERIAL_WITHOUT_COPY(IPSDKBaseProcessing, BaseAttribute);

    // friend class for private members access
    friend class BaseProcessor;

protected:
    BaseAttribute();

public:
    virtual ~BaseAttribute() = 0;
    
// methods
public:
    bool                                    isInit() const;

    virtual eAttributeType                  getAttributeType() const = 0;

    virtual const boost::filesystem::path   getHeaderPath() const = 0;

    virtual const std::string               getLibraryName() const = 0;

    const BaseRule&                         getRule() const;

    BoolResult                              isValid() const;

    bool                                    isOutOptionalInitForced() const;
    void                                    setOutOptionalInitForced(bool bOutOptionalInitForced) const;

    void                                    clear();

protected:
    void                    initBase();

    virtual BoolResult      syncInputDerived(const Guid& processingSocketGuid) {return true;}

    virtual BoolResult      syncOutputDerived(const Guid& processingSocketGuid) {return true;}

    virtual RulePtr         createRule(const AttributePtr& pBaseThis) const = 0;

    virtual void            clearDerived() {}

private:
    BoolResult              syncInputAttribute(const Guid& processingSocketGuid);

    BoolResult              syncOutputAttribute(const Guid& processingSocketGuid);

// attributes
private:
    mutable RulePtr         _pRule;

    mutable bool            _bOutOptionalInitForced;

    bool                    _bInit;
};


inline bool
BaseAttribute::isInit() const
{
    return _bInit;
}


} // end of namespace processor
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKBASEPROCESSING_BASEATTRIBUTE_H__