fobject.h

Go to the documentation of this file.

 //------------------------------------------------------------------------
// Project     : SDK Base
// Version     : 1.0
//
// Category    : Helpers
// Filename    : base/source/fobject.h
// Created by  : Steinberg, 2008
// Description : Basic Object implementing FUnknown
//
//-----------------------------------------------------------------------------
// LICENSE
// (c) 2023, Steinberg Media Technologies GmbH, All Rights Reserved
//-----------------------------------------------------------------------------
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
// 
//   * Redistributions of source code must retain the above copyright notice, 
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation 
//     and/or other materials provided with the distribution.
//   * Neither the name of the Steinberg Media Technologies nor the names of its
//     contributors may be used to endorse or promote products derived from this 
//     software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//-----------------------------------------------------------------------------
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#pragma once
 
#include "pluginterfaces/base/funknown.h"
#include "pluginterfaces/base/iupdatehandler.h"
#include "base/source/fdebug.h" // use of NEW
 
#define SMTG_DEPENDENCY_COUNT   DEVELOPMENT
 
namespace Steinberg {
 
//----------------------------------
 
using FClassID = FIDString;
 
//------------------------------------------------------------------------
// Basic FObject - implements FUnknown + IDependent
//------------------------------------------------------------------------
//------------------------------------------------------------------------
class FObject : public IDependent
{
public:
    //------------------------------------------------------------------------
    FObject () = default;                                                   
    FObject (const FObject&)                                                
        : refCount (1)
#if SMTG_DEPENDENCY_COUNT
        , dependencyCount (0) 
#endif      
    {}          
    FObject& operator= (const FObject&) { return *this; }                   
    virtual ~FObject ();                                                    
 
    // OBJECT_METHODS
    static inline FClassID getFClassID () {return "FObject";}               
    virtual FClassID isA () const {return FObject::getFClassID ();}         
    virtual bool isA (FClassID s) const {return isTypeOf (s, false);}       
    virtual bool isTypeOf (FClassID s, bool /*askBaseClass*/ = true) const {return classIDsEqual (s, FObject::getFClassID ());}
    int32 getRefCount () {return refCount;}                                 
    FUnknown* unknownCast () {return this;}                                 
 
    // FUnknown
    tresult PLUGIN_API queryInterface (const TUID _iid, void** obj) SMTG_OVERRIDE; 
    uint32 PLUGIN_API addRef () SMTG_OVERRIDE;                      
    uint32 PLUGIN_API release () SMTG_OVERRIDE;                     
 
    // IDependent
    void PLUGIN_API update (FUnknown* /*changedUnknown*/, int32 /*message*/) SMTG_OVERRIDE {}
    // IDependency
    virtual void addDependent (IDependent* dep);                            
    virtual void removeDependent (IDependent* dep);                         
    virtual void changed (int32 msg = kChanged);                            
    virtual void deferUpdate (int32 msg = kChanged);                        
    virtual void updateDone (int32 /* msg */) {}                            
    virtual bool isEqualInstance (FUnknown* d) {return this == d;}
    
    static void setUpdateHandler (IUpdateHandler* handler) {gUpdateHandler = handler;}  
    static IUpdateHandler* getUpdateHandler () {return gUpdateHandler;}                 
 
    // static helper functions
    static inline bool classIDsEqual (FClassID ci1, FClassID ci2);          
    static inline FObject* unknownToObject (FUnknown* unknown);             
 
