dl_component.h

浏览该文件的文档.

#pragma once
 
#include <typeinfo>
#include <typeindex>
#include <string>
#include <vector>
#include <array>
#include <functional>
 
#include "dl_type.h"
#include "math/dl_align.h"
#include "math/dl_coor.h"
 
namespace dl
{
namespace Cpt
{
    template<typename T, uint64_t UID>
    class Variable
    {
    public:
        void Set(T v) { _v = v; }
        T Get() { return _v; }
 
        operator bool() { return _v != 0; }
        Variable(T v) : _v(v) {}
        Variable() {}
    private:
        T _v;
    };

    template<typename T, uint64_t UID>
    class Function
    {
    public:
        Function() = default;
        void operator=(const T& func) { Call = func; }
        T Call;
    };
}

class AnyType
{
    friend class VectorAny;
public:
    bool operator==(const AnyType& b) { return _p == b._p; }
    bool operator!=(const AnyType& b) { return _id != b._id || _p != b._p; }
 
    //默认构造id为自己
    AnyType():
        _p{nullptr},
        _id{ typeid(AnyType) }
    {}
 
    template<typename T>
    AnyType(T* p):
        _id{ typeid(T) }
    {
        _p = p;
#ifndef NDEBUG
        _nameDebug = typeid(T).name();
#endif
    }

    template<typename T>
    T* Cast()
    {
        if (std::type_index(typeid(T)) == _id)
        {
            return (T*)_p;
        }
        else
            return nullptr;
    }

    std::type_index GetId()
    {
        return _id;
    }

    bool IsNull()
    {
        return !_p;
    }
 
    std::string GetNameDebug()
    {
#ifndef NDEBUG
        return _nameDebug;
#else
        return "Debug版本才有此字段！";
#endif
    }
 
private:
    void* _p;
    std::type_index _id;
#ifndef NDEBUG
    std::string _nameDebug;
#endif
};

class VectorAny
{
public:
    void PushBack(AnyType any)
    {
        _vec.push_back(any);
    }
 
    void Clear()
    {
        _vec.clear();
    }

    template<typename T>
    std::vector<T*> GetMulti()
    {
        std::vector<T*> ret;
        for (auto& iter : _vec)
        {
            if (iter._id == std::type_index(typeid(T)))
            {
                ret.push_back((T*)iter._p);
            }
        }
 
        return ret;
    }

    template<typename T>
    T* Get(size_t index = 0)
    {
        for (auto& iter : _vec)
        {
            if (iter._id == std::type_index(typeid(T)))
            {
                if (index == 0)
                    return (T*)(iter._p);
                else
                    --index;
            }
        }
        return nullptr;
    }

    auto& GetVector()
    {
        return _vec;
    }
 
    std::vector<AnyType>::iterator begin() { return _vec.begin(); }
 
    std::vector<AnyType>::iterator end() { return _vec.end(); }
 
    size_t GetSize() { return _vec.size(); }
 
private:
    std::vector<AnyType> _vec;
};

class Components
{
public:
    template <typename T>
    Components(T* p) : _any(p)
    {
#ifndef NDEBUG
        _nameDebug = _any.GetNameDebug();
#endif
    }
 
    bool operator==(const Components& b) { return _any == b._any; }
    bool operator!=(const Components& b) { return _any != b._any; }

    template <typename T>
    T* Cast() { return _any.Cast<T>(); }

    template <typename T>
    T* Get(size_t index = 0) { return _vec.Get<T>(index); }

    AnyType GetSelf()
    {
        return _any;
    }

    void PushBack(AnyType any)
    {
        _vec.PushBack(any);
    }
 
    void Clear()
    {
        _vec.Clear();
    }
 
    VectorAny& GetVectorAny() { return _vec; }
 
    std::string GetName()
    {
        return _name;
    }

    void SetName(std::string_view name)
    {
        _name = name;
    }

    bool IsPure()
    {
        return _any.IsNull();
    }
private:
    VectorAny _vec;
    AnyType _any;
    std::string _name;
#ifndef NDEBUG
    std::string _nameDebug;
#endif
};
 
inline Components* createComponents(std::string_view name = {})
{
    Components* ret = new Components((int*)nullptr);
    ret->SetName(name);
    return ret;
}
 
namespace Cpt
{
    template<typename T>
    std::vector<T*> GetComp(std::vector<Components*>& vec)
    {
        std::vector<T*> ret;
        for (Components* cpt : vec)
        {
            VectorAny& vec_any = cpt->GetVectorAny();
            std::vector<T*> mul = vec_any.GetMulti<T>();
            ret.insert(ret.end(), mul.begin(), mul.end());
        }
        return ret;
    }

    template<typename T>
    T* GetFirst(std::vector<Components*>& vec)
    {
        for (Components* cpt : vec)
        {
            T* p = cpt->GetSelf().Cast<T>();
            if (p)
                return p;
        }
        return nullptr;
    }

    template<typename T>
    T* GetN(std::vector<Components*>& vec, size_t n)
    {
        for (Components* cpt : vec)
        {
            T* p = cpt->GetSelf().Cast<T>();
            if(!p || n--)
                continue;
            return p;
        }
        return nullptr;
    }
}
 
}