geoloc_gml.c File Reference

#include "asterisk.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/res_geolocation.h"
#include "geoloc_private.h"

Include dependency graph for geoloc_gml.c:

Go to the source code of this file.

Data Structures
struct	geoloc_gml_attr
struct	geoloc_gml_shape_def

Macros
#define	_SENTRY   {NULL, -1, -1, NULL}
#define	CRS_OPT   {"crs", 0, 1, crs_validator}
#define	CRS_REQ   {"crs", 1, 1, crs_validator}
#define	MAX_SHAPE_ATTRIBUTES   9
#define	SET_RESULT(__result, ...)

Enumerations
enum	angle_parse_result {   ANGLE_PARSE_RESULT_SUCCESS = 0 , ANGLE_PARSE_ERROR_NO_ANGLE , ANGLE_PARSE_ERROR_INVALID_ANGLE , ANGLE_PARSE_ERROR_ANGLE_OUT_OF_RANGE ,   ANGLE_PARSE_ERROR_INVALID_UOM }

Functions
static enum angle_parse_result	angle_parser (const char *name, const char *value, char **angle, char **uom, char **result)
static int	angle_validator (const char *name, const char *value, const struct ast_variable *varlist, char **result)
enum ast_geoloc_validate_result	ast_geoloc_gml_validate_varlist (struct ast_variable *varlist, char **result)
	Validate that the variables in the list represent a valid GML shape.
static int	crs_validator (const char *name, const char *value, const struct ast_variable *varlist, char **result)
static int	find_attribute_index (int shape_index, const char *name)
static int	find_shape_index (const char *shape)
static int	float_validator (const char *name, const char *value, const struct ast_variable *varlist, char **result)
struct ast_xml_node *	geoloc_gml_list_to_xml (struct ast_variable *resolved_location, const char *ref_string)
int	geoloc_gml_load (void)
int	geoloc_gml_reload (void)
int	geoloc_gml_unload (void)
static char *	handle_gml_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	pos_validator (const char *name, const char *value, const struct ast_variable *varlist, char **result)
static enum ast_geoloc_validate_result	validate_def_varlist (int shape_index, const struct ast_variable *varlist, char **result)

Variables
static struct ast_cli_entry	geoloc_gml_cli []
static struct geoloc_gml_shape_def	gml_shape_defs []

Macro Definition Documentation

_SENTRY

#define _SENTRY   {NULL, -1, -1, NULL}

Definition at line 156 of file geoloc_gml.c.

CRS_OPT

#define CRS_OPT   {"crs", 0, 1, crs_validator}

Definition at line 158 of file geoloc_gml.c.

CRS_REQ

#define CRS_REQ   {"crs", 1, 1, crs_validator}

Definition at line 159 of file geoloc_gml.c.

MAX_SHAPE_ATTRIBUTES

#define MAX_SHAPE_ATTRIBUTES   9

Definition at line 31 of file geoloc_gml.c.

SET_RESULT

#define SET_RESULT	(		__result,
			...
	)

Value:

({ \
    if (__result) { \
        __ast_asprintf(__FILE__, __LINE__, __PRETTY_FUNCTION__, result,  __VA_ARGS__); \
    } \
})

Definition at line 38 of file geoloc_gml.c.

 { \
    if (__result) { \
        __ast_asprintf(__FILE__, __LINE__, __PRETTY_FUNCTION__, result,  __VA_ARGS__); \
    } \
})

Enumeration Type Documentation

angle_parse_result

enum angle_parse_result

Enumerator
ANGLE_PARSE_RESULT_SUCCESS
ANGLE_PARSE_ERROR_NO_ANGLE
ANGLE_PARSE_ERROR_INVALID_ANGLE
ANGLE_PARSE_ERROR_ANGLE_OUT_OF_RANGE
ANGLE_PARSE_ERROR_INVALID_UOM

Definition at line 87 of file geoloc_gml.c.

                        {
    ANGLE_PARSE_RESULT_SUCCESS = 0,
    ANGLE_PARSE_ERROR_NO_ANGLE,
    ANGLE_PARSE_ERROR_INVALID_ANGLE,
    ANGLE_PARSE_ERROR_ANGLE_OUT_OF_RANGE,
    ANGLE_PARSE_ERROR_INVALID_UOM,
};

Function Documentation

angle_parser()

