BaseClass.h

#pragma once
 
 
#include <functional>
 
#include "pool.h"
#include "BaseClassIO.h"
class BaseClass;
class cStruct;
#ifdef COAT_SG
 
namespace SG {
    class SG_Object;
}
 
#endif
 
struct BaseClassElement {
    comms::cStr RegOpt;
    BaseClass* BC;
    void* Ptr;
    void* Extra;
    const char* ID;
    DWORD Mask;
    bool Visible : 1;
    bool ReadOnly : 1;
    bool Serialize : 1;
    bool ApplyScale : 1;
    bool Noname : 1;
    bool Noreset : 1;
    float Scaling;  
    bool CachedValue : 1;
    unsigned short CachedIndex;
    void fill(void* _Ptr, void* _Extra, bool _vis, bool _ui, bool OnlyPointersMode);
 
    void reset(bool initmask=true);
    void minimal_reset();
    BaseClassElement();
};
 
typedef void (*voidFunc)();
class APICALL BaseClass{
protected:
    BaseClass* ParentBC;
    DWORD _ClassMask;
public:
#ifndef PY_PARSER
    friend BaseClassElement;
#endif
    //explicit BaseClass(const BaseClass&);
    //BaseClass& operator = (const BaseClass&);
#ifndef PY_PARSER
    BaseClass* GetRoot();
#endif
    BaseClass();
#ifndef PY_PARSER
    BaseClass(const BaseClass&);
#endif
    virtual ~BaseClass();
 
    virtual DWORD GetClassMask() { return 0xFFFFFFFF; }
    DWORD& ClassMask() { return _ClassMask; }
 
    void runFunction(voidFunc func) { func(); }
 
    virtual void reset_class(void* DataPtr = nullptr);
 
    
    virtual void CountObjects(int& required_index, int* counter, HashSummator* hash, BaseClassElement* result, const std::function<bool(BaseClassElement*)>* ForEachElem = nullptr, bool OnlyPointersMode = false) { }
 
    void ForEach(const std::function<bool(BaseClassElement* el)>& fn, bool OnlyPointsers = false);
 
    virtual     bool CopyBaseClass(BaseClass* Dest, bool Add = false);
 
 
    virtual void Save(TagsList& xml, void* ClassPtr, void* Extra = NULL);
    virtual bool Load(TagsList& xml, void* ClassPtr, void* Extra = NULL);
    virtual     bool FullCopy(const void* SrcData, const void* SrcDataExtra, BaseClass* Dest, void* DestData, void* DstDataExtra, CECopyContext* C);
    virtual     void SaveBin(void* Data, void* Extra, BinStream* Out, Enumerator* ExDictionary, Enumerator* SkipList);
    virtual     void LoadBin(void* Data, void* Extra, BinStream* In, Enumerator* ExDictionary);
#ifndef PY_PARSER
    virtual void UpdateHash(HashSummator& S, void* data = nullptr, void* extra = nullptr);
#endif
    virtual int GetAmountOfElementsInUI();
    virtual int GetAmountOfElementsInXML();
 
    virtual cStruct* pySerialize() { 
        return nullptr; 
    }
    virtual cStruct* pySerialize() {…}
    
#ifndef PY_PARSER
    virtual const char* GetClassName() const;
    virtual void RegisterMembers();
    virtual int GetAmountOfElements();
 
    virtual bool CheckDirectCasting() const { return false; }
 
    virtual int GetClassSize() const;
 
    virtual BaseClass* new_element() const;
#endif
 
 
    
    virtual bool GetElement(BaseClassElement& res, int idx, const void* Ptr = nullptr, const void* Extra = nullptr);
    bool GetElementByName(const char* Name, void* Ptr, void* Extra, BaseClassElement& res, bool UI = false, bool Serialize = true);
    bool GetElementByNameAndType(const char* Name, const char* Type, void* Ptr, void* Extra, BaseClassElement& res, bool UI = false, bool Serialize = true);
 
    
    void DeleteDefaultSubFields(TagsList& xml, void* ClassPtr, void* Extra = NULL);
    virtual bool ShouldSaveInShortForm() { return false; }
 
    
    virtual int ExpandWith(const char* ElmName,void* base){ return -1; }
    virtual bool DelElement(int Index){return false;}
 
 
#ifndef PY_PARSER
    template<class Type = BaseClass>
    bool valid() const;
    template<>
    bool valid<BaseClass>() const;
#endif
    BaseClass* auto_cast(void* ptr) const;
 
