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