static enum angle_parse_result angle_parser ( const char *  name, const char *  value, char **  angle, char **  uom, char **  result  )

static

Definition at line 95 of file geoloc_gml.c.

{
    char *tmp_angle = NULL;
    char *tmp_uom = NULL;
    float f_angle;
    char *junk;
    char *work = ast_strdupa(value);
 
    tmp_angle = ast_strsep(&work, ' ', AST_STRSEP_ALL);
    if (ast_strlen_zero(tmp_angle)) {
        SET_RESULT(result, "Empty angle in '%s'", name);
        return ANGLE_PARSE_ERROR_NO_ANGLE;
    }
    f_angle = strtof(tmp_angle, &junk);
    if (!ast_strlen_zero(junk)) {
        SET_RESULT(result, "Invalid angle '%s' in '%s'", value, name);
        return ANGLE_PARSE_ERROR_INVALID_ANGLE;
    }
 
    tmp_uom = ast_strsep(&work, ' ', AST_STRSEP_ALL);
    if (ast_strlen_zero(tmp_uom)) {
        tmp_uom = "degrees";
    }
 
    if (ast_begins_with(tmp_uom, "deg")) {
        tmp_uom = "degrees";
    } else if (ast_begins_with(tmp_uom, "rad")) {
        tmp_uom = "radians";
    } else {
        SET_RESULT(result, "Invalid UOM '%s' in '%s'.  Must be 'degrees' or 'radians'.", value, name);
        return ANGLE_PARSE_ERROR_INVALID_UOM;
    }
 
    if (ast_strings_equal(tmp_uom, "degrees") && f_angle > 360.0) {
        SET_RESULT(result, "Angle '%s' must be <= 360.0 for UOM '%s' in '%s'", tmp_angle, tmp_uom, name);
        return ANGLE_PARSE_ERROR_ANGLE_OUT_OF_RANGE;
    }
 
    if (ast_strings_equal(tmp_uom, "radians") && f_angle > 100.0) {
        SET_RESULT(result, "Angle '%s' must be <= 100.0 for UOM '%s' in '%s'", tmp_angle, tmp_uom, name);
        return ANGLE_PARSE_ERROR_ANGLE_OUT_OF_RANGE;
    }
 
    if (angle) {
        *angle = ast_strdup(tmp_angle);
    }
    if (uom) {
        *uom = ast_strdup(tmp_uom);
    }
    return ANGLE_PARSE_RESULT_SUCCESS;
}

References ANGLE_PARSE_ERROR_ANGLE_OUT_OF_RANGE, ANGLE_PARSE_ERROR_INVALID_ANGLE, ANGLE_PARSE_ERROR_INVALID_UOM, ANGLE_PARSE_ERROR_NO_ANGLE, ANGLE_PARSE_RESULT_SUCCESS, ast_begins_with(), ast_strdup, ast_strdupa, ast_strings_equal(), ast_strlen_zero(), ast_strsep(), AST_STRSEP_ALL, name, NULL, result, SET_RESULT, and value.

Referenced by angle_validator(), and geoloc_gml_list_to_xml().

angle_validator()

static int angle_validator ( const char *  name, const char *  value, const struct ast_variable *  varlist, char **  result  )

static

Definition at line 148 of file geoloc_gml.c.

{
    enum angle_parse_result rc = angle_parser(name, value, NULL, NULL, result);
 
    return rc == ANGLE_PARSE_RESULT_SUCCESS;
}

References ANGLE_PARSE_RESULT_SUCCESS, angle_parser(), name, NULL, result, and value.

ast_geoloc_gml_validate_varlist()

enum ast_geoloc_validate_result ast_geoloc_gml_validate_varlist	(	struct ast_variable *	varlist,
		char **	result
	)

Validate that the variables in the list represent a valid GML shape.

Parameters

	varlist	Variable list to check.
[out]	result	Pointer to char * to receive failing item.

Returns

result code.

Definition at line 260 of file geoloc_gml.c.

