1 /* 2 * Copyright 2001-2008 The Apache Software Foundation. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 * 16 */ 17 package org.apache.juddi.v3.client; 18 19 import org.apache.juddi.v3.client.config.Property; 20 import org.apache.juddi.v3.client.ext.wsdm.WSDMQosConstants; 21 22 /** 23 * This file was borrowed from juddi-core's constants file with modifications 24 * 25 * @author <a href="mailto:alexoree@apache.org">Alex O'Ree</a> 26 * @see WSDMQosConstants 27 * @see Property 28 * 29 */ 30 public interface UDDIConstants { 31 32 /** 33 * identifies a tmodel instance info containing some version information 34 * of a service a juddi extension based on 35 * http://www.ibm.com/developerworks/webservices/library/ws-version/ 36 */ 37 public static final String VERSION_TMODEL = "urn:uddi:uddi.org:version"; 38 /** 39 * When using this tModel as a tModelInstance, it can be used to 40 * describe a service endpoint that was automatically registered by 41 * jUDDI. This is a jUDDI specific addon and may not be present in other 42 * registries. 43 */ 44 public static final String JUDDI_TMODEL_AUTOREG = "uddi:juddi.apache.org:autoregistration"; 45 46 public static final int MAX_xml_lang_length = 26; 47 public static final int MAX_description_length = 255; 48 public static final int MAX_discoveryURL_length = 4096; 49 /** 50 * andAllKeys: this changes the behavior for identifierBag to AND keys 51 * rather than OR them. This is already the default for categoryBag and 52 * tModelBag. 53 */ 54 public static final String AND_ALL_KEYS = "andAllKeys"; 55 /** 56 * andAllKeys: this changes the behavior for identifierBag to AND keys 57 * rather than OR them. This is already the default for categoryBag and 58 * tModelBag. 59 */ 60 public static final String AND_ALL_KEYS_TMODEL = "uddi:uddi.org:findqualifier:andallkeys"; 61 /** 62 * approximateMatch: signifies that wildcard search behavior is desired. 63 * This behavior is defined by the uddi-org:approximatematch:SQL99 64 * tModel and means "approximate matching as defined for the character 65 * like predicate in ISO/IEC9075-2:1999(E) Section 8.5 like predicate, 66 * where the percent sign (%) indicates any number of characters and an 67 * underscore (_) indicates any single character. The backslash 68 * character (\) is used as an escape character for the percent sign, 69 * underscore and backslash characters. This find qualifier adjusts the 70 * matching behavior for name, keyValue and keyName (where applicable). 71 */ 72 public static final String APPROXIMATE_MATCH = "approximateMatch"; 73 /** 74 * approximateMatch: signifies that wildcard search behavior is desired. 75 * This behavior is defined by the uddi-org:approximatematch:SQL99 76 * tModel and means "approximate matching as defined for the character 77 * like predicate in ISO/IEC9075-2:1999(E) Section 8.5 like predicate, 78 * where the percent sign (%) indicates any number of characters and an 79 * underscore (_) indicates any single character. The backslash 80 * character (\) is used as an escape character for the percent sign, 81 * underscore and backslash characters. This find qualifier adjusts the 82 * matching behavior for name, keyValue and keyName (where applicable). 83 */ 84 public static final String APPROXIMATE_MATCH_TMODEL = "uddi:uddi.org:findqualifier:approximatematch"; 85 /** 86 * binarySort: this qualifier allows for greater speed in sorting. It 87 * causes a binary sort by name, as represented in Unicode codepoints. 88 */ 89 public static final String BINARY_SORT = "binarySort"; 90 /** 91 * binarySort: this qualifier allows for greater speed in sorting. It 92 * causes a binary sort by name, as represented in Unicode codepoints. 93 */ 94 public static final String BINARY_SORT_TMODEL = "uddi:uddi.org:sortorder:binarysort"; 95 /** 96 * bindingSubset: this is used in the find_business API or the 97 * find_service API and is used only in conjunction with a categoryBag 98 * argument. It causes the component of the search that involves 99 * categorization to use only the categoryBag elements from contained 100 * bindingTemplate elements within the registered data and ignores any 101 * entries found in the categoryBag which are not direct descendent 102 * elements of registered businessEntity elements or businessService 103 * elements. The resulting businessList or serviceList return those 104 * businesses or services that matched based on this modified behavior, 105 * in conjunction with any other search arguments provided. 106 * Additionally, in the case of the returned businessList from a 107 * find_business, the contained serviceInfos elements will only reflect 108 * summary data (in a serviceInfo element) for those services (contained 109 * or referenced) that contained a binding that matched on one of the 110 * supplied categoryBag arguments. 111 */ 112 public static final String BINDING_SUBSET = "bindingSubset"; 113 /** 114 * bindingSubset: this is used in the find_business API or the 115 * find_service API and is used only in conjunction with a categoryBag 116 * argument. It causes the component of the search that involves 117 * categorization to use only the categoryBag elements from contained 118 * bindingTemplate elements within the registered data and ignores any 119 * entries found in the categoryBag which are not direct descendent 120 * elements of registered businessEntity elements or businessService 121 * elements. The resulting businessList or serviceList return those 122 * businesses or services that matched based on this modified behavior, 123 * in conjunction with any other search arguments provided. 124 * Additionally, in the case of the returned businessList from a 125 * find_business, the contained serviceInfos elements will only reflect 126 * summary data (in a serviceInfo element) for those services (contained 127 * or referenced) that contained a binding that matched on one of the 128 * supplied categoryBag arguments. 129 */ 130 public static final String BINDING_SUBSET_TMODEL = "uddi:uddi.org:findqualifier:bindingsubset"; 131 /** 132 * caseInsensitiveSort: signifies that the result set should be sorted 133 * without regard to case. This overrides the default case sensitive 134 * sorting behavior. <br><br> 135 * 136 * WARNING: The current JPA specification does NOT support 137 * caseInsensitiveSort. jUDDI services therefore does not support the 138 * caseInsensitive sort setting. See also 139 * https://issues.apache.org/jira/browse/JUDDI-785 A work around is to 140 * perform a caseInsensitiveMatch. 141 */ 142 public static final String CASE_INSENSITIVE_SORT = "caseInsensitiveSort"; 143 /** 144 * caseInsensitiveSort: signifies that the result set should be sorted 145 * without regard to case. This overrides the default case sensitive 146 * sorting behavior. 147 */ 148 public static final String CASE_INSENSITIVE_SORT_TMODEL = "uddi:uddi.org:findqualifier:caseinsensitivesort"; 149 /** 150 * caseInsensitiveMatch: signifies that the matching behavior for name, 151 * keyValue and keyName (where applicable) should be performed without 152 * regard to case. 153 */ 154 public static final String CASE_INSENSITIVE_MATCH = "caseInsensitiveMatch"; 155 /** 156 * caseInsensitiveMatch: signifies that the matching behavior for name, 157 * keyValue and keyName (where applicable) should be performed without 158 * regard to case. 159 */ 160 public static final String CASE_INSENSITIVE_MATCH_TMODEL = "uddi:uddi.org:findqualifier:caseinsensitivematch"; 161 /** 162 * caseSensitiveSort: signifies that the result set should be sorted 163 * with regard to case. This is the default behavior. 164 */ 165 public static final String CASE_SENSITIVE_SORT = "caseSensitiveSort"; 166 /** 167 * caseSensitiveSort: signifies that the result set should be sorted 168 * with regard to case. This is the default behavior. 169 */ 170 public static final String CASE_SENSITIVE_SORT_TMODEL = "uddi:uddi.org:findqualifier:casesensitivesort"; 171 /** 172 * caseSensitiveMatch: signifies that the matching behavior for name, 173 * keyValue and keyName (where applicable) should be performed with 174 * regard to case. This is the default behavior. 175 */ 176 public static final String CASE_SENSITIVE_MATCH = "caseSensitiveMatch"; 177 /** 178 * caseSensitiveMatch: signifies that the matching behavior for name, 179 * keyValue and keyName (where applicable) should be performed with 180 * regard to case. This is the default behavior. 181 */ 182 public static final String CASE_SENSITIVE_MATCH_TMODEL = "uddi:uddi.org:findqualifier:casesensitivematch"; 183 /** 184 * combineCategoryBags: this may only be used in the find_business and 185 * find_service calls. In the case of find_business, this qualifier 186 * makes the categoryBag entries for the full businessEntity element 187 * behave as though all categoryBag elements found at the businessEntity 188 * level and in all contained or referenced businessService elements and 189 * bindingTemplate elements were combined. Searching for a category will 190 * yield a positive match on a registered business if any of the 191 * categoryBag elements contained within the full businessEntity element 192 * (including the categoryBag elements within contained or referenced 193 * businessService elements or bindingTemplate elements) contains the 194 * filter criteria. In the case of find_service, this qualifier makes 195 * the categoryBag entries for the full businessService element behave 196 * as though all categoryBag elements found at the businessService level 197 * and in all contained or referenced elements in the bindingTemplate 198 * elements were combined. Searching for a category will yield a 199 * positive match on a registered service if any of the categoryBag 200 * elements contained within the full businessService element (including 201 * the categoryBag elements within contained or referenced 202 * bindingTemplate elements) contains the filter criteria. This find 203 * qualifier does not cause the keyedReferences in categoryBags to be 204 * combined with the keyedReferences in keyedReferenceGroups in 205 * categoryBags when performing the comparison. The keyedReferences are 206 * combined with each other, and the keyedReferenceGroups are combined 207 * with each other. 208 */ 209 public static final String COMBINE_CATEGORY_BAGS = "combineCategoryBags"; 210 /** 211 * combineCategoryBags: this may only be used in the find_business and 212 * find_service calls. In the case of find_business, this qualifier 213 * makes the categoryBag entries for the full businessEntity element 214 * behave as though all categoryBag elements found at the businessEntity 215 * level and in all contained or referenced businessService elements and 216 * bindingTemplate elements were combined. Searching for a category will 217 * yield a positive match on a registered business if any of the 218 * categoryBag elements contained within the full businessEntity element 219 * (including the categoryBag elements within contained or referenced 220 * businessService elements or bindingTemplate elements) contains the 221 * filter criteria. In the case of find_service, this qualifier makes 222 * the categoryBag entries for the full businessService element behave 223 * as though all categoryBag elements found at the businessService level 224 * and in all contained or referenced elements in the bindingTemplate 225 * elements were combined. Searching for a category will yield a 226 * positive match on a registered service if any of the categoryBag 227 * elements contained within the full businessService element (including 228 * the categoryBag elements within contained or referenced 229 * bindingTemplate elements) contains the filter criteria. This find 230 * qualifier does not cause the keyedReferences in categoryBags to be 231 * combined with the keyedReferences in keyedReferenceGroups in 232 * categoryBags when performing the comparison. The keyedReferences are 233 * combined with each other, and the keyedReferenceGroups are combined 234 * with each other. 235 */ 236 public static final String COMBINE_CATEGORY_BAGS_TMODEL = "uddi:uddi.org:findqualifier:combinecategorybags"; 237 /** 238 * diacriticInsensitiveMatch: signifies that matching behavior for name, 239 * keyValue and keyName (where applicable) should be performed without 240 * regard to diacritics. Support for this findQualifier by nodes is 241 * OPTIONAL. 242 */ 243 public static final String DIACRITIC_INSENSITIVE_MATCH = "diacriticInsensitiveMatch"; 244 /** 245 * diacriticInsensitiveMatch: signifies that matching behavior for name, 246 * keyValue and keyName (where applicable) should be performed without 247 * regard to diacritics. Support for this findQualifier by nodes is 248 * OPTIONAL. 249 */ 250 public static final String DIACRITIC_INSENSITIVE_MATCH_TMODEL = "uddi:uddi.org:findqualifier:diacriticsinsensitivematch"; 251 /** 252 * diacriticSensitiveMatch: signifies that the matching behavior for 253 * name, keyValue and keyName (where applicable) should be performed 254 * with regard to diacritics. This is the default behavior. 255 */ 256 public static final String DIACRITIC_SENSITIVE_MATCH = "diacriticSensitiveMatch"; 257 /** 258 * diacriticSensitiveMatch: signifies that the matching behavior for 259 * name, keyValue and keyName (where applicable) should be performed 260 * with regard to diacritics. This is the default behavior. 261 */ 262 public static final String DIACRITIC_SENSITIVE_MATCH_TMODEL = "uddi:uddi.org:findqualifier:diacriticssensitivematch"; 263 /** 264 * exactMatch: signifies that only entries with names, keyValues and 265 * keyNames (where applicable) that exactly match the name argument 266 * passed in, after normalization, will be returned. This qualifier is 267 * sensitive to case and diacritics where applicable. This qualifier 268 * represents the default behavior. 269 */ 270 public static final String EXACT_MATCH = "exactMatch"; 271 /** 272 * exactMatch: signifies that only entries with names, keyValues and 273 * keyNames (where applicable) that exactly match the name argument 274 * passed in, after normalization, will be returned. This qualifier is 275 * sensitive to case and diacritics where applicable. This qualifier 276 * represents the default behavior. 277 */ 278 public static final String EXACT_MATCH_TMODEL = "uddi:uddi.org:findqualifier:exactmatch"; 279 /** 280 * signaturePresent: this is used with any find_xx API to restrict the 281 * result set to entities which either contain an XML Digital Signature 282 * element, or are contained in an entity which contains one. The 283 * Signature element is retrieved using a get_xx API call and SHOULD be 284 * verified by the client. A UDDI node may or may not verify the 285 * signature and therefore use of this find qualifier, or the presence 286 * of a Signature element SHOULD only be for the refinement of the 287 * result set from the find_xx API and SHOULD not be used as a 288 * verification mechanism by UDDI clients. 289 */ 290 public static final String SIGNATURE_PRESENT = "signaturePresent"; 291 /** 292 * signaturePresent: this is used with any find_xx API to restrict the 293 * result set to entities which either contain an XML Digital Signature 294 * element, or are contained in an entity which contains one. The 295 * Signature element is retrieved using a get_xx API call and SHOULD be 296 * verified by the client. A UDDI node may or may not verify the 297 * signature and therefore use of this find qualifier, or the presence 298 * of a Signature element SHOULD only be for the refinement of the 299 * result set from the find_xx API and SHOULD not be used as a 300 * verification mechanism by UDDI clients. 301 */ 302 public static final String SIGNATURE_PRESENT_TMODEL = "uddi:uddi.org:findqualifier:signaturepresent"; 303 /** 304 * orAllKeys: this changes the behavior for tModelBag and categoryBag to 305 * OR the keys within a bag, rather than to AND them. Using this 306 * findQualifier with both a categoryBag and a tModelBag, will cause all 307 * of the keys in BOTH the categoryBag and the tModelBag to be OR’d 308 * together rather than AND’d. It is not possible to OR the categories 309 * and retain the default AND behavior of the tModels. The behavior of 310 * keyedReferenceGroups in a categoryBag is analogous to that of 311 * individual keyedReferences, that is, the complete categoryBag is 312 * changed to OR the keys. 313 */ 314 public static final String OR_ALL_KEYS = "orAllKeys"; 315 /** 316 * orAllKeys: this changes the behavior for tModelBag and categoryBag to 317 * OR the keys within a bag, rather than to AND them. Using this 318 * findQualifier with both a categoryBag and a tModelBag, will cause all 319 * of the keys in BOTH the categoryBag and the tModelBag to be OR’d 320 * together rather than AND’d. It is not possible to OR the categories 321 * and retain the default AND behavior of the tModels. The behavior of 322 * keyedReferenceGroups in a categoryBag is analogous to that of 323 * individual keyedReferences, that is, the complete categoryBag is 324 * changed to OR the keys. 325 */ 326 public static final String OR_ALL_KEYS_TMODEL = "uddi:uddi.org:findqualifier:orallkeys"; 327 /** 328 * orLikeKeys: when a bag container (i.e. categoryBag or identifierBag) 329 * contains multiple keyedReference elements, any keyedReference filters 330 * that come from the same namespace (e.g. have the same tModelKey 331 * value) are OR’d together rather than AND’d. For example "find any of 332 * these four values from this namespace, and any of these two values 333 * from this namespace". The behavior of keyedReferenceGroups is 334 * analogous to that of keyedReferences, that is, keyedReferenceGroups 335 * that have the same tModelKey value are OR’d together rather than 336 * AND’d. 337 */ 338 public static final String OR_LIKE_KEYS = "orLikeKeys"; 339 /** 340 * orLikeKeys: when a bag container (i.e. categoryBag or identifierBag) 341 * contains multiple keyedReference elements, any keyedReference filters 342 * that come from the same namespace (e.g. have the same tModelKey 343 * value) are OR’d together rather than AND’d. For example "find any of 344 * these four values from this namespace, and any of these two values 345 * from this namespace". The behavior of keyedReferenceGroups is 346 * analogous to that of keyedReferences, that is, keyedReferenceGroups 347 * that have the same tModelKey value are OR’d together rather than 348 * AND’d. 349 */ 350 public static final String OR_LIKE_KEYS_TMODEL = "uddi:uddi.org:findqualifier:orlikekeys"; 351 /** 352 * serviceSubset: this is used only with the find_business API and is 353 * used only in conjunction with a categoryBag argument. It causes the 354 * component of the search that involves categorization to use only the 355 * categoryBag elements from contained or referenced businessService 356 * elements within the registered data and ignores any entries found in 357 * the categoryBag which are not direct descendent elements of 358 * registered businessEntity elements. The resulting businessList 359 * structure contains those businesses that matched based on this 360 * modified behavior, in conjunction with any other search arguments 361 * provided. Additionally, the contained serviceInfos elements will only 362 * reflect summary data (in a serviceInfo element) for those services 363 * (contained or referenced) that matched on one of the supplied 364 * categoryBag arguments. 365 */ 366 public static final String SERVICE_SUBSET = "serviceSubset"; 367 /** 368 * serviceSubset: this is used only with the find_business API and is 369 * used only in conjunction with a categoryBag argument. It causes the 370 * component of the search that involves categorization to use only the 371 * categoryBag elements from contained or referenced businessService 372 * elements within the registered data and ignores any entries found in 373 * the categoryBag which are not direct descendent elements of 374 * registered businessEntity elements. The resulting businessList 375 * structure contains those businesses that matched based on this 376 * modified behavior, in conjunction with any other search arguments 377 * provided. Additionally, the contained serviceInfos elements will only 378 * reflect summary data (in a serviceInfo element) for those services 379 * (contained or referenced) that matched on one of the supplied 380 * categoryBag arguments. 381 */ 382 public static final String SERVICE_SUBSET_TMODEL = "uddi:uddi.org:findqualifier:servicesubset"; 383 /** 384 * sortByNameAsc: causes the result set returned by a find_xx or get_xx 385 * inquiry APIs to be sorted on the name field in ascending order. This 386 * sort is applied prior to any truncation of result sets. It is only 387 * applicable to queries that return a name element in the top-most 388 * detail level of the result set and if no conflicting sort qualifier 389 * is specified, this is the default sorting direction. This 390 * findQualifier takes precedence over sortByDateAsc and sortByDateDesc 391 * qualifiers, but if a sortByDateXxx findQualifier is used without a 392 * sortByNameXxx qualifier, sorting is performed based on date with or 393 * without regard to name. 394 */ 395 public static final String SORT_BY_NAME_ASC = "sortByNameAsc"; 396 /** 397 * sortByNameAsc: causes the result set returned by a find_xx or get_xx 398 * inquiry APIs to be sorted on the name field in ascending order. This 399 * sort is applied prior to any truncation of result sets. It is only 400 * applicable to queries that return a name element in the top-most 401 * detail level of the result set and if no conflicting sort qualifier 402 * is specified, this is the default sorting direction. This 403 * findQualifier takes precedence over sortByDateAsc and sortByDateDesc 404 * qualifiers, but if a sortByDateXxx findQualifier is used without a 405 * sortByNameXxx qualifier, sorting is performed based on date with or 406 * without regard to name. 407 */ 408 public static final String SORT_BY_NAME_ASC_TMODEL = "uddi:uddi.org:findqualifier:sortbynameasc"; 409 /** 410 * sortByNameDesc: causes the result set returned by a find_xx or get_xx 411 * inquiry call to be sorted on the name field in descending order. This 412 * sort is applied prior to any truncation of result sets. It is only 413 * applicable to queries that return a name element in the top-most 414 * detail level of the result set. This is the reverse of the default 415 * sorting direction. This findQualifier takes precedence over 416 * sortByDateAsc and sortByDateDesc qualifiers but if a sortByDateXxx 417 * findQualifier is used without a sortByNameXxx qualifier, sorting is 418 * performed based on date with or without regard to name. 419 */ 420 public static final String SORT_BY_NAME_DESC = "sortByNameDesc"; 421 /** 422 * sortByNameDesc: causes the result set returned by a find_xx or get_xx 423 * inquiry call to be sorted on the name field in descending order. This 424 * sort is applied prior to any truncation of result sets. It is only 425 * applicable to queries that return a name element in the top-most 426 * detail level of the result set. This is the reverse of the default 427 * sorting direction. This findQualifier takes precedence over 428 * sortByDateAsc and sortByDateDesc qualifiers but if a sortByDateXxx 429 * findQualifier is used without a sortByNameXxx qualifier, sorting is 430 * performed based on date with or without regard to name. 431 */ 432 public static final String SORT_BY_NAME_DESC_TMODEL = "uddi:uddi.org:findqualifier:sortbynamedesc"; 433 /** 434 * sortByDateAsc: causes the result set returned by a find_xx or get_xx 435 * inquiry call to be sorted based on the most recent date when each 436 * entity, or any entities they contain, were last updated, in ascending 437 * chronological order (oldest are returned first). When names are 438 * included in the result set returned, this find qualifier may also be 439 * used in conjunction with either the sortByNameAsc or sortByNameDesc 440 * findQualifiers. When so combined, the date-based sort is secondary to 441 * the name-based sort (results are sorted within name by date, oldest 442 * to newest). 443 */ 444 public static final String SORT_BY_DATE_ASC = "sortByDateAsc"; 445 /** 446 * sortByDateAsc: causes the result set returned by a find_xx or get_xx 447 * inquiry call to be sorted based on the most recent date when each 448 * entity, or any entities they contain, were last updated, in ascending 449 * chronological order (oldest are returned first). When names are 450 * included in the result set returned, this find qualifier may also be 451 * used in conjunction with either the sortByNameAsc or sortByNameDesc 452 * findQualifiers. When so combined, the date-based sort is secondary to 453 * the name-based sort (results are sorted within name by date, oldest 454 * to newest). 455 */ 456 public static final String SORT_BY_DATE_ASC_TMODEL = "uddi:uddi.org:findqualifier:sortbydateasc"; 457 /** 458 * sortByDateDesc: causes the result set returned by a find_xx or get_xx 459 * inquiry call to be sorted based on the most recent date when each 460 * entity, or any entities they contain, were last updated, in 461 * descending chronological order (most recently changed are returned 462 * first. When names are included in the result set returned, this find 463 * qualifier may also be used in conjunction with either the 464 * sortByNameAsc or sortByNameDesc find qualifiers. When so combined, 465 * the date-based sort is secondary to the name-based sort (results are 466 * sorted within name by date, newest to oldest). 467 */ 468 public static final String SORT_BY_DATE_DESC = "sortByDateDesc"; 469 /** 470 * sortByDateDesc: causes the result set returned by a find_xx or get_xx 471 * inquiry call to be sorted based on the most recent date when each 472 * entity, or any entities they contain, were last updated, in 473 * descending chronological order (most recently changed are returned 474 * first. When names are included in the result set returned, this find 475 * qualifier may also be used in conjunction with either the 476 * sortByNameAsc or sortByNameDesc find qualifiers. When so combined, 477 * the date-based sort is secondary to the name-based sort (results are 478 * sorted within name by date, newest to oldest). 479 */ 480 public static final String SORT_BY_DATE_DESC_TMODEL = "uddi:uddi.org:findqualifier:sortbydatedesc"; 481 /** 482 * suppressProjectedServices: signifies that service projections MUST 483 * NOT be returned by the find_service or find_business APIs with which 484 * this findQualifier is associated. This findQualifier is automatically 485 * enabled by default whenever find_service is used without a 486 * businessKey. 487 */ 488 public static final String SUPPRESS_PROJECTED_SERVICES = "suppressProjectedServices"; 489 /** 490 * suppressProjectedServices: signifies that service projections MUST 491 * NOT be returned by the find_service or find_business APIs with which 492 * this findQualifier is associated. This findQualifier is automatically 493 * enabled by default whenever find_service is used without a 494 * businessKey. 495 */ 496 public static final String SUPPRESS_PROJECTED_SERVICES_TMODEL = "uddi:uddi.org:findqualifier:suppressprojectedservices"; 497 /** 498 * UTS-10: this is used to cause sorting of results based on the Unicode 499 * Collation Algorithm on elements normalized according to Unicode 500 * Normalization Form C. When this qualifier is referenced, a sort is 501 * performed according to the Unicode Collation Element Table in 502 * conjunction with the Unicode Collation Algorithm on the name field, 503 * normalized using Unicode Normalization Form C. Support of this 504 * findQualifier by nodes is OPTIONAL. 505 */ 506 public static final String UTS_10 = "UTS-10"; 507 /** 508 * UTS-10: this is used to cause sorting of results based on the Unicode 509 * Collation Algorithm on elements normalized according to Unicode 510 * Normalization Form C. When this qualifier is referenced, a sort is 511 * performed according to the Unicode Collation Element Table in 512 * conjunction with the Unicode Collation Algorithm on the name field, 513 * normalized using Unicode Normalization Form C. Support of this 514 * findQualifier by nodes is OPTIONAL. 515 */ 516 public static final String UTS_10_TMODEL = "uddi:uddi.org:sortorder:uts-10"; 517 /** 518 * This is the Wild card field used by UDDI, represents any number of 519 * characters Wildcards, when they are allowed, may occur at any 520 * position in the string of characters that constitutes the argument 521 * value and may occur more than once. Wildcards are denoted with a 522 * percent sign (%) to indicate any value for any number of characters 523 * and an underscore (_) to indicate any value for a single character. 524 * The backslash character (\) is used as an escape character for the 525 * percent sign, underscore and backslash characters. Use of the 526 * "exactMatch" findQualifier will cause wildcard characters to be 527 * interpreted literally, and as such should not also be combined with 528 * the escape character. 529 */ 530 public static final String WILDCARD = "%"; 531 /** 532 * Presents any SINGLE character<br> Wildcards, when they are allowed, 533 * may occur at any position in the string of characters that 534 * constitutes the argument value and may occur more than once. 535 * Wildcards are denoted with a percent sign (%) to indicate any value 536 * for any number of characters and an underscore (_) to indicate any 537 * value for a single character. The backslash character (\) is used as 538 * an escape character for the percent sign, underscore and backslash 539 * characters. Use of the "exactMatch" findQualifier will cause wildcard 540 * characters to be interpreted literally, and as such should not also 541 * be combined with the escape character. 542 */ 543 public static final String WILDCARD_CHAR = "_"; 544 /** 545 * unchecked: Marking a tModel with this categorization asserts that it 546 * represents a value set or category group system whose use, through 547 * keyedReferences, is not checked. 548 */ 549 public static final String TMODEL_GENERAL_KEYWORDS = "uddi:uddi.org:categorization:general_keywords"; 550 /** 551 * An unchecked value set is one that allows unrestricted references to 552 * its values. A UDDI registry is REQUIRED to have a policy to 553 * differentiate between unchecked value sets and checked value sets. 554 * UDDI registries MUST allow unchecked value sets to be referred to in 555 * keyedReferences. tModels that represent unchecked value sets SHOULD 556 * be categorized with the unchecked value from the uddi-org:types 557 * category system. 558 */ 559 public static final String UNCHECKED = "uddi-org:types:unchecked"; 560 /** 561 * checked: Marking a tModel with this categorization asserts that it 562 * represents a value set or category group system whose use, through 563 * keyedReferences, may be checked. Registry, and possibly node policy 564 * determines when and how a checked value set is supported. 565 */ 566 public static final String CHECKED = "uddi-org:types:checked"; 567 /** 568 * uncacheable: Marking a tModel with this categorization asserts that 569 * it represents a checked value set or category group system whose 570 * values must not be cached for validation. The validation algorithm 571 * for a supported uncacheable checked value set must be specified and 572 * associated with the tModel marked with this categorization and may 573 * consider contextual criteria involving the entity associated with the 574 * reference. 575 */ 576 public static final String UNCACHEABLE = "uddi-org:types:uncacheable"; 577 /** 578 * Basic types of business relationships 579 */ 580 public static final String RELATIONSHIPS = "uddi:uddi.org:relationships"; 581 /** 582 * "uddi:uddi.org:keygenerator" keyGenerator: Marking a tModel with this 583 * categorization designates it as one whose tModelKey identifies a key 584 * generator partition that can be used by its owner to derive and 585 * assign other entity keys. This categorization is reserved for key 586 * generator tModels. Any attempt to use this categorization for 587 * something other than a key generator tModel will fail with 588 * E_valueNotAllowed returned. 589 */ 590 public static final String KEY_GENERATOR_TMODEL = "uddi:uddi.org:keygenerator"; 591 /** 592 * "uddi.org:keygenerator" keyGenerator: Marking a tModel with this 593 * categorization designates it as one whose tModelKey identifies a key 594 * generator partition that can be used by its owner to derive and 595 * assign other entity keys. This categorization is reserved for key 596 * generator tModels. Any attempt to use this categorization for 597 * something other than a key generator tModel will fail with 598 * E_valueNotAllowed returned. 599 */ 600 public static final String KEY_GENERATOR = "uddi.org:keygenerator"; 601 /** 602 * "keyGenerator" keyGenerator: Marking a tModel with this 603 * categorization designates it as one whose tModelKey identifies a key 604 * generator partition that can be used by its owner to derive and 605 * assign other entity keys. This categorization is reserved for key 606 * generator tModels. Any attempt to use this categorization for 607 * something other than a key generator tModel will fail with 608 * E_valueNotAllowed returned. 609 */ 610 public static final String KEY_GENERATOR_VALUE = "keyGenerator"; 611 /** 612 * Identifier system used to point to the UDDI entity, using UDDI keys, 613 * that is the logical replacement for the one in which isReplacedBy is 614 * used. 615 */ 616 public static final String IS_REPLACED_BY = "uddi:uddi.org:identifier:isreplacedby"; 617 /** 618 * Category system used to point a value set or category group system 619 * tModel to associated value set Web service implementations. used for 620 * keyedReference tmodel key<br> 621 * hint: use the ValueSetValidation binding template key as the value 622 */ 623 public static final String IS_VALIDATED_BY = "uddi:uddi.org:categorization:validatedby"; 624 /** 625 * Category system used to point a value set or category group system 626 * tModel to associated value set Web service implementations. used for 627 * keyedReference key name<br> 628 * hint: use the ValueSetValidation binding template key as the value 629 */ 630 public static final String IS_VALIDATED_BY_KEY_NAME = "uddi-org:validatedBy"; 631 /** 632 * Category system for referring tModels to other tModels for the 633 * purpose of reuse. 634 */ 635 public static final String IS_DERIVED_FROM = "uddi:uddi.org:categorization:derivedfrom"; 636 /** 637 * Category system used to declare that a value set uses entity keys as 638 * valid values. 639 */ 640 public static final String ENTITY_KEY_VALUES = "uddi:uddi.org:categorization:entitykeyvalues"; 641 /** 642 * Category system used to point to the businessEntity associated with 643 * the publisher of the tModel. 644 */ 645 public static final String OWNING_BUSINESS = "uddi:uddi.org:categorization:owningbusiness"; 646 /** 647 * Secure Sockets Layer Version 3.0 with Server Authentication 648 */ 649 public static final String PROTOCOL_SSLv3 = "uddi:uddi.org:protocol:serverauthenticatedssl3"; 650 /** 651 * Secure Sockets Layer Version 3.0 with Mutual Authentication 652 */ 653 public static final String PROTOCOL_SSLv3_CLIENT_CERT = "uddi:uddi.org:protocol:mutualauthenticatedssl3"; 654 /** 655 * A Web service that uses HTTP transport - 656 */ 657 public static final String TRANSPORT_HTTP = "uddi:uddi.org:transport:http"; 658 /** 659 * E-mail based Web service 660 */ 661 public static final String TRANSPORT_EMAIL = "uddi:uddi.org:transport:smtp"; 662 /** 663 * File Transfer Protocol (FTP) based Web service 664 */ 665 public static final String TRANSPORT_FTP = "uddi:uddi.org:transport:ftp"; 666 /** 667 * Fax-based Web service 668 */ 669 public static final String TRANSPORT_FAX = "uddi:uddi.org:transport:fax"; 670 /** 671 * Telephone based service 672 */ 673 public static final String TRANSPORT_POTS = "uddi:uddi.org:transport:telephone"; 674 /** 675 * Java RMI based service registered to the Java Registry 676 */ 677 @Deprecated 678 public static final String TRANSPORT_RMI = "uddi:uddi.org:transport:rmi"; 679 /** 680 * A Java RMI based service registered to a JNDI Registry 681 */ 682 @Deprecated 683 public static final String TRANSPORT_JNDI_RMI = "uddi:uddi.org:transport:jndi-rmi"; 684 /** 685 * A Web service that uses the AMQP transport 686 */ 687 public static final String TRANSPORT_AMQP = "uddi:uddi.org:transport:amqp"; 688 /** 689 * A Web service that uses the OMG DDS transport 690 */ 691 public static final String TRANSPORT_OMGDDS = "uddi:uddi.org:transport:omgdds"; 692 /** 693 * A Web service that uses UDP 694 */ 695 public static final String TRANSPORT_UDP = "uddi:uddi.org:transport:udp"; 696 /** 697 * A Web service that uses the JMS API 698 */ 699 public static final String TRANSPORT_JMS = "uddi:uddi.org:transport:jms"; 700 /** 701 * A tModel that represents the Representational State Transfer 702 * architectural style 703 */ 704 public static final String PROTOCOL_REST = "uddi:uddi.org:protocol:rest"; 705 /** 706 * A tModel that represents the SOAP 1.1 protocol 707 */ 708 public static final String PROTOCOL_SOAP = "uddi:uddi.org:protocol:soap"; 709 /** 710 * A tModel that represents the SOAP 1.2 protocol 711 */ 712 public static final String PROTOCOL_SOAP12 = "uddi:uddi.org:protocol:soap12"; 713 /** 714 * A tModel that represents the HTTP protocol 715 */ 716 public static final String PROTOCOL_HTTP = "uddi:uddi.org:protocol:http"; 717 718 public static final String INQUIRY = "uddi:uddi.org:v3_inquiry"; 719 public static final String PUBLISH = "uddi:uddi.org:v3_publication"; 720 public static final String SECURITY = "uddi:uddi.org:v3_security"; 721 public static final String REPLICATION = "uddi:uddi.org:v3_replication"; 722 public static final String CUSTODY_TRANSFER = "uddi:uddi.org:v3_ownership_transfer"; 723 public static final String NODE_TRANSFER = "uddi:uddi.org:v3_node_custody_transfer"; 724 public static final String VSV_CACHE = "uddi:uddi.org:v3_valuesetcaching"; 725 public static final String VSV_VALIDATE = "uddi:uddi.org:v3_valuesetvalidation"; 726 public static final String SUBSCRIPTION = "uddi:uddi.org:v3_subscription"; 727 public static final String SUBSCRIPTION_LISTENER = "uddi:uddi.org:v3_subscriptionlistener"; 728 /** 729 * @since 3.3 730 */ 731 public static final String CategorizationTypes_Cacheable = "uddi-org:types:cacheable"; 732 /** 733 * @since 3.3 734 */ 735 public static final String CategorizationTypes = "uddi-org:categorization:types"; 736 737 public static final String General_Keywords = "uddi:uddi.org:categorization:general_keywords"; 738 }