001 /** 002 * Copyright (c) 2000-2013 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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.asset.model.AssetVocabulary; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the asset vocabulary service. This utility wraps {@link 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. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see AssetVocabularyPersistence 037 * @see AssetVocabularyPersistenceImpl 038 * @generated 039 */ 040 public class AssetVocabularyUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(AssetVocabulary assetVocabulary) { 058 getPersistence().clearCache(assetVocabulary); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<AssetVocabulary> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<AssetVocabulary> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 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 orderByComparator) throws SystemException { 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 throws SystemException { 102 return getPersistence().update(assetVocabulary); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static AssetVocabulary update(AssetVocabulary assetVocabulary, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(assetVocabulary, serviceContext); 111 } 112 113 /** 114 * Returns all the asset vocabularies where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching asset vocabularies 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the asset vocabularies where uuid = ?. 128 * 129 * <p> 130 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 131 * </p> 132 * 133 * @param uuid the uuid 134 * @param start the lower bound of the range of asset vocabularies 135 * @param end the upper bound of the range of asset vocabularies (not inclusive) 136 * @return the range of matching asset vocabularies 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the asset vocabularies where uuid = ?. 147 * 148 * <p> 149 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of asset vocabularies 154 * @param end the upper bound of the range of asset vocabularies (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching asset vocabularies 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first asset vocabulary in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching asset vocabulary 172 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.asset.model.AssetVocabulary findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.asset.NoSuchVocabularyException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first 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 first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last asset vocabulary in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching asset vocabulary 204 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portlet.asset.model.AssetVocabulary findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.kernel.exception.SystemException, 211 com.liferay.portlet.asset.NoSuchVocabularyException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last asset vocabulary in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ?. 232 * 233 * @param vocabularyId the primary key of the current asset vocabulary 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next asset vocabulary 237 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portlet.asset.model.AssetVocabulary[] findByUuid_PrevAndNext( 241 long vocabularyId, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException, 244 com.liferay.portlet.asset.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 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of asset vocabularies where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching asset vocabularies 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the asset vocabulary where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.asset.NoSuchVocabularyException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @return the matching asset vocabulary 278 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.asset.model.AssetVocabulary findByUUID_G( 282 java.lang.String uuid, long groupId) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.asset.NoSuchVocabularyException { 285 return getPersistence().findByUUID_G(uuid, groupId); 286 } 287 288 /** 289 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 290 * 291 * @param uuid the uuid 292 * @param groupId the group ID 293 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 294 * @throws SystemException if a system exception occurred 295 */ 296 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByUUID_G( 297 java.lang.String uuid, long groupId) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence().fetchByUUID_G(uuid, groupId); 300 } 301 302 /** 303 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @param retrieveFromCache whether to use the finder cache 308 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByUUID_G( 312 java.lang.String uuid, long groupId, boolean retrieveFromCache) 313 throws com.liferay.portal.kernel.exception.SystemException { 314 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 315 } 316 317 /** 318 * Removes the asset vocabulary where uuid = ? and groupId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the asset vocabulary that was removed 323 * @throws SystemException if a system exception occurred 324 */ 325 public static com.liferay.portlet.asset.model.AssetVocabulary removeByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.asset.NoSuchVocabularyException { 329 return getPersistence().removeByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns the number of asset vocabularies where uuid = ? and groupId = ?. 334 * 335 * @param uuid the uuid 336 * @param groupId the group ID 337 * @return the number of matching asset vocabularies 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUUID_G(java.lang.String uuid, long groupId) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns all the asset vocabularies where uuid = ? and companyId = ?. 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @return the matching asset vocabularies 351 * @throws SystemException if a system exception occurred 352 */ 353 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByUuid_C( 354 java.lang.String uuid, long companyId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().findByUuid_C(uuid, companyId); 357 } 358 359 /** 360 * Returns a range of all the asset vocabularies where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of asset vocabularies 369 * @param end the upper bound of the range of asset vocabularies (not inclusive) 370 * @return the range of matching asset vocabularies 371 * @throws SystemException if a system exception occurred 372 */ 373 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByUuid_C( 374 java.lang.String uuid, long companyId, int start, int end) 375 throws com.liferay.portal.kernel.exception.SystemException { 376 return getPersistence().findByUuid_C(uuid, companyId, start, end); 377 } 378 379 /** 380 * Returns an ordered range of all the asset vocabularies where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of asset vocabularies 389 * @param end the upper bound of the range of asset vocabularies (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @return the ordered range of matching asset vocabularies 392 * @throws SystemException if a system exception occurred 393 */ 394 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByUuid_C( 395 java.lang.String uuid, long companyId, int start, int end, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 400 } 401 402 /** 403 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching asset vocabulary 409 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.asset.model.AssetVocabulary findByUuid_C_First( 413 java.lang.String uuid, long companyId, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.kernel.exception.SystemException, 416 com.liferay.portlet.asset.NoSuchVocabularyException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByUuid_C_First( 431 java.lang.String uuid, long companyId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException { 434 return getPersistence() 435 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 436 } 437 438 /** 439 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the last matching asset vocabulary 445 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 446 * @throws SystemException if a system exception occurred 447 */ 448 public static com.liferay.portlet.asset.model.AssetVocabulary findByUuid_C_Last( 449 java.lang.String uuid, long companyId, 450 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 451 throws com.liferay.portal.kernel.exception.SystemException, 452 com.liferay.portlet.asset.NoSuchVocabularyException { 453 return getPersistence() 454 .findByUuid_C_Last(uuid, companyId, orderByComparator); 455 } 456 457 /** 458 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 459 * 460 * @param uuid the uuid 461 * @param companyId the company ID 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByUuid_C_Last( 467 java.lang.String uuid, long companyId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence() 471 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ? and companyId = ?. 476 * 477 * @param vocabularyId the primary key of the current asset vocabulary 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next asset vocabulary 482 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.asset.model.AssetVocabulary[] findByUuid_C_PrevAndNext( 486 long vocabularyId, java.lang.String uuid, long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.asset.NoSuchVocabularyException { 490 return getPersistence() 491 .findByUuid_C_PrevAndNext(vocabularyId, uuid, companyId, 492 orderByComparator); 493 } 494 495 /** 496 * Removes all the asset vocabularies where uuid = ? and companyId = ? from the database. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @throws SystemException if a system exception occurred 501 */ 502 public static void removeByUuid_C(java.lang.String uuid, long companyId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 getPersistence().removeByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns the number of asset vocabularies where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the number of matching asset vocabularies 513 * @throws SystemException if a system exception occurred 514 */ 515 public static int countByUuid_C(java.lang.String uuid, long companyId) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().countByUuid_C(uuid, companyId); 518 } 519 520 /** 521 * Returns all the asset vocabularies where groupId = ?. 522 * 523 * @param groupId the group ID 524 * @return the matching asset vocabularies 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByGroupId( 528 long groupId) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence().findByGroupId(groupId); 531 } 532 533 /** 534 * Returns a 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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 * @return the range of matching asset vocabularies 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByGroupId( 547 long groupId, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence().findByGroupId(groupId, start, end); 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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 * @return the ordered range of matching asset vocabularies 564 * @throws SystemException if a system exception occurred 565 */ 566 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByGroupId( 567 long groupId, int start, int end, 568 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 569 throws com.liferay.portal.kernel.exception.SystemException { 570 return getPersistence() 571 .findByGroupId(groupId, start, end, orderByComparator); 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 com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.asset.model.AssetVocabulary findByGroupId_First( 584 long groupId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.asset.NoSuchVocabularyException { 588 return getPersistence().findByGroupId_First(groupId, orderByComparator); 589 } 590 591 /** 592 * Returns the first asset vocabulary in the ordered set where groupId = ?. 593 * 594 * @param groupId the group ID 595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 596 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 597 * @throws SystemException if a system exception occurred 598 */ 599 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByGroupId_First( 600 long groupId, 601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 602 throws com.liferay.portal.kernel.exception.SystemException { 603 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 604 } 605 606 /** 607 * Returns the last asset vocabulary in the ordered set where groupId = ?. 608 * 609 * @param groupId the group ID 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the last matching asset vocabulary 612 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 613 * @throws SystemException if a system exception occurred 614 */ 615 public static com.liferay.portlet.asset.model.AssetVocabulary findByGroupId_Last( 616 long groupId, 617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 618 throws com.liferay.portal.kernel.exception.SystemException, 619 com.liferay.portlet.asset.NoSuchVocabularyException { 620 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 621 } 622 623 /** 624 * Returns the last asset vocabulary in the ordered set where groupId = ?. 625 * 626 * @param groupId the group ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 629 * @throws SystemException if a system exception occurred 630 */ 631 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByGroupId_Last( 632 long groupId, 633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 634 throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 636 } 637 638 /** 639 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = ?. 640 * 641 * @param vocabularyId the primary key of the current asset vocabulary 642 * @param groupId the group ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next asset vocabulary 645 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public static com.liferay.portlet.asset.model.AssetVocabulary[] findByGroupId_PrevAndNext( 649 long vocabularyId, long groupId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.asset.NoSuchVocabularyException { 653 return getPersistence() 654 .findByGroupId_PrevAndNext(vocabularyId, groupId, 655 orderByComparator); 656 } 657 658 /** 659 * Returns all the asset vocabularies that the user has permission to view where groupId = ?. 660 * 661 * @param groupId the group ID 662 * @return the matching asset vocabularies that the user has permission to view 663 * @throws SystemException if a system exception occurred 664 */ 665 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> filterFindByGroupId( 666 long groupId) 667 throws com.liferay.portal.kernel.exception.SystemException { 668 return getPersistence().filterFindByGroupId(groupId); 669 } 670 671 /** 672 * Returns a range of all the asset vocabularies that the user has permission 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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 * @return the range of matching asset vocabularies that the user has permission to view 682 * @throws SystemException if a system exception occurred 683 */ 684 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> filterFindByGroupId( 685 long groupId, int start, int end) 686 throws com.liferay.portal.kernel.exception.SystemException { 687 return getPersistence().filterFindByGroupId(groupId, start, end); 688 } 689 690 /** 691 * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = ?. 692 * 693 * <p> 694 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 695 * </p> 696 * 697 * @param groupId the group ID 698 * @param start the lower bound of the range of asset vocabularies 699 * @param end the upper bound of the range of asset vocabularies (not inclusive) 700 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 701 * @return the ordered range of matching asset vocabularies that the user has permission to view 702 * @throws SystemException if a system exception occurred 703 */ 704 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> filterFindByGroupId( 705 long groupId, int start, int end, 706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 707 throws com.liferay.portal.kernel.exception.SystemException { 708 return getPersistence() 709 .filterFindByGroupId(groupId, start, end, orderByComparator); 710 } 711 712 /** 713 * 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 = ?. 714 * 715 * @param vocabularyId the primary key of the current asset vocabulary 716 * @param groupId the group ID 717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 718 * @return the previous, current, and next asset vocabulary 719 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 720 * @throws SystemException if a system exception occurred 721 */ 722 public static com.liferay.portlet.asset.model.AssetVocabulary[] filterFindByGroupId_PrevAndNext( 723 long vocabularyId, long groupId, 724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 725 throws com.liferay.portal.kernel.exception.SystemException, 726 com.liferay.portlet.asset.NoSuchVocabularyException { 727 return getPersistence() 728 .filterFindByGroupId_PrevAndNext(vocabularyId, groupId, 729 orderByComparator); 730 } 731 732 /** 733 * Removes all the asset vocabularies where groupId = ? from the database. 734 * 735 * @param groupId the group ID 736 * @throws SystemException if a system exception occurred 737 */ 738 public static void removeByGroupId(long groupId) 739 throws com.liferay.portal.kernel.exception.SystemException { 740 getPersistence().removeByGroupId(groupId); 741 } 742 743 /** 744 * Returns the number of asset vocabularies where groupId = ?. 745 * 746 * @param groupId the group ID 747 * @return the number of matching asset vocabularies 748 * @throws SystemException if a system exception occurred 749 */ 750 public static int countByGroupId(long groupId) 751 throws com.liferay.portal.kernel.exception.SystemException { 752 return getPersistence().countByGroupId(groupId); 753 } 754 755 /** 756 * Returns the number of asset vocabularies that the user has permission to view where groupId = ?. 757 * 758 * @param groupId the group ID 759 * @return the number of matching asset vocabularies that the user has permission to view 760 * @throws SystemException if a system exception occurred 761 */ 762 public static int filterCountByGroupId(long groupId) 763 throws com.liferay.portal.kernel.exception.SystemException { 764 return getPersistence().filterCountByGroupId(groupId); 765 } 766 767 /** 768 * Returns all the asset vocabularies where companyId = ?. 769 * 770 * @param companyId the company ID 771 * @return the matching asset vocabularies 772 * @throws SystemException if a system exception occurred 773 */ 774 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByCompanyId( 775 long companyId) 776 throws com.liferay.portal.kernel.exception.SystemException { 777 return getPersistence().findByCompanyId(companyId); 778 } 779 780 /** 781 * Returns a range of all the asset vocabularies where companyId = ?. 782 * 783 * <p> 784 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 785 * </p> 786 * 787 * @param companyId the company ID 788 * @param start the lower bound of the range of asset vocabularies 789 * @param end the upper bound of the range of asset vocabularies (not inclusive) 790 * @return the range of matching asset vocabularies 791 * @throws SystemException if a system exception occurred 792 */ 793 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByCompanyId( 794 long companyId, int start, int end) 795 throws com.liferay.portal.kernel.exception.SystemException { 796 return getPersistence().findByCompanyId(companyId, start, end); 797 } 798 799 /** 800 * Returns an ordered range of all the asset vocabularies where companyId = ?. 801 * 802 * <p> 803 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 804 * </p> 805 * 806 * @param companyId the company ID 807 * @param start the lower bound of the range of asset vocabularies 808 * @param end the upper bound of the range of asset vocabularies (not inclusive) 809 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 810 * @return the ordered range of matching asset vocabularies 811 * @throws SystemException if a system exception occurred 812 */ 813 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findByCompanyId( 814 long companyId, int start, int end, 815 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 816 throws com.liferay.portal.kernel.exception.SystemException { 817 return getPersistence() 818 .findByCompanyId(companyId, start, end, orderByComparator); 819 } 820 821 /** 822 * Returns the first asset vocabulary in the ordered set where companyId = ?. 823 * 824 * @param companyId the company ID 825 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 826 * @return the first matching asset vocabulary 827 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 828 * @throws SystemException if a system exception occurred 829 */ 830 public static com.liferay.portlet.asset.model.AssetVocabulary findByCompanyId_First( 831 long companyId, 832 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 833 throws com.liferay.portal.kernel.exception.SystemException, 834 com.liferay.portlet.asset.NoSuchVocabularyException { 835 return getPersistence() 836 .findByCompanyId_First(companyId, orderByComparator); 837 } 838 839 /** 840 * Returns the first asset vocabulary in the ordered set where companyId = ?. 841 * 842 * @param companyId the company ID 843 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 844 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 845 * @throws SystemException if a system exception occurred 846 */ 847 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByCompanyId_First( 848 long companyId, 849 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 850 throws com.liferay.portal.kernel.exception.SystemException { 851 return getPersistence() 852 .fetchByCompanyId_First(companyId, orderByComparator); 853 } 854 855 /** 856 * Returns the last asset vocabulary in the ordered set where companyId = ?. 857 * 858 * @param companyId the company ID 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the last matching asset vocabulary 861 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 862 * @throws SystemException if a system exception occurred 863 */ 864 public static com.liferay.portlet.asset.model.AssetVocabulary findByCompanyId_Last( 865 long companyId, 866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 867 throws com.liferay.portal.kernel.exception.SystemException, 868 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 * @throws SystemException if a system exception occurred 880 */ 881 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByCompanyId_Last( 882 long companyId, 883 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 884 throws com.liferay.portal.kernel.exception.SystemException { 885 return getPersistence() 886 .fetchByCompanyId_Last(companyId, orderByComparator); 887 } 888 889 /** 890 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where companyId = ?. 891 * 892 * @param vocabularyId the primary key of the current asset vocabulary 893 * @param companyId the company ID 894 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 895 * @return the previous, current, and next asset vocabulary 896 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 897 * @throws SystemException if a system exception occurred 898 */ 899 public static com.liferay.portlet.asset.model.AssetVocabulary[] findByCompanyId_PrevAndNext( 900 long vocabularyId, long companyId, 901 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 902 throws com.liferay.portal.kernel.exception.SystemException, 903 com.liferay.portlet.asset.NoSuchVocabularyException { 904 return getPersistence() 905 .findByCompanyId_PrevAndNext(vocabularyId, companyId, 906 orderByComparator); 907 } 908 909 /** 910 * Removes all the asset vocabularies where companyId = ? from the database. 911 * 912 * @param companyId the company ID 913 * @throws SystemException if a system exception occurred 914 */ 915 public static void removeByCompanyId(long companyId) 916 throws com.liferay.portal.kernel.exception.SystemException { 917 getPersistence().removeByCompanyId(companyId); 918 } 919 920 /** 921 * Returns the number of asset vocabularies where companyId = ?. 922 * 923 * @param companyId the company ID 924 * @return the number of matching asset vocabularies 925 * @throws SystemException if a system exception occurred 926 */ 927 public static int countByCompanyId(long companyId) 928 throws com.liferay.portal.kernel.exception.SystemException { 929 return getPersistence().countByCompanyId(companyId); 930 } 931 932 /** 933 * Returns the asset vocabulary where groupId = ? and name = ? or throws a {@link com.liferay.portlet.asset.NoSuchVocabularyException} if it could not be found. 934 * 935 * @param groupId the group ID 936 * @param name the name 937 * @return the matching asset vocabulary 938 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a matching asset vocabulary could not be found 939 * @throws SystemException if a system exception occurred 940 */ 941 public static com.liferay.portlet.asset.model.AssetVocabulary findByG_N( 942 long groupId, java.lang.String name) 943 throws com.liferay.portal.kernel.exception.SystemException, 944 com.liferay.portlet.asset.NoSuchVocabularyException { 945 return getPersistence().findByG_N(groupId, name); 946 } 947 948 /** 949 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 950 * 951 * @param groupId the group ID 952 * @param name the name 953 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 954 * @throws SystemException if a system exception occurred 955 */ 956 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByG_N( 957 long groupId, java.lang.String name) 958 throws com.liferay.portal.kernel.exception.SystemException { 959 return getPersistence().fetchByG_N(groupId, name); 960 } 961 962 /** 963 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 964 * 965 * @param groupId the group ID 966 * @param name the name 967 * @param retrieveFromCache whether to use the finder cache 968 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 969 * @throws SystemException if a system exception occurred 970 */ 971 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByG_N( 972 long groupId, java.lang.String name, boolean retrieveFromCache) 973 throws com.liferay.portal.kernel.exception.SystemException { 974 return getPersistence().fetchByG_N(groupId, name, retrieveFromCache); 975 } 976 977 /** 978 * Removes the asset vocabulary where groupId = ? and name = ? from the database. 979 * 980 * @param groupId the group ID 981 * @param name the name 982 * @return the asset vocabulary that was removed 983 * @throws SystemException if a system exception occurred 984 */ 985 public static com.liferay.portlet.asset.model.AssetVocabulary removeByG_N( 986 long groupId, java.lang.String name) 987 throws com.liferay.portal.kernel.exception.SystemException, 988 com.liferay.portlet.asset.NoSuchVocabularyException { 989 return getPersistence().removeByG_N(groupId, name); 990 } 991 992 /** 993 * Returns the number of asset vocabularies where groupId = ? and name = ?. 994 * 995 * @param groupId the group ID 996 * @param name the name 997 * @return the number of matching asset vocabularies 998 * @throws SystemException if a system exception occurred 999 */ 1000 public static int countByG_N(long groupId, java.lang.String name) 1001 throws com.liferay.portal.kernel.exception.SystemException { 1002 return getPersistence().countByG_N(groupId, name); 1003 } 1004 1005 /** 1006 * Caches the asset vocabulary in the entity cache if it is enabled. 1007 * 1008 * @param assetVocabulary the asset vocabulary 1009 */ 1010 public static void cacheResult( 1011 com.liferay.portlet.asset.model.AssetVocabulary assetVocabulary) { 1012 getPersistence().cacheResult(assetVocabulary); 1013 } 1014 1015 /** 1016 * Caches the asset vocabularies in the entity cache if it is enabled. 1017 * 1018 * @param assetVocabularies the asset vocabularies 1019 */ 1020 public static void cacheResult( 1021 java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> assetVocabularies) { 1022 getPersistence().cacheResult(assetVocabularies); 1023 } 1024 1025 /** 1026 * Creates a new asset vocabulary with the primary key. Does not add the asset vocabulary to the database. 1027 * 1028 * @param vocabularyId the primary key for the new asset vocabulary 1029 * @return the new asset vocabulary 1030 */ 1031 public static com.liferay.portlet.asset.model.AssetVocabulary create( 1032 long vocabularyId) { 1033 return getPersistence().create(vocabularyId); 1034 } 1035 1036 /** 1037 * Removes the asset vocabulary with the primary key from the database. Also notifies the appropriate model listeners. 1038 * 1039 * @param vocabularyId the primary key of the asset vocabulary 1040 * @return the asset vocabulary that was removed 1041 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1042 * @throws SystemException if a system exception occurred 1043 */ 1044 public static com.liferay.portlet.asset.model.AssetVocabulary remove( 1045 long vocabularyId) 1046 throws com.liferay.portal.kernel.exception.SystemException, 1047 com.liferay.portlet.asset.NoSuchVocabularyException { 1048 return getPersistence().remove(vocabularyId); 1049 } 1050 1051 public static com.liferay.portlet.asset.model.AssetVocabulary updateImpl( 1052 com.liferay.portlet.asset.model.AssetVocabulary assetVocabulary) 1053 throws com.liferay.portal.kernel.exception.SystemException { 1054 return getPersistence().updateImpl(assetVocabulary); 1055 } 1056 1057 /** 1058 * Returns the asset vocabulary with the primary key or throws a {@link com.liferay.portlet.asset.NoSuchVocabularyException} if it could not be found. 1059 * 1060 * @param vocabularyId the primary key of the asset vocabulary 1061 * @return the asset vocabulary 1062 * @throws com.liferay.portlet.asset.NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1063 * @throws SystemException if a system exception occurred 1064 */ 1065 public static com.liferay.portlet.asset.model.AssetVocabulary findByPrimaryKey( 1066 long vocabularyId) 1067 throws com.liferay.portal.kernel.exception.SystemException, 1068 com.liferay.portlet.asset.NoSuchVocabularyException { 1069 return getPersistence().findByPrimaryKey(vocabularyId); 1070 } 1071 1072 /** 1073 * Returns the asset vocabulary with the primary key or returns <code>null</code> if it could not be found. 1074 * 1075 * @param vocabularyId the primary key of the asset vocabulary 1076 * @return the asset vocabulary, or <code>null</code> if a asset vocabulary with the primary key could not be found 1077 * @throws SystemException if a system exception occurred 1078 */ 1079 public static com.liferay.portlet.asset.model.AssetVocabulary fetchByPrimaryKey( 1080 long vocabularyId) 1081 throws com.liferay.portal.kernel.exception.SystemException { 1082 return getPersistence().fetchByPrimaryKey(vocabularyId); 1083 } 1084 1085 /** 1086 * Returns all the asset vocabularies. 1087 * 1088 * @return the asset vocabularies 1089 * @throws SystemException if a system exception occurred 1090 */ 1091 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findAll() 1092 throws com.liferay.portal.kernel.exception.SystemException { 1093 return getPersistence().findAll(); 1094 } 1095 1096 /** 1097 * Returns a range of all the asset vocabularies. 1098 * 1099 * <p> 1100 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 1101 * </p> 1102 * 1103 * @param start the lower bound of the range of asset vocabularies 1104 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1105 * @return the range of asset vocabularies 1106 * @throws SystemException if a system exception occurred 1107 */ 1108 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findAll( 1109 int start, int end) 1110 throws com.liferay.portal.kernel.exception.SystemException { 1111 return getPersistence().findAll(start, end); 1112 } 1113 1114 /** 1115 * Returns an ordered range of all the asset vocabularies. 1116 * 1117 * <p> 1118 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.asset.model.impl.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. 1119 * </p> 1120 * 1121 * @param start the lower bound of the range of asset vocabularies 1122 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1123 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1124 * @return the ordered range of asset vocabularies 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> findAll( 1128 int start, int end, 1129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1130 throws com.liferay.portal.kernel.exception.SystemException { 1131 return getPersistence().findAll(start, end, orderByComparator); 1132 } 1133 1134 /** 1135 * Removes all the asset vocabularies from the database. 1136 * 1137 * @throws SystemException if a system exception occurred 1138 */ 1139 public static void removeAll() 1140 throws com.liferay.portal.kernel.exception.SystemException { 1141 getPersistence().removeAll(); 1142 } 1143 1144 /** 1145 * Returns the number of asset vocabularies. 1146 * 1147 * @return the number of asset vocabularies 1148 * @throws SystemException if a system exception occurred 1149 */ 1150 public static int countAll() 1151 throws com.liferay.portal.kernel.exception.SystemException { 1152 return getPersistence().countAll(); 1153 } 1154 1155 public static AssetVocabularyPersistence getPersistence() { 1156 if (_persistence == null) { 1157 _persistence = (AssetVocabularyPersistence)PortalBeanLocatorUtil.locate(AssetVocabularyPersistence.class.getName()); 1158 1159 ReferenceRegistry.registerReference(AssetVocabularyUtil.class, 1160 "_persistence"); 1161 } 1162 1163 return _persistence; 1164 } 1165 1166 /** 1167 * @deprecated As of 6.2.0 1168 */ 1169 public void setPersistence(AssetVocabularyPersistence persistence) { 1170 } 1171 1172 private static AssetVocabularyPersistence _persistence; 1173 }