local_handler.c File Reference

Implements localization for the game. More...

#include "local_handler.h"
#include "../logging/logger.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Go to the source code of this file.

Data Structures
struct	observer_node

Macros
#define	PATH_SEP   "/"
#define	LOCAL_DIRECTORY   "resources/local"

Typedefs
typedef struct observer_node	observer_node_t

Functions
int	init_local_handler (const local_lang_t lang)
	Initialize the local language handler by setting up the language and opening the corresponding resource file.
char *	get_local_string (const char *key)
	Get the localized string for the given key.
int	set_language (const local_lang_t lang)
	Sets the current language for the local handler and updates all registered observers.
local_lang_t	get_language (void)
	Retrieve the currently set language of the local handler.
void	observe_local (void(*update_func)(void))
	Registers an observer function to be notified of updates from the local handler.
void	shutdown_local_handler (void)
	Shut down the local language handler by releasing resources and closing the resource file.

Variables
observer_node_t *	observer_list = NULL
FILE *	local_file = NULL
local_lang_t	current_lang

Detailed Description

Implements localization for the game.

Definition in file local_handler.c.

Macro Definition Documentation

LOCAL_DIRECTORY

#define LOCAL_DIRECTORY   "resources/local"

Definition at line 18 of file local_handler.c.

PATH_SEP

#define PATH_SEP   "/"

Definition at line 17 of file local_handler.c.

Typedef Documentation

observer_node_t

typedef struct observer_node observer_node_t

Definition at line 21 of file local_handler.c.

Function Documentation

get_language()

local_lang_t get_language

(

void

)

Retrieve the currently set language of the local handler.

This function returns the current language configured for the local handler. If the local handler is not initialized, it logs a warning message and defaults the language to English.

Returns

the current language as a value of local_lang_t, or LANGE_EN if the handler is not initialized

Definition at line 116 of file local_handler.c.

                                {
    if (local_file == NULL) {
        log_msg(WARNING, "Local", "Local handler is not initialized.");
        return LANGE_EN;// default to English if not initialized
    }
    return current_lang;
}

get_local_string()

char * get_local_string

(

const char *

key

)

Get the localized string for the given key.

Parameters

key	the key for the localized string

Returns

the localized string, if the key is not found, returns the key itself

Note

The caller must free the returned string.

Definition at line 54 of file local_handler.c.

                                        {
    RETURN_WHEN_NULL(local_file, NULL, "Local", "Local handler is not initialized.");
    static char line[512];
    const size_t key_len = strlen(key);
 
    rewind(local_file);
 
    while (fgets(line, sizeof(line), local_file)) {
        //if the line is empty or a comment, skip it
        if (line[0] == '\n' || line[0] == '#') continue;
 
        if (line[key_len] == '=') {
            if (strncmp(line, key, key_len) == 0) {
                // get the starting position
                char* start = strchr(line, '"');
                if (!start) continue;
 
                // get the end position
                char* end = strchr(start + 1, '"');
                if (!end) continue;
 
                const size_t len = end - (start + 1);
                char* result = (char*) malloc(len + 1);
                RETURN_WHEN_NULL(result, NULL, "Local", "Failed to allocate memory for local string.");
 
                snprintf(result, len + 1, "%s", start + 1);
                return result;
            }
        }
    }
 
    return strdup(key);
}

init_local_handler()

int init_local_handler

(

local_lang_t

lang

)

Initialize the local language handler by setting up the language and opening the corresponding resource file.

This function initializes the handler to use the specified language. It opens the associated language file based on a predefined mapping and prepares the observer list for updates. If the handler is already initialized, a warning is logged and initialization is skipped.

Parameters

lang	the language to be set for the local handler

Returns

0 on success, or 1 if the resource file cannot be opened

