/* auto-generated, do not modify */

#include "config.h"

#include <glib.h>

#include "fu-genesys-usbhub-struct.h"

#include "fu-byte-array.h"

#include "fu-mem-private.h"

#include "fu-string.h"

#ifdef G_LOG_DOMAIN

  #undef G_LOG_DOMAIN

#endif

#define G_LOG_DOMAIN "FuStruct"

const gchar *

fu_genesys_ts_version_to_string(FuGenesysTsVersion val)

{

    if (val == FU_GENESYS_TS_VERSION_DYNAMIC_9_BYTE)

        return "dynamic-9-byte";

    if (val == FU_GENESYS_TS_VERSION_BONDING)

        return "bonding";

    if (val == FU_GENESYS_TS_VERSION_BONDING_QC)

        return "bonding-qc";

    if (val == FU_GENESYS_TS_VERSION_VENDOR_SUPPORT)

        return "vendor-support";

    if (val == FU_GENESYS_TS_VERSION_MULTI_TOKEN)

        return "multi-token";

    if (val == FU_GENESYS_TS_VERSION_DYNAMIC_2ND)

        return "dynamic-2nd";

    if (val == FU_GENESYS_TS_VERSION_RESERVED)

        return "reserved";

    if (val == FU_GENESYS_TS_VERSION_DYNAMIC_13_BYTE)

        return "dynamic-13-byte";

    if (val == FU_GENESYS_TS_VERSION_BRAND_PROJECT)

        return "brand-project";

    return NULL;

}

const gchar *

fu_genesys_fw_status_to_string(FuGenesysFwStatus val)

{

    if (val == FU_GENESYS_FW_STATUS_MASK)

        return "mask";

    if (val == FU_GENESYS_FW_STATUS_BANK1)

        return "bank1";

    if (val == FU_GENESYS_FW_STATUS_BANK2)

        return "bank2";

    return NULL;

}

const gchar *

fu_genesys_vs_codesign_check_to_string(FuGenesysVsCodesignCheck val)

{

    if (val == FU_GENESYS_VS_CODESIGN_CHECK_UNSUPPORTED)

        return "unsupported";

    if (val == FU_GENESYS_VS_CODESIGN_CHECK_SCALER)

        return "scaler";

    if (val == FU_GENESYS_VS_CODESIGN_CHECK_FW)

        return "fw";

    if (val == FU_GENESYS_VS_CODESIGN_CHECK_MASTER)

        return "master";

    if (val == FU_GENESYS_VS_CODESIGN_CHECK_RESERVED)

        return "reserved";

    if (val == FU_GENESYS_VS_CODESIGN_CHECK_HW)

        return "hw";

    return NULL;

}

static const gchar *

fu_genesys_vs_hid_isp_to_string(FuGenesysVsHidIsp val)

{

    if (val == FU_GENESYS_VS_HID_ISP_UNSUPPORTED)

        return "unsupported";

    if (val == FU_GENESYS_VS_HID_ISP_SUPPORT)

        return "support";

    if (val == FU_GENESYS_VS_HID_ISP_CODESIGN_N_RESET)

        return "codesign-n-reset";

    return NULL;

}

const gchar *

fu_genesys_fw_codesign_to_string(FuGenesysFwCodesign val)

{

    if (val == FU_GENESYS_FW_CODESIGN_NONE)

        return "none";

    if (val == FU_GENESYS_FW_CODESIGN_RSA)

        return "rsa";

    if (val == FU_GENESYS_FW_CODESIGN_ECDSA)

        return "ecdsa";

    return NULL;

}

const gchar *

fu_genesys_fw_type_to_string(FuGenesysFwType val)

{

    if (val == FU_GENESYS_FW_TYPE_HUB)

        return "hub";

    if (val == FU_GENESYS_FW_TYPE_DEV_BRIDGE)

        return "dev-bridge";

    if (val == FU_GENESYS_FW_TYPE_PD)

        return "pd";

    if (val == FU_GENESYS_FW_TYPE_CODESIGN)

        return "codesign";

    if (val == FU_GENESYS_FW_TYPE_INSIDE_HUB_COUNT)

        return "inside-hub-count";

    if (val == FU_GENESYS_FW_TYPE_SCALER)

        return "scaler";

    if (val == FU_GENESYS_FW_TYPE_UNKNOWN)

        return "unknown";

    return NULL;

}

