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) 2021, 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
 
namespace Steinberg {
 
//----------------------------------
 
using FClassID = FIDString;
 
//------------------------------------------------------------------------
// Basic FObject - implements FUnknown + IDependent
//------------------------------------------------------------------------
//------------------------------------------------------------------------
class FObject : public IDependent
{
public:
        //------------------------------------------------------------------------
        FObject () : refCount (1) {}                                                                                    
        FObject (const FObject&) : refCount (1) {}                                                              
        virtual ~FObject () {}                                                                                                  
        FObject& operator = (const FObject&) { return *this; }                                  
 
        // 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;                                                                                                                 
 
        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 (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