Definition at line 32 of file local_handler.c.

                                                {
    if (local_file != NULL) {
        log_msg(WARNING, "Local", "Local handler is already initialized.");
        return 0;
    }
 
    current_lang = lang;
 
    char rel_path[128];
    snprintf(rel_path, sizeof(rel_path), "%s" PATH_SEP "%s", LOCAL_DIRECTORY, local_file_mapping[lang].file_name);
 
    local_file = fopen(rel_path, "r");
    RETURN_WHEN_NULL(local_file, 1, "Local", "Failed to open local file.");
 
    observer_list = malloc(sizeof(observer_node_t));
    RETURN_WHEN_NULL(observer_list, 1, "Local", "Failed to allocate memory for observer list.");
 
    observer_list->update_func = NULL;
    observer_list->next = NULL;
    return 0;
}

observe_local()

void observe_local

(

void(*

update_func )(void)

)

Registers an observer function to be notified of updates from the local handler.

This function adds a new observer to the observer list maintained by the local handler. The observer function will be invoked when relevant updates occur. The observer handler must be initialized before calling this function. If the observer function or handler is invalid, the registration is aborted, and an error is logged.

Parameters

update_func

the observer function to be registered for receiving updates

Definition at line 124 of file local_handler.c.

                                              {
    RETURN_WHEN_NULL(local_file, , "Local", "Local handler is not initialized.");
    RETURN_WHEN_NULL(update_func, , "Local", "Invalid observer function.");
 
    observer_node_t* new_node = malloc(sizeof(observer_node_t));
    RETURN_WHEN_NULL(new_node, , "Local", "Failed to allocate memory for observer node.");
 
    new_node->update_func = update_func;
    new_node->next = NULL;
    observer_node_t* current = observer_list;
    while (current->next != NULL) {
        current = current->next;
    }
    current->next = new_node;
}

set_language()

int set_language

(

local_lang_t

lang

)

Sets the current language for the local handler and updates all registered observers.

This function updates the current language setting which determines the active language file to be used. It attempts to close the current language file, opens the new associated language resource file, and subsequently notifies the observer list by invoking their respective update functions. The function ensures the validity of the input language and handles errors related to file operations or uninitialized states.

Parameters

lang	the language to be set (e.g., LANGE_EN, LANGE_DE)

Returns

0 on success, 1 if the specified language file cannot be opened, or 2 if the handler is not initialized or the language is invalid

Definition at line 89 of file local_handler.c.

                                          {
    RETURN_WHEN_NULL(local_file, 2, "Local", "Local handler is not initialized.");
 
    if (lang >= MAX_LANG) {
        log_msg(WARNING, "Local", "Invalid language: %d.", lang);
        return 2;
    }
    current_lang = lang;
    fclose(local_file);
 
    char rel_path[128];
    snprintf(rel_path, sizeof(rel_path), "%s" PATH_SEP "%s", LOCAL_DIRECTORY, local_file_mapping[lang].file_name);
    local_file = fopen(rel_path, "r");
    RETURN_WHEN_NULL(local_file, 1, "Local", "Failed to open local file.");
 
    // go through the observer list
    const observer_node_t* current = observer_list;
    while (current != NULL) {
        if (current->update_func != NULL) {
            current->update_func();//call the observer function
        }
        current = current->next;
    }
 
    return 0;
}

shutdown_local_handler()

void shutdown_local_handler

(

void

)

Shut down the local language handler by releasing resources and closing the resource file.

This function deallocates all memory used by the observer list tied to the local handler. It ensures that all dynamically allocated observer nodes are freed to prevent memory leaks. Additionally, it closes the language resource file if it was previously opened.

Proper usage of this function ensures a clean shutdown of the local language handler by releasing occupied resources and leaving no lingering operations.

Definition at line 140 of file local_handler.c.

                                  {
    // free the observer list
    observer_node_t* current = observer_list;
    while (current != NULL) {
        observer_node_t* next = current->next;
        free(current);
        current = next;
    }
 
    if (local_file != NULL) fclose(local_file);
}

Variable Documentation

current_lang

local_lang_t current_lang

Definition at line 30 of file local_handler.c.

local_file

FILE* local_file = NULL

Definition at line 29 of file local_handler.c.

observer_list

observer_node_t* observer_list = NULL

Definition at line 28 of file local_handler.c.