/**

 * fu_struct_genesys_firmware_hdr_ref: (skip):

 **/

FuStructGenesysFirmwareHdr *

fu_struct_genesys_firmware_hdr_ref(FuStructGenesysFirmwareHdr *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    st->refcount++;

    return st;

}

/**

 * fu_struct_genesys_firmware_hdr_unref: (skip):

 **/

void

fu_struct_genesys_firmware_hdr_unref(FuStructGenesysFirmwareHdr *st)

{

    g_return_if_fail(st != NULL);

    if (st->refcount == 0) {

        g_critical("FuStructGenesysFirmwareHdr refcount already zero");

        return;

    }

    if (--st->refcount > 0)

        return;

    if (st->buf != NULL)

        g_byte_array_unref(st->buf);

    g_free(st);

}

/**

 * fu_struct_genesys_firmware_hdr_new_internal: (skip):

 **/

static FuStructGenesysFirmwareHdr *

fu_struct_genesys_firmware_hdr_new_internal(void)

{

    FuStructGenesysFirmwareHdr *st = g_new0(FuStructGenesysFirmwareHdr, 1);

    st->refcount = 1;

    return st;

}

/* getters */

/**

 * fu_struct_genesys_firmware_hdr_get_magic: (skip):

 **/

static gchar *

fu_struct_genesys_firmware_hdr_get_magic(const FuStructGenesysFirmwareHdr *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 252, 4, NULL);

}

/* setters */

static gboolean

fu_struct_genesys_firmware_hdr_validate_internal(FuStructGenesysFirmwareHdr *st, GError **error)

{

    g_return_val_if_fail(st != NULL, FALSE);

    if (strncmp((const gchar *) (st->buf->data + 252), "XROM", 4) != 0) {

        g_autofree gchar *str = fu_struct_genesys_firmware_hdr_get_magic(st);

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "constant FuStructGenesysFirmwareHdr.magic was not valid, "

                    "expected 'XROM' and got '%s'",

                    str);

        return FALSE;

    }

    return TRUE;

}

/**

 * fu_struct_genesys_firmware_hdr_validate_stream: (skip):

 **/

gboolean

fu_struct_genesys_firmware_hdr_validate_stream(GInputStream *stream, gsize offset, GError **error)

{

    g_autoptr(FuStructGenesysFirmwareHdr) st = fu_struct_genesys_firmware_hdr_new_internal();

    g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    st->buf = fu_input_stream_read_byte_array(stream, offset, 256, NULL, error);

    if (st->buf == NULL) {

        g_prefix_error(error, "FuStructGenesysFirmwareHdr failed read of 0x%x: ", (guint) 256);

        return FALSE;

    }

    if (st->buf->len != 256) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "FuStructGenesysFirmwareHdr requested 0x%x and got 0x%x",

                    (guint) 256,

                    (guint) st->buf->len);

        return FALSE;

    }

    return fu_struct_genesys_firmware_hdr_validate_internal(st, error);

}

/**

 * fu_struct_genesys_dev_firmware_hdr_ref: (skip):

 **/

FuStructGenesysDevFirmwareHdr *

fu_struct_genesys_dev_firmware_hdr_ref(FuStructGenesysDevFirmwareHdr *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    st->refcount++;

    return st;

}

/**

 * fu_struct_genesys_dev_firmware_hdr_unref: (skip):

 **/

void

fu_struct_genesys_dev_firmware_hdr_unref(FuStructGenesysDevFirmwareHdr *st)

{

    g_return_if_fail(st != NULL);

    if (st->refcount == 0) {

        g_critical("FuStructGenesysDevFirmwareHdr refcount already zero");

        return;

    }

    if (--st->refcount > 0)

        return;

    if (st->buf != NULL)

        g_byte_array_unref(st->buf);

    g_free(st);

}

/**

 * fu_struct_genesys_dev_firmware_hdr_new_internal: (skip):

 **/

