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