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