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, boolean) 099 */ 100 public static BookmarksFolder update(BookmarksFolder bookmarksFolder, 101 boolean merge) throws SystemException { 102 return getPersistence().update(bookmarksFolder, merge); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 107 */ 108 public static BookmarksFolder update(BookmarksFolder bookmarksFolder, 109 boolean merge, ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(bookmarksFolder, merge, 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 boolean merge) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().updateImpl(bookmarksFolder, merge); 164 } 165 166 /** 167 * Returns the bookmarks folder with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 168 * 169 * @param folderId the primary key of the bookmarks folder 170 * @return the bookmarks folder 171 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 172 * @throws SystemException if a system exception occurred 173 */ 174 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByPrimaryKey( 175 long folderId) 176 throws com.liferay.portal.kernel.exception.SystemException, 177 com.liferay.portlet.bookmarks.NoSuchFolderException { 178 return getPersistence().findByPrimaryKey(folderId); 179 } 180 181 /** 182 * Returns the bookmarks folder with the primary key or returns <code>null</code> if it could not be found. 183 * 184 * @param folderId the primary key of the bookmarks folder 185 * @return the bookmarks folder, or <code>null</code> if a bookmarks folder with the primary key could not be found 186 * @throws SystemException if a system exception occurred 187 */ 188 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByPrimaryKey( 189 long folderId) 190 throws com.liferay.portal.kernel.exception.SystemException { 191 return getPersistence().fetchByPrimaryKey(folderId); 192 } 193 194 /** 195 * Returns all the bookmarks folders where resourceBlockId = ?. 196 * 197 * @param resourceBlockId the resource block ID 198 * @return the matching bookmarks folders 199 * @throws SystemException if a system exception occurred 200 */ 201 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 202 long resourceBlockId) 203 throws com.liferay.portal.kernel.exception.SystemException { 204 return getPersistence().findByResourceBlockId(resourceBlockId); 205 } 206 207 /** 208 * Returns a range of all the bookmarks folders where resourceBlockId = ?. 209 * 210 * <p> 211 * 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. 212 * </p> 213 * 214 * @param resourceBlockId the resource block ID 215 * @param start the lower bound of the range of bookmarks folders 216 * @param end the upper bound of the range of bookmarks folders (not inclusive) 217 * @return the range of matching bookmarks folders 218 * @throws SystemException if a system exception occurred 219 */ 220 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 221 long resourceBlockId, int start, int end) 222 throws com.liferay.portal.kernel.exception.SystemException { 223 return getPersistence() 224 .findByResourceBlockId(resourceBlockId, start, end); 225 } 226 227 /** 228 * Returns an ordered range of all the bookmarks folders where resourceBlockId = ?. 229 * 230 * <p> 231 * 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. 232 * </p> 233 * 234 * @param resourceBlockId the resource block ID 235 * @param start the lower bound of the range of bookmarks folders 236 * @param end the upper bound of the range of bookmarks folders (not inclusive) 237 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 238 * @return the ordered range of matching bookmarks folders 239 * @throws SystemException if a system exception occurred 240 */ 241 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 242 long resourceBlockId, int start, int end, 243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 244 throws com.liferay.portal.kernel.exception.SystemException { 245 return getPersistence() 246 .findByResourceBlockId(resourceBlockId, start, end, 247 orderByComparator); 248 } 249 250 /** 251 * Returns the first bookmarks folder in the ordered set where resourceBlockId = ?. 252 * 253 * <p> 254 * 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. 255 * </p> 256 * 257 * @param resourceBlockId the resource block ID 258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 259 * @return the first matching bookmarks folder 260 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 261 * @throws SystemException if a system exception occurred 262 */ 263 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_First( 264 long resourceBlockId, 265 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 266 throws com.liferay.portal.kernel.exception.SystemException, 267 com.liferay.portlet.bookmarks.NoSuchFolderException { 268 return getPersistence() 269 .findByResourceBlockId_First(resourceBlockId, 270 orderByComparator); 271 } 272 273 /** 274 * Returns the last bookmarks folder in the ordered set where resourceBlockId = ?. 275 * 276 * <p> 277 * 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. 278 * </p> 279 * 280 * @param resourceBlockId the resource block ID 281 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 282 * @return the last matching bookmarks folder 283 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 284 * @throws SystemException if a system exception occurred 285 */ 286 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_Last( 287 long resourceBlockId, 288 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 289 throws com.liferay.portal.kernel.exception.SystemException, 290 com.liferay.portlet.bookmarks.NoSuchFolderException { 291 return getPersistence() 292 .findByResourceBlockId_Last(resourceBlockId, 293 orderByComparator); 294 } 295 296 /** 297 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where resourceBlockId = ?. 298 * 299 * <p> 300 * 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. 301 * </p> 302 * 303 * @param folderId the primary key of the current bookmarks folder 304 * @param resourceBlockId the resource block ID 305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 306 * @return the previous, current, and next bookmarks folder 307 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 308 * @throws SystemException if a system exception occurred 309 */ 310 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByResourceBlockId_PrevAndNext( 311 long folderId, long resourceBlockId, 312 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 313 throws com.liferay.portal.kernel.exception.SystemException, 314 com.liferay.portlet.bookmarks.NoSuchFolderException { 315 return getPersistence() 316 .findByResourceBlockId_PrevAndNext(folderId, 317 resourceBlockId, orderByComparator); 318 } 319 320 /** 321 * Returns all the bookmarks folders where uuid = ?. 322 * 323 * @param uuid the uuid 324 * @return the matching bookmarks folders 325 * @throws SystemException if a system exception occurred 326 */ 327 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 328 java.lang.String uuid) 329 throws com.liferay.portal.kernel.exception.SystemException { 330 return getPersistence().findByUuid(uuid); 331 } 332 333 /** 334 * Returns a range of all the bookmarks folders where uuid = ?. 335 * 336 * <p> 337 * 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. 338 * </p> 339 * 340 * @param uuid the uuid 341 * @param start the lower bound of the range of bookmarks folders 342 * @param end the upper bound of the range of bookmarks folders (not inclusive) 343 * @return the range of matching bookmarks folders 344 * @throws SystemException if a system exception occurred 345 */ 346 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 347 java.lang.String uuid, int start, int end) 348 throws com.liferay.portal.kernel.exception.SystemException { 349 return getPersistence().findByUuid(uuid, start, end); 350 } 351 352 /** 353 * Returns an ordered range of all the bookmarks folders where uuid = ?. 354 * 355 * <p> 356 * 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. 357 * </p> 358 * 359 * @param uuid the uuid 360 * @param start the lower bound of the range of bookmarks folders 361 * @param end the upper bound of the range of bookmarks folders (not inclusive) 362 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 363 * @return the ordered range of matching bookmarks folders 364 * @throws SystemException if a system exception occurred 365 */ 366 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 367 java.lang.String uuid, int start, int end, 368 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 369 throws com.liferay.portal.kernel.exception.SystemException { 370 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 371 } 372 373 /** 374 * Returns the first bookmarks folder in the ordered set 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 orderByComparator the comparator to order the set by (optionally <code>null</code>) 382 * @return the first matching bookmarks folder 383 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 384 * @throws SystemException if a system exception occurred 385 */ 386 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_First( 387 java.lang.String uuid, 388 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 389 throws com.liferay.portal.kernel.exception.SystemException, 390 com.liferay.portlet.bookmarks.NoSuchFolderException { 391 return getPersistence().findByUuid_First(uuid, orderByComparator); 392 } 393 394 /** 395 * Returns the last bookmarks folder in the ordered set where uuid = ?. 396 * 397 * <p> 398 * 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. 399 * </p> 400 * 401 * @param uuid the uuid 402 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 403 * @return the last matching bookmarks folder 404 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 405 * @throws SystemException if a system exception occurred 406 */ 407 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_Last( 408 java.lang.String uuid, 409 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 410 throws com.liferay.portal.kernel.exception.SystemException, 411 com.liferay.portlet.bookmarks.NoSuchFolderException { 412 return getPersistence().findByUuid_Last(uuid, orderByComparator); 413 } 414 415 /** 416 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = ?. 417 * 418 * <p> 419 * 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. 420 * </p> 421 * 422 * @param folderId the primary key of the current bookmarks folder 423 * @param uuid the uuid 424 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 425 * @return the previous, current, and next bookmarks folder 426 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 427 * @throws SystemException if a system exception occurred 428 */ 429 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_PrevAndNext( 430 long folderId, java.lang.String uuid, 431 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 432 throws com.liferay.portal.kernel.exception.SystemException, 433 com.liferay.portlet.bookmarks.NoSuchFolderException { 434 return getPersistence() 435 .findByUuid_PrevAndNext(folderId, uuid, orderByComparator); 436 } 437 438 /** 439 * Returns the bookmarks folder where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 440 * 441 * @param uuid the uuid 442 * @param groupId the group ID 443 * @return the matching bookmarks folder 444 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 445 * @throws SystemException if a system exception occurred 446 */ 447 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUUID_G( 448 java.lang.String uuid, long groupId) 449 throws com.liferay.portal.kernel.exception.SystemException, 450 com.liferay.portlet.bookmarks.NoSuchFolderException { 451 return getPersistence().findByUUID_G(uuid, groupId); 452 } 453 454 /** 455 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 456 * 457 * @param uuid the uuid 458 * @param groupId the group ID 459 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 460 * @throws SystemException if a system exception occurred 461 */ 462 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 463 java.lang.String uuid, long groupId) 464 throws com.liferay.portal.kernel.exception.SystemException { 465 return getPersistence().fetchByUUID_G(uuid, groupId); 466 } 467 468 /** 469 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 470 * 471 * @param uuid the uuid 472 * @param groupId the group ID 473 * @param retrieveFromCache whether to use the finder cache 474 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 475 * @throws SystemException if a system exception occurred 476 */ 477 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 478 java.lang.String uuid, long groupId, boolean retrieveFromCache) 479 throws com.liferay.portal.kernel.exception.SystemException { 480 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 481 } 482 483 /** 484 * Returns all the bookmarks folders where groupId = ?. 485 * 486 * @param groupId the group ID 487 * @return the matching bookmarks folders 488 * @throws SystemException if a system exception occurred 489 */ 490 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 491 long groupId) 492 throws com.liferay.portal.kernel.exception.SystemException { 493 return getPersistence().findByGroupId(groupId); 494 } 495 496 /** 497 * Returns a range of all the bookmarks folders where groupId = ?. 498 * 499 * <p> 500 * 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. 501 * </p> 502 * 503 * @param groupId the group ID 504 * @param start the lower bound of the range of bookmarks folders 505 * @param end the upper bound of the range of bookmarks folders (not inclusive) 506 * @return the range of matching bookmarks folders 507 * @throws SystemException if a system exception occurred 508 */ 509 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 510 long groupId, int start, int end) 511 throws com.liferay.portal.kernel.exception.SystemException { 512 return getPersistence().findByGroupId(groupId, start, end); 513 } 514 515 /** 516 * Returns an ordered range of all the bookmarks folders where groupId = ?. 517 * 518 * <p> 519 * 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. 520 * </p> 521 * 522 * @param groupId the group ID 523 * @param start the lower bound of the range of bookmarks folders 524 * @param end the upper bound of the range of bookmarks folders (not inclusive) 525 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 526 * @return the ordered range of matching bookmarks folders 527 * @throws SystemException if a system exception occurred 528 */ 529 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 530 long groupId, int start, int end, 531 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 532 throws com.liferay.portal.kernel.exception.SystemException { 533 return getPersistence() 534 .findByGroupId(groupId, start, end, orderByComparator); 535 } 536 537 /** 538 * Returns the first bookmarks folder in the ordered set where groupId = ?. 539 * 540 * <p> 541 * 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. 542 * </p> 543 * 544 * @param groupId the group ID 545 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 546 * @return the first matching bookmarks folder 547 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 548 * @throws SystemException if a system exception occurred 549 */ 550 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_First( 551 long groupId, 552 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 553 throws com.liferay.portal.kernel.exception.SystemException, 554 com.liferay.portlet.bookmarks.NoSuchFolderException { 555 return getPersistence().findByGroupId_First(groupId, orderByComparator); 556 } 557 558 /** 559 * Returns the last bookmarks folder in the ordered set where groupId = ?. 560 * 561 * <p> 562 * 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. 563 * </p> 564 * 565 * @param groupId the group ID 566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 567 * @return the last matching bookmarks folder 568 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 569 * @throws SystemException if a system exception occurred 570 */ 571 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_Last( 572 long groupId, 573 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 574 throws com.liferay.portal.kernel.exception.SystemException, 575 com.liferay.portlet.bookmarks.NoSuchFolderException { 576 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 577 } 578 579 /** 580 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ?. 581 * 582 * <p> 583 * 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. 584 * </p> 585 * 586 * @param folderId the primary key of the current bookmarks folder 587 * @param groupId the group ID 588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 589 * @return the previous, current, and next bookmarks folder 590 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 591 * @throws SystemException if a system exception occurred 592 */ 593 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByGroupId_PrevAndNext( 594 long folderId, long groupId, 595 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 596 throws com.liferay.portal.kernel.exception.SystemException, 597 com.liferay.portlet.bookmarks.NoSuchFolderException { 598 return getPersistence() 599 .findByGroupId_PrevAndNext(folderId, groupId, 600 orderByComparator); 601 } 602 603 /** 604 * Returns all the bookmarks folders that the user has permission to view where groupId = ?. 605 * 606 * @param groupId the group ID 607 * @return the matching bookmarks folders that the user has permission to view 608 * @throws SystemException if a system exception occurred 609 */ 610 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 611 long groupId) 612 throws com.liferay.portal.kernel.exception.SystemException { 613 return getPersistence().filterFindByGroupId(groupId); 614 } 615 616 /** 617 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ?. 618 * 619 * <p> 620 * 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. 621 * </p> 622 * 623 * @param groupId the group ID 624 * @param start the lower bound of the range of bookmarks folders 625 * @param end the upper bound of the range of bookmarks folders (not inclusive) 626 * @return the range of matching bookmarks folders that the user has permission to view 627 * @throws SystemException if a system exception occurred 628 */ 629 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 630 long groupId, int start, int end) 631 throws com.liferay.portal.kernel.exception.SystemException { 632 return getPersistence().filterFindByGroupId(groupId, start, end); 633 } 634 635 /** 636 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ?. 637 * 638 * <p> 639 * 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. 640 * </p> 641 * 642 * @param groupId the group ID 643 * @param start the lower bound of the range of bookmarks folders 644 * @param end the upper bound of the range of bookmarks folders (not inclusive) 645 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 646 * @return the ordered range of matching bookmarks folders that the user has permission to view 647 * @throws SystemException if a system exception occurred 648 */ 649 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 650 long groupId, int start, int end, 651 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 652 throws com.liferay.portal.kernel.exception.SystemException { 653 return getPersistence() 654 .filterFindByGroupId(groupId, start, end, orderByComparator); 655 } 656 657 /** 658 * 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 = ?. 659 * 660 * @param folderId the primary key of the current bookmarks folder 661 * @param groupId the group ID 662 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 663 * @return the previous, current, and next bookmarks folder 664 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 665 * @throws SystemException if a system exception occurred 666 */ 667 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByGroupId_PrevAndNext( 668 long folderId, long groupId, 669 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 670 throws com.liferay.portal.kernel.exception.SystemException, 671 com.liferay.portlet.bookmarks.NoSuchFolderException { 672 return getPersistence() 673 .filterFindByGroupId_PrevAndNext(folderId, groupId, 674 orderByComparator); 675 } 676 677 /** 678 * Returns all the bookmarks folders where companyId = ?. 679 * 680 * @param companyId the company ID 681 * @return the matching bookmarks folders 682 * @throws SystemException if a system exception occurred 683 */ 684 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 685 long companyId) 686 throws com.liferay.portal.kernel.exception.SystemException { 687 return getPersistence().findByCompanyId(companyId); 688 } 689 690 /** 691 * Returns a range of all the bookmarks folders where companyId = ?. 692 * 693 * <p> 694 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 695 * </p> 696 * 697 * @param companyId the company ID 698 * @param start the lower bound of the range of bookmarks folders 699 * @param end the upper bound of the range of bookmarks folders (not inclusive) 700 * @return the range of matching bookmarks folders 701 * @throws SystemException if a system exception occurred 702 */ 703 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 704 long companyId, int start, int end) 705 throws com.liferay.portal.kernel.exception.SystemException { 706 return getPersistence().findByCompanyId(companyId, start, end); 707 } 708 709 /** 710 * Returns an ordered range of all the bookmarks folders where companyId = ?. 711 * 712 * <p> 713 * 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. 714 * </p> 715 * 716 * @param companyId the company ID 717 * @param start the lower bound of the range of bookmarks folders 718 * @param end the upper bound of the range of bookmarks folders (not inclusive) 719 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 720 * @return the ordered range of matching bookmarks folders 721 * @throws SystemException if a system exception occurred 722 */ 723 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 724 long companyId, int start, int end, 725 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 726 throws com.liferay.portal.kernel.exception.SystemException { 727 return getPersistence() 728 .findByCompanyId(companyId, start, end, orderByComparator); 729 } 730 731 /** 732 * Returns the first bookmarks folder in the ordered set where companyId = ?. 733 * 734 * <p> 735 * 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. 736 * </p> 737 * 738 * @param companyId the company ID 739 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 740 * @return the first matching bookmarks folder 741 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 742 * @throws SystemException if a system exception occurred 743 */ 744 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_First( 745 long companyId, 746 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 747 throws com.liferay.portal.kernel.exception.SystemException, 748 com.liferay.portlet.bookmarks.NoSuchFolderException { 749 return getPersistence() 750 .findByCompanyId_First(companyId, orderByComparator); 751 } 752 753 /** 754 * Returns the last bookmarks folder in the ordered set where companyId = ?. 755 * 756 * <p> 757 * 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. 758 * </p> 759 * 760 * @param companyId the company ID 761 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 762 * @return the last matching bookmarks folder 763 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 764 * @throws SystemException if a system exception occurred 765 */ 766 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_Last( 767 long companyId, 768 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 769 throws com.liferay.portal.kernel.exception.SystemException, 770 com.liferay.portlet.bookmarks.NoSuchFolderException { 771 return getPersistence() 772 .findByCompanyId_Last(companyId, orderByComparator); 773 } 774 775 /** 776 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = ?. 777 * 778 * <p> 779 * 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. 780 * </p> 781 * 782 * @param folderId the primary key of the current bookmarks folder 783 * @param companyId the company ID 784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 785 * @return the previous, current, and next bookmarks folder 786 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 787 * @throws SystemException if a system exception occurred 788 */ 789 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByCompanyId_PrevAndNext( 790 long folderId, long companyId, 791 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 792 throws com.liferay.portal.kernel.exception.SystemException, 793 com.liferay.portlet.bookmarks.NoSuchFolderException { 794 return getPersistence() 795 .findByCompanyId_PrevAndNext(folderId, companyId, 796 orderByComparator); 797 } 798 799 /** 800 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ?. 801 * 802 * @param groupId the group ID 803 * @param parentFolderId the parent folder ID 804 * @return the matching bookmarks folders 805 * @throws SystemException if a system exception occurred 806 */ 807 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 808 long groupId, long parentFolderId) 809 throws com.liferay.portal.kernel.exception.SystemException { 810 return getPersistence().findByG_P(groupId, parentFolderId); 811 } 812 813 /** 814 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 815 * 816 * <p> 817 * 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. 818 * </p> 819 * 820 * @param groupId the group ID 821 * @param parentFolderId the parent folder ID 822 * @param start the lower bound of the range of bookmarks folders 823 * @param end the upper bound of the range of bookmarks folders (not inclusive) 824 * @return the range of matching bookmarks folders 825 * @throws SystemException if a system exception occurred 826 */ 827 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 828 long groupId, long parentFolderId, int start, int end) 829 throws com.liferay.portal.kernel.exception.SystemException { 830 return getPersistence().findByG_P(groupId, parentFolderId, start, end); 831 } 832 833 /** 834 * Returns an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 835 * 836 * <p> 837 * 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. 838 * </p> 839 * 840 * @param groupId the group ID 841 * @param parentFolderId the parent folder ID 842 * @param start the lower bound of the range of bookmarks folders 843 * @param end the upper bound of the range of bookmarks folders (not inclusive) 844 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 845 * @return the ordered range of matching bookmarks folders 846 * @throws SystemException if a system exception occurred 847 */ 848 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 849 long groupId, long parentFolderId, int start, int end, 850 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 851 throws com.liferay.portal.kernel.exception.SystemException { 852 return getPersistence() 853 .findByG_P(groupId, parentFolderId, start, end, 854 orderByComparator); 855 } 856 857 /** 858 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 859 * 860 * <p> 861 * 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. 862 * </p> 863 * 864 * @param groupId the group ID 865 * @param parentFolderId the parent folder ID 866 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 867 * @return the first matching bookmarks folder 868 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 869 * @throws SystemException if a system exception occurred 870 */ 871 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_First( 872 long groupId, long parentFolderId, 873 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 874 throws com.liferay.portal.kernel.exception.SystemException, 875 com.liferay.portlet.bookmarks.NoSuchFolderException { 876 return getPersistence() 877 .findByG_P_First(groupId, parentFolderId, orderByComparator); 878 } 879 880 /** 881 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 882 * 883 * <p> 884 * 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. 885 * </p> 886 * 887 * @param groupId the group ID 888 * @param parentFolderId the parent folder ID 889 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 890 * @return the last matching bookmarks folder 891 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 892 * @throws SystemException if a system exception occurred 893 */ 894 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_Last( 895 long groupId, long parentFolderId, 896 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 897 throws com.liferay.portal.kernel.exception.SystemException, 898 com.liferay.portlet.bookmarks.NoSuchFolderException { 899 return getPersistence() 900 .findByG_P_Last(groupId, parentFolderId, orderByComparator); 901 } 902 903 /** 904 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 905 * 906 * <p> 907 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 908 * </p> 909 * 910 * @param folderId the primary key of the current bookmarks folder 911 * @param groupId the group ID 912 * @param parentFolderId the parent folder ID 913 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 914 * @return the previous, current, and next bookmarks folder 915 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 916 * @throws SystemException if a system exception occurred 917 */ 918 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_PrevAndNext( 919 long folderId, long groupId, long parentFolderId, 920 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 921 throws com.liferay.portal.kernel.exception.SystemException, 922 com.liferay.portlet.bookmarks.NoSuchFolderException { 923 return getPersistence() 924 .findByG_P_PrevAndNext(folderId, groupId, parentFolderId, 925 orderByComparator); 926 } 927 928 /** 929 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 930 * 931 * @param groupId the group ID 932 * @param parentFolderId the parent folder ID 933 * @return the matching bookmarks folders that the user has permission to view 934 * @throws SystemException if a system exception occurred 935 */ 936 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 937 long groupId, long parentFolderId) 938 throws com.liferay.portal.kernel.exception.SystemException { 939 return getPersistence().filterFindByG_P(groupId, parentFolderId); 940 } 941 942 /** 943 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 944 * 945 * <p> 946 * 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. 947 * </p> 948 * 949 * @param groupId the group ID 950 * @param parentFolderId the parent folder ID 951 * @param start the lower bound of the range of bookmarks folders 952 * @param end the upper bound of the range of bookmarks folders (not inclusive) 953 * @return the range of matching bookmarks folders that the user has permission to view 954 * @throws SystemException if a system exception occurred 955 */ 956 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 957 long groupId, long parentFolderId, int start, int end) 958 throws com.liferay.portal.kernel.exception.SystemException { 959 return getPersistence() 960 .filterFindByG_P(groupId, parentFolderId, start, end); 961 } 962 963 /** 964 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ?. 965 * 966 * <p> 967 * 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. 968 * </p> 969 * 970 * @param groupId the group ID 971 * @param parentFolderId the parent folder ID 972 * @param start the lower bound of the range of bookmarks folders 973 * @param end the upper bound of the range of bookmarks folders (not inclusive) 974 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 975 * @return the ordered range of matching bookmarks folders that the user has permission to view 976 * @throws SystemException if a system exception occurred 977 */ 978 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 979 long groupId, long parentFolderId, int start, int end, 980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 981 throws com.liferay.portal.kernel.exception.SystemException { 982 return getPersistence() 983 .filterFindByG_P(groupId, parentFolderId, start, end, 984 orderByComparator); 985 } 986 987 /** 988 * 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 = ?. 989 * 990 * @param folderId the primary key of the current bookmarks folder 991 * @param groupId the group ID 992 * @param parentFolderId the parent folder ID 993 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 994 * @return the previous, current, and next bookmarks folder 995 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 996 * @throws SystemException if a system exception occurred 997 */ 998 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_PrevAndNext( 999 long folderId, long groupId, long parentFolderId, 1000 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1001 throws com.liferay.portal.kernel.exception.SystemException, 1002 com.liferay.portlet.bookmarks.NoSuchFolderException { 1003 return getPersistence() 1004 .filterFindByG_P_PrevAndNext(folderId, groupId, 1005 parentFolderId, orderByComparator); 1006 } 1007 1008 /** 1009 * Returns all the bookmarks folders. 1010 * 1011 * @return the bookmarks folders 1012 * @throws SystemException if a system exception occurred 1013 */ 1014 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll() 1015 throws com.liferay.portal.kernel.exception.SystemException { 1016 return getPersistence().findAll(); 1017 } 1018 1019 /** 1020 * Returns a range of all the bookmarks folders. 1021 * 1022 * <p> 1023 * 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. 1024 * </p> 1025 * 1026 * @param start the lower bound of the range of bookmarks folders 1027 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1028 * @return the range of bookmarks folders 1029 * @throws SystemException if a system exception occurred 1030 */ 1031 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 1032 int start, int end) 1033 throws com.liferay.portal.kernel.exception.SystemException { 1034 return getPersistence().findAll(start, end); 1035 } 1036 1037 /** 1038 * Returns an ordered range of all the bookmarks folders. 1039 * 1040 * <p> 1041 * 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. 1042 * </p> 1043 * 1044 * @param start the lower bound of the range of bookmarks folders 1045 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1046 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1047 * @return the ordered range of bookmarks folders 1048 * @throws SystemException if a system exception occurred 1049 */ 1050 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 1051 int start, int end, 1052 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1053 throws com.liferay.portal.kernel.exception.SystemException { 1054 return getPersistence().findAll(start, end, orderByComparator); 1055 } 1056 1057 /** 1058 * Removes all the bookmarks folders where resourceBlockId = ? from the database. 1059 * 1060 * @param resourceBlockId the resource block ID 1061 * @throws SystemException if a system exception occurred 1062 */ 1063 public static void removeByResourceBlockId(long resourceBlockId) 1064 throws com.liferay.portal.kernel.exception.SystemException { 1065 getPersistence().removeByResourceBlockId(resourceBlockId); 1066 } 1067 1068 /** 1069 * Removes all the bookmarks folders where uuid = ? from the database. 1070 * 1071 * @param uuid the uuid 1072 * @throws SystemException if a system exception occurred 1073 */ 1074 public static void removeByUuid(java.lang.String uuid) 1075 throws com.liferay.portal.kernel.exception.SystemException { 1076 getPersistence().removeByUuid(uuid); 1077 } 1078 1079 /** 1080 * Removes the bookmarks folder where uuid = ? and groupId = ? from the database. 1081 * 1082 * @param uuid the uuid 1083 * @param groupId the group ID 1084 * @throws SystemException if a system exception occurred 1085 */ 1086 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1087 throws com.liferay.portal.kernel.exception.SystemException, 1088 com.liferay.portlet.bookmarks.NoSuchFolderException { 1089 getPersistence().removeByUUID_G(uuid, groupId); 1090 } 1091 1092 /** 1093 * Removes all the bookmarks folders where groupId = ? from the database. 1094 * 1095 * @param groupId the group ID 1096 * @throws SystemException if a system exception occurred 1097 */ 1098 public static void removeByGroupId(long groupId) 1099 throws com.liferay.portal.kernel.exception.SystemException { 1100 getPersistence().removeByGroupId(groupId); 1101 } 1102 1103 /** 1104 * Removes all the bookmarks folders where companyId = ? from the database. 1105 * 1106 * @param companyId the company ID 1107 * @throws SystemException if a system exception occurred 1108 */ 1109 public static void removeByCompanyId(long companyId) 1110 throws com.liferay.portal.kernel.exception.SystemException { 1111 getPersistence().removeByCompanyId(companyId); 1112 } 1113 1114 /** 1115 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? from the database. 1116 * 1117 * @param groupId the group ID 1118 * @param parentFolderId the parent folder ID 1119 * @throws SystemException if a system exception occurred 1120 */ 1121 public static void removeByG_P(long groupId, long parentFolderId) 1122 throws com.liferay.portal.kernel.exception.SystemException { 1123 getPersistence().removeByG_P(groupId, parentFolderId); 1124 } 1125 1126 /** 1127 * Removes all the bookmarks folders from the database. 1128 * 1129 * @throws SystemException if a system exception occurred 1130 */ 1131 public static void removeAll() 1132 throws com.liferay.portal.kernel.exception.SystemException { 1133 getPersistence().removeAll(); 1134 } 1135 1136 /** 1137 * Returns the number of bookmarks folders where resourceBlockId = ?. 1138 * 1139 * @param resourceBlockId the resource block ID 1140 * @return the number of matching bookmarks folders 1141 * @throws SystemException if a system exception occurred 1142 */ 1143 public static int countByResourceBlockId(long resourceBlockId) 1144 throws com.liferay.portal.kernel.exception.SystemException { 1145 return getPersistence().countByResourceBlockId(resourceBlockId); 1146 } 1147 1148 /** 1149 * Returns the number of bookmarks folders where uuid = ?. 1150 * 1151 * @param uuid the uuid 1152 * @return the number of matching bookmarks folders 1153 * @throws SystemException if a system exception occurred 1154 */ 1155 public static int countByUuid(java.lang.String uuid) 1156 throws com.liferay.portal.kernel.exception.SystemException { 1157 return getPersistence().countByUuid(uuid); 1158 } 1159 1160 /** 1161 * Returns the number of bookmarks folders where uuid = ? and groupId = ?. 1162 * 1163 * @param uuid the uuid 1164 * @param groupId the group ID 1165 * @return the number of matching bookmarks folders 1166 * @throws SystemException if a system exception occurred 1167 */ 1168 public static int countByUUID_G(java.lang.String uuid, long groupId) 1169 throws com.liferay.portal.kernel.exception.SystemException { 1170 return getPersistence().countByUUID_G(uuid, groupId); 1171 } 1172 1173 /** 1174 * Returns the number of bookmarks folders where groupId = ?. 1175 * 1176 * @param groupId the group ID 1177 * @return the number of matching bookmarks folders 1178 * @throws SystemException if a system exception occurred 1179 */ 1180 public static int countByGroupId(long groupId) 1181 throws com.liferay.portal.kernel.exception.SystemException { 1182 return getPersistence().countByGroupId(groupId); 1183 } 1184 1185 /** 1186 * Returns the number of bookmarks folders that the user has permission to view where groupId = ?. 1187 * 1188 * @param groupId the group ID 1189 * @return the number of matching bookmarks folders that the user has permission to view 1190 * @throws SystemException if a system exception occurred 1191 */ 1192 public static int filterCountByGroupId(long groupId) 1193 throws com.liferay.portal.kernel.exception.SystemException { 1194 return getPersistence().filterCountByGroupId(groupId); 1195 } 1196 1197 /** 1198 * Returns the number of bookmarks folders where companyId = ?. 1199 * 1200 * @param companyId the company ID 1201 * @return the number of matching bookmarks folders 1202 * @throws SystemException if a system exception occurred 1203 */ 1204 public static int countByCompanyId(long companyId) 1205 throws com.liferay.portal.kernel.exception.SystemException { 1206 return getPersistence().countByCompanyId(companyId); 1207 } 1208 1209 /** 1210 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ?. 1211 * 1212 * @param groupId the group ID 1213 * @param parentFolderId the parent folder ID 1214 * @return the number of matching bookmarks folders 1215 * @throws SystemException if a system exception occurred 1216 */ 1217 public static int countByG_P(long groupId, long parentFolderId) 1218 throws com.liferay.portal.kernel.exception.SystemException { 1219 return getPersistence().countByG_P(groupId, parentFolderId); 1220 } 1221 1222 /** 1223 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1224 * 1225 * @param groupId the group ID 1226 * @param parentFolderId the parent folder ID 1227 * @return the number of matching bookmarks folders that the user has permission to view 1228 * @throws SystemException if a system exception occurred 1229 */ 1230 public static int filterCountByG_P(long groupId, long parentFolderId) 1231 throws com.liferay.portal.kernel.exception.SystemException { 1232 return getPersistence().filterCountByG_P(groupId, parentFolderId); 1233 } 1234 1235 /** 1236 * Returns the number of bookmarks folders. 1237 * 1238 * @return the number of bookmarks folders 1239 * @throws SystemException if a system exception occurred 1240 */ 1241 public static int countAll() 1242 throws com.liferay.portal.kernel.exception.SystemException { 1243 return getPersistence().countAll(); 1244 } 1245 1246 public static BookmarksFolderPersistence getPersistence() { 1247 if (_persistence == null) { 1248 _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName()); 1249 1250 ReferenceRegistry.registerReference(BookmarksFolderUtil.class, 1251 "_persistence"); 1252 } 1253 1254 return _persistence; 1255 } 1256 1257 public void setPersistence(BookmarksFolderPersistence persistence) { 1258 _persistence = persistence; 1259 1260 ReferenceRegistry.registerReference(BookmarksFolderUtil.class, 1261 "_persistence"); 1262 } 1263 1264 private static BookmarksFolderPersistence _persistence; 1265 }