static FuStructGenesysDevFirmwareHdr *

fu_struct_genesys_dev_firmware_hdr_new_internal(void)

{

    FuStructGenesysDevFirmwareHdr *st = g_new0(FuStructGenesysDevFirmwareHdr, 1);

    st->refcount = 1;

    return st;

}

/* getters */

/**

 * fu_struct_genesys_dev_firmware_hdr_get_magic: (skip):

 **/

static gchar *

fu_struct_genesys_dev_firmware_hdr_get_magic(const FuStructGenesysDevFirmwareHdr *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 252, 4, NULL);

}

/* setters */

static gboolean

fu_struct_genesys_dev_firmware_hdr_validate_internal(FuStructGenesysDevFirmwareHdr *st, GError **error)

{

    g_return_val_if_fail(st != NULL, FALSE);

    if (strncmp((const gchar *) (st->buf->data + 252), "HOST", 4) != 0) {

        g_autofree gchar *str = fu_struct_genesys_dev_firmware_hdr_get_magic(st);

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "constant FuStructGenesysDevFirmwareHdr.magic was not valid, "

                    "expected 'HOST' and got '%s'",

                    str);

        return FALSE;

    }

    return TRUE;

}

/**

 * fu_struct_genesys_dev_firmware_hdr_validate_stream: (skip):

 **/

gboolean

fu_struct_genesys_dev_firmware_hdr_validate_stream(GInputStream *stream, gsize offset, GError **error)

{

    g_autoptr(FuStructGenesysDevFirmwareHdr) st = fu_struct_genesys_dev_firmware_hdr_new_internal();

    g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    st->buf = fu_input_stream_read_byte_array(stream, offset, 256, NULL, error);

    if (st->buf == NULL) {

        g_prefix_error(error, "FuStructGenesysDevFirmwareHdr failed read of 0x%x: ", (guint) 256);

        return FALSE;

    }

    if (st->buf->len != 256) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "FuStructGenesysDevFirmwareHdr requested 0x%x and got 0x%x",

                    (guint) 256,

                    (guint) st->buf->len);

        return FALSE;

    }

    return fu_struct_genesys_dev_firmware_hdr_validate_internal(st, error);

}

/**

 * fu_struct_genesys_pd_firmware_hdr_ref: (skip):

 **/

FuStructGenesysPdFirmwareHdr *

fu_struct_genesys_pd_firmware_hdr_ref(FuStructGenesysPdFirmwareHdr *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    st->refcount++;

    return st;

}

/**

 * fu_struct_genesys_pd_firmware_hdr_unref: (skip):

 **/

void

fu_struct_genesys_pd_firmware_hdr_unref(FuStructGenesysPdFirmwareHdr *st)

{

    g_return_if_fail(st != NULL);

    if (st->refcount == 0) {

        g_critical("FuStructGenesysPdFirmwareHdr refcount already zero");

        return;

    }

    if (--st->refcount > 0)

        return;

    if (st->buf != NULL)

        g_byte_array_unref(st->buf);

    g_free(st);

}

/**

 * fu_struct_genesys_pd_firmware_hdr_new_internal: (skip):

 **/

static FuStructGenesysPdFirmwareHdr *

fu_struct_genesys_pd_firmware_hdr_new_internal(void)

{

    FuStructGenesysPdFirmwareHdr *st = g_new0(FuStructGenesysPdFirmwareHdr, 1);

    st->refcount = 1;

    return st;

}

/* getters */

/**

 * fu_struct_genesys_pd_firmware_hdr_get_magic: (skip):

 **/

static gchar *

fu_struct_genesys_pd_firmware_hdr_get_magic(const FuStructGenesysPdFirmwareHdr *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 252, 4, NULL);

}

/* setters */

static gboolean

fu_struct_genesys_pd_firmware_hdr_validate_internal(FuStructGenesysPdFirmwareHdr *st, GError **error)

