ObjectBase.h

// Copyright (c) 2016-2018 Kiwano - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
 
#pragma once
#include <kiwano/macros.h>
#include <kiwano/core/Common.h>
#include <kiwano/core/Exception.h>
#include <kiwano/core/Serializable.h>
#include <kiwano/base/RefObject.h>
#include <kiwano/base/RefPtr.h>
 
namespace kiwano
{
 
class ObjectBase;
 
struct ObjectStatus
{
    int    code = 0;  
    String msg;       
 
    ObjectStatus() = default;
 
    ObjectStatus(int code, StringView msg)
        : code(code)
        , msg(msg)
    {
    }
 
    inline bool Success() const
    {
        return this->code == 0;
    }
 
    static const int fail = -1;
};
 
class ObjectFailException : public Exception
{
public:
    ObjectFailException(ObjectBase* obj, const ObjectStatus& status);
 
    inline ObjectBase* GetObj() const
    {
        return obj_;
    }
 
    inline ObjectStatus GetStatus() const
    {
        return status_;
    }
 
    virtual char const* what() const override;
 
private:
    ObjectBase*  obj_;
    ObjectStatus status_;
};
 
typedef Function<void(ObjectBase*, const ObjectStatus&)> ObjectPolicyFunc;
 
struct ObjectPolicy
{
    static inline ObjectPolicyFunc Ignore()
    {
        return nullptr;
    }
 
    static ObjectPolicyFunc WarnLog(int threshold = ObjectStatus::fail);
 
    static ObjectPolicyFunc ErrorLog(int threshold = ObjectStatus::fail);
 
    static ObjectPolicyFunc Exception(int threshold = ObjectStatus::fail);
};
 
class KGE_API ObjectBase
    : public RefObject
    , public Serializable
{
public:
    ObjectBase();
 
    virtual ~ObjectBase();
 
    void SetName(StringView name);
 
    StringView GetName() const;
 
    bool IsName(StringView name) const;
 
    void* GetUserData() const;
 
    void SetUserData(void* data);
 
    void Hold(RefPtr<ObjectBase> other);
 
    void Unhold(RefPtr<ObjectBase> other);
 
    uint64_t GetObjectID() const;
 
    void DoSerialize(Serializer* serializer) const override;
 
    void DoDeserialize(Deserializer* deserializer) override;
 
    virtual bool IsValid() const;
 
    ObjectStatus* GetStatus() const;
 
    void SetStatus(const ObjectStatus& status);
 
    void Fail(StringView msg, int code = ObjectStatus::fail);
 
    void ClearStatus();
 
    static void SetObjectPolicy(const ObjectPolicyFunc& policy);
 
public:
    static bool IsTracingLeaks();
 
    static void StartTracingLeaks();
 
    static void StopTracingLeaks();
 
    static void DumpTracingObjects();
 
    static Vector<ObjectBase*>& GetTracingObjects();
 
private:
    static void AddObjectToTracingList(ObjectBase*);
 
    static void RemoveObjectFromTracingList(ObjectBase*);
 
private:
    const uint64_t id_;
 
    bool    tracing_leak_;
    String* name_;
    void*   user_data_;
 
    ObjectStatus*            status_;
    Set<RefPtr<ObjectBase>>* holdings_;
};
 
inline StringView ObjectBase::GetName() const
{
    if (name_)
        return StringView(*name_);
    return StringView();
}
 
inline bool ObjectBase::IsName(StringView name) const
{
    return name_ ? (*name_ == name) : name.empty();
}
 
inline uint64_t ObjectBase::GetObjectID() const
{
    return id_;
}
}  // namespace kiwano