block.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <string>
 
#include "../fields.h"
 
#ifdef GUERILLA_LIB_EXPORTS
#define GUERILLA_LIB_API __declspec(dllexport) 
#else
#define GUERILLA_LIB_API __declspec(dllimport) 
#endif
 
class BlamTagField_Bitfield;
class BlamTagField_Block;
class BlamTagField_Boolean;
class BlamTagField_Color;
class BlamTagField_Comment;
class BlamTagField_Dataref;
class BlamTagField_Enum;
class BlamTagField_Fieldref;
class BlamTagField_Float32;
class BlamTagField_Int;
class BlamTagField_Tagref;
class BlamTagField_Vector;
 
class GUERILLA_LIB_API BlamTagBlockEntry
{
public:
    std::string name; 
    std::vector<BlamTagField*> fields; 
 
    ~BlamTagBlockEntry();
 
    BlamTagField* GetField(std::string field_id);
 
    BlamTagField* GetField(std::string field_id, BlamTagFieldType field_type);
 
    template <typename T> T* GetField(std::string field_id, BlamTagFieldType field_type = BlamTagFieldType::Unspecified)
    {
        if (std::is_same_v<T, BlamTagField_Bitfield>) return (T*)GetField(field_id, field_type);
        else if (std::is_same_v<T, BlamTagField_Block>) return (T*)GetField(field_id, BlamTagFieldType::Block);
        else if (std::is_same_v<T, BlamTagField_Boolean>) return (T*)GetField(field_id, BlamTagFieldType::Boolean);
        else if (std::is_same_v<T, BlamTagField_Color>) return (T*)GetField(field_id, BlamTagFieldType::Color);
        else if (std::is_same_v<T, BlamTagField_Comment>) return (T*)GetField(field_id, BlamTagFieldType::Comment);
        else if (std::is_same_v<T, BlamTagField_Dataref>) return (T*)GetField(field_id, BlamTagFieldType::DataReference);
        else if (std::is_same_v<T, BlamTagField_Enum>) return (T*)GetField(field_id, field_type);
        else if (std::is_same_v<T, BlamTagField_Fieldref>) return (T*)GetField(field_id, BlamTagFieldType::Block);
        else if (std::is_same_v<T, BlamTagField_Float32>) return (T*)GetField(field_id, BlamTagFieldType::Block);
        else if (std::is_same_v<T, BlamTagField_Int>) return (T*)GetField(field_id, field_type);
        else if (std::is_same_v<T, BlamTagField_Tagref>) return (T*)GetField(field_id, BlamTagFieldType::Block);
        else if (std::is_same_v<T, BlamTagField_Vector>) return (T*)GetField(field_id, field_type);
 
        return nullptr;
    };
 
    BlamTagBlockEntry* Copy();
 
    BlamTagField* GetFieldFromRelativeAddress(std::string address);
};
 
class GUERILLA_LIB_API BlamPluginField_Block : public BlamPluginField
{
public:
    int entry_size = 0; 
    std::vector<BlamPluginField*> fields; 
 
    int c_entry_count = 0;  
    int c_entry_offset = 0; 
    int max_entry_count = -1; 
 
    BlamPluginField_Block(BlamPluginField* base_field);
 
    ~BlamPluginField_Block();
 
    BlamPluginField* GetField(std::string id);
 
    BlamPluginField* GetField(std::string id, BlamTagFieldType type);
 
    void UpdateOffsetData(int new_offset) override;
    std::string GenerateXMLString() override;
    std::string GenerateCppStructString(std::string line_prefix = "", BlamPluginExportOptions options = BlamPluginExportOptions()) override;
    std::string GenerateCppClassString(std::string line_prefix = "") override;
    bool ParseXMLData(rapidxml::xml_node<>* field_node) override;
    BlamTagField* GenerateTagField(BlamTag* tag, void* address) override;
    BlamTagField* GenerateTagField(BlamTag* tag) override;
    BlamPluginField* Copy(BlamPlugin* new_plugin) override;
};
 
class GUERILLA_LIB_API BlamTagField_Block : public BlamTagField
{
public:
    std::vector<BlamTagBlockEntry*> entries; 
 
    BlamTagField_Block(BlamTag* _tag);
 
    bool AddEntry(int offset = -1);
 
    bool DuplicateEntry(int index);
 
    bool DeleteEntry(int index);
 
    void DeleteAllEntries();
 
    BlamTagBlockEntry* CreateNewEntry();
 
    std::string GenerateXMLString(bool keep_unused, bool keep_invalid);
 
    std::vector<char> GetEntryDataAsBytes();
 
    std::string GenerateXMLString() override;
    std::vector<char> GetValueAsBytes() override;
};