    static const FUID iid;
 
//------------------------------------------------------------------------
protected:
    int32 refCount = 1;                                                         
#if SMTG_DEPENDENCY_COUNT
    int16 dependencyCount = 0;
#endif
    static IUpdateHandler* gUpdateHandler;
};
 
 
//------------------------------------------------------------------------
// conversion from FUnknown to FObject
//------------------------------------------------------------------------
inline FObject* FObject::unknownToObject (FUnknown* unknown)
{
    FObject* object = nullptr;
    if (unknown) 
    {
        unknown->queryInterface (FObject::iid, (void**)&object);
        if (object)
            object->release (); // queryInterface has added ref     
    }
    return object;
}
 
//------------------------------------------------------------------------
inline bool FObject::classIDsEqual (FClassID ci1, FClassID ci2)
{
    return (ci1 && ci2) ? (strcmp (ci1, ci2) == 0) : false;
}
 
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
template <class C>
inline C* FCast (const FObject* object)
{
    if (object && object->isTypeOf (C::getFClassID (), true))
        return (C*) object;
    return 0;
}
 
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
template <class C>
inline C* FCast (FUnknown* unknown)
{
    FObject* object = FObject::unknownToObject (unknown);
    return FCast<C> (object);
}
 
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
template <class C>
inline C* FUCast (FObject* object)
{
    return FUnknownPtr<C> (object ? object->unknownCast () : nullptr);
}
 
template <class C>
inline C* FUCast (FUnknown* object)
{
    return FUnknownPtr<C> (object);
}
 
//------------------------------------------------------------------------
 
//-----------------------------------------------------------------------
template <class I>
inline void SafeRelease (I *& ptr) 
{ 
    if (ptr) 
    {
        ptr->release (); 
        ptr = 0;
    }
}
 
//-----------------------------------------------------------------------
template <class I>
inline void SafeRelease (IPtr<I> & ptr) 
{ 
    ptr = 0;
}
 
 
//-----------------------------------------------------------------------
template <class T>
inline void SafeDelete (T *& ptr)
{
    if (ptr) 
    {
        delete ptr;
        ptr = 0;
    }
}
 
//-----------------------------------------------------------------------
template <class T>
inline void AssignShared (T*& dest, T* newPtr)
{
    if (dest == newPtr)
        return;
    
    if (dest) 
        dest->release (); 
    dest = newPtr; 
    if (dest) 
        dest->addRef ();
}
 
//-----------------------------------------------------------------------
template <class T>
inline void AssignSharedDependent (IDependent* _this, T*& dest, T* newPtr)
{
    if (dest == newPtr)
        return;
 
    if (dest)
        dest->removeDependent (_this);
    AssignShared (dest, newPtr);
    if (dest)
        dest->addDependent (_this);
}
 
//-----------------------------------------------------------------------
template <class T>
inline void AssignSharedDependent (IDependent* _this, IPtr<T>& dest, T* newPtr)
{
    if (dest == newPtr)
        return;
 
    if (dest)
        dest->removeDependent (_this);
    dest = newPtr;
    if (dest)
        dest->addDependent (_this);
}
    
//-----------------------------------------------------------------------
template <class T>
inline void SafeReleaseDependent (IDependent* _this, T*& dest)
{
    if (dest)
        dest->removeDependent (_this);
    SafeRelease (dest);
}
    
//-----------------------------------------------------------------------
template <class T>
inline void SafeReleaseDependent (IDependent* _this, IPtr<T>& dest)
{
    if (dest)
        dest->removeDependent (_this);
    SafeRelease (dest);
}
 
 
//------------------------------------------------------------------------
namespace Singleton {
    void registerInstance (FObject** o);
 
    bool isTerminated ();
 
    void lockRegister ();
    void unlockRegister ();
}
 
//------------------------------------------------------------------------
} // namespace Steinberg
 
//-----------------------------------------------------------------------
#define SINGLETON(ClassName)    \
    static ClassName* instance (bool create = true) \
    { \
        static Steinberg::FObject* inst = nullptr; \
        if (inst == nullptr && create && Steinberg::Singleton::isTerminated () == false) \
        {   \
            Steinberg::Singleton::lockRegister (); \
            if (inst == nullptr) \
            { \
                inst = NEW ClassName; \
                Steinberg::Singleton::registerInstance (&inst); \
            } \
            Steinberg::Singleton::unlockRegister (); \
        }   \
        return (ClassName*)inst; \
    }
 