{

    g_return_val_if_fail(st != NULL, FALSE);

    if (strncmp((const gchar *) (st->buf->data + 252), "PRDY", 4) != 0) {

        g_autofree gchar *str = fu_struct_genesys_pd_firmware_hdr_get_magic(st);

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "constant FuStructGenesysPdFirmwareHdr.magic was not valid, "

                    "expected 'PRDY' and got '%s'",

                    str);

        return FALSE;

    }

    return TRUE;

}

/**

 * fu_struct_genesys_pd_firmware_hdr_validate_stream: (skip):

 **/

gboolean

fu_struct_genesys_pd_firmware_hdr_validate_stream(GInputStream *stream, gsize offset, GError **error)

{

    g_autoptr(FuStructGenesysPdFirmwareHdr) st = fu_struct_genesys_pd_firmware_hdr_new_internal();

    g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    st->buf = fu_input_stream_read_byte_array(stream, offset, 256, NULL, error);

    if (st->buf == NULL) {

        g_prefix_error(error, "FuStructGenesysPdFirmwareHdr failed read of 0x%x: ", (guint) 256);

        return FALSE;

    }

    if (st->buf->len != 256) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "FuStructGenesysPdFirmwareHdr requested 0x%x and got 0x%x",

                    (guint) 256,

                    (guint) st->buf->len);

        return FALSE;

    }

    return fu_struct_genesys_pd_firmware_hdr_validate_internal(st, error);

}

/**

 * fu_struct_genesys_ts_static_ref: (skip):

 **/

FuStructGenesysTsStatic *

fu_struct_genesys_ts_static_ref(FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    st->refcount++;

    return st;

}

/**

 * fu_struct_genesys_ts_static_unref: (skip):

 **/

void

fu_struct_genesys_ts_static_unref(FuStructGenesysTsStatic *st)

{

    g_return_if_fail(st != NULL);

    if (st->refcount == 0) {

        g_critical("FuStructGenesysTsStatic refcount already zero");

        return;

    }

    if (--st->refcount > 0)

        return;

    if (st->buf != NULL)

        g_byte_array_unref(st->buf);

    g_free(st);

}

/**

 * fu_struct_genesys_ts_static_new_internal: (skip):

 **/

static FuStructGenesysTsStatic *

fu_struct_genesys_ts_static_new_internal(void)

{

    FuStructGenesysTsStatic *st = g_new0(FuStructGenesysTsStatic, 1);

    st->refcount = 1;

    return st;

}

/* getters */

/**

 * fu_struct_genesys_ts_static_get_tool_string_version: (skip):

 **/

FuGenesysTsVersion

fu_struct_genesys_ts_static_get_tool_string_version(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, 0x0);

    return st->buf->data[0];

}

/**

 * fu_struct_genesys_ts_static_get_mask_project_code: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_mask_project_code(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 1, 4, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_mask_project_hardware: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_mask_project_hardware(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 5, 1, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_mask_project_firmware: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_mask_project_firmware(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 6, 2, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_mask_project_ic_type: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_mask_project_ic_type(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 8, 6, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_running_project_code: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_running_project_code(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 14, 4, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_running_project_hardware: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_running_project_hardware(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 18, 1, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_running_project_firmware: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_running_project_firmware(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 19, 2, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_running_project_ic_type: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_running_project_ic_type(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 21, 6, NULL);

}

/**

 * fu_struct_genesys_ts_static_get_firmware_version: (skip):

 **/

gchar *

fu_struct_genesys_ts_static_get_firmware_version(const FuStructGenesysTsStatic *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    return fu_memstrsafe(st->buf->data, st->buf->len, 27, 4, NULL);

}

/* setters */

/**

 * fu_struct_genesys_ts_static_set_tool_string_version: (skip):

 **/

void

fu_struct_genesys_ts_static_set_tool_string_version(FuStructGenesysTsStatic *st, FuGenesysTsVersion value)

{

    g_return_if_fail(st != NULL);

    st->buf->data[0] = value;

}

