UNIVERS  15.3
UNIVERS base processing software API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
simsel.h
1 /* simsel.h */
2 /* $Id: simsel.h,v 1.1 2003/09/22 13:30:45 vlad Exp $ */
3 #ifndef __simsel_h
4 #define __simsel_h
5 
6 /*********************************************************************
7  *
8  * UNIVERS
9  * (C) ООО "ГЕОВЕРС", 2001
10  *
11  * Все права защищены * * Использование, копирование или передача регулируются законами * Российской Федерации "Об авторском праве и смежных правах", "О * правовой охране программ для электронных вычислительных машин и баз * данных" * * Encoding: ISO-8859-5 (GOST) * *********************************************************************/ #include <stdarg.h> #include <mix/DataAtom.h> #include <mix/ErrCodes.h> /** * Available operations: */ typedef enum { UssEQ, /**< equal to <arg> */ UssNE, /**< not equal to <arg> */ UssMultiEQ, /**< equal to one of values in <arg> list at least */ UssGT, /**< greater than <arg> */ UssLT, /**< less than <arg> */ UssRange, /**< in range <arg1>..<arg2> (arg1 < arg2) */ UssUnique, /**< unqiue group among all matched records */ UssAscent, /**< sort in ascent order a[i]<=a[i+1] */ UssDescent, /**< sort in descent order a[i]>=a[i+1] */ UssMax, /**< one record with the max value in given domain */ UssMin /**< one record with the min value in given domain */ } UssOperator; /** * Way to store <arg> for all atom types */ typedef DataAtom UssDataAtom; /** * Defines an elementary matching operation over some trace header field * with additional argument. */ typedef struct { char *domain_name; /**< name of domain for matching */ UssOperator match_op; /**< matching operator */ UssDataAtom match_arg; /**< matching argument */ } UssInclRule; /** * Defines part of unique matching rule. */ typedef struct { char *domain_name; /**< name of domain in unique group */ } UssUniqRule; /** * Defines domain name to sort by it and order direction. */ typedef struct { char *domain_name; /**< name of domain to sort by */ Compar order; /**< way to sort */ } UssSortRule; /** * Defines domain name to for fetching exact record(s) */ typedef struct { char *domain_name; /**< name of domain to fetch by */ UssOperator fetch_op; /**< way to fetch */ } UssFetchRule; /** * Table selection structure. Parts of expression are: include, * making unique and sort rules. */ typedef struct { /* include rules part */ unsigned incl_rules_n; UssInclRule *incl_rules; /* unique rules part */ unsigned uniq_rules_n; UssUniqRule *uniq_rules; /* sorting rules part */ unsigned sort_rules_n; UssSortRule *sort_rules; /* fetching rules part */ unsigned fetch_rules_n; UssFetchRule *fetch_rules; } UssExpr; /* Data macros for variable length argument list */ #define UssInt(value) INT_4, 0, (int)(value) #define UssInt8(value) INT_8, 0, (long long)(value) #define UssReal(value) REAL_8, 0, (double)(value) #define UssChar(value) CHAR_1, 0, (char)(value) #define UssString(value) CHAR_1, strlen(value), (value) #define UssIntRange(min,max) INT_4, (int)(min), (int)(max) #define UssInt8Range(min,max) INT_8, (long long)(min), (long long)(max) #define UssRealRange(min,max) REAL_8, (double)(min), (double)(max) #define UssCharRange(min,max) CHAR_1, (char)(min), (char)(max) /** Standard size of match op argument; seems enough for integer(4b), real(4b) and even for trace header char[N] words */ #define UssMargStdSize 20 /** Default value of TsMatchingPrecision variable. */ #define UssDefaultMatchingPrecision 0.001 /** Text representation of "Select all" */ #define UssSelectAllString "*" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /* * PROCEDURES */ /** * Build expression from variable argument list. The format of * va_list is * * "DomainName", UssEQ|UssNE|UssGT|UssLT, AtomType, Dimension, Value, * "DomainName", UssMultiEQ, AtomType, Dimension, Value, * "DomainName", UssRange, AtomType, MinValue, MaxValue, * "DomainName", UssUnique, * "DomainName", UssAscent, * "DomainName", UssDescent, * "DomainName", UssMax, * "DomainName", UssMin, * NULL <as a mark for end of list> * * Dimension==0 means scalar in place of value, that is int, double or char. * Dimension>=1 means vector (i.e. pointer) value, that is int*, double* ... * * Input expr is supposed uninitialized. */ ErrCode UssBuildExpr (UssExpr* expr, va_list val); /* * MEMORY ALLOCATION AND RELEASING */ /** Add several include rules to the end of rule list without any initialization. */ ErrCode UssAddInclRules (UssExpr* expr, unsigned number); /** Add several unique rules to the end of rule list without any initialization. */ ErrCode UssAddUniqRules (UssExpr* expr, unsigned number); /** Add several sort rules to the end of rule list without any initialization. */ ErrCode UssAddSortRules (UssExpr* expr, unsigned number); /** Add several fetch rules to the end of rule list without any initialization. */ ErrCode UssAddFetchRules (UssExpr* expr, unsigned number); /** Free memory from under expression */ void UssFreeExpr (UssExpr* expr); /** Copy expression from one to another. Previous values of destination expression is ignored. */ ErrCode UssCopyExpr (UssExpr* dst, const UssExpr* src); /* * TEXT PORTABLE REPRESENTATION * * Text is composed from items each of them has a format: * DomainName Operator Argument(s) ';' * where DomainName is a name of db field, * Operator is one of next symbols: * '=' means UssEQ (one or several arguments needed) * '%' means UssNE (one or several arguments needed) * '~' means UssMultiEQ (one or several arguments needed) * '>' means UssGT (one or several arguments needed) * '<' means UssLT (one or several arguments needed) * ':' means UssRange (exactly two scalar arguments needed) * '!' means UssUnique (no arguments needed) * '/' means UssAscent (no arguments needed) * '\' means UssDescent (no arguments needed) * '^' means UssMax (no arguments needed) * '_' means UssMin (no arguments needed) * Arguments must be listed via ',' separator. * Special string "*-" means "select all". */ /** Convert given expression to the text portable format (malloc allocated string). NULL means some severe error. */ char* UssToString (const UssExpr* expr); /** Parse given text to expression (append rules simply). */ ErrCode UssFromString (UssExpr* expr, const char* str); /** Allocate data atom range just from va_list: AtomType, MinValue, MaxValue */ ErrCode UssVaDataRange (UssDataAtom* datom, va_list* val); /** Allocate data atom just from va_list: AtomType, Dimension, Value where Dimension==0 means scalar in place of value, that is int, double or char. Dimension>=1 means vector (i.e. pointer) value, that is int*, double* ... */ ErrCode UssVaDataItem (UssDataAtom* datom, va_list* val); #ifdef __cplusplus }; #endif /* __cplusplus */ #ifndef __simsel_variables extern UssExpr UssSelectAll[1]; #endif /* __simsel_variables */ #endif /* simsel.h */
12  *
13  * Использование, копирование или передача регулируются законами
14  * Российской Федерации "Об авторском праве и смежных правах", "О * правовой охране программ для электронных вычислительных машин и баз * данных" * * Encoding: ISO-8859-5 (GOST) * *********************************************************************/ #include <stdarg.h> #include <mix/DataAtom.h> #include <mix/ErrCodes.h> /** * Available operations: */ typedef enum { UssEQ, /**< equal to <arg> */ UssNE, /**< not equal to <arg> */ UssMultiEQ, /**< equal to one of values in <arg> list at least */ UssGT, /**< greater than <arg> */ UssLT, /**< less than <arg> */ UssRange, /**< in range <arg1>..<arg2> (arg1 < arg2) */ UssUnique, /**< unqiue group among all matched records */ UssAscent, /**< sort in ascent order a[i]<=a[i+1] */ UssDescent, /**< sort in descent order a[i]>=a[i+1] */ UssMax, /**< one record with the max value in given domain */ UssMin /**< one record with the min value in given domain */ } UssOperator; /** * Way to store <arg> for all atom types */ typedef DataAtom UssDataAtom; /** * Defines an elementary matching operation over some trace header field * with additional argument. */ typedef struct { char *domain_name; /**< name of domain for matching */ UssOperator match_op; /**< matching operator */ UssDataAtom match_arg; /**< matching argument */ } UssInclRule; /** * Defines part of unique matching rule. */ typedef struct { char *domain_name; /**< name of domain in unique group */ } UssUniqRule; /** * Defines domain name to sort by it and order direction. */ typedef struct { char *domain_name; /**< name of domain to sort by */ Compar order; /**< way to sort */ } UssSortRule; /** * Defines domain name to for fetching exact record(s) */ typedef struct { char *domain_name; /**< name of domain to fetch by */ UssOperator fetch_op; /**< way to fetch */ } UssFetchRule; /** * Table selection structure. Parts of expression are: include, * making unique and sort rules. */ typedef struct { /* include rules part */ unsigned incl_rules_n; UssInclRule *incl_rules; /* unique rules part */ unsigned uniq_rules_n; UssUniqRule *uniq_rules; /* sorting rules part */ unsigned sort_rules_n; UssSortRule *sort_rules; /* fetching rules part */ unsigned fetch_rules_n; UssFetchRule *fetch_rules; } UssExpr; /* Data macros for variable length argument list */ #define UssInt(value) INT_4, 0, (int)(value) #define UssInt8(value) INT_8, 0, (long long)(value) #define UssReal(value) REAL_8, 0, (double)(value) #define UssChar(value) CHAR_1, 0, (char)(value) #define UssString(value) CHAR_1, strlen(value), (value) #define UssIntRange(min,max) INT_4, (int)(min), (int)(max) #define UssInt8Range(min,max) INT_8, (long long)(min), (long long)(max) #define UssRealRange(min,max) REAL_8, (double)(min), (double)(max) #define UssCharRange(min,max) CHAR_1, (char)(min), (char)(max) /** Standard size of match op argument; seems enough for integer(4b), real(4b) and even for trace header char[N] words */ #define UssMargStdSize 20 /** Default value of TsMatchingPrecision variable. */ #define UssDefaultMatchingPrecision 0.001 /** Text representation of "Select all" */ #define UssSelectAllString "*" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /* * PROCEDURES */ /** * Build expression from variable argument list. The format of * va_list is * * "DomainName", UssEQ|UssNE|UssGT|UssLT, AtomType, Dimension, Value, * "DomainName", UssMultiEQ, AtomType, Dimension, Value, * "DomainName", UssRange, AtomType, MinValue, MaxValue, * "DomainName", UssUnique, * "DomainName", UssAscent, * "DomainName", UssDescent, * "DomainName", UssMax, * "DomainName", UssMin, * NULL <as a mark for end of list> * * Dimension==0 means scalar in place of value, that is int, double or char. * Dimension>=1 means vector (i.e. pointer) value, that is int*, double* ... * * Input expr is supposed uninitialized. */ ErrCode UssBuildExpr (UssExpr* expr, va_list val); /* * MEMORY ALLOCATION AND RELEASING */ /** Add several include rules to the end of rule list without any initialization. */ ErrCode UssAddInclRules (UssExpr* expr, unsigned number); /** Add several unique rules to the end of rule list without any initialization. */ ErrCode UssAddUniqRules (UssExpr* expr, unsigned number); /** Add several sort rules to the end of rule list without any initialization. */ ErrCode UssAddSortRules (UssExpr* expr, unsigned number); /** Add several fetch rules to the end of rule list without any initialization. */ ErrCode UssAddFetchRules (UssExpr* expr, unsigned number); /** Free memory from under expression */ void UssFreeExpr (UssExpr* expr); /** Copy expression from one to another. Previous values of destination expression is ignored. */ ErrCode UssCopyExpr (UssExpr* dst, const UssExpr* src); /* * TEXT PORTABLE REPRESENTATION * * Text is composed from items each of them has a format: * DomainName Operator Argument(s) ';' * where DomainName is a name of db field, * Operator is one of next symbols: * '=' means UssEQ (one or several arguments needed) * '%' means UssNE (one or several arguments needed) * '~' means UssMultiEQ (one or several arguments needed) * '>' means UssGT (one or several arguments needed) * '<' means UssLT (one or several arguments needed) * ':' means UssRange (exactly two scalar arguments needed) * '!' means UssUnique (no arguments needed) * '/' means UssAscent (no arguments needed) * '\' means UssDescent (no arguments needed) * '^' means UssMax (no arguments needed) * '_' means UssMin (no arguments needed) * Arguments must be listed via ',' separator. * Special string "*-" means "select all". */ /** Convert given expression to the text portable format (malloc allocated string). NULL means some severe error. */ char* UssToString (const UssExpr* expr); /** Parse given text to expression (append rules simply). */ ErrCode UssFromString (UssExpr* expr, const char* str); /** Allocate data atom range just from va_list: AtomType, MinValue, MaxValue */ ErrCode UssVaDataRange (UssDataAtom* datom, va_list* val); /** Allocate data atom just from va_list: AtomType, Dimension, Value where Dimension==0 means scalar in place of value, that is int, double or char. Dimension>=1 means vector (i.e. pointer) value, that is int*, double* ... */ ErrCode UssVaDataItem (UssDataAtom* datom, va_list* val); #ifdef __cplusplus }; #endif /* __cplusplus */ #ifndef __simsel_variables extern UssExpr UssSelectAll[1]; #endif /* __simsel_variables */ #endif /* simsel.h */
15  * правовой охране программ для электронных вычислительных машин и баз * данных" * * Encoding: ISO-8859-5 (GOST) * *********************************************************************/ #include <stdarg.h> #include <mix/DataAtom.h> #include <mix/ErrCodes.h> /** * Available operations: */ typedef enum { UssEQ, /**< equal to <arg> */ UssNE, /**< not equal to <arg> */ UssMultiEQ, /**< equal to one of values in <arg> list at least */ UssGT, /**< greater than <arg> */ UssLT, /**< less than <arg> */ UssRange, /**< in range <arg1>..<arg2> (arg1 < arg2) */ UssUnique, /**< unqiue group among all matched records */ UssAscent, /**< sort in ascent order a[i]<=a[i+1] */ UssDescent, /**< sort in descent order a[i]>=a[i+1] */ UssMax, /**< one record with the max value in given domain */ UssMin /**< one record with the min value in given domain */ } UssOperator; /** * Way to store <arg> for all atom types */ typedef DataAtom UssDataAtom; /** * Defines an elementary matching operation over some trace header field * with additional argument. */ typedef struct { char *domain_name; /**< name of domain for matching */ UssOperator match_op; /**< matching operator */ UssDataAtom match_arg; /**< matching argument */ } UssInclRule; /** * Defines part of unique matching rule. */ typedef struct { char *domain_name; /**< name of domain in unique group */ } UssUniqRule; /** * Defines domain name to sort by it and order direction. */ typedef struct { char *domain_name; /**< name of domain to sort by */ Compar order; /**< way to sort */ } UssSortRule; /** * Defines domain name to for fetching exact record(s) */ typedef struct { char *domain_name; /**< name of domain to fetch by */ UssOperator fetch_op; /**< way to fetch */ } UssFetchRule; /** * Table selection structure. Parts of expression are: include, * making unique and sort rules. */ typedef struct { /* include rules part */ unsigned incl_rules_n; UssInclRule *incl_rules; /* unique rules part */ unsigned uniq_rules_n; UssUniqRule *uniq_rules; /* sorting rules part */ unsigned sort_rules_n; UssSortRule *sort_rules; /* fetching rules part */ unsigned fetch_rules_n; UssFetchRule *fetch_rules; } UssExpr; /* Data macros for variable length argument list */ #define UssInt(value) INT_4, 0, (int)(value) #define UssInt8(value) INT_8, 0, (long long)(value) #define UssReal(value) REAL_8, 0, (double)(value) #define UssChar(value) CHAR_1, 0, (char)(value) #define UssString(value) CHAR_1, strlen(value), (value) #define UssIntRange(min,max) INT_4, (int)(min), (int)(max) #define UssInt8Range(min,max) INT_8, (long long)(min), (long long)(max) #define UssRealRange(min,max) REAL_8, (double)(min), (double)(max) #define UssCharRange(min,max) CHAR_1, (char)(min), (char)(max) /** Standard size of match op argument; seems enough for integer(4b), real(4b) and even for trace header char[N] words */ #define UssMargStdSize 20 /** Default value of TsMatchingPrecision variable. */ #define UssDefaultMatchingPrecision 0.001 /** Text representation of "Select all" */ #define UssSelectAllString "*" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /* * PROCEDURES */ /** * Build expression from variable argument list. The format of * va_list is * * "DomainName", UssEQ|UssNE|UssGT|UssLT, AtomType, Dimension, Value, * "DomainName", UssMultiEQ, AtomType, Dimension, Value, * "DomainName", UssRange, AtomType, MinValue, MaxValue, * "DomainName", UssUnique, * "DomainName", UssAscent, * "DomainName", UssDescent, * "DomainName", UssMax, * "DomainName", UssMin, * NULL <as a mark for end of list> * * Dimension==0 means scalar in place of value, that is int, double or char. * Dimension>=1 means vector (i.e. pointer) value, that is int*, double* ... * * Input expr is supposed uninitialized. */ ErrCode UssBuildExpr (UssExpr* expr, va_list val); /* * MEMORY ALLOCATION AND RELEASING */ /** Add several include rules to the end of rule list without any initialization. */ ErrCode UssAddInclRules (UssExpr* expr, unsigned number); /** Add several unique rules to the end of rule list without any initialization. */ ErrCode UssAddUniqRules (UssExpr* expr, unsigned number); /** Add several sort rules to the end of rule list without any initialization. */ ErrCode UssAddSortRules (UssExpr* expr, unsigned number); /** Add several fetch rules to the end of rule list without any initialization. */ ErrCode UssAddFetchRules (UssExpr* expr, unsigned number); /** Free memory from under expression */ void UssFreeExpr (UssExpr* expr); /** Copy expression from one to another. Previous values of destination expression is ignored. */ ErrCode UssCopyExpr (UssExpr* dst, const UssExpr* src); /* * TEXT PORTABLE REPRESENTATION * * Text is composed from items each of them has a format: * DomainName Operator Argument(s) ';' * where DomainName is a name of db field, * Operator is one of next symbols: * '=' means UssEQ (one or several arguments needed) * '%' means UssNE (one or several arguments needed) * '~' means UssMultiEQ (one or several arguments needed) * '>' means UssGT (one or several arguments needed) * '<' means UssLT (one or several arguments needed) * ':' means UssRange (exactly two scalar arguments needed) * '!' means UssUnique (no arguments needed) * '/' means UssAscent (no arguments needed) * '\' means UssDescent (no arguments needed) * '^' means UssMax (no arguments needed) * '_' means UssMin (no arguments needed) * Arguments must be listed via ',' separator. * Special string "*-" means "select all". */ /** Convert given expression to the text portable format (malloc allocated string). NULL means some severe error. */ char* UssToString (const UssExpr* expr); /** Parse given text to expression (append rules simply). */ ErrCode UssFromString (UssExpr* expr, const char* str); /** Allocate data atom range just from va_list: AtomType, MinValue, MaxValue */ ErrCode UssVaDataRange (UssDataAtom* datom, va_list* val); /** Allocate data atom just from va_list: AtomType, Dimension, Value where Dimension==0 means scalar in place of value, that is int, double or char. Dimension>=1 means vector (i.e. pointer) value, that is int*, double* ... */ ErrCode UssVaDataItem (UssDataAtom* datom, va_list* val); #ifdef __cplusplus }; #endif /* __cplusplus */ #ifndef __simsel_variables extern UssExpr UssSelectAll[1]; #endif /* __simsel_variables */ #endif /* simsel.h */
16  * данных"
17  *
18  * Encoding: ISO-8859-5 (GOST)
19  *
20  *********************************************************************/
21 
22 #include <stdarg.h>
23 #include <mix/DataAtom.h>
24 #include <mix/ErrCodes.h>
25 
26 
30 typedef enum
31 {
32  UssEQ,
33  UssNE,
34  UssMultiEQ,
35  UssGT,
36  UssLT,
37  UssRange,
38  UssUnique,
39  UssAscent,
40  UssDescent,
41  UssMax,
42  UssMin
44 } UssOperator;
45 
46 
50 typedef DataAtom UssDataAtom;
51 
52 
57 typedef struct
58 {
59  char *domain_name;
60  UssOperator match_op;
61  UssDataAtom match_arg;
63 } UssInclRule;
64 
68 typedef struct
69 {
70  char *domain_name;
72 } UssUniqRule;
73 
74 
78 typedef struct
79 {
80  char *domain_name;
81  Compar order;
83 } UssSortRule;
84 
85 
89 typedef struct
90 {
91  char *domain_name;
92  UssOperator fetch_op;
94 } UssFetchRule;
95 
96 
102 typedef struct
103 {
104  /* include rules part */
105  unsigned incl_rules_n;
106  UssInclRule *incl_rules;
107 
108  /* unique rules part */
109  unsigned uniq_rules_n;
110  UssUniqRule *uniq_rules;
111 
112  /* sorting rules part */
113  unsigned sort_rules_n;
114  UssSortRule *sort_rules;
115 
116  /* fetching rules part */
117  unsigned fetch_rules_n;
118  UssFetchRule *fetch_rules;
119 
120 } UssExpr;
121 
122 
123 /* Data macros for variable length argument list */
124 #define UssInt(value) INT_4, 0, (int)(value)
125 #define UssInt8(value) INT_8, 0, (long long)(value)
126 #define UssReal(value) REAL_8, 0, (double)(value)
127 #define UssChar(value) CHAR_1, 0, (char)(value)
128 #define UssString(value) CHAR_1, strlen(value), (value)
129 
130 #define UssIntRange(min,max) INT_4, (int)(min), (int)(max)
131 #define UssInt8Range(min,max) INT_8, (long long)(min), (long long)(max)
132 #define UssRealRange(min,max) REAL_8, (double)(min), (double)(max)
133 #define UssCharRange(min,max) CHAR_1, (char)(min), (char)(max)
134 
135 
138 #define UssMargStdSize 20
139 
141 #define UssDefaultMatchingPrecision 0.001
142 
144 #define UssSelectAllString "*"
145 
146 
147 #ifdef __cplusplus
148 extern "C" {
149 #endif /* __cplusplus */
150 
151 
152  /*
153  * PROCEDURES
154  */
155 
175  ErrCode UssBuildExpr (UssExpr* expr, va_list val);
176 
177 
178  /*
179  * MEMORY ALLOCATION AND RELEASING
180  */
181 
184  ErrCode UssAddInclRules (UssExpr* expr, unsigned number);
185 
188  ErrCode UssAddUniqRules (UssExpr* expr, unsigned number);
189 
192  ErrCode UssAddSortRules (UssExpr* expr, unsigned number);
193 
196  ErrCode UssAddFetchRules (UssExpr* expr, unsigned number);
197 
199  void UssFreeExpr (UssExpr* expr);
200 
203  ErrCode UssCopyExpr (UssExpr* dst, const UssExpr* src);
204 
205 
206  /*
207  * TEXT PORTABLE REPRESENTATION
208  *
209  * Text is composed from items each of them has a format:
210  * DomainName Operator Argument(s) ';'
211  * where DomainName is a name of db field,
212  * Operator is one of next symbols:
213  * '=' means UssEQ (one or several arguments needed)
214  * '%' means UssNE (one or several arguments needed)
215  * '~' means UssMultiEQ (one or several arguments needed)
216  * '>' means UssGT (one or several arguments needed)
217  * '<' means UssLT (one or several arguments needed)
218  * ':' means UssRange (exactly two scalar arguments needed)
219  * '!' means UssUnique (no arguments needed)
220  * '/' means UssAscent (no arguments needed)
221  * '\' means UssDescent (no arguments needed)
222  * '^' means UssMax (no arguments needed)
223  * '_' means UssMin (no arguments needed)
224  * Arguments must be listed via ',' separator.
225  * Special string "*-" means "select all".
226  */
227 
230  char* UssToString (const UssExpr* expr);
231 
233  ErrCode UssFromString (UssExpr* expr, const char* str);
234 
235 
238  ErrCode UssVaDataRange (UssDataAtom* datom, va_list* val);
239 
246  ErrCode UssVaDataItem (UssDataAtom* datom, va_list* val);
247 
248 
249 #ifdef __cplusplus
250 };
251 #endif /* __cplusplus */
252 
253 
254 #ifndef __simsel_variables
255 
256 extern UssExpr UssSelectAll[1];
257 
258 #endif /* __simsel_variables */
259 
260 
261 #endif /* simsel.h */
UssFetchRule
Definition: simsel.h:89
UssSortRule::domain_name
char * domain_name
Definition: simsel.h:80
UssInclRule::match_op
UssOperator match_op
Definition: simsel.h:60
UssFetchRule::domain_name
char * domain_name
Definition: simsel.h:91
UssInclRule::domain_name
char * domain_name
Definition: simsel.h:59
UssSortRule
Definition: simsel.h:78
UssInclRule
Definition: simsel.h:57
UssFetchRule::fetch_op
UssOperator fetch_op
Definition: simsel.h:92
UssExpr
Definition: simsel.h:102
UssUniqRule::domain_name
char * domain_name
Definition: simsel.h:70
UssSortRule::order
Compar order
Definition: simsel.h:81
UssUniqRule
Definition: simsel.h:68
UssInclRule::match_arg
UssDataAtom match_arg
Definition: simsel.h:61
DataAtom
Definition: DataAtom.h:14
Generated by   doxygen 1.8.5