{
    const char *shape_type = ast_variable_find_in_list(varlist, "shape");
    int shape_index = -1;
    const char *crs = ast_variable_find_in_list(varlist, "crs");
 
    if (!shape_type) {
        SET_RESULT(result, "Missing 'shape'");
        return AST_GEOLOC_VALIDATE_MISSING_SHAPE;
    }
 
    shape_index = find_shape_index(shape_type);
    if (shape_index < 0) {
        SET_RESULT(result, "Invalid shape '%s'", shape_type);
        return AST_GEOLOC_VALIDATE_INVALID_SHAPE;
    }
 
    if (ast_strlen_zero(crs)) {
        struct ast_variable *vcrs = NULL;
        if (ast_strings_equal("any", gml_shape_defs[shape_index].crs)) {
            crs = "2d";
        } else {
            crs = gml_shape_defs[shape_index].crs;
        }
 
        vcrs = ast_variable_new("crs", "2d", "");
        if (vcrs) {
            ast_variable_list_append(&varlist, vcrs);
        }
    }
    if (!crs_validator("crs", crs, varlist, result)) {
        return AST_GEOLOC_VALIDATE_INVALID_CRS;
    }
 
    if (!ast_strings_equal("any", gml_shape_defs[shape_index].crs)
        && !ast_strings_equal(crs, gml_shape_defs[shape_index].crs)) {
        SET_RESULT(result, "Invalid crs '%s' for shape '%s'", crs, shape_type);
        return AST_GEOLOC_VALIDATE_INVALID_CRS_FOR_SHAPE;
    }
 
    return validate_def_varlist(shape_index, varlist, result);
}

References AST_GEOLOC_VALIDATE_INVALID_CRS, AST_GEOLOC_VALIDATE_INVALID_CRS_FOR_SHAPE, AST_GEOLOC_VALIDATE_INVALID_SHAPE, AST_GEOLOC_VALIDATE_MISSING_SHAPE, ast_strings_equal(), ast_strlen_zero(), ast_variable_find_in_list(), ast_variable_list_append, ast_variable_new, geoloc_gml_shape_def::crs, crs_validator(), find_shape_index(), gml_shape_defs, NULL, result, SET_RESULT, and validate_def_varlist().

Referenced by geoloc_gml_list_to_xml(), and validate_location_info().

crs_validator()

static int crs_validator ( const char *  name, const char *  value, const struct ast_variable *  varlist, char **  result  )

static

Definition at line 45 of file geoloc_gml.c.

{
    if (!ast_strings_equal(value, "2d") && !ast_strings_equal(value, "3d")) {
        SET_RESULT(result, "Invalid crs '%s'.  Must be either '2d' or '3d'", value);
        return 0;
    }
    return 1;
}

References ast_strings_equal(), result, SET_RESULT, and value.

Referenced by ast_geoloc_gml_validate_varlist().

find_attribute_index()

static int find_attribute_index ( int  shape_index, const char *  name  )

static

Definition at line 191 of file geoloc_gml.c.

{
    int i = 0;
 
    for (i = 0; i <  MAX_SHAPE_ATTRIBUTES; i++) {
        if (gml_shape_defs[shape_index].required_attributes[i].name == NULL) {
            return -1;
        }
        if (ast_strings_equal(name, gml_shape_defs[shape_index].required_attributes[i].name)) {
            return i;
        }
    }
    return -1;
}

References ast_strings_equal(), gml_shape_defs, MAX_SHAPE_ATTRIBUTES, name, NULL, and geoloc_gml_shape_def::required_attributes.

Referenced by validate_def_varlist().

find_shape_index()

static int find_shape_index ( const char *  shape )

static

Definition at line 178 of file geoloc_gml.c.

{
    int i = 0;
    int shape_count = ARRAY_LEN(gml_shape_defs);
 
    for (i = 0; i < shape_count; i++) {
        if (ast_strings_equal(shape, gml_shape_defs[i].shape_type)) {
            return i;
        }
    }
    return -1;
}

References ARRAY_LEN, ast_strings_equal(), gml_shape_defs, and geoloc_gml_shape_def::shape_type.

Referenced by ast_geoloc_gml_validate_varlist().

float_validator()

static int float_validator ( const char *  name, const char *  value, const struct ast_variable *  varlist, char **  result  )

static

Definition at line 76 of file geoloc_gml.c.

{
    float val;
    if (sscanf(value, "%f", &val) != 1) {
        SET_RESULT(result, "Invalid floating point value '%s' in '%s'.", value, name);
        return 0;
    }
    return 1;
}

References name, result, SET_RESULT, and value.

geoloc_gml_list_to_xml()