    virtual     bool ReadFromFile           (const char* Name, bool very_safe_with_backup = false);
    virtual     bool WriteToFile            (const char* Name);
    virtual     bool WriteToFileIfChanged   (const char* Name);
 
#ifndef PY_PARSER
    virtual void ToBS(BinStream& bs, bool IncludeLength);
    virtual void FromBS(BinStream& bs);
    virtual void ToBS(BinStream& bs, void* data, void* extra, bool IncludeLength);
    virtual void FromBS(BinStream& bs, void* data, void* extra);
#endif
    virtual void ToStr(comms::cStr& bs);
    virtual void FromStr(const comms::cStr& bs);
    
    
#ifndef PY_PARSER   
    virtual bool CheckIfFunction() const { return false; }
    virtual int         condition_call(void* ptr) { return -1; }
    
    virtual BaseClass* GetParent() const {return ParentBC;}
    template <typename type> type* FindParent();
#endif
    virtual void SetParent(BaseClass* Parent);
    virtual void SimplySetParent(BaseClass* Parent);
    virtual bool MayBeParent() { return true; }
 
    virtual bool CheckCompartabilityWith(const char* TypeName,int TypeSize){return true;}
    
    // Editor events.
    virtual bool ProcessInEditor(BaseClass* Parent) { return false; }
    virtual bool RenderInScene(BaseClass* Parent) { return false; }
    // Editor events.
    virtual bool HandleKey(int code) { return false; }
    virtual bool OnChangeMember(BaseClass* MembClass,void* MembPtr,void* MembExtra,const char* MembName){return false;}
    virtual void BeforeChangeMember(BaseClass* MembClass,void* MembPtr,void* MembExtra,const char* MembName){}
    virtual int GetElementLevel(const char* EName){return 0;}
    virtual BaseWidget* OnCreateControlFromScratch(const ClassEditorContext& Context, Rct& Rect){ return NULL; }
    virtual void OnModifyControl(const char* FieldName, BaseWidget* W, ClassEditorContext& Context){};
 
    virtual bool CanBeDragged(const char* MemberID,int& dx,int& dy){return false;}
    virtual bool CanAcceptDrag(const char* MemberID){return false;}
    virtual bool OnStartDrag( const char* MemberID ){ return false; }
    virtual bool OnEndDrag( const char* MemberID ){ return false; }
    virtual bool OnAcceptDrag( BaseClass* DraggedItemParent, const char* DraggedMemberID, const char* AcceptorMemberID, iRct MyRect ){ return false; }
    virtual bool UsePointerInHashCalculation() { return false; }
    virtual bool SkipHash(){return false;}
    virtual bool IsArray() const { return false; }
    virtual const char* GetCmdID(){return NULL;}
    void SetParents();
    void SetParentsSafe();
 
 
    static const char* GetCurrentSaveFile();
    
    static const char* CurrentSaveFile;
 
    virtual void UpdateClassMembersAndMask( bool recursive );
    
    static bool SaveInShortForm;
#ifndef PY_PARSER   
    virtual bool CallFromScript() const { return bCallFromScript; }
    virtual void CallFromScript(const bool& b) { bCallFromScript = b; }
#endif
    static bool& UI_definition();
    static bool& Serialization();
protected:
    bool bCallFromScript;
    void test_presence_integrity();
    static std::mutex& get_bc_mutex();
    static uni_hash<_empty, cPtrDiff, (1 << 18), 2048>& presence();
    void register_this();
    void remove_this();
#ifdef COAT_SG
protected:
    SG::SG_Object* sgObj; // pointer to the script generator base obj
 
    template <class T>  T* toCastSGObj() const {
        return static_cast<T*>(sgObj);
    }
public:
    SG::SG_Object* GetSGObj() const { return sgObj; }
    virtual void SetSGObj(SG::SG_Object* obj, bool bInit = false);
    virtual void OnSetupSG() { ; }
    virtual bool OnScriptRecorder(BaseClass* MembClass, void* MembPtr, void* MembExtra, const char* MembName);
#endif // !PY_PARSER
 
};
class APICALL BaseClass {…};
#ifndef PY_PARSER
inline void HashSummator::operator+=(BaseClass* value) {
    if(value)value->UpdateHash(*this);
}
#endif // !PY_PARSER