//-----------------------------------------------------------------------
#define OBJ_METHODS(className, baseClass)                               \
    static inline Steinberg::FClassID getFClassID () {return (#className);}     \
    virtual Steinberg::FClassID isA () const SMTG_OVERRIDE {return className::getFClassID ();}  \
    virtual bool isA (Steinberg::FClassID s) const SMTG_OVERRIDE {return isTypeOf (s, false);}  \
    virtual bool isTypeOf (Steinberg::FClassID s, bool askBaseClass = true) const SMTG_OVERRIDE \
    {  return (FObject::classIDsEqual (s, #className) ? true : (askBaseClass ? baseClass::isTypeOf (s, true) : false)); } 
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#define REFCOUNT_METHODS(BaseClass) \
virtual Steinberg::uint32 PLUGIN_API addRef ()SMTG_OVERRIDE{ return BaseClass::addRef (); } \
virtual Steinberg::uint32 PLUGIN_API release ()SMTG_OVERRIDE{ return BaseClass::release (); }
 
//------------------------------------------------------------------------
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#define DEFINE_INTERFACES \
Steinberg::tresult PLUGIN_API queryInterface (const Steinberg::TUID iid, void** obj) SMTG_OVERRIDE \
{
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#define DEF_INTERFACE(InterfaceName) \
    QUERY_INTERFACE (iid, obj, InterfaceName::iid, InterfaceName)
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#define END_DEFINE_INTERFACES(BaseClass) \
    return BaseClass::queryInterface (iid, obj); \
}
 
//------------------------------------------------------------------------
 
//------------------------------------------------------------------------
#define DEF_INTERFACES_1(InterfaceName,BaseClass) \
DEFINE_INTERFACES \
DEF_INTERFACE (InterfaceName) \
END_DEFINE_INTERFACES (BaseClass)
 
//------------------------------------------------------------------------
#define DEF_INTERFACES_2(InterfaceName1,InterfaceName2,BaseClass) \
DEFINE_INTERFACES \
DEF_INTERFACE (InterfaceName1) \
DEF_INTERFACE (InterfaceName2) \
END_DEFINE_INTERFACES (BaseClass)
 
//------------------------------------------------------------------------
#define DEF_INTERFACES_3(InterfaceName1,InterfaceName2,InterfaceName3,BaseClass) \
DEFINE_INTERFACES \
DEF_INTERFACE (InterfaceName1) \
DEF_INTERFACE (InterfaceName2) \
DEF_INTERFACE (InterfaceName3) \
END_DEFINE_INTERFACES (BaseClass)
 
//------------------------------------------------------------------------
#define DEF_INTERFACES_4(InterfaceName1,InterfaceName2,InterfaceName3,InterfaceName4,BaseClass) \
    DEFINE_INTERFACES \
    DEF_INTERFACE (InterfaceName1) \
    DEF_INTERFACE (InterfaceName2) \
    DEF_INTERFACE (InterfaceName3) \
    DEF_INTERFACE (InterfaceName4) \
    END_DEFINE_INTERFACES (BaseClass)
 
//------------------------------------------------------------------------
 
#define FUNKNOWN_METHODS(InterfaceName,BaseClass) \
DEF_INTERFACES_1(InterfaceName,BaseClass) \
REFCOUNT_METHODS(BaseClass)
 
#define FUNKNOWN_METHODS2(InterfaceName1,InterfaceName2,BaseClass) \
DEF_INTERFACES_2(InterfaceName1,InterfaceName2,BaseClass) \
REFCOUNT_METHODS(BaseClass)
 
#define FUNKNOWN_METHODS3(InterfaceName1,InterfaceName2,InterfaceName3,BaseClass) \
DEF_INTERFACES_3(InterfaceName1,InterfaceName2,InterfaceName3,BaseClass) \
REFCOUNT_METHODS(BaseClass)
 
#define FUNKNOWN_METHODS4(InterfaceName1,InterfaceName2,InterfaceName3,InterfaceName4,BaseClass) \
DEF_INTERFACES_4(InterfaceName1,InterfaceName2,InterfaceName3,InterfaceName4,BaseClass) \
REFCOUNT_METHODS(BaseClass)
 
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#if COM_COMPATIBLE
//------------------------------------------------------------------------
 
//------------------------------------------------------------------------
#define IUNKNOWN_REFCOUNT_METHODS(BaseClass) \
STDMETHOD_ (ULONG, AddRef) (void) {return BaseClass::addRef ();} \
STDMETHOD_ (ULONG, Release) (void) {return BaseClass::release ();}
 
//------------------------------------------------------------------------
#define COM_QUERY_INTERFACE(iid, obj, InterfaceName)     \
if (riid == __uuidof(InterfaceName))                     \
{                                                        \
    addRef ();                                           \
    *obj = (InterfaceName*)this;                         \
    return kResultOk;                                    \
}
 
//------------------------------------------------------------------------
#define COM_OBJECT_QUERY_INTERFACE(InterfaceName,BaseClass)        \
STDMETHOD (QueryInterface) (REFIID riid, void** object)            \
{                                                                  \
    COM_QUERY_INTERFACE (riid, object, InterfaceName)              \
    return BaseClass::queryInterface ((FIDString)&riid, object);   \
}
 
//------------------------------------------------------------------------
#define COM_UNKNOWN_METHODS(InterfaceName,BaseClass) \
COM_OBJECT_QUERY_INTERFACE(InterfaceName,BaseClass) \
IUNKNOWN_REFCOUNT_METHODS(BaseClass)
 
#endif // COM_COMPATIBLE