struct ast_xml_node * geoloc_gml_list_to_xml	(	struct ast_variable *	resolved_location,
		const char *	ref_string
	)

Definition at line 349 of file geoloc_gml.c.

{
    const char *shape;
    const char *crs;
    struct ast_variable *var;
    struct ast_xml_node *gml_node;
    struct ast_xml_node *child_node;
    enum ast_geoloc_validate_result res;
    RAII_VAR(char *, result, NULL, ast_free);
    int rc = 0;
 
    SCOPE_ENTER(3, "%s", ref_string);
 
    if (!resolved_location) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: resolved_location was NULL\n",
            ref_string);
    }
 
    res = ast_geoloc_gml_validate_varlist(resolved_location, &result);
    if (res != AST_GEOLOC_VALIDATE_SUCCESS) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: %s\n",
            ref_string, result);
    }
 
    shape = ast_variable_find_in_list(resolved_location, "shape");
    if (ast_strlen_zero(shape)) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: There's no 'shape' parameter\n",
            ref_string);
    }
 
    crs = ast_variable_find_in_list(resolved_location, "crs");
    if (ast_strlen_zero(crs)) {
        struct ast_variable *vcrs = ast_variable_new("crs", "2d", "");
        if (vcrs) {
            ast_variable_list_append(&resolved_location, vcrs);
        }
        crs = "2d";
    }
 
    gml_node = ast_xml_new_node(shape);
    if (!gml_node) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Unable to create '%s' XML node\n", shape, ref_string);
    }
    rc = ast_xml_set_attribute(gml_node, "crs", crs);
    if (rc != 0) {
        ast_xml_free_node(gml_node);
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Unable to create 'crs' XML attribute\n", ref_string);
    }
 
    for (var = (struct ast_variable *)resolved_location; var; var = var->next) {
 
        if (ast_strings_equal(var->name, "shape") || ast_strings_equal(var->name, "crs")) {
            continue;
        }
 
        child_node = ast_xml_new_child(gml_node, var->name);
        if (!child_node) {
            ast_xml_free_node(gml_node);
            SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Unable to create '%s' XML node\n", var->name, ref_string);
        }
 
        if (ast_strings_equal(var->name, "orientation") || ast_strings_equal(var->name, "startAngle")
            || ast_strings_equal(var->name, "openingAngle")) {
            RAII_VAR(char *, angle, NULL, ast_free);
            RAII_VAR(char *, uom, NULL, ast_free);
 
            enum angle_parse_result rc = angle_parser(var->name, var->value, &angle, &uom, &result);
            if (rc != ANGLE_PARSE_RESULT_SUCCESS) {
                ast_xml_free_node(gml_node);
                SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: %s\n", ref_string, result);
            }
            rc = ast_xml_set_attribute(child_node, "uom", uom);
            if (rc != 0) {
                ast_xml_free_node(gml_node);
                SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Unable to create 'uom' XML attribute\n", ref_string);
            }
            ast_xml_set_text(child_node, angle);
        } else {
            ast_xml_set_text(child_node, var->value);
        }
    }
 
    SCOPE_EXIT_RTN_VALUE(gml_node, "%s: Done\n", ref_string);
}

References ANGLE_PARSE_RESULT_SUCCESS, angle_parser(), ast_free, ast_geoloc_gml_validate_varlist(), AST_GEOLOC_VALIDATE_SUCCESS, ast_strings_equal(), ast_strlen_zero(), ast_variable_find_in_list(), ast_variable_list_append, ast_variable_new, ast_xml_free_node(), ast_xml_new_child(), ast_xml_new_node(), ast_xml_set_attribute(), ast_xml_set_text(), LOG_ERROR, ast_variable::next, NULL, RAII_VAR, result, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, and var.

Referenced by geoloc_eprofile_to_intermediate().

geoloc_gml_load()

int geoloc_gml_load

(

void

)

Definition at line 442 of file geoloc_gml.c.