/**

 * fu_struct_genesys_ts_static_set_mask_project_code: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_mask_project_code(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 1, 0x0, 4);

        return TRUE;

    }

    len = strlen(value);

    if (len > 4) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.mask_project_code (0x%x bytes)",

                    value, (guint) len, (guint) 4);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 1, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_mask_project_hardware: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_mask_project_hardware(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 5, 0x0, 1);

        return TRUE;

    }

    len = strlen(value);

    if (len > 1) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.mask_project_hardware (0x%x bytes)",

                    value, (guint) len, (guint) 1);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 5, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_mask_project_firmware: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_mask_project_firmware(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 6, 0x0, 2);

        return TRUE;

    }

    len = strlen(value);

    if (len > 2) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.mask_project_firmware (0x%x bytes)",

                    value, (guint) len, (guint) 2);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 6, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_mask_project_ic_type: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_mask_project_ic_type(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 8, 0x0, 6);

        return TRUE;

    }

    len = strlen(value);

    if (len > 6) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.mask_project_ic_type (0x%x bytes)",

                    value, (guint) len, (guint) 6);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 8, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_running_project_code: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_running_project_code(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 14, 0x0, 4);

        return TRUE;

    }

    len = strlen(value);

    if (len > 4) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.running_project_code (0x%x bytes)",

                    value, (guint) len, (guint) 4);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 14, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_running_project_hardware: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_running_project_hardware(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 18, 0x0, 1);

        return TRUE;

    }

    len = strlen(value);

    if (len > 1) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.running_project_hardware (0x%x bytes)",

                    value, (guint) len, (guint) 1);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 18, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_running_project_firmware: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_running_project_firmware(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 19, 0x0, 2);

        return TRUE;

    }

    len = strlen(value);

    if (len > 2) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.running_project_firmware (0x%x bytes)",

                    value, (guint) len, (guint) 2);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 19, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_running_project_ic_type: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_running_project_ic_type(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 21, 0x0, 6);

        return TRUE;

    }

    len = strlen(value);

    if (len > 6) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.running_project_ic_type (0x%x bytes)",

                    value, (guint) len, (guint) 6);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 21, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_set_firmware_version: (skip):

 **/

gboolean

fu_struct_genesys_ts_static_set_firmware_version(FuStructGenesysTsStatic *st, const gchar *value, GError **error)

{

    gsize len;

    g_return_val_if_fail(st != NULL, FALSE);

    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    if (value == NULL) {

        memset(st->buf->data + 27, 0x0, 4);

        return TRUE;

    }

    len = strlen(value);

    if (len > 4) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "string '%s' (0x%x bytes) does not fit in FuStructGenesysTsStatic.firmware_version (0x%x bytes)",

                    value, (guint) len, (guint) 4);

        return FALSE;

    }

    return fu_memcpy_safe(st->buf->data, st->buf->len, 27, (const guint8 *)value, len, 0x0, len, error);

}

/**

 * fu_struct_genesys_ts_static_new: (skip):

 **/

FuStructGenesysTsStatic *

fu_struct_genesys_ts_static_new(void)

{

    FuStructGenesysTsStatic *st = fu_struct_genesys_ts_static_new_internal();

    st->buf = g_byte_array_sized_new(31);

    fu_byte_array_set_size(st->buf, 31, 0x0);

    return st;

}

/**

 * fu_struct_genesys_ts_static_to_string: (skip):

 **/

static gchar *

fu_struct_genesys_ts_static_to_string(const FuStructGenesysTsStatic *st)

