001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.asset.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.asset.model.AssetVocabulary; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the asset vocabulary service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetVocabularyPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see AssetVocabularyPersistence 038 * @see com.liferay.portlet.asset.service.persistence.impl.AssetVocabularyPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class AssetVocabularyUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(AssetVocabulary assetVocabulary) { 060 getPersistence().clearCache(assetVocabulary); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<AssetVocabulary> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<AssetVocabulary> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<AssetVocabulary> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<AssetVocabulary> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static AssetVocabulary update(AssetVocabulary assetVocabulary) { 101 return getPersistence().update(assetVocabulary); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static AssetVocabulary update(AssetVocabulary assetVocabulary, 108 ServiceContext serviceContext) { 109 return getPersistence().update(assetVocabulary, serviceContext); 110 } 111 112 /** 113 * Returns all the asset vocabularies where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching asset vocabularies 117 */ 118 public static List<AssetVocabulary> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the asset vocabularies where uuid = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of asset vocabularies 131 * @param end the upper bound of the range of asset vocabularies (not inclusive) 132 * @return the range of matching asset vocabularies 133 */ 134 public static List<AssetVocabulary> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the asset vocabularies where uuid = ?. 141 * 142 * <p> 143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of asset vocabularies 148 * @param end the upper bound of the range of asset vocabularies (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching asset vocabularies 151 */ 152 public static List<AssetVocabulary> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first asset vocabulary in the ordered set where uuid = ?. 159 * 160 * @param uuid the uuid 161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 162 * @return the first matching asset vocabulary 163 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 164 */ 165 public static AssetVocabulary findByUuid_First(java.lang.String uuid, 166 OrderByComparator<AssetVocabulary> orderByComparator) 167 throws com.liferay.portlet.asset.NoSuchVocabularyException { 168 return getPersistence().findByUuid_First(uuid, orderByComparator); 169 } 170 171 /** 172 * Returns the first asset vocabulary in the ordered set where uuid = ?. 173 * 174 * @param uuid the uuid 175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 176 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 177 */ 178 public static AssetVocabulary fetchByUuid_First(java.lang.String uuid, 179 OrderByComparator<AssetVocabulary> orderByComparator) { 180 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the last asset vocabulary in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the last matching asset vocabulary 189 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 190 */ 191 public static AssetVocabulary findByUuid_Last(java.lang.String uuid, 192 OrderByComparator<AssetVocabulary> orderByComparator) 193 throws com.liferay.portlet.asset.NoSuchVocabularyException { 194 return getPersistence().findByUuid_Last(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last asset vocabulary in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 203 */ 204 public static AssetVocabulary fetchByUuid_Last(java.lang.String uuid, 205 OrderByComparator<AssetVocabulary> orderByComparator) { 206 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 207 } 208 209 /** 210 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ?. 211 * 212 * @param vocabularyId the primary key of the current asset vocabulary 213 * @param uuid the uuid 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next asset vocabulary 216 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 217 */ 218 public static AssetVocabulary[] findByUuid_PrevAndNext(long vocabularyId, 219 java.lang.String uuid, 220 OrderByComparator<AssetVocabulary> orderByComparator) 221 throws com.liferay.portlet.asset.NoSuchVocabularyException { 222 return getPersistence() 223 .findByUuid_PrevAndNext(vocabularyId, uuid, orderByComparator); 224 } 225 226 /** 227 * Removes all the asset vocabularies where uuid = ? from the database. 228 * 229 * @param uuid the uuid 230 */ 231 public static void removeByUuid(java.lang.String uuid) { 232 getPersistence().removeByUuid(uuid); 233 } 234 235 /** 236 * Returns the number of asset vocabularies where uuid = ?. 237 * 238 * @param uuid the uuid 239 * @return the number of matching asset vocabularies 240 */ 241 public static int countByUuid(java.lang.String uuid) { 242 return getPersistence().countByUuid(uuid); 243 } 244 245 /** 246 * Returns the asset vocabulary where uuid = ? and groupId = ? or throws a {@link NoSuchVocabularyException} if it could not be found. 247 * 248 * @param uuid the uuid 249 * @param groupId the group ID 250 * @return the matching asset vocabulary 251 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 252 */ 253 public static AssetVocabulary findByUUID_G(java.lang.String uuid, 254 long groupId) 255 throws com.liferay.portlet.asset.NoSuchVocabularyException { 256 return getPersistence().findByUUID_G(uuid, groupId); 257 } 258 259 /** 260 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 261 * 262 * @param uuid the uuid 263 * @param groupId the group ID 264 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 265 */ 266 public static AssetVocabulary fetchByUUID_G(java.lang.String uuid, 267 long groupId) { 268 return getPersistence().fetchByUUID_G(uuid, groupId); 269 } 270 271 /** 272 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 273 * 274 * @param uuid the uuid 275 * @param groupId the group ID 276 * @param retrieveFromCache whether to use the finder cache 277 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 278 */ 279 public static AssetVocabulary fetchByUUID_G(java.lang.String uuid, 280 long groupId, boolean retrieveFromCache) { 281 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 282 } 283 284 /** 285 * Removes the asset vocabulary where uuid = ? and groupId = ? from the database. 286 * 287 * @param uuid the uuid 288 * @param groupId the group ID 289 * @return the asset vocabulary that was removed 290 */ 291 public static AssetVocabulary removeByUUID_G(java.lang.String uuid, 292 long groupId) 293 throws com.liferay.portlet.asset.NoSuchVocabularyException { 294 return getPersistence().removeByUUID_G(uuid, groupId); 295 } 296 297 /** 298 * Returns the number of asset vocabularies where uuid = ? and groupId = ?. 299 * 300 * @param uuid the uuid 301 * @param groupId the group ID 302 * @return the number of matching asset vocabularies 303 */ 304 public static int countByUUID_G(java.lang.String uuid, long groupId) { 305 return getPersistence().countByUUID_G(uuid, groupId); 306 } 307 308 /** 309 * Returns all the asset vocabularies where uuid = ? and companyId = ?. 310 * 311 * @param uuid the uuid 312 * @param companyId the company ID 313 * @return the matching asset vocabularies 314 */ 315 public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 316 long companyId) { 317 return getPersistence().findByUuid_C(uuid, companyId); 318 } 319 320 /** 321 * Returns a range of all the asset vocabularies where uuid = ? and companyId = ?. 322 * 323 * <p> 324 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 325 * </p> 326 * 327 * @param uuid the uuid 328 * @param companyId the company ID 329 * @param start the lower bound of the range of asset vocabularies 330 * @param end the upper bound of the range of asset vocabularies (not inclusive) 331 * @return the range of matching asset vocabularies 332 */ 333 public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 334 long companyId, int start, int end) { 335 return getPersistence().findByUuid_C(uuid, companyId, start, end); 336 } 337 338 /** 339 * Returns an ordered range of all the asset vocabularies where uuid = ? and companyId = ?. 340 * 341 * <p> 342 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 343 * </p> 344 * 345 * @param uuid the uuid 346 * @param companyId the company ID 347 * @param start the lower bound of the range of asset vocabularies 348 * @param end the upper bound of the range of asset vocabularies (not inclusive) 349 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 350 * @return the ordered range of matching asset vocabularies 351 */ 352 public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 353 long companyId, int start, int end, 354 OrderByComparator<AssetVocabulary> orderByComparator) { 355 return getPersistence() 356 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 357 } 358 359 /** 360 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 361 * 362 * @param uuid the uuid 363 * @param companyId the company ID 364 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 365 * @return the first matching asset vocabulary 366 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 367 */ 368 public static AssetVocabulary findByUuid_C_First(java.lang.String uuid, 369 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) 370 throws com.liferay.portlet.asset.NoSuchVocabularyException { 371 return getPersistence() 372 .findByUuid_C_First(uuid, companyId, orderByComparator); 373 } 374 375 /** 376 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 377 * 378 * @param uuid the uuid 379 * @param companyId the company ID 380 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 381 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 382 */ 383 public static AssetVocabulary fetchByUuid_C_First(java.lang.String uuid, 384 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) { 385 return getPersistence() 386 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 387 } 388 389 /** 390 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 391 * 392 * @param uuid the uuid 393 * @param companyId the company ID 394 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 395 * @return the last matching asset vocabulary 396 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 397 */ 398 public static AssetVocabulary findByUuid_C_Last(java.lang.String uuid, 399 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) 400 throws com.liferay.portlet.asset.NoSuchVocabularyException { 401 return getPersistence() 402 .findByUuid_C_Last(uuid, companyId, orderByComparator); 403 } 404 405 /** 406 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 407 * 408 * @param uuid the uuid 409 * @param companyId the company ID 410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 411 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 412 */ 413 public static AssetVocabulary fetchByUuid_C_Last(java.lang.String uuid, 414 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) { 415 return getPersistence() 416 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 417 } 418 419 /** 420 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ? and companyId = ?. 421 * 422 * @param vocabularyId the primary key of the current asset vocabulary 423 * @param uuid the uuid 424 * @param companyId the company ID 425 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 426 * @return the previous, current, and next asset vocabulary 427 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 428 */ 429 public static AssetVocabulary[] findByUuid_C_PrevAndNext( 430 long vocabularyId, java.lang.String uuid, long companyId, 431 OrderByComparator<AssetVocabulary> orderByComparator) 432 throws com.liferay.portlet.asset.NoSuchVocabularyException { 433 return getPersistence() 434 .findByUuid_C_PrevAndNext(vocabularyId, uuid, companyId, 435 orderByComparator); 436 } 437 438 /** 439 * Removes all the asset vocabularies where uuid = ? and companyId = ? from the database. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 */ 444 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 445 getPersistence().removeByUuid_C(uuid, companyId); 446 } 447 448 /** 449 * Returns the number of asset vocabularies where uuid = ? and companyId = ?. 450 * 451 * @param uuid the uuid 452 * @param companyId the company ID 453 * @return the number of matching asset vocabularies 454 */ 455 public static int countByUuid_C(java.lang.String uuid, long companyId) { 456 return getPersistence().countByUuid_C(uuid, companyId); 457 } 458 459 /** 460 * Returns all the asset vocabularies where groupId = ?. 461 * 462 * @param groupId the group ID 463 * @return the matching asset vocabularies 464 */ 465 public static List<AssetVocabulary> findByGroupId(long groupId) { 466 return getPersistence().findByGroupId(groupId); 467 } 468 469 /** 470 * Returns a range of all the asset vocabularies where groupId = ?. 471 * 472 * <p> 473 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 474 * </p> 475 * 476 * @param groupId the group ID 477 * @param start the lower bound of the range of asset vocabularies 478 * @param end the upper bound of the range of asset vocabularies (not inclusive) 479 * @return the range of matching asset vocabularies 480 */ 481 public static List<AssetVocabulary> findByGroupId(long groupId, int start, 482 int end) { 483 return getPersistence().findByGroupId(groupId, start, end); 484 } 485 486 /** 487 * Returns an ordered range of all the asset vocabularies where groupId = ?. 488 * 489 * <p> 490 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 491 * </p> 492 * 493 * @param groupId the group ID 494 * @param start the lower bound of the range of asset vocabularies 495 * @param end the upper bound of the range of asset vocabularies (not inclusive) 496 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 497 * @return the ordered range of matching asset vocabularies 498 */ 499 public static List<AssetVocabulary> findByGroupId(long groupId, int start, 500 int end, OrderByComparator<AssetVocabulary> orderByComparator) { 501 return getPersistence() 502 .findByGroupId(groupId, start, end, orderByComparator); 503 } 504 505 /** 506 * Returns the first asset vocabulary in the ordered set where groupId = ?. 507 * 508 * @param groupId the group ID 509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 510 * @return the first matching asset vocabulary 511 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 512 */ 513 public static AssetVocabulary findByGroupId_First(long groupId, 514 OrderByComparator<AssetVocabulary> orderByComparator) 515 throws com.liferay.portlet.asset.NoSuchVocabularyException { 516 return getPersistence().findByGroupId_First(groupId, orderByComparator); 517 } 518 519 /** 520 * Returns the first asset vocabulary in the ordered set where groupId = ?. 521 * 522 * @param groupId the group ID 523 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 524 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 525 */ 526 public static AssetVocabulary fetchByGroupId_First(long groupId, 527 OrderByComparator<AssetVocabulary> orderByComparator) { 528 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 529 } 530 531 /** 532 * Returns the last asset vocabulary in the ordered set where groupId = ?. 533 * 534 * @param groupId the group ID 535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 536 * @return the last matching asset vocabulary 537 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 538 */ 539 public static AssetVocabulary findByGroupId_Last(long groupId, 540 OrderByComparator<AssetVocabulary> orderByComparator) 541 throws com.liferay.portlet.asset.NoSuchVocabularyException { 542 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 543 } 544 545 /** 546 * Returns the last asset vocabulary in the ordered set where groupId = ?. 547 * 548 * @param groupId the group ID 549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 550 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 551 */ 552 public static AssetVocabulary fetchByGroupId_Last(long groupId, 553 OrderByComparator<AssetVocabulary> orderByComparator) { 554 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 555 } 556 557 /** 558 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = ?. 559 * 560 * @param vocabularyId the primary key of the current asset vocabulary 561 * @param groupId the group ID 562 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 563 * @return the previous, current, and next asset vocabulary 564 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 565 */ 566 public static AssetVocabulary[] findByGroupId_PrevAndNext( 567 long vocabularyId, long groupId, 568 OrderByComparator<AssetVocabulary> orderByComparator) 569 throws com.liferay.portlet.asset.NoSuchVocabularyException { 570 return getPersistence() 571 .findByGroupId_PrevAndNext(vocabularyId, groupId, 572 orderByComparator); 573 } 574 575 /** 576 * Returns all the asset vocabularies that the user has permission to view where groupId = ?. 577 * 578 * @param groupId the group ID 579 * @return the matching asset vocabularies that the user has permission to view 580 */ 581 public static List<AssetVocabulary> filterFindByGroupId(long groupId) { 582 return getPersistence().filterFindByGroupId(groupId); 583 } 584 585 /** 586 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = ?. 587 * 588 * <p> 589 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 590 * </p> 591 * 592 * @param groupId the group ID 593 * @param start the lower bound of the range of asset vocabularies 594 * @param end the upper bound of the range of asset vocabularies (not inclusive) 595 * @return the range of matching asset vocabularies that the user has permission to view 596 */ 597 public static List<AssetVocabulary> filterFindByGroupId(long groupId, 598 int start, int end) { 599 return getPersistence().filterFindByGroupId(groupId, start, end); 600 } 601 602 /** 603 * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = ?. 604 * 605 * <p> 606 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 607 * </p> 608 * 609 * @param groupId the group ID 610 * @param start the lower bound of the range of asset vocabularies 611 * @param end the upper bound of the range of asset vocabularies (not inclusive) 612 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 613 * @return the ordered range of matching asset vocabularies that the user has permission to view 614 */ 615 public static List<AssetVocabulary> filterFindByGroupId(long groupId, 616 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 617 return getPersistence() 618 .filterFindByGroupId(groupId, start, end, orderByComparator); 619 } 620 621 /** 622 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = ?. 623 * 624 * @param vocabularyId the primary key of the current asset vocabulary 625 * @param groupId the group ID 626 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 627 * @return the previous, current, and next asset vocabulary 628 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 629 */ 630 public static AssetVocabulary[] filterFindByGroupId_PrevAndNext( 631 long vocabularyId, long groupId, 632 OrderByComparator<AssetVocabulary> orderByComparator) 633 throws com.liferay.portlet.asset.NoSuchVocabularyException { 634 return getPersistence() 635 .filterFindByGroupId_PrevAndNext(vocabularyId, groupId, 636 orderByComparator); 637 } 638 639 /** 640 * Returns all the asset vocabularies that the user has permission to view where groupId = any ?. 641 * 642 * @param groupIds the group IDs 643 * @return the matching asset vocabularies that the user has permission to view 644 */ 645 public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds) { 646 return getPersistence().filterFindByGroupId(groupIds); 647 } 648 649 /** 650 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = any ?. 651 * 652 * <p> 653 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 654 * </p> 655 * 656 * @param groupIds the group IDs 657 * @param start the lower bound of the range of asset vocabularies 658 * @param end the upper bound of the range of asset vocabularies (not inclusive) 659 * @return the range of matching asset vocabularies that the user has permission to view 660 */ 661 public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds, 662 int start, int end) { 663 return getPersistence().filterFindByGroupId(groupIds, start, end); 664 } 665 666 /** 667 * Returns an ordered range of all the asset vocabularies that the user has permission to view where groupId = any ?. 668 * 669 * <p> 670 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 671 * </p> 672 * 673 * @param groupIds the group IDs 674 * @param start the lower bound of the range of asset vocabularies 675 * @param end the upper bound of the range of asset vocabularies (not inclusive) 676 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 677 * @return the ordered range of matching asset vocabularies that the user has permission to view 678 */ 679 public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds, 680 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 681 return getPersistence() 682 .filterFindByGroupId(groupIds, start, end, orderByComparator); 683 } 684 685 /** 686 * Returns all the asset vocabularies where groupId = any ?. 687 * 688 * <p> 689 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 690 * </p> 691 * 692 * @param groupIds the group IDs 693 * @return the matching asset vocabularies 694 */ 695 public static List<AssetVocabulary> findByGroupId(long[] groupIds) { 696 return getPersistence().findByGroupId(groupIds); 697 } 698 699 /** 700 * Returns a range of all the asset vocabularies where groupId = any ?. 701 * 702 * <p> 703 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 704 * </p> 705 * 706 * @param groupIds the group IDs 707 * @param start the lower bound of the range of asset vocabularies 708 * @param end the upper bound of the range of asset vocabularies (not inclusive) 709 * @return the range of matching asset vocabularies 710 */ 711 public static List<AssetVocabulary> findByGroupId(long[] groupIds, 712 int start, int end) { 713 return getPersistence().findByGroupId(groupIds, start, end); 714 } 715 716 /** 717 * Returns an ordered range of all the asset vocabularies where groupId = any ?. 718 * 719 * <p> 720 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 721 * </p> 722 * 723 * @param groupIds the group IDs 724 * @param start the lower bound of the range of asset vocabularies 725 * @param end the upper bound of the range of asset vocabularies (not inclusive) 726 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 727 * @return the ordered range of matching asset vocabularies 728 */ 729 public static List<AssetVocabulary> findByGroupId(long[] groupIds, 730 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 731 return getPersistence() 732 .findByGroupId(groupIds, start, end, orderByComparator); 733 } 734 735 /** 736 * Removes all the asset vocabularies where groupId = ? from the database. 737 * 738 * @param groupId the group ID 739 */ 740 public static void removeByGroupId(long groupId) { 741 getPersistence().removeByGroupId(groupId); 742 } 743 744 /** 745 * Returns the number of asset vocabularies where groupId = ?. 746 * 747 * @param groupId the group ID 748 * @return the number of matching asset vocabularies 749 */ 750 public static int countByGroupId(long groupId) { 751 return getPersistence().countByGroupId(groupId); 752 } 753 754 /** 755 * Returns the number of asset vocabularies where groupId = any ?. 756 * 757 * @param groupIds the group IDs 758 * @return the number of matching asset vocabularies 759 */ 760 public static int countByGroupId(long[] groupIds) { 761 return getPersistence().countByGroupId(groupIds); 762 } 763 764 /** 765 * Returns the number of asset vocabularies that the user has permission to view where groupId = ?. 766 * 767 * @param groupId the group ID 768 * @return the number of matching asset vocabularies that the user has permission to view 769 */ 770 public static int filterCountByGroupId(long groupId) { 771 return getPersistence().filterCountByGroupId(groupId); 772 } 773 774 /** 775 * Returns the number of asset vocabularies that the user has permission to view where groupId = any ?. 776 * 777 * @param groupIds the group IDs 778 * @return the number of matching asset vocabularies that the user has permission to view 779 */ 780 public static int filterCountByGroupId(long[] groupIds) { 781 return getPersistence().filterCountByGroupId(groupIds); 782 } 783 784 /** 785 * Returns all the asset vocabularies where companyId = ?. 786 * 787 * @param companyId the company ID 788 * @return the matching asset vocabularies 789 */ 790 public static List<AssetVocabulary> findByCompanyId(long companyId) { 791 return getPersistence().findByCompanyId(companyId); 792 } 793 794 /** 795 * Returns a range of all the asset vocabularies where companyId = ?. 796 * 797 * <p> 798 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 799 * </p> 800 * 801 * @param companyId the company ID 802 * @param start the lower bound of the range of asset vocabularies 803 * @param end the upper bound of the range of asset vocabularies (not inclusive) 804 * @return the range of matching asset vocabularies 805 */ 806 public static List<AssetVocabulary> findByCompanyId(long companyId, 807 int start, int end) { 808 return getPersistence().findByCompanyId(companyId, start, end); 809 } 810 811 /** 812 * Returns an ordered range of all the asset vocabularies where companyId = ?. 813 * 814 * <p> 815 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 816 * </p> 817 * 818 * @param companyId the company ID 819 * @param start the lower bound of the range of asset vocabularies 820 * @param end the upper bound of the range of asset vocabularies (not inclusive) 821 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 822 * @return the ordered range of matching asset vocabularies 823 */ 824 public static List<AssetVocabulary> findByCompanyId(long companyId, 825 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 826 return getPersistence() 827 .findByCompanyId(companyId, start, end, orderByComparator); 828 } 829 830 /** 831 * Returns the first asset vocabulary in the ordered set where companyId = ?. 832 * 833 * @param companyId the company ID 834 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 835 * @return the first matching asset vocabulary 836 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 837 */ 838 public static AssetVocabulary findByCompanyId_First(long companyId, 839 OrderByComparator<AssetVocabulary> orderByComparator) 840 throws com.liferay.portlet.asset.NoSuchVocabularyException { 841 return getPersistence() 842 .findByCompanyId_First(companyId, orderByComparator); 843 } 844 845 /** 846 * Returns the first asset vocabulary in the ordered set where companyId = ?. 847 * 848 * @param companyId the company ID 849 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 850 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 851 */ 852 public static AssetVocabulary fetchByCompanyId_First(long companyId, 853 OrderByComparator<AssetVocabulary> orderByComparator) { 854 return getPersistence() 855 .fetchByCompanyId_First(companyId, orderByComparator); 856 } 857 858 /** 859 * Returns the last asset vocabulary in the ordered set where companyId = ?. 860 * 861 * @param companyId the company ID 862 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 863 * @return the last matching asset vocabulary 864 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 865 */ 866 public static AssetVocabulary findByCompanyId_Last(long companyId, 867 OrderByComparator<AssetVocabulary> orderByComparator) 868 throws com.liferay.portlet.asset.NoSuchVocabularyException { 869 return getPersistence() 870 .findByCompanyId_Last(companyId, orderByComparator); 871 } 872 873 /** 874 * Returns the last asset vocabulary in the ordered set where companyId = ?. 875 * 876 * @param companyId the company ID 877 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 878 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 879 */ 880 public static AssetVocabulary fetchByCompanyId_Last(long companyId, 881 OrderByComparator<AssetVocabulary> orderByComparator) { 882 return getPersistence() 883 .fetchByCompanyId_Last(companyId, orderByComparator); 884 } 885 886 /** 887 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where companyId = ?. 888 * 889 * @param vocabularyId the primary key of the current asset vocabulary 890 * @param companyId the company ID 891 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 892 * @return the previous, current, and next asset vocabulary 893 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 894 */ 895 public static AssetVocabulary[] findByCompanyId_PrevAndNext( 896 long vocabularyId, long companyId, 897 OrderByComparator<AssetVocabulary> orderByComparator) 898 throws com.liferay.portlet.asset.NoSuchVocabularyException { 899 return getPersistence() 900 .findByCompanyId_PrevAndNext(vocabularyId, companyId, 901 orderByComparator); 902 } 903 904 /** 905 * Removes all the asset vocabularies where companyId = ? from the database. 906 * 907 * @param companyId the company ID 908 */ 909 public static void removeByCompanyId(long companyId) { 910 getPersistence().removeByCompanyId(companyId); 911 } 912 913 /** 914 * Returns the number of asset vocabularies where companyId = ?. 915 * 916 * @param companyId the company ID 917 * @return the number of matching asset vocabularies 918 */ 919 public static int countByCompanyId(long companyId) { 920 return getPersistence().countByCompanyId(companyId); 921 } 922 923 /** 924 * Returns the asset vocabulary where groupId = ? and name = ? or throws a {@link NoSuchVocabularyException} if it could not be found. 925 * 926 * @param groupId the group ID 927 * @param name the name 928 * @return the matching asset vocabulary 929 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 930 */ 931 public static AssetVocabulary findByG_N(long groupId, java.lang.String name) 932 throws com.liferay.portlet.asset.NoSuchVocabularyException { 933 return getPersistence().findByG_N(groupId, name); 934 } 935 936 /** 937 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 938 * 939 * @param groupId the group ID 940 * @param name the name 941 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 942 */ 943 public static AssetVocabulary fetchByG_N(long groupId, java.lang.String name) { 944 return getPersistence().fetchByG_N(groupId, name); 945 } 946 947 /** 948 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 949 * 950 * @param groupId the group ID 951 * @param name the name 952 * @param retrieveFromCache whether to use the finder cache 953 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 954 */ 955 public static AssetVocabulary fetchByG_N(long groupId, 956 java.lang.String name, boolean retrieveFromCache) { 957 return getPersistence().fetchByG_N(groupId, name, retrieveFromCache); 958 } 959 960 /** 961 * Removes the asset vocabulary where groupId = ? and name = ? from the database. 962 * 963 * @param groupId the group ID 964 * @param name the name 965 * @return the asset vocabulary that was removed 966 */ 967 public static AssetVocabulary removeByG_N(long groupId, 968 java.lang.String name) 969 throws com.liferay.portlet.asset.NoSuchVocabularyException { 970 return getPersistence().removeByG_N(groupId, name); 971 } 972 973 /** 974 * Returns the number of asset vocabularies where groupId = ? and name = ?. 975 * 976 * @param groupId the group ID 977 * @param name the name 978 * @return the number of matching asset vocabularies 979 */ 980 public static int countByG_N(long groupId, java.lang.String name) { 981 return getPersistence().countByG_N(groupId, name); 982 } 983 984 /** 985 * Returns all the asset vocabularies where groupId = ? and name LIKE ?. 986 * 987 * @param groupId the group ID 988 * @param name the name 989 * @return the matching asset vocabularies 990 */ 991 public static List<AssetVocabulary> findByG_LikeN(long groupId, 992 java.lang.String name) { 993 return getPersistence().findByG_LikeN(groupId, name); 994 } 995 996 /** 997 * Returns a range of all the asset vocabularies where groupId = ? and name LIKE ?. 998 * 999 * <p> 1000 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1001 * </p> 1002 * 1003 * @param groupId the group ID 1004 * @param name the name 1005 * @param start the lower bound of the range of asset vocabularies 1006 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1007 * @return the range of matching asset vocabularies 1008 */ 1009 public static List<AssetVocabulary> findByG_LikeN(long groupId, 1010 java.lang.String name, int start, int end) { 1011 return getPersistence().findByG_LikeN(groupId, name, start, end); 1012 } 1013 1014 /** 1015 * Returns an ordered range of all the asset vocabularies where groupId = ? and name LIKE ?. 1016 * 1017 * <p> 1018 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1019 * </p> 1020 * 1021 * @param groupId the group ID 1022 * @param name the name 1023 * @param start the lower bound of the range of asset vocabularies 1024 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1025 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1026 * @return the ordered range of matching asset vocabularies 1027 */ 1028 public static List<AssetVocabulary> findByG_LikeN(long groupId, 1029 java.lang.String name, int start, int end, 1030 OrderByComparator<AssetVocabulary> orderByComparator) { 1031 return getPersistence() 1032 .findByG_LikeN(groupId, name, start, end, orderByComparator); 1033 } 1034 1035 /** 1036 * Returns the first asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1037 * 1038 * @param groupId the group ID 1039 * @param name the name 1040 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1041 * @return the first matching asset vocabulary 1042 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 1043 */ 1044 public static AssetVocabulary findByG_LikeN_First(long groupId, 1045 java.lang.String name, 1046 OrderByComparator<AssetVocabulary> orderByComparator) 1047 throws com.liferay.portlet.asset.NoSuchVocabularyException { 1048 return getPersistence() 1049 .findByG_LikeN_First(groupId, name, orderByComparator); 1050 } 1051 1052 /** 1053 * Returns the first asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1054 * 1055 * @param groupId the group ID 1056 * @param name the name 1057 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1058 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 1059 */ 1060 public static AssetVocabulary fetchByG_LikeN_First(long groupId, 1061 java.lang.String name, 1062 OrderByComparator<AssetVocabulary> orderByComparator) { 1063 return getPersistence() 1064 .fetchByG_LikeN_First(groupId, name, orderByComparator); 1065 } 1066 1067 /** 1068 * Returns the last asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1069 * 1070 * @param groupId the group ID 1071 * @param name the name 1072 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1073 * @return the last matching asset vocabulary 1074 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 1075 */ 1076 public static AssetVocabulary findByG_LikeN_Last(long groupId, 1077 java.lang.String name, 1078 OrderByComparator<AssetVocabulary> orderByComparator) 1079 throws com.liferay.portlet.asset.NoSuchVocabularyException { 1080 return getPersistence() 1081 .findByG_LikeN_Last(groupId, name, orderByComparator); 1082 } 1083 1084 /** 1085 * Returns the last asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1086 * 1087 * @param groupId the group ID 1088 * @param name the name 1089 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1090 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 1091 */ 1092 public static AssetVocabulary fetchByG_LikeN_Last(long groupId, 1093 java.lang.String name, 1094 OrderByComparator<AssetVocabulary> orderByComparator) { 1095 return getPersistence() 1096 .fetchByG_LikeN_Last(groupId, name, orderByComparator); 1097 } 1098 1099 /** 1100 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1101 * 1102 * @param vocabularyId the primary key of the current asset vocabulary 1103 * @param groupId the group ID 1104 * @param name the name 1105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1106 * @return the previous, current, and next asset vocabulary 1107 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1108 */ 1109 public static AssetVocabulary[] findByG_LikeN_PrevAndNext( 1110 long vocabularyId, long groupId, java.lang.String name, 1111 OrderByComparator<AssetVocabulary> orderByComparator) 1112 throws com.liferay.portlet.asset.NoSuchVocabularyException { 1113 return getPersistence() 1114 .findByG_LikeN_PrevAndNext(vocabularyId, groupId, name, 1115 orderByComparator); 1116 } 1117 1118 /** 1119 * Returns all the asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1120 * 1121 * @param groupId the group ID 1122 * @param name the name 1123 * @return the matching asset vocabularies that the user has permission to view 1124 */ 1125 public static List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1126 java.lang.String name) { 1127 return getPersistence().filterFindByG_LikeN(groupId, name); 1128 } 1129 1130 /** 1131 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1132 * 1133 * <p> 1134 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1135 * </p> 1136 * 1137 * @param groupId the group ID 1138 * @param name the name 1139 * @param start the lower bound of the range of asset vocabularies 1140 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1141 * @return the range of matching asset vocabularies that the user has permission to view 1142 */ 1143 public static List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1144 java.lang.String name, int start, int end) { 1145 return getPersistence().filterFindByG_LikeN(groupId, name, start, end); 1146 } 1147 1148 /** 1149 * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = ? and name LIKE ?. 1150 * 1151 * <p> 1152 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1153 * </p> 1154 * 1155 * @param groupId the group ID 1156 * @param name the name 1157 * @param start the lower bound of the range of asset vocabularies 1158 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1159 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1160 * @return the ordered range of matching asset vocabularies that the user has permission to view 1161 */ 1162 public static List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1163 java.lang.String name, int start, int end, 1164 OrderByComparator<AssetVocabulary> orderByComparator) { 1165 return getPersistence() 1166 .filterFindByG_LikeN(groupId, name, start, end, 1167 orderByComparator); 1168 } 1169 1170 /** 1171 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1172 * 1173 * @param vocabularyId the primary key of the current asset vocabulary 1174 * @param groupId the group ID 1175 * @param name the name 1176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1177 * @return the previous, current, and next asset vocabulary 1178 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1179 */ 1180 public static AssetVocabulary[] filterFindByG_LikeN_PrevAndNext( 1181 long vocabularyId, long groupId, java.lang.String name, 1182 OrderByComparator<AssetVocabulary> orderByComparator) 1183 throws com.liferay.portlet.asset.NoSuchVocabularyException { 1184 return getPersistence() 1185 .filterFindByG_LikeN_PrevAndNext(vocabularyId, groupId, 1186 name, orderByComparator); 1187 } 1188 1189 /** 1190 * Removes all the asset vocabularies where groupId = ? and name LIKE ? from the database. 1191 * 1192 * @param groupId the group ID 1193 * @param name the name 1194 */ 1195 public static void removeByG_LikeN(long groupId, java.lang.String name) { 1196 getPersistence().removeByG_LikeN(groupId, name); 1197 } 1198 1199 /** 1200 * Returns the number of asset vocabularies where groupId = ? and name LIKE ?. 1201 * 1202 * @param groupId the group ID 1203 * @param name the name 1204 * @return the number of matching asset vocabularies 1205 */ 1206 public static int countByG_LikeN(long groupId, java.lang.String name) { 1207 return getPersistence().countByG_LikeN(groupId, name); 1208 } 1209 1210 /** 1211 * Returns the number of asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1212 * 1213 * @param groupId the group ID 1214 * @param name the name 1215 * @return the number of matching asset vocabularies that the user has permission to view 1216 */ 1217 public static int filterCountByG_LikeN(long groupId, java.lang.String name) { 1218 return getPersistence().filterCountByG_LikeN(groupId, name); 1219 } 1220 1221 /** 1222 * Caches the asset vocabulary in the entity cache if it is enabled. 1223 * 1224 * @param assetVocabulary the asset vocabulary 1225 */ 1226 public static void cacheResult(AssetVocabulary assetVocabulary) { 1227 getPersistence().cacheResult(assetVocabulary); 1228 } 1229 1230 /** 1231 * Caches the asset vocabularies in the entity cache if it is enabled. 1232 * 1233 * @param assetVocabularies the asset vocabularies 1234 */ 1235 public static void cacheResult(List<AssetVocabulary> assetVocabularies) { 1236 getPersistence().cacheResult(assetVocabularies); 1237 } 1238 1239 /** 1240 * Creates a new asset vocabulary with the primary key. Does not add the asset vocabulary to the database. 1241 * 1242 * @param vocabularyId the primary key for the new asset vocabulary 1243 * @return the new asset vocabulary 1244 */ 1245 public static AssetVocabulary create(long vocabularyId) { 1246 return getPersistence().create(vocabularyId); 1247 } 1248 1249 /** 1250 * Removes the asset vocabulary with the primary key from the database. Also notifies the appropriate model listeners. 1251 * 1252 * @param vocabularyId the primary key of the asset vocabulary 1253 * @return the asset vocabulary that was removed 1254 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1255 */ 1256 public static AssetVocabulary remove(long vocabularyId) 1257 throws com.liferay.portlet.asset.NoSuchVocabularyException { 1258 return getPersistence().remove(vocabularyId); 1259 } 1260 1261 public static AssetVocabulary updateImpl(AssetVocabulary assetVocabulary) { 1262 return getPersistence().updateImpl(assetVocabulary); 1263 } 1264 1265 /** 1266 * Returns the asset vocabulary with the primary key or throws a {@link NoSuchVocabularyException} if it could not be found. 1267 * 1268 * @param vocabularyId the primary key of the asset vocabulary 1269 * @return the asset vocabulary 1270 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1271 */ 1272 public static AssetVocabulary findByPrimaryKey(long vocabularyId) 1273 throws com.liferay.portlet.asset.NoSuchVocabularyException { 1274 return getPersistence().findByPrimaryKey(vocabularyId); 1275 } 1276 1277 /** 1278 * Returns the asset vocabulary with the primary key or returns <code>null</code> if it could not be found. 1279 * 1280 * @param vocabularyId the primary key of the asset vocabulary 1281 * @return the asset vocabulary, or <code>null</code> if a asset vocabulary with the primary key could not be found 1282 */ 1283 public static AssetVocabulary fetchByPrimaryKey(long vocabularyId) { 1284 return getPersistence().fetchByPrimaryKey(vocabularyId); 1285 } 1286 1287 public static java.util.Map<java.io.Serializable, AssetVocabulary> fetchByPrimaryKeys( 1288 java.util.Set<java.io.Serializable> primaryKeys) { 1289 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1290 } 1291 1292 /** 1293 * Returns all the asset vocabularies. 1294 * 1295 * @return the asset vocabularies 1296 */ 1297 public static List<AssetVocabulary> findAll() { 1298 return getPersistence().findAll(); 1299 } 1300 1301 /** 1302 * Returns a range of all the asset vocabularies. 1303 * 1304 * <p> 1305 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1306 * </p> 1307 * 1308 * @param start the lower bound of the range of asset vocabularies 1309 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1310 * @return the range of asset vocabularies 1311 */ 1312 public static List<AssetVocabulary> findAll(int start, int end) { 1313 return getPersistence().findAll(start, end); 1314 } 1315 1316 /** 1317 * Returns an ordered range of all the asset vocabularies. 1318 * 1319 * <p> 1320 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1321 * </p> 1322 * 1323 * @param start the lower bound of the range of asset vocabularies 1324 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1325 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1326 * @return the ordered range of asset vocabularies 1327 */ 1328 public static List<AssetVocabulary> findAll(int start, int end, 1329 OrderByComparator<AssetVocabulary> orderByComparator) { 1330 return getPersistence().findAll(start, end, orderByComparator); 1331 } 1332 1333 /** 1334 * Removes all the asset vocabularies from the database. 1335 */ 1336 public static void removeAll() { 1337 getPersistence().removeAll(); 1338 } 1339 1340 /** 1341 * Returns the number of asset vocabularies. 1342 * 1343 * @return the number of asset vocabularies 1344 */ 1345 public static int countAll() { 1346 return getPersistence().countAll(); 1347 } 1348 1349 public static AssetVocabularyPersistence getPersistence() { 1350 if (_persistence == null) { 1351 _persistence = (AssetVocabularyPersistence)PortalBeanLocatorUtil.locate(AssetVocabularyPersistence.class.getName()); 1352 1353 ReferenceRegistry.registerReference(AssetVocabularyUtil.class, 1354 "_persistence"); 1355 } 1356 1357 return _persistence; 1358 } 1359 1360 /** 1361 * @deprecated As of 6.2.0 1362 */ 1363 @Deprecated 1364 public void setPersistence(AssetVocabularyPersistence persistence) { 1365 } 1366 1367 private static AssetVocabularyPersistence _persistence; 1368 }