{
    ast_cli_register_multiple(geoloc_gml_cli, ARRAY_LEN(geoloc_gml_cli));
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ARRAY_LEN, ast_cli_register_multiple, AST_MODULE_LOAD_SUCCESS, and geoloc_gml_cli.

Referenced by load_module().

geoloc_gml_reload()

int geoloc_gml_reload

(

void

)

Definition at line 449 of file geoloc_gml.c.

{
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS.

Referenced by reload_module().

geoloc_gml_unload()

int geoloc_gml_unload

(

void

)

Definition at line 435 of file geoloc_gml.c.

{
    ast_cli_unregister_multiple(geoloc_gml_cli, ARRAY_LEN(geoloc_gml_cli));
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ARRAY_LEN, ast_cli_unregister_multiple(), AST_MODULE_LOAD_SUCCESS, and geoloc_gml_cli.

Referenced by unload_module().

handle_gml_show()

static char * handle_gml_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 304 of file geoloc_gml.c.

{
    int i;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "geoloc show gml_shape_defs";
        e->usage =
            "Usage: geoloc show gml_shape_defs\n"
            "       Show the GML Shape definitions.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    ast_cli(a->fd, "%-16s %-3s %-32s\n", "Shape", "CRS", "Attributes name(min,max)");
    ast_cli(a->fd, "================ === ===============================\n");
 
    for (i = 0; i < ARRAY_LEN(gml_shape_defs); i++) {
        int j;
        ast_cli(a->fd, "%-16s %-3s", gml_shape_defs[i].shape_type, gml_shape_defs[i].crs);
        for (j = 0; j < ARRAY_LEN(gml_shape_defs[i].required_attributes); j++) {
            if (gml_shape_defs[i].required_attributes[j].name == NULL) {
                break;
            }
            if (gml_shape_defs[i].required_attributes[j].max_allowed >= 0) {
                ast_cli(a->fd, " %s(%d,%d)", gml_shape_defs[i].required_attributes[j].name,
                    gml_shape_defs[i].required_attributes[j].min_required,
                    gml_shape_defs[i].required_attributes[j].max_allowed);
            } else {
                ast_cli(a->fd, " %s(%d,unl)", gml_shape_defs[i].required_attributes[j].name,
                    gml_shape_defs[i].required_attributes[j].min_required);
            }
        }
        ast_cli(a->fd, "\n");
    }
    ast_cli(a->fd, "\n");
 
    return CLI_SUCCESS;
}

References a, ARRAY_LEN, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, geoloc_gml_shape_def::crs, gml_shape_defs, geoloc_gml_attr::max_allowed, geoloc_gml_attr::min_required, name, geoloc_gml_attr::name, NULL, geoloc_gml_shape_def::required_attributes, geoloc_gml_shape_def::shape_type, and ast_cli_entry::usage.

pos_validator()

static int pos_validator ( const char *  name, const char *  value, const struct ast_variable *  varlist, char **  result  )

static

Definition at line 55 of file geoloc_gml.c.

{
    const char *crs = S_OR(ast_variable_find_in_list(varlist, "crs"), "2d");
    float lat;
    float lon;
    float alt;
    int count;
 
    count = sscanf(value, "%f %f %f", &lat, &lon, &alt);
    if (ast_strings_equal(crs, "3d") && count != 3) {
        SET_RESULT(result, "Invalid 3d position '%s'.  Must be 3 floating point values.", value);
        return 0;
    }
    if (ast_strings_equal(crs, "2d") && count != 2) {
        SET_RESULT(result, "Invalid 2d position '%s'.  Must be 2 floating point values.", value);
        return 0;
    }
    return 1;
}

References ast_strings_equal(), ast_variable_find_in_list(), result, S_OR, SET_RESULT, and value.

validate_def_varlist()

static enum ast_geoloc_validate_result validate_def_varlist ( int  shape_index, const struct ast_variable *  varlist, char **  result  )

static

Definition at line 206 of file geoloc_gml.c.

{
    const struct ast_variable *var;
    int i;
 
    for (var = varlist; var; var = var->next) {
        int vname_index = -1;
        if (ast_strings_equal("shape", var->name)) {
            continue;
        }
 
        vname_index = find_attribute_index(shape_index, var->name);
        if (vname_index < 0) {
            SET_RESULT(result, "Invalid variable name '%s'\n", var->name);
            return AST_GEOLOC_VALIDATE_INVALID_VARNAME;
        }
        if (!gml_shape_defs[shape_index].required_attributes[vname_index].validator(var->name, var->value,
            varlist, result)) {
            return AST_GEOLOC_VALIDATE_INVALID_VALUE;
        }
    }
 
    for (i = 0; i < ARRAY_LEN(gml_shape_defs[shape_index].required_attributes); i++) {
        int count = 0;
        if (gml_shape_defs[shape_index].required_attributes[i].name == NULL) {
            break;
        }
 
        for (var = varlist; var; var = var->next) {
            if (ast_strings_equal(gml_shape_defs[shape_index].required_attributes[i].name, var->name)) {
                count++;
            }
        }
        if (count < gml_shape_defs[shape_index].required_attributes[i].min_required) {
            SET_RESULT(result, "Number of '%s' variables %d is < %d",
                gml_shape_defs[shape_index].required_attributes[i].name,
                count,
                gml_shape_defs[shape_index].required_attributes[i].min_required);
            return AST_GEOLOC_VALIDATE_NOT_ENOUGH_VARNAMES;
        }
        if (gml_shape_defs[shape_index].required_attributes[i].max_allowed > 0 &&
            count > gml_shape_defs[shape_index].required_attributes[i].max_allowed) {
            SET_RESULT(result, "Number of '%s' variables %d is > %d",
                gml_shape_defs[shape_index].required_attributes[i].name,
                count,
                gml_shape_defs[shape_index].required_attributes[i].max_allowed);
            return AST_GEOLOC_VALIDATE_TOO_MANY_VARNAMES;
        }
    }
 
    return AST_GEOLOC_VALIDATE_SUCCESS;
}

References ARRAY_LEN, AST_GEOLOC_VALIDATE_INVALID_VALUE, AST_GEOLOC_VALIDATE_INVALID_VARNAME, AST_GEOLOC_VALIDATE_NOT_ENOUGH_VARNAMES, AST_GEOLOC_VALIDATE_SUCCESS, AST_GEOLOC_VALIDATE_TOO_MANY_VARNAMES, ast_strings_equal(), find_attribute_index(), gml_shape_defs, name, ast_variable::next, NULL, result, SET_RESULT, and var.

Referenced by ast_geoloc_gml_validate_varlist().

Variable Documentation

geoloc_gml_cli

struct ast_cli_entry geoloc_gml_cli[]

static

Initial value:

= {
    { .handler =  handle_gml_show , .summary =  "Show the GML Shape definitions" ,},
}

Definition at line 345 of file geoloc_gml.c.

                                               {
    AST_CLI_DEFINE(handle_gml_show, "Show the GML Shape definitions"),
};

Referenced by geoloc_gml_load(), and geoloc_gml_unload().

gml_shape_defs

struct geoloc_gml_shape_def gml_shape_defs[]

static

Definition at line 161 of file geoloc_gml.c.

                                                      {
    { "Point", "any", { CRS_OPT, {"pos", 1, 1, pos_validator}, _SENTRY }},
    { "Polygon", "any", { CRS_OPT, {"pos", 3, -1, pos_validator}, _SENTRY }},
    { "Circle", "2d", { CRS_OPT, {"pos", 1, 1, pos_validator}, {"radius", 1, 1, float_validator}, _SENTRY }},
    { "Ellipse", "2d", { CRS_OPT, {"pos", 1, 1, pos_validator}, {"semiMajorAxis", 1, 1, float_validator},
        {"semiMinorAxis", 1, 1, float_validator}, {"orientation", 1, 1, angle_validator}, _SENTRY }},
    { "ArcBand", "2d", { CRS_OPT, {"pos", 1, 1, pos_validator}, {"innerRadius", 1, 1, float_validator},
        {"outerRadius", 1, 1, float_validator}, {"startAngle", 1, 1, angle_validator},
        {"openingAngle", 1, 1, angle_validator},
        _SENTRY }},
    { "Sphere", "3d", { CRS_REQ, {"pos", 1, 1, pos_validator}, {"radius", 1, 1, float_validator}, _SENTRY }},
    { "Ellipsoid", "3d", { CRS_REQ, {"pos", 1, 1, pos_validator}, {"semiMajorAxis", 1, 1, float_validator},
        {"semiMinorAxis", 1, 1, float_validator}, {"verticalAxis", 1, 1, float_validator},
        {"orientation", 1, 1, angle_validator}, _SENTRY }},
    { "Prism", "3d", { CRS_REQ, {"pos", 3, -1, pos_validator}, {"height", 1, 1, float_validator}, _SENTRY }},
};

Referenced by ast_geoloc_gml_validate_varlist(), find_attribute_index(), find_shape_index(), handle_gml_show(), and validate_def_varlist().