{

    g_autoptr(GString) str = g_string_new("FuStructGenesysTsStatic:\n");

    g_return_val_if_fail(st != NULL, NULL);

    {

        const gchar *tmp = fu_genesys_ts_version_to_string(fu_struct_genesys_ts_static_get_tool_string_version(st));

        if (tmp != NULL) {

            g_string_append_printf(str, "  tool_string_version: 0x%x [%s]\n", (guint) fu_struct_genesys_ts_static_get_tool_string_version(st), tmp);

        } else {

            g_string_append_printf(str, "  tool_string_version: 0x%x\n", (guint) fu_struct_genesys_ts_static_get_tool_string_version(st));

        }

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_mask_project_code(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  mask_project_code: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_mask_project_hardware(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  mask_project_hardware: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_mask_project_firmware(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  mask_project_firmware: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_mask_project_ic_type(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  mask_project_ic_type: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_running_project_code(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  running_project_code: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_running_project_hardware(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  running_project_hardware: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_running_project_firmware(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  running_project_firmware: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_running_project_ic_type(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  running_project_ic_type: %s\n", tmp);

    }

    {

        g_autofree gchar *tmp = fu_struct_genesys_ts_static_get_firmware_version(st);

        if (tmp != NULL)

            g_string_append_printf(str, "  firmware_version: %s\n", tmp);

    }

    if (str->len > 0)

        g_string_set_size(str, str->len - 1);

    return g_string_free(g_steal_pointer(&str), FALSE);

}

static gboolean

fu_struct_genesys_ts_static_validate_internal(FuStructGenesysTsStatic *st, GError **error)

{

    g_return_val_if_fail(st != NULL, FALSE);

    return TRUE;

}

static gboolean

fu_struct_genesys_ts_static_parse_internal(FuStructGenesysTsStatic *st, GError **error)

{

    if (g_getenv("FWUPD_VERBOSE") != NULL) {

        g_autofree gchar *str = fu_struct_genesys_ts_static_to_string(st);

        g_debug("%s", str);

    }

    if (!fu_struct_genesys_ts_static_validate_internal(st, error))

        return FALSE;

    return TRUE;

}

/**

 * fu_struct_genesys_ts_static_parse: (skip):

 **/

FuStructGenesysTsStatic *

fu_struct_genesys_ts_static_parse(const guint8 *buf, gsize bufsz, gsize offset, GError **error)

{

    g_autoptr(FuStructGenesysTsStatic) st = fu_struct_genesys_ts_static_new_internal();

    g_return_val_if_fail(buf != NULL, NULL);

    g_return_val_if_fail(error == NULL || *error == NULL, NULL);

    if (!fu_memchk_read(bufsz, offset, 31, error)) {

        g_prefix_error_literal(error, "invalid struct FuStructGenesysTsStatic: ");

        return NULL;

    }

    st->buf = g_byte_array_new();

    g_byte_array_append(st->buf, buf + offset, 31);

    if (!fu_struct_genesys_ts_static_parse_internal(st, error))

        return NULL;

    return g_steal_pointer(&st);

}

/**

 * fu_struct_genesys_ts_static_parse_stream: (skip):

 **/

FuStructGenesysTsStatic *

fu_struct_genesys_ts_static_parse_stream(GInputStream *stream, gsize offset, GError **error)

{

    g_autoptr(FuStructGenesysTsStatic) st = fu_struct_genesys_ts_static_new_internal();

    st->buf = fu_input_stream_read_byte_array(stream, offset, 31, NULL, error);

    if (st->buf == NULL) {

        g_prefix_error(error, "FuStructGenesysTsStatic failed read of 0x%x: ", (guint) 31);

        return NULL;

    }

    if (st->buf->len != 31) {

        g_set_error(error,

                    FWUPD_ERROR,

                    FWUPD_ERROR_INVALID_DATA,

                    "FuStructGenesysTsStatic requested 0x%x and got 0x%x",

                    (guint) 31,

                    (guint) st->buf->len);

        return NULL;

    }

    if (!fu_struct_genesys_ts_static_parse_internal(st, error))

        return NULL;

    return g_steal_pointer(&st);

}

/**

 * fu_struct_genesys_ts_dynamic_gl3523_ref: (skip):

 **/

FuStructGenesysTsDynamicGl3523 *

fu_struct_genesys_ts_dynamic_gl3523_ref(FuStructGenesysTsDynamicGl3523 *st)

{

    g_return_val_if_fail(st != NULL, NULL);

    st->refcount++;

    return st;

}

/**

 * fu_struct_genesys_ts_dynamic_gl3523_unref: (skip):

 **/

void

fu_struct_genesys_ts_dynamic_gl3523_unref(FuStructGenesysTsDynamicGl3523 *st)

{

    g_return_if_fail(st != NULL);

    if (st->refcount == 0) {

        g_critical("FuStructGenesysTsDynamicGl3523 refcount already zero");

        return;

    }

    if (--st->refcount > 0)

        return;

    if (st->buf != NULL)

        g_byte_array_unref(st->buf);

    g_free(st);

}

/**