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 an ordered range of all the asset vocabularies where uuid = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of asset vocabularies 166 * @param end the upper bound of the range of asset vocabularies (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching asset vocabularies 170 */ 171 public static List<AssetVocabulary> findByUuid(java.lang.String uuid, 172 int start, int end, 173 OrderByComparator<AssetVocabulary> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByUuid(uuid, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first asset vocabulary in the ordered set where uuid = ?. 182 * 183 * @param uuid the uuid 184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 185 * @return the first matching asset vocabulary 186 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 187 */ 188 public static AssetVocabulary findByUuid_First(java.lang.String uuid, 189 OrderByComparator<AssetVocabulary> orderByComparator) 190 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 191 return getPersistence().findByUuid_First(uuid, orderByComparator); 192 } 193 194 /** 195 * Returns the first asset vocabulary in the ordered set where uuid = ?. 196 * 197 * @param uuid the uuid 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 200 */ 201 public static AssetVocabulary fetchByUuid_First(java.lang.String uuid, 202 OrderByComparator<AssetVocabulary> orderByComparator) { 203 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 204 } 205 206 /** 207 * Returns the last asset vocabulary in the ordered set where uuid = ?. 208 * 209 * @param uuid the uuid 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the last matching asset vocabulary 212 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 213 */ 214 public static AssetVocabulary findByUuid_Last(java.lang.String uuid, 215 OrderByComparator<AssetVocabulary> orderByComparator) 216 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 217 return getPersistence().findByUuid_Last(uuid, orderByComparator); 218 } 219 220 /** 221 * Returns the last asset vocabulary in the ordered set where uuid = ?. 222 * 223 * @param uuid the uuid 224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 225 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 226 */ 227 public static AssetVocabulary fetchByUuid_Last(java.lang.String uuid, 228 OrderByComparator<AssetVocabulary> orderByComparator) { 229 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 230 } 231 232 /** 233 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ?. 234 * 235 * @param vocabularyId the primary key of the current asset vocabulary 236 * @param uuid the uuid 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the previous, current, and next asset vocabulary 239 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 240 */ 241 public static AssetVocabulary[] findByUuid_PrevAndNext(long vocabularyId, 242 java.lang.String uuid, 243 OrderByComparator<AssetVocabulary> orderByComparator) 244 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(vocabularyId, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the asset vocabularies where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 */ 254 public static void removeByUuid(java.lang.String uuid) { 255 getPersistence().removeByUuid(uuid); 256 } 257 258 /** 259 * Returns the number of asset vocabularies where uuid = ?. 260 * 261 * @param uuid the uuid 262 * @return the number of matching asset vocabularies 263 */ 264 public static int countByUuid(java.lang.String uuid) { 265 return getPersistence().countByUuid(uuid); 266 } 267 268 /** 269 * Returns the asset vocabulary where uuid = ? and groupId = ? or throws a {@link NoSuchVocabularyException} if it could not be found. 270 * 271 * @param uuid the uuid 272 * @param groupId the group ID 273 * @return the matching asset vocabulary 274 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 275 */ 276 public static AssetVocabulary findByUUID_G(java.lang.String uuid, 277 long groupId) 278 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 279 return getPersistence().findByUUID_G(uuid, groupId); 280 } 281 282 /** 283 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 284 * 285 * @param uuid the uuid 286 * @param groupId the group ID 287 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 288 */ 289 public static AssetVocabulary fetchByUUID_G(java.lang.String uuid, 290 long groupId) { 291 return getPersistence().fetchByUUID_G(uuid, groupId); 292 } 293 294 /** 295 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 296 * 297 * @param uuid the uuid 298 * @param groupId the group ID 299 * @param retrieveFromCache whether to retrieve from the finder cache 300 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 301 */ 302 public static AssetVocabulary fetchByUUID_G(java.lang.String uuid, 303 long groupId, boolean retrieveFromCache) { 304 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 305 } 306 307 /** 308 * Removes the asset vocabulary where uuid = ? and groupId = ? from the database. 309 * 310 * @param uuid the uuid 311 * @param groupId the group ID 312 * @return the asset vocabulary that was removed 313 */ 314 public static AssetVocabulary removeByUUID_G(java.lang.String uuid, 315 long groupId) 316 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 317 return getPersistence().removeByUUID_G(uuid, groupId); 318 } 319 320 /** 321 * Returns the number of asset vocabularies where uuid = ? and groupId = ?. 322 * 323 * @param uuid the uuid 324 * @param groupId the group ID 325 * @return the number of matching asset vocabularies 326 */ 327 public static int countByUUID_G(java.lang.String uuid, long groupId) { 328 return getPersistence().countByUUID_G(uuid, groupId); 329 } 330 331 /** 332 * Returns all the asset vocabularies where uuid = ? and companyId = ?. 333 * 334 * @param uuid the uuid 335 * @param companyId the company ID 336 * @return the matching asset vocabularies 337 */ 338 public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 339 long companyId) { 340 return getPersistence().findByUuid_C(uuid, companyId); 341 } 342 343 /** 344 * Returns a range of all the asset vocabularies where uuid = ? and companyId = ?. 345 * 346 * <p> 347 * 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. 348 * </p> 349 * 350 * @param uuid the uuid 351 * @param companyId the company ID 352 * @param start the lower bound of the range of asset vocabularies 353 * @param end the upper bound of the range of asset vocabularies (not inclusive) 354 * @return the range of matching asset vocabularies 355 */ 356 public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 357 long companyId, int start, int end) { 358 return getPersistence().findByUuid_C(uuid, companyId, start, end); 359 } 360 361 /** 362 * Returns an ordered range of all the asset vocabularies where uuid = ? and companyId = ?. 363 * 364 * <p> 365 * 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. 366 * </p> 367 * 368 * @param uuid the uuid 369 * @param companyId the company ID 370 * @param start the lower bound of the range of asset vocabularies 371 * @param end the upper bound of the range of asset vocabularies (not inclusive) 372 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 373 * @return the ordered range of matching asset vocabularies 374 */ 375 public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 376 long companyId, int start, int end, 377 OrderByComparator<AssetVocabulary> orderByComparator) { 378 return getPersistence() 379 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 380 } 381 382 /** 383 * Returns an ordered range of all the asset vocabularies where uuid = ? and companyId = ?. 384 * 385 * <p> 386 * 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. 387 * </p> 388 * 389 * @param uuid the uuid 390 * @param companyId the company ID 391 * @param start the lower bound of the range of asset vocabularies 392 * @param end the upper bound of the range of asset vocabularies (not inclusive) 393 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 394 * @param retrieveFromCache whether to retrieve from the finder cache 395 * @return the ordered range of matching asset vocabularies 396 */ 397 public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 398 long companyId, int start, int end, 399 OrderByComparator<AssetVocabulary> orderByComparator, 400 boolean retrieveFromCache) { 401 return getPersistence() 402 .findByUuid_C(uuid, companyId, start, end, 403 orderByComparator, retrieveFromCache); 404 } 405 406 /** 407 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 408 * 409 * @param uuid the uuid 410 * @param companyId the company ID 411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 412 * @return the first matching asset vocabulary 413 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 414 */ 415 public static AssetVocabulary findByUuid_C_First(java.lang.String uuid, 416 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) 417 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 418 return getPersistence() 419 .findByUuid_C_First(uuid, companyId, orderByComparator); 420 } 421 422 /** 423 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 424 * 425 * @param uuid the uuid 426 * @param companyId the company ID 427 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 428 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 429 */ 430 public static AssetVocabulary fetchByUuid_C_First(java.lang.String uuid, 431 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) { 432 return getPersistence() 433 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 434 } 435 436 /** 437 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 438 * 439 * @param uuid the uuid 440 * @param companyId the company ID 441 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 442 * @return the last matching asset vocabulary 443 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 444 */ 445 public static AssetVocabulary findByUuid_C_Last(java.lang.String uuid, 446 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) 447 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 448 return getPersistence() 449 .findByUuid_C_Last(uuid, companyId, orderByComparator); 450 } 451 452 /** 453 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 454 * 455 * @param uuid the uuid 456 * @param companyId the company ID 457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 458 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 459 */ 460 public static AssetVocabulary fetchByUuid_C_Last(java.lang.String uuid, 461 long companyId, OrderByComparator<AssetVocabulary> orderByComparator) { 462 return getPersistence() 463 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 464 } 465 466 /** 467 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ? and companyId = ?. 468 * 469 * @param vocabularyId the primary key of the current asset vocabulary 470 * @param uuid the uuid 471 * @param companyId the company ID 472 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 473 * @return the previous, current, and next asset vocabulary 474 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 475 */ 476 public static AssetVocabulary[] findByUuid_C_PrevAndNext( 477 long vocabularyId, java.lang.String uuid, long companyId, 478 OrderByComparator<AssetVocabulary> orderByComparator) 479 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 480 return getPersistence() 481 .findByUuid_C_PrevAndNext(vocabularyId, uuid, companyId, 482 orderByComparator); 483 } 484 485 /** 486 * Removes all the asset vocabularies where uuid = ? and companyId = ? from the database. 487 * 488 * @param uuid the uuid 489 * @param companyId the company ID 490 */ 491 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 492 getPersistence().removeByUuid_C(uuid, companyId); 493 } 494 495 /** 496 * Returns the number of asset vocabularies where uuid = ? and companyId = ?. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @return the number of matching asset vocabularies 501 */ 502 public static int countByUuid_C(java.lang.String uuid, long companyId) { 503 return getPersistence().countByUuid_C(uuid, companyId); 504 } 505 506 /** 507 * Returns all the asset vocabularies where groupId = ?. 508 * 509 * @param groupId the group ID 510 * @return the matching asset vocabularies 511 */ 512 public static List<AssetVocabulary> findByGroupId(long groupId) { 513 return getPersistence().findByGroupId(groupId); 514 } 515 516 /** 517 * Returns a range of all the asset vocabularies where groupId = ?. 518 * 519 * <p> 520 * 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. 521 * </p> 522 * 523 * @param groupId the group ID 524 * @param start the lower bound of the range of asset vocabularies 525 * @param end the upper bound of the range of asset vocabularies (not inclusive) 526 * @return the range of matching asset vocabularies 527 */ 528 public static List<AssetVocabulary> findByGroupId(long groupId, int start, 529 int end) { 530 return getPersistence().findByGroupId(groupId, start, end); 531 } 532 533 /** 534 * Returns an ordered range of all the asset vocabularies where groupId = ?. 535 * 536 * <p> 537 * 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. 538 * </p> 539 * 540 * @param groupId the group ID 541 * @param start the lower bound of the range of asset vocabularies 542 * @param end the upper bound of the range of asset vocabularies (not inclusive) 543 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 544 * @return the ordered range of matching asset vocabularies 545 */ 546 public static List<AssetVocabulary> findByGroupId(long groupId, int start, 547 int end, OrderByComparator<AssetVocabulary> orderByComparator) { 548 return getPersistence() 549 .findByGroupId(groupId, start, end, orderByComparator); 550 } 551 552 /** 553 * Returns an ordered range of all the asset vocabularies where groupId = ?. 554 * 555 * <p> 556 * 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. 557 * </p> 558 * 559 * @param groupId the group ID 560 * @param start the lower bound of the range of asset vocabularies 561 * @param end the upper bound of the range of asset vocabularies (not inclusive) 562 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 563 * @param retrieveFromCache whether to retrieve from the finder cache 564 * @return the ordered range of matching asset vocabularies 565 */ 566 public static List<AssetVocabulary> findByGroupId(long groupId, int start, 567 int end, OrderByComparator<AssetVocabulary> orderByComparator, 568 boolean retrieveFromCache) { 569 return getPersistence() 570 .findByGroupId(groupId, start, end, orderByComparator, 571 retrieveFromCache); 572 } 573 574 /** 575 * Returns the first asset vocabulary in the ordered set where groupId = ?. 576 * 577 * @param groupId the group ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching asset vocabulary 580 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 581 */ 582 public static AssetVocabulary findByGroupId_First(long groupId, 583 OrderByComparator<AssetVocabulary> orderByComparator) 584 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 585 return getPersistence().findByGroupId_First(groupId, orderByComparator); 586 } 587 588 /** 589 * Returns the first asset vocabulary in the ordered set where groupId = ?. 590 * 591 * @param groupId the group ID 592 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 593 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 594 */ 595 public static AssetVocabulary fetchByGroupId_First(long groupId, 596 OrderByComparator<AssetVocabulary> orderByComparator) { 597 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 598 } 599 600 /** 601 * Returns the last asset vocabulary in the ordered set where groupId = ?. 602 * 603 * @param groupId the group ID 604 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 605 * @return the last matching asset vocabulary 606 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 607 */ 608 public static AssetVocabulary findByGroupId_Last(long groupId, 609 OrderByComparator<AssetVocabulary> orderByComparator) 610 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 611 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 612 } 613 614 /** 615 * Returns the last asset vocabulary in the ordered set where groupId = ?. 616 * 617 * @param groupId the group ID 618 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 619 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 620 */ 621 public static AssetVocabulary fetchByGroupId_Last(long groupId, 622 OrderByComparator<AssetVocabulary> orderByComparator) { 623 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 624 } 625 626 /** 627 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = ?. 628 * 629 * @param vocabularyId the primary key of the current asset vocabulary 630 * @param groupId the group ID 631 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 632 * @return the previous, current, and next asset vocabulary 633 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 634 */ 635 public static AssetVocabulary[] findByGroupId_PrevAndNext( 636 long vocabularyId, long groupId, 637 OrderByComparator<AssetVocabulary> orderByComparator) 638 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 639 return getPersistence() 640 .findByGroupId_PrevAndNext(vocabularyId, groupId, 641 orderByComparator); 642 } 643 644 /** 645 * Returns all the asset vocabularies that the user has permission to view where groupId = ?. 646 * 647 * @param groupId the group ID 648 * @return the matching asset vocabularies that the user has permission to view 649 */ 650 public static List<AssetVocabulary> filterFindByGroupId(long groupId) { 651 return getPersistence().filterFindByGroupId(groupId); 652 } 653 654 /** 655 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = ?. 656 * 657 * <p> 658 * 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. 659 * </p> 660 * 661 * @param groupId the group ID 662 * @param start the lower bound of the range of asset vocabularies 663 * @param end the upper bound of the range of asset vocabularies (not inclusive) 664 * @return the range of matching asset vocabularies that the user has permission to view 665 */ 666 public static List<AssetVocabulary> filterFindByGroupId(long groupId, 667 int start, int end) { 668 return getPersistence().filterFindByGroupId(groupId, start, end); 669 } 670 671 /** 672 * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = ?. 673 * 674 * <p> 675 * 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. 676 * </p> 677 * 678 * @param groupId the group ID 679 * @param start the lower bound of the range of asset vocabularies 680 * @param end the upper bound of the range of asset vocabularies (not inclusive) 681 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 682 * @return the ordered range of matching asset vocabularies that the user has permission to view 683 */ 684 public static List<AssetVocabulary> filterFindByGroupId(long groupId, 685 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 686 return getPersistence() 687 .filterFindByGroupId(groupId, start, end, orderByComparator); 688 } 689 690 /** 691 * 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 = ?. 692 * 693 * @param vocabularyId the primary key of the current asset vocabulary 694 * @param groupId the group ID 695 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 696 * @return the previous, current, and next asset vocabulary 697 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 698 */ 699 public static AssetVocabulary[] filterFindByGroupId_PrevAndNext( 700 long vocabularyId, long groupId, 701 OrderByComparator<AssetVocabulary> orderByComparator) 702 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 703 return getPersistence() 704 .filterFindByGroupId_PrevAndNext(vocabularyId, groupId, 705 orderByComparator); 706 } 707 708 /** 709 * Returns all the asset vocabularies that the user has permission to view where groupId = any ?. 710 * 711 * @param groupIds the group IDs 712 * @return the matching asset vocabularies that the user has permission to view 713 */ 714 public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds) { 715 return getPersistence().filterFindByGroupId(groupIds); 716 } 717 718 /** 719 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = any ?. 720 * 721 * <p> 722 * 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. 723 * </p> 724 * 725 * @param groupIds the group IDs 726 * @param start the lower bound of the range of asset vocabularies 727 * @param end the upper bound of the range of asset vocabularies (not inclusive) 728 * @return the range of matching asset vocabularies that the user has permission to view 729 */ 730 public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds, 731 int start, int end) { 732 return getPersistence().filterFindByGroupId(groupIds, start, end); 733 } 734 735 /** 736 * Returns an ordered range of all the asset vocabularies that the user has permission to view where groupId = any ?. 737 * 738 * <p> 739 * 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. 740 * </p> 741 * 742 * @param groupIds the group IDs 743 * @param start the lower bound of the range of asset vocabularies 744 * @param end the upper bound of the range of asset vocabularies (not inclusive) 745 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 746 * @return the ordered range of matching asset vocabularies that the user has permission to view 747 */ 748 public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds, 749 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 750 return getPersistence() 751 .filterFindByGroupId(groupIds, start, end, orderByComparator); 752 } 753 754 /** 755 * Returns all the asset vocabularies where groupId = any ?. 756 * 757 * <p> 758 * 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. 759 * </p> 760 * 761 * @param groupIds the group IDs 762 * @return the matching asset vocabularies 763 */ 764 public static List<AssetVocabulary> findByGroupId(long[] groupIds) { 765 return getPersistence().findByGroupId(groupIds); 766 } 767 768 /** 769 * Returns a range of all the asset vocabularies where groupId = any ?. 770 * 771 * <p> 772 * 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. 773 * </p> 774 * 775 * @param groupIds the group IDs 776 * @param start the lower bound of the range of asset vocabularies 777 * @param end the upper bound of the range of asset vocabularies (not inclusive) 778 * @return the range of matching asset vocabularies 779 */ 780 public static List<AssetVocabulary> findByGroupId(long[] groupIds, 781 int start, int end) { 782 return getPersistence().findByGroupId(groupIds, start, end); 783 } 784 785 /** 786 * Returns an ordered range of all the asset vocabularies where groupId = any ?. 787 * 788 * <p> 789 * 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. 790 * </p> 791 * 792 * @param groupIds the group IDs 793 * @param start the lower bound of the range of asset vocabularies 794 * @param end the upper bound of the range of asset vocabularies (not inclusive) 795 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 796 * @return the ordered range of matching asset vocabularies 797 */ 798 public static List<AssetVocabulary> findByGroupId(long[] groupIds, 799 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 800 return getPersistence() 801 .findByGroupId(groupIds, start, end, orderByComparator); 802 } 803 804 /** 805 * Returns an ordered range of all the asset vocabularies where groupId = ?, optionally using the finder cache. 806 * 807 * <p> 808 * 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. 809 * </p> 810 * 811 * @param groupId the group ID 812 * @param start the lower bound of the range of asset vocabularies 813 * @param end the upper bound of the range of asset vocabularies (not inclusive) 814 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 815 * @param retrieveFromCache whether to retrieve from the finder cache 816 * @return the ordered range of matching asset vocabularies 817 */ 818 public static List<AssetVocabulary> findByGroupId(long[] groupIds, 819 int start, int end, 820 OrderByComparator<AssetVocabulary> orderByComparator, 821 boolean retrieveFromCache) { 822 return getPersistence() 823 .findByGroupId(groupIds, start, end, orderByComparator, 824 retrieveFromCache); 825 } 826 827 /** 828 * Removes all the asset vocabularies where groupId = ? from the database. 829 * 830 * @param groupId the group ID 831 */ 832 public static void removeByGroupId(long groupId) { 833 getPersistence().removeByGroupId(groupId); 834 } 835 836 /** 837 * Returns the number of asset vocabularies where groupId = ?. 838 * 839 * @param groupId the group ID 840 * @return the number of matching asset vocabularies 841 */ 842 public static int countByGroupId(long groupId) { 843 return getPersistence().countByGroupId(groupId); 844 } 845 846 /** 847 * Returns the number of asset vocabularies where groupId = any ?. 848 * 849 * @param groupIds the group IDs 850 * @return the number of matching asset vocabularies 851 */ 852 public static int countByGroupId(long[] groupIds) { 853 return getPersistence().countByGroupId(groupIds); 854 } 855 856 /** 857 * Returns the number of asset vocabularies that the user has permission to view where groupId = ?. 858 * 859 * @param groupId the group ID 860 * @return the number of matching asset vocabularies that the user has permission to view 861 */ 862 public static int filterCountByGroupId(long groupId) { 863 return getPersistence().filterCountByGroupId(groupId); 864 } 865 866 /** 867 * Returns the number of asset vocabularies that the user has permission to view where groupId = any ?. 868 * 869 * @param groupIds the group IDs 870 * @return the number of matching asset vocabularies that the user has permission to view 871 */ 872 public static int filterCountByGroupId(long[] groupIds) { 873 return getPersistence().filterCountByGroupId(groupIds); 874 } 875 876 /** 877 * Returns all the asset vocabularies where companyId = ?. 878 * 879 * @param companyId the company ID 880 * @return the matching asset vocabularies 881 */ 882 public static List<AssetVocabulary> findByCompanyId(long companyId) { 883 return getPersistence().findByCompanyId(companyId); 884 } 885 886 /** 887 * Returns a range of all the asset vocabularies where companyId = ?. 888 * 889 * <p> 890 * 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. 891 * </p> 892 * 893 * @param companyId the company ID 894 * @param start the lower bound of the range of asset vocabularies 895 * @param end the upper bound of the range of asset vocabularies (not inclusive) 896 * @return the range of matching asset vocabularies 897 */ 898 public static List<AssetVocabulary> findByCompanyId(long companyId, 899 int start, int end) { 900 return getPersistence().findByCompanyId(companyId, start, end); 901 } 902 903 /** 904 * Returns an ordered range of all the asset vocabularies where companyId = ?. 905 * 906 * <p> 907 * 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. 908 * </p> 909 * 910 * @param companyId the company ID 911 * @param start the lower bound of the range of asset vocabularies 912 * @param end the upper bound of the range of asset vocabularies (not inclusive) 913 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 914 * @return the ordered range of matching asset vocabularies 915 */ 916 public static List<AssetVocabulary> findByCompanyId(long companyId, 917 int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) { 918 return getPersistence() 919 .findByCompanyId(companyId, start, end, orderByComparator); 920 } 921 922 /** 923 * Returns an ordered range of all the asset vocabularies where companyId = ?. 924 * 925 * <p> 926 * 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. 927 * </p> 928 * 929 * @param companyId the company ID 930 * @param start the lower bound of the range of asset vocabularies 931 * @param end the upper bound of the range of asset vocabularies (not inclusive) 932 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 933 * @param retrieveFromCache whether to retrieve from the finder cache 934 * @return the ordered range of matching asset vocabularies 935 */ 936 public static List<AssetVocabulary> findByCompanyId(long companyId, 937 int start, int end, 938 OrderByComparator<AssetVocabulary> orderByComparator, 939 boolean retrieveFromCache) { 940 return getPersistence() 941 .findByCompanyId(companyId, start, end, orderByComparator, 942 retrieveFromCache); 943 } 944 945 /** 946 * Returns the first asset vocabulary in the ordered set where companyId = ?. 947 * 948 * @param companyId the company ID 949 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 950 * @return the first matching asset vocabulary 951 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 952 */ 953 public static AssetVocabulary findByCompanyId_First(long companyId, 954 OrderByComparator<AssetVocabulary> orderByComparator) 955 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 956 return getPersistence() 957 .findByCompanyId_First(companyId, orderByComparator); 958 } 959 960 /** 961 * Returns the first asset vocabulary in the ordered set where companyId = ?. 962 * 963 * @param companyId the company ID 964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 965 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 966 */ 967 public static AssetVocabulary fetchByCompanyId_First(long companyId, 968 OrderByComparator<AssetVocabulary> orderByComparator) { 969 return getPersistence() 970 .fetchByCompanyId_First(companyId, orderByComparator); 971 } 972 973 /** 974 * Returns the last asset vocabulary in the ordered set where companyId = ?. 975 * 976 * @param companyId the company ID 977 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 978 * @return the last matching asset vocabulary 979 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 980 */ 981 public static AssetVocabulary findByCompanyId_Last(long companyId, 982 OrderByComparator<AssetVocabulary> orderByComparator) 983 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 984 return getPersistence() 985 .findByCompanyId_Last(companyId, orderByComparator); 986 } 987 988 /** 989 * Returns the last asset vocabulary in the ordered set where companyId = ?. 990 * 991 * @param companyId the company ID 992 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 993 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 994 */ 995 public static AssetVocabulary fetchByCompanyId_Last(long companyId, 996 OrderByComparator<AssetVocabulary> orderByComparator) { 997 return getPersistence() 998 .fetchByCompanyId_Last(companyId, orderByComparator); 999 } 1000 1001 /** 1002 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where companyId = ?. 1003 * 1004 * @param vocabularyId the primary key of the current asset vocabulary 1005 * @param companyId the company ID 1006 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1007 * @return the previous, current, and next asset vocabulary 1008 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1009 */ 1010 public static AssetVocabulary[] findByCompanyId_PrevAndNext( 1011 long vocabularyId, long companyId, 1012 OrderByComparator<AssetVocabulary> orderByComparator) 1013 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1014 return getPersistence() 1015 .findByCompanyId_PrevAndNext(vocabularyId, companyId, 1016 orderByComparator); 1017 } 1018 1019 /** 1020 * Removes all the asset vocabularies where companyId = ? from the database. 1021 * 1022 * @param companyId the company ID 1023 */ 1024 public static void removeByCompanyId(long companyId) { 1025 getPersistence().removeByCompanyId(companyId); 1026 } 1027 1028 /** 1029 * Returns the number of asset vocabularies where companyId = ?. 1030 * 1031 * @param companyId the company ID 1032 * @return the number of matching asset vocabularies 1033 */ 1034 public static int countByCompanyId(long companyId) { 1035 return getPersistence().countByCompanyId(companyId); 1036 } 1037 1038 /** 1039 * Returns the asset vocabulary where groupId = ? and name = ? or throws a {@link NoSuchVocabularyException} if it could not be found. 1040 * 1041 * @param groupId the group ID 1042 * @param name the name 1043 * @return the matching asset vocabulary 1044 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 1045 */ 1046 public static AssetVocabulary findByG_N(long groupId, java.lang.String name) 1047 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1048 return getPersistence().findByG_N(groupId, name); 1049 } 1050 1051 /** 1052 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1053 * 1054 * @param groupId the group ID 1055 * @param name the name 1056 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 1057 */ 1058 public static AssetVocabulary fetchByG_N(long groupId, java.lang.String name) { 1059 return getPersistence().fetchByG_N(groupId, name); 1060 } 1061 1062 /** 1063 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1064 * 1065 * @param groupId the group ID 1066 * @param name the name 1067 * @param retrieveFromCache whether to retrieve from the finder cache 1068 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 1069 */ 1070 public static AssetVocabulary fetchByG_N(long groupId, 1071 java.lang.String name, boolean retrieveFromCache) { 1072 return getPersistence().fetchByG_N(groupId, name, retrieveFromCache); 1073 } 1074 1075 /** 1076 * Removes the asset vocabulary where groupId = ? and name = ? from the database. 1077 * 1078 * @param groupId the group ID 1079 * @param name the name 1080 * @return the asset vocabulary that was removed 1081 */ 1082 public static AssetVocabulary removeByG_N(long groupId, 1083 java.lang.String name) 1084 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1085 return getPersistence().removeByG_N(groupId, name); 1086 } 1087 1088 /** 1089 * Returns the number of asset vocabularies where groupId = ? and name = ?. 1090 * 1091 * @param groupId the group ID 1092 * @param name the name 1093 * @return the number of matching asset vocabularies 1094 */ 1095 public static int countByG_N(long groupId, java.lang.String name) { 1096 return getPersistence().countByG_N(groupId, name); 1097 } 1098 1099 /** 1100 * Returns all the asset vocabularies where groupId = ? and name LIKE ?. 1101 * 1102 * @param groupId the group ID 1103 * @param name the name 1104 * @return the matching asset vocabularies 1105 */ 1106 public static List<AssetVocabulary> findByG_LikeN(long groupId, 1107 java.lang.String name) { 1108 return getPersistence().findByG_LikeN(groupId, name); 1109 } 1110 1111 /** 1112 * Returns a range of all the asset vocabularies where groupId = ? and name LIKE ?. 1113 * 1114 * <p> 1115 * 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. 1116 * </p> 1117 * 1118 * @param groupId the group ID 1119 * @param name the name 1120 * @param start the lower bound of the range of asset vocabularies 1121 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1122 * @return the range of matching asset vocabularies 1123 */ 1124 public static List<AssetVocabulary> findByG_LikeN(long groupId, 1125 java.lang.String name, int start, int end) { 1126 return getPersistence().findByG_LikeN(groupId, name, start, end); 1127 } 1128 1129 /** 1130 * Returns an ordered range of all the asset vocabularies where groupId = ? and name LIKE ?. 1131 * 1132 * <p> 1133 * 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. 1134 * </p> 1135 * 1136 * @param groupId the group ID 1137 * @param name the name 1138 * @param start the lower bound of the range of asset vocabularies 1139 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1140 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1141 * @return the ordered range of matching asset vocabularies 1142 */ 1143 public static List<AssetVocabulary> findByG_LikeN(long groupId, 1144 java.lang.String name, int start, int end, 1145 OrderByComparator<AssetVocabulary> orderByComparator) { 1146 return getPersistence() 1147 .findByG_LikeN(groupId, name, start, end, orderByComparator); 1148 } 1149 1150 /** 1151 * Returns an ordered range of all the asset vocabularies where groupId = ? and name LIKE ?. 1152 * 1153 * <p> 1154 * 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. 1155 * </p> 1156 * 1157 * @param groupId the group ID 1158 * @param name the name 1159 * @param start the lower bound of the range of asset vocabularies 1160 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1161 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1162 * @param retrieveFromCache whether to retrieve from the finder cache 1163 * @return the ordered range of matching asset vocabularies 1164 */ 1165 public static List<AssetVocabulary> findByG_LikeN(long groupId, 1166 java.lang.String name, int start, int end, 1167 OrderByComparator<AssetVocabulary> orderByComparator, 1168 boolean retrieveFromCache) { 1169 return getPersistence() 1170 .findByG_LikeN(groupId, name, start, end, orderByComparator, 1171 retrieveFromCache); 1172 } 1173 1174 /** 1175 * Returns the first asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1176 * 1177 * @param groupId the group ID 1178 * @param name the name 1179 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1180 * @return the first matching asset vocabulary 1181 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 1182 */ 1183 public static AssetVocabulary findByG_LikeN_First(long groupId, 1184 java.lang.String name, 1185 OrderByComparator<AssetVocabulary> orderByComparator) 1186 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1187 return getPersistence() 1188 .findByG_LikeN_First(groupId, name, orderByComparator); 1189 } 1190 1191 /** 1192 * Returns the first asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1193 * 1194 * @param groupId the group ID 1195 * @param name the name 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 1198 */ 1199 public static AssetVocabulary fetchByG_LikeN_First(long groupId, 1200 java.lang.String name, 1201 OrderByComparator<AssetVocabulary> orderByComparator) { 1202 return getPersistence() 1203 .fetchByG_LikeN_First(groupId, name, orderByComparator); 1204 } 1205 1206 /** 1207 * Returns the last asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1208 * 1209 * @param groupId the group ID 1210 * @param name the name 1211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1212 * @return the last matching asset vocabulary 1213 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 1214 */ 1215 public static AssetVocabulary findByG_LikeN_Last(long groupId, 1216 java.lang.String name, 1217 OrderByComparator<AssetVocabulary> orderByComparator) 1218 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1219 return getPersistence() 1220 .findByG_LikeN_Last(groupId, name, orderByComparator); 1221 } 1222 1223 /** 1224 * Returns the last asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1225 * 1226 * @param groupId the group ID 1227 * @param name the name 1228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1229 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 1230 */ 1231 public static AssetVocabulary fetchByG_LikeN_Last(long groupId, 1232 java.lang.String name, 1233 OrderByComparator<AssetVocabulary> orderByComparator) { 1234 return getPersistence() 1235 .fetchByG_LikeN_Last(groupId, name, orderByComparator); 1236 } 1237 1238 /** 1239 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 1240 * 1241 * @param vocabularyId the primary key of the current asset vocabulary 1242 * @param groupId the group ID 1243 * @param name the name 1244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1245 * @return the previous, current, and next asset vocabulary 1246 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1247 */ 1248 public static AssetVocabulary[] findByG_LikeN_PrevAndNext( 1249 long vocabularyId, long groupId, java.lang.String name, 1250 OrderByComparator<AssetVocabulary> orderByComparator) 1251 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1252 return getPersistence() 1253 .findByG_LikeN_PrevAndNext(vocabularyId, groupId, name, 1254 orderByComparator); 1255 } 1256 1257 /** 1258 * Returns all the asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1259 * 1260 * @param groupId the group ID 1261 * @param name the name 1262 * @return the matching asset vocabularies that the user has permission to view 1263 */ 1264 public static List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1265 java.lang.String name) { 1266 return getPersistence().filterFindByG_LikeN(groupId, name); 1267 } 1268 1269 /** 1270 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1271 * 1272 * <p> 1273 * 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. 1274 * </p> 1275 * 1276 * @param groupId the group ID 1277 * @param name the name 1278 * @param start the lower bound of the range of asset vocabularies 1279 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1280 * @return the range of matching asset vocabularies that the user has permission to view 1281 */ 1282 public static List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1283 java.lang.String name, int start, int end) { 1284 return getPersistence().filterFindByG_LikeN(groupId, name, start, end); 1285 } 1286 1287 /** 1288 * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = ? and name LIKE ?. 1289 * 1290 * <p> 1291 * 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. 1292 * </p> 1293 * 1294 * @param groupId the group ID 1295 * @param name the name 1296 * @param start the lower bound of the range of asset vocabularies 1297 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1298 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1299 * @return the ordered range of matching asset vocabularies that the user has permission to view 1300 */ 1301 public static List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1302 java.lang.String name, int start, int end, 1303 OrderByComparator<AssetVocabulary> orderByComparator) { 1304 return getPersistence() 1305 .filterFindByG_LikeN(groupId, name, start, end, 1306 orderByComparator); 1307 } 1308 1309 /** 1310 * 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 ?. 1311 * 1312 * @param vocabularyId the primary key of the current asset vocabulary 1313 * @param groupId the group ID 1314 * @param name the name 1315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1316 * @return the previous, current, and next asset vocabulary 1317 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1318 */ 1319 public static AssetVocabulary[] filterFindByG_LikeN_PrevAndNext( 1320 long vocabularyId, long groupId, java.lang.String name, 1321 OrderByComparator<AssetVocabulary> orderByComparator) 1322 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1323 return getPersistence() 1324 .filterFindByG_LikeN_PrevAndNext(vocabularyId, groupId, 1325 name, orderByComparator); 1326 } 1327 1328 /** 1329 * Removes all the asset vocabularies where groupId = ? and name LIKE ? from the database. 1330 * 1331 * @param groupId the group ID 1332 * @param name the name 1333 */ 1334 public static void removeByG_LikeN(long groupId, java.lang.String name) { 1335 getPersistence().removeByG_LikeN(groupId, name); 1336 } 1337 1338 /** 1339 * Returns the number of asset vocabularies where groupId = ? and name LIKE ?. 1340 * 1341 * @param groupId the group ID 1342 * @param name the name 1343 * @return the number of matching asset vocabularies 1344 */ 1345 public static int countByG_LikeN(long groupId, java.lang.String name) { 1346 return getPersistence().countByG_LikeN(groupId, name); 1347 } 1348 1349 /** 1350 * Returns the number of asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1351 * 1352 * @param groupId the group ID 1353 * @param name the name 1354 * @return the number of matching asset vocabularies that the user has permission to view 1355 */ 1356 public static int filterCountByG_LikeN(long groupId, java.lang.String name) { 1357 return getPersistence().filterCountByG_LikeN(groupId, name); 1358 } 1359 1360 /** 1361 * Caches the asset vocabulary in the entity cache if it is enabled. 1362 * 1363 * @param assetVocabulary the asset vocabulary 1364 */ 1365 public static void cacheResult(AssetVocabulary assetVocabulary) { 1366 getPersistence().cacheResult(assetVocabulary); 1367 } 1368 1369 /** 1370 * Caches the asset vocabularies in the entity cache if it is enabled. 1371 * 1372 * @param assetVocabularies the asset vocabularies 1373 */ 1374 public static void cacheResult(List<AssetVocabulary> assetVocabularies) { 1375 getPersistence().cacheResult(assetVocabularies); 1376 } 1377 1378 /** 1379 * Creates a new asset vocabulary with the primary key. Does not add the asset vocabulary to the database. 1380 * 1381 * @param vocabularyId the primary key for the new asset vocabulary 1382 * @return the new asset vocabulary 1383 */ 1384 public static AssetVocabulary create(long vocabularyId) { 1385 return getPersistence().create(vocabularyId); 1386 } 1387 1388 /** 1389 * Removes the asset vocabulary with the primary key from the database. Also notifies the appropriate model listeners. 1390 * 1391 * @param vocabularyId the primary key of the asset vocabulary 1392 * @return the asset vocabulary that was removed 1393 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1394 */ 1395 public static AssetVocabulary remove(long vocabularyId) 1396 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1397 return getPersistence().remove(vocabularyId); 1398 } 1399 1400 public static AssetVocabulary updateImpl(AssetVocabulary assetVocabulary) { 1401 return getPersistence().updateImpl(assetVocabulary); 1402 } 1403 1404 /** 1405 * Returns the asset vocabulary with the primary key or throws a {@link NoSuchVocabularyException} if it could not be found. 1406 * 1407 * @param vocabularyId the primary key of the asset vocabulary 1408 * @return the asset vocabulary 1409 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1410 */ 1411 public static AssetVocabulary findByPrimaryKey(long vocabularyId) 1412 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException { 1413 return getPersistence().findByPrimaryKey(vocabularyId); 1414 } 1415 1416 /** 1417 * Returns the asset vocabulary with the primary key or returns <code>null</code> if it could not be found. 1418 * 1419 * @param vocabularyId the primary key of the asset vocabulary 1420 * @return the asset vocabulary, or <code>null</code> if a asset vocabulary with the primary key could not be found 1421 */ 1422 public static AssetVocabulary fetchByPrimaryKey(long vocabularyId) { 1423 return getPersistence().fetchByPrimaryKey(vocabularyId); 1424 } 1425 1426 public static java.util.Map<java.io.Serializable, AssetVocabulary> fetchByPrimaryKeys( 1427 java.util.Set<java.io.Serializable> primaryKeys) { 1428 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1429 } 1430 1431 /** 1432 * Returns all the asset vocabularies. 1433 * 1434 * @return the asset vocabularies 1435 */ 1436 public static List<AssetVocabulary> findAll() { 1437 return getPersistence().findAll(); 1438 } 1439 1440 /** 1441 * Returns a range of all the asset vocabularies. 1442 * 1443 * <p> 1444 * 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. 1445 * </p> 1446 * 1447 * @param start the lower bound of the range of asset vocabularies 1448 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1449 * @return the range of asset vocabularies 1450 */ 1451 public static List<AssetVocabulary> findAll(int start, int end) { 1452 return getPersistence().findAll(start, end); 1453 } 1454 1455 /** 1456 * Returns an ordered range of all the asset vocabularies. 1457 * 1458 * <p> 1459 * 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. 1460 * </p> 1461 * 1462 * @param start the lower bound of the range of asset vocabularies 1463 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1464 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1465 * @return the ordered range of asset vocabularies 1466 */ 1467 public static List<AssetVocabulary> findAll(int start, int end, 1468 OrderByComparator<AssetVocabulary> orderByComparator) { 1469 return getPersistence().findAll(start, end, orderByComparator); 1470 } 1471 1472 /** 1473 * Returns an ordered range of all the asset vocabularies. 1474 * 1475 * <p> 1476 * 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. 1477 * </p> 1478 * 1479 * @param start the lower bound of the range of asset vocabularies 1480 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1481 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1482 * @param retrieveFromCache whether to retrieve from the finder cache 1483 * @return the ordered range of asset vocabularies 1484 */ 1485 public static List<AssetVocabulary> findAll(int start, int end, 1486 OrderByComparator<AssetVocabulary> orderByComparator, 1487 boolean retrieveFromCache) { 1488 return getPersistence() 1489 .findAll(start, end, orderByComparator, retrieveFromCache); 1490 } 1491 1492 /** 1493 * Removes all the asset vocabularies from the database. 1494 */ 1495 public static void removeAll() { 1496 getPersistence().removeAll(); 1497 } 1498 1499 /** 1500 * Returns the number of asset vocabularies. 1501 * 1502 * @return the number of asset vocabularies 1503 */ 1504 public static int countAll() { 1505 return getPersistence().countAll(); 1506 } 1507 1508 public static java.util.Set<java.lang.String> getBadColumnNames() { 1509 return getPersistence().getBadColumnNames(); 1510 } 1511 1512 public static AssetVocabularyPersistence getPersistence() { 1513 if (_persistence == null) { 1514 _persistence = (AssetVocabularyPersistence)PortalBeanLocatorUtil.locate(AssetVocabularyPersistence.class.getName()); 1515 1516 ReferenceRegistry.registerReference(AssetVocabularyUtil.class, 1517 "_persistence"); 1518 } 1519 1520 return _persistence; 1521 } 1522 1523 private static AssetVocabularyPersistence _persistence; 1524 }