virtypedparam.h 5.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * virtypedparam.h: managing typed parameters
 *
 * Copyright (C) 2011-2012 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library.  If not, see
O
Osier Yang 已提交
18
 * <http://www.gnu.org/licenses/>.
19 20 21 22 23 24 25 26
 *
 */


#ifndef __VIR_TYPED_PARAM_H_
# define __VIR_TYPED_PARAM_H_

# include "internal.h"
27
# include "virutil.h"
28

29 30 31 32 33 34 35 36 37 38
/**
 * VIR_TYPED_PARAM_MULTIPLE:
 *
 * Flag indicating that the params has multiple occurrences of the parameter.
 * Only used as a flag for @type argument of the virTypedParamsValidate.
 */
# define VIR_TYPED_PARAM_MULTIPLE (1 << 31)

verify(!(VIR_TYPED_PARAM_LAST & VIR_TYPED_PARAM_MULTIPLE));

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
typedef struct _virTypedParameterRemoteValue virTypedParameterRemoteValue;
typedef struct virTypedParameterRemoteValue *virTypedParameterRemoteValuePtr;

struct _virTypedParameterRemoteValue {
    int type;
    union {
        int i; /* exempt from syntax-check */
        unsigned int ui;
        long long int l;
        unsigned long long int ul;
        double d;
        char b;
        char *s;
    } remote_typed_param_value;
};

typedef struct _virTypedParameterRemote *virTypedParameterRemotePtr;

struct _virTypedParameterRemote {
    char *field;
    virTypedParameterRemoteValue value;
};


63 64
int virTypedParamsValidate(virTypedParameterPtr params, int nparams,
                           /* const char *name, int type ... */ ...)
E
Eric Blake 已提交
65
    ATTRIBUTE_SENTINEL ATTRIBUTE_RETURN_CHECK;
66

67 68 69 70 71
bool virTypedParamsCheck(virTypedParameterPtr params,
                         int nparams,
                         const char **names,
                         int nnames);

72 73 74 75 76 77 78 79 80 81 82 83 84 85
int
virTypedParamsGetStringList(virTypedParameterPtr params,
                            int nparams,
                            const char *name,
                            const char ***values);
int
virTypedParamsFilter(virTypedParameterPtr params,
                     int nparams,
                     const char *name,
                     virTypedParameterPtr **ret)
    ATTRIBUTE_RETURN_CHECK  ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3)
    ATTRIBUTE_NONNULL(4);


86
int virTypedParameterAssign(virTypedParameterPtr param, const char *name,
E
Eric Blake 已提交
87 88
                            int type, /* TYPE arg */ ...)
    ATTRIBUTE_RETURN_CHECK;
89

90 91 92 93 94 95
int virTypedParameterAssignFromStr(virTypedParameterPtr param,
                                   const char *name,
                                   int type,
                                   const char *val)
    ATTRIBUTE_RETURN_CHECK;

96 97 98 99 100
int virTypedParamsReplaceString(virTypedParameterPtr *params,
                                int *nparams,
                                const char *name,
                                const char *value);

101 102 103 104
int virTypedParamsCopy(virTypedParameterPtr *dst,
                       virTypedParameterPtr src,
                       int nparams);

105 106
char *virTypedParameterToString(virTypedParameterPtr param);

107 108 109
void virTypedParamsRemoteFree(virTypedParameterRemotePtr remote_params_val,
                              unsigned int remote_params_len);

110 111 112 113 114 115
int virTypedParamsDeserialize(virTypedParameterRemotePtr remote_params,
                              unsigned int remote_params_len,
                              int limit,
                              virTypedParameterPtr *params,
                              int *nparams);

116 117 118 119 120 121
int virTypedParamsSerialize(virTypedParameterPtr params,
                            int nparams,
                            virTypedParameterRemotePtr *remote_params_val,
                            unsigned int *remote_params_len,
                            unsigned int flags);

122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
VIR_ENUM_DECL(virTypedParameter)

# define VIR_TYPED_PARAMS_DEBUG(params, nparams)                            \
    do {                                                                    \
        int _i;                                                             \
        if (!params)                                                        \
            break;                                                          \
        for (_i = 0; _i < (nparams); _i++) {                                \
            char *_value = virTypedParameterToString((params) + _i);        \
            VIR_DEBUG("params[\"%s\"]=(%s)%s",                              \
                      (params)[_i].field,                                   \
                      virTypedParameterTypeToString((params)[_i].type),     \
                      NULLSTR(_value));                                     \
            VIR_FREE(_value);                                               \
        }                                                                   \
    } while (0)

139
#endif /* __VIR_TYPED_PARAM_H */