001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.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 * @param resourceBlockId the resource block ID 254 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 255 * @return the first matching bookmarks folder 256 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 257 * @throws SystemException if a system exception occurred 258 */ 259 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_First( 260 long resourceBlockId, 261 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 262 throws com.liferay.portal.kernel.exception.SystemException, 263 com.liferay.portlet.bookmarks.NoSuchFolderException { 264 return getPersistence() 265 .findByResourceBlockId_First(resourceBlockId, 266 orderByComparator); 267 } 268 269 /** 270 * Returns the first bookmarks folder in the ordered set where resourceBlockId = ?. 271 * 272 * @param resourceBlockId the resource block ID 273 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 274 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 275 * @throws SystemException if a system exception occurred 276 */ 277 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_First( 278 long resourceBlockId, 279 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 280 throws com.liferay.portal.kernel.exception.SystemException { 281 return getPersistence() 282 .fetchByResourceBlockId_First(resourceBlockId, 283 orderByComparator); 284 } 285 286 /** 287 * Returns the last bookmarks folder in the ordered set where resourceBlockId = ?. 288 * 289 * @param resourceBlockId the resource block ID 290 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 291 * @return the last matching bookmarks folder 292 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 293 * @throws SystemException if a system exception occurred 294 */ 295 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_Last( 296 long resourceBlockId, 297 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 298 throws com.liferay.portal.kernel.exception.SystemException, 299 com.liferay.portlet.bookmarks.NoSuchFolderException { 300 return getPersistence() 301 .findByResourceBlockId_Last(resourceBlockId, 302 orderByComparator); 303 } 304 305 /** 306 * Returns the last bookmarks folder in the ordered set where resourceBlockId = ?. 307 * 308 * @param resourceBlockId the resource block ID 309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 310 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 311 * @throws SystemException if a system exception occurred 312 */ 313 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_Last( 314 long resourceBlockId, 315 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 316 throws com.liferay.portal.kernel.exception.SystemException { 317 return getPersistence() 318 .fetchByResourceBlockId_Last(resourceBlockId, 319 orderByComparator); 320 } 321 322 /** 323 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where resourceBlockId = ?. 324 * 325 * @param folderId the primary key of the current bookmarks folder 326 * @param resourceBlockId the resource block ID 327 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 328 * @return the previous, current, and next bookmarks folder 329 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 330 * @throws SystemException if a system exception occurred 331 */ 332 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByResourceBlockId_PrevAndNext( 333 long folderId, long resourceBlockId, 334 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 335 throws com.liferay.portal.kernel.exception.SystemException, 336 com.liferay.portlet.bookmarks.NoSuchFolderException { 337 return getPersistence() 338 .findByResourceBlockId_PrevAndNext(folderId, 339 resourceBlockId, orderByComparator); 340 } 341 342 /** 343 * Returns all the bookmarks folders where uuid = ?. 344 * 345 * @param uuid the uuid 346 * @return the matching bookmarks folders 347 * @throws SystemException if a system exception occurred 348 */ 349 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 350 java.lang.String uuid) 351 throws com.liferay.portal.kernel.exception.SystemException { 352 return getPersistence().findByUuid(uuid); 353 } 354 355 /** 356 * Returns a range of all the bookmarks folders where uuid = ?. 357 * 358 * <p> 359 * 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. 360 * </p> 361 * 362 * @param uuid the uuid 363 * @param start the lower bound of the range of bookmarks folders 364 * @param end the upper bound of the range of bookmarks folders (not inclusive) 365 * @return the range of matching bookmarks folders 366 * @throws SystemException if a system exception occurred 367 */ 368 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 369 java.lang.String uuid, int start, int end) 370 throws com.liferay.portal.kernel.exception.SystemException { 371 return getPersistence().findByUuid(uuid, start, end); 372 } 373 374 /** 375 * Returns an ordered range of all the bookmarks folders where uuid = ?. 376 * 377 * <p> 378 * 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. 379 * </p> 380 * 381 * @param uuid the uuid 382 * @param start the lower bound of the range of bookmarks folders 383 * @param end the upper bound of the range of bookmarks folders (not inclusive) 384 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 385 * @return the ordered range of matching bookmarks folders 386 * @throws SystemException if a system exception occurred 387 */ 388 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 389 java.lang.String uuid, int start, int end, 390 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 391 throws com.liferay.portal.kernel.exception.SystemException { 392 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 393 } 394 395 /** 396 * Returns the first bookmarks folder in the ordered set where uuid = ?. 397 * 398 * @param uuid the uuid 399 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 400 * @return the first matching bookmarks folder 401 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 402 * @throws SystemException if a system exception occurred 403 */ 404 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_First( 405 java.lang.String uuid, 406 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 407 throws com.liferay.portal.kernel.exception.SystemException, 408 com.liferay.portlet.bookmarks.NoSuchFolderException { 409 return getPersistence().findByUuid_First(uuid, orderByComparator); 410 } 411 412 /** 413 * Returns the first bookmarks folder in the ordered set where uuid = ?. 414 * 415 * @param uuid the uuid 416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 417 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 418 * @throws SystemException if a system exception occurred 419 */ 420 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_First( 421 java.lang.String uuid, 422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 423 throws com.liferay.portal.kernel.exception.SystemException { 424 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 425 } 426 427 /** 428 * Returns the last bookmarks folder in the ordered set where uuid = ?. 429 * 430 * @param uuid the uuid 431 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 432 * @return the last matching bookmarks folder 433 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 434 * @throws SystemException if a system exception occurred 435 */ 436 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_Last( 437 java.lang.String uuid, 438 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 439 throws com.liferay.portal.kernel.exception.SystemException, 440 com.liferay.portlet.bookmarks.NoSuchFolderException { 441 return getPersistence().findByUuid_Last(uuid, orderByComparator); 442 } 443 444 /** 445 * Returns the last bookmarks folder in the ordered set where uuid = ?. 446 * 447 * @param uuid the uuid 448 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 449 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 450 * @throws SystemException if a system exception occurred 451 */ 452 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_Last( 453 java.lang.String uuid, 454 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 455 throws com.liferay.portal.kernel.exception.SystemException { 456 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 457 } 458 459 /** 460 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = ?. 461 * 462 * @param folderId the primary key of the current bookmarks folder 463 * @param uuid the uuid 464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 465 * @return the previous, current, and next bookmarks folder 466 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 467 * @throws SystemException if a system exception occurred 468 */ 469 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_PrevAndNext( 470 long folderId, java.lang.String uuid, 471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 472 throws com.liferay.portal.kernel.exception.SystemException, 473 com.liferay.portlet.bookmarks.NoSuchFolderException { 474 return getPersistence() 475 .findByUuid_PrevAndNext(folderId, uuid, orderByComparator); 476 } 477 478 /** 479 * Returns the bookmarks folder where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 480 * 481 * @param uuid the uuid 482 * @param groupId the group ID 483 * @return the matching bookmarks folder 484 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 485 * @throws SystemException if a system exception occurred 486 */ 487 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUUID_G( 488 java.lang.String uuid, long groupId) 489 throws com.liferay.portal.kernel.exception.SystemException, 490 com.liferay.portlet.bookmarks.NoSuchFolderException { 491 return getPersistence().findByUUID_G(uuid, groupId); 492 } 493 494 /** 495 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 496 * 497 * @param uuid the uuid 498 * @param groupId the group ID 499 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 500 * @throws SystemException if a system exception occurred 501 */ 502 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 503 java.lang.String uuid, long groupId) 504 throws com.liferay.portal.kernel.exception.SystemException { 505 return getPersistence().fetchByUUID_G(uuid, groupId); 506 } 507 508 /** 509 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 510 * 511 * @param uuid the uuid 512 * @param groupId the group ID 513 * @param retrieveFromCache whether to use the finder cache 514 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 515 * @throws SystemException if a system exception occurred 516 */ 517 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 518 java.lang.String uuid, long groupId, boolean retrieveFromCache) 519 throws com.liferay.portal.kernel.exception.SystemException { 520 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 521 } 522 523 /** 524 * Returns all the bookmarks folders where groupId = ?. 525 * 526 * @param groupId the group ID 527 * @return the matching bookmarks folders 528 * @throws SystemException if a system exception occurred 529 */ 530 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 531 long groupId) 532 throws com.liferay.portal.kernel.exception.SystemException { 533 return getPersistence().findByGroupId(groupId); 534 } 535 536 /** 537 * Returns a range of all the bookmarks folders where groupId = ?. 538 * 539 * <p> 540 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 541 * </p> 542 * 543 * @param groupId the group ID 544 * @param start the lower bound of the range of bookmarks folders 545 * @param end the upper bound of the range of bookmarks folders (not inclusive) 546 * @return the range of matching bookmarks folders 547 * @throws SystemException if a system exception occurred 548 */ 549 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 550 long groupId, int start, int end) 551 throws com.liferay.portal.kernel.exception.SystemException { 552 return getPersistence().findByGroupId(groupId, start, end); 553 } 554 555 /** 556 * Returns an ordered range of all the bookmarks folders where groupId = ?. 557 * 558 * <p> 559 * 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. 560 * </p> 561 * 562 * @param groupId the group ID 563 * @param start the lower bound of the range of bookmarks folders 564 * @param end the upper bound of the range of bookmarks folders (not inclusive) 565 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 566 * @return the ordered range of matching bookmarks folders 567 * @throws SystemException if a system exception occurred 568 */ 569 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 570 long groupId, int start, int end, 571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 572 throws com.liferay.portal.kernel.exception.SystemException { 573 return getPersistence() 574 .findByGroupId(groupId, start, end, orderByComparator); 575 } 576 577 /** 578 * Returns the first bookmarks folder in the ordered set where groupId = ?. 579 * 580 * @param groupId the group ID 581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 582 * @return the first matching bookmarks folder 583 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 584 * @throws SystemException if a system exception occurred 585 */ 586 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_First( 587 long groupId, 588 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 589 throws com.liferay.portal.kernel.exception.SystemException, 590 com.liferay.portlet.bookmarks.NoSuchFolderException { 591 return getPersistence().findByGroupId_First(groupId, orderByComparator); 592 } 593 594 /** 595 * Returns the first bookmarks folder in the ordered set where groupId = ?. 596 * 597 * @param groupId the group ID 598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 599 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 600 * @throws SystemException if a system exception occurred 601 */ 602 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_First( 603 long groupId, 604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 605 throws com.liferay.portal.kernel.exception.SystemException { 606 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 607 } 608 609 /** 610 * Returns the last bookmarks folder in the ordered set where groupId = ?. 611 * 612 * @param groupId the group ID 613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 614 * @return the last matching bookmarks folder 615 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 616 * @throws SystemException if a system exception occurred 617 */ 618 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_Last( 619 long groupId, 620 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 621 throws com.liferay.portal.kernel.exception.SystemException, 622 com.liferay.portlet.bookmarks.NoSuchFolderException { 623 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 624 } 625 626 /** 627 * Returns the last bookmarks folder in the ordered set where groupId = ?. 628 * 629 * @param groupId the group ID 630 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 631 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 632 * @throws SystemException if a system exception occurred 633 */ 634 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_Last( 635 long groupId, 636 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 637 throws com.liferay.portal.kernel.exception.SystemException { 638 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 639 } 640 641 /** 642 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ?. 643 * 644 * @param folderId the primary key of the current bookmarks folder 645 * @param groupId the group ID 646 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 647 * @return the previous, current, and next bookmarks folder 648 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 649 * @throws SystemException if a system exception occurred 650 */ 651 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByGroupId_PrevAndNext( 652 long folderId, long groupId, 653 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 654 throws com.liferay.portal.kernel.exception.SystemException, 655 com.liferay.portlet.bookmarks.NoSuchFolderException { 656 return getPersistence() 657 .findByGroupId_PrevAndNext(folderId, groupId, 658 orderByComparator); 659 } 660 661 /** 662 * Returns all the bookmarks folders that the user has permission to view where groupId = ?. 663 * 664 * @param groupId the group ID 665 * @return the matching bookmarks folders that the user has permission to view 666 * @throws SystemException if a system exception occurred 667 */ 668 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 669 long groupId) 670 throws com.liferay.portal.kernel.exception.SystemException { 671 return getPersistence().filterFindByGroupId(groupId); 672 } 673 674 /** 675 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ?. 676 * 677 * <p> 678 * 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. 679 * </p> 680 * 681 * @param groupId the group ID 682 * @param start the lower bound of the range of bookmarks folders 683 * @param end the upper bound of the range of bookmarks folders (not inclusive) 684 * @return the range of matching bookmarks folders that the user has permission to view 685 * @throws SystemException if a system exception occurred 686 */ 687 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 688 long groupId, int start, int end) 689 throws com.liferay.portal.kernel.exception.SystemException { 690 return getPersistence().filterFindByGroupId(groupId, start, end); 691 } 692 693 /** 694 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ?. 695 * 696 * <p> 697 * 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. 698 * </p> 699 * 700 * @param groupId the group ID 701 * @param start the lower bound of the range of bookmarks folders 702 * @param end the upper bound of the range of bookmarks folders (not inclusive) 703 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 704 * @return the ordered range of matching bookmarks folders that the user has permission to view 705 * @throws SystemException if a system exception occurred 706 */ 707 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 708 long groupId, int start, int end, 709 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 710 throws com.liferay.portal.kernel.exception.SystemException { 711 return getPersistence() 712 .filterFindByGroupId(groupId, start, end, orderByComparator); 713 } 714 715 /** 716 * 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 = ?. 717 * 718 * @param folderId the primary key of the current bookmarks folder 719 * @param groupId the group ID 720 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 721 * @return the previous, current, and next bookmarks folder 722 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 723 * @throws SystemException if a system exception occurred 724 */ 725 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByGroupId_PrevAndNext( 726 long folderId, long groupId, 727 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 728 throws com.liferay.portal.kernel.exception.SystemException, 729 com.liferay.portlet.bookmarks.NoSuchFolderException { 730 return getPersistence() 731 .filterFindByGroupId_PrevAndNext(folderId, groupId, 732 orderByComparator); 733 } 734 735 /** 736 * Returns all the bookmarks folders where companyId = ?. 737 * 738 * @param companyId the company ID 739 * @return the matching bookmarks folders 740 * @throws SystemException if a system exception occurred 741 */ 742 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 743 long companyId) 744 throws com.liferay.portal.kernel.exception.SystemException { 745 return getPersistence().findByCompanyId(companyId); 746 } 747 748 /** 749 * Returns a range of all the bookmarks folders where companyId = ?. 750 * 751 * <p> 752 * 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. 753 * </p> 754 * 755 * @param companyId the company ID 756 * @param start the lower bound of the range of bookmarks folders 757 * @param end the upper bound of the range of bookmarks folders (not inclusive) 758 * @return the range of matching bookmarks folders 759 * @throws SystemException if a system exception occurred 760 */ 761 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 762 long companyId, int start, int end) 763 throws com.liferay.portal.kernel.exception.SystemException { 764 return getPersistence().findByCompanyId(companyId, start, end); 765 } 766 767 /** 768 * Returns an ordered range of all the bookmarks folders where companyId = ?. 769 * 770 * <p> 771 * 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. 772 * </p> 773 * 774 * @param companyId the company ID 775 * @param start the lower bound of the range of bookmarks folders 776 * @param end the upper bound of the range of bookmarks folders (not inclusive) 777 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 778 * @return the ordered range of matching bookmarks folders 779 * @throws SystemException if a system exception occurred 780 */ 781 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 782 long companyId, int start, int end, 783 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 784 throws com.liferay.portal.kernel.exception.SystemException { 785 return getPersistence() 786 .findByCompanyId(companyId, start, end, orderByComparator); 787 } 788 789 /** 790 * Returns the first bookmarks folder in the ordered set where companyId = ?. 791 * 792 * @param companyId the company ID 793 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 794 * @return the first matching bookmarks folder 795 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 796 * @throws SystemException if a system exception occurred 797 */ 798 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_First( 799 long companyId, 800 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 801 throws com.liferay.portal.kernel.exception.SystemException, 802 com.liferay.portlet.bookmarks.NoSuchFolderException { 803 return getPersistence() 804 .findByCompanyId_First(companyId, orderByComparator); 805 } 806 807 /** 808 * Returns the first bookmarks folder in the ordered set where companyId = ?. 809 * 810 * @param companyId the company ID 811 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 812 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 813 * @throws SystemException if a system exception occurred 814 */ 815 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_First( 816 long companyId, 817 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 818 throws com.liferay.portal.kernel.exception.SystemException { 819 return getPersistence() 820 .fetchByCompanyId_First(companyId, orderByComparator); 821 } 822 823 /** 824 * Returns the last bookmarks folder in the ordered set where companyId = ?. 825 * 826 * @param companyId the company ID 827 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 828 * @return the last matching bookmarks folder 829 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 830 * @throws SystemException if a system exception occurred 831 */ 832 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_Last( 833 long companyId, 834 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 835 throws com.liferay.portal.kernel.exception.SystemException, 836 com.liferay.portlet.bookmarks.NoSuchFolderException { 837 return getPersistence() 838 .findByCompanyId_Last(companyId, orderByComparator); 839 } 840 841 /** 842 * Returns the last bookmarks folder in the ordered set where companyId = ?. 843 * 844 * @param companyId the company ID 845 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 846 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 847 * @throws SystemException if a system exception occurred 848 */ 849 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_Last( 850 long companyId, 851 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 852 throws com.liferay.portal.kernel.exception.SystemException { 853 return getPersistence() 854 .fetchByCompanyId_Last(companyId, orderByComparator); 855 } 856 857 /** 858 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = ?. 859 * 860 * @param folderId the primary key of the current bookmarks folder 861 * @param companyId the company ID 862 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 863 * @return the previous, current, and next bookmarks folder 864 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 865 * @throws SystemException if a system exception occurred 866 */ 867 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByCompanyId_PrevAndNext( 868 long folderId, long companyId, 869 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 870 throws com.liferay.portal.kernel.exception.SystemException, 871 com.liferay.portlet.bookmarks.NoSuchFolderException { 872 return getPersistence() 873 .findByCompanyId_PrevAndNext(folderId, companyId, 874 orderByComparator); 875 } 876 877 /** 878 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ?. 879 * 880 * @param groupId the group ID 881 * @param parentFolderId the parent folder ID 882 * @return the matching bookmarks folders 883 * @throws SystemException if a system exception occurred 884 */ 885 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 886 long groupId, long parentFolderId) 887 throws com.liferay.portal.kernel.exception.SystemException { 888 return getPersistence().findByG_P(groupId, parentFolderId); 889 } 890 891 /** 892 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 893 * 894 * <p> 895 * 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. 896 * </p> 897 * 898 * @param groupId the group ID 899 * @param parentFolderId the parent folder ID 900 * @param start the lower bound of the range of bookmarks folders 901 * @param end the upper bound of the range of bookmarks folders (not inclusive) 902 * @return the range of matching bookmarks folders 903 * @throws SystemException if a system exception occurred 904 */ 905 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 906 long groupId, long parentFolderId, int start, int end) 907 throws com.liferay.portal.kernel.exception.SystemException { 908 return getPersistence().findByG_P(groupId, parentFolderId, start, end); 909 } 910 911 /** 912 * Returns an ordered range of all the bookmarks folders 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 groupId the group ID 919 * @param parentFolderId the parent folder ID 920 * @param start the lower bound of the range of bookmarks folders 921 * @param end the upper bound of the range of bookmarks folders (not inclusive) 922 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 923 * @return the ordered range of matching bookmarks folders 924 * @throws SystemException if a system exception occurred 925 */ 926 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 927 long groupId, long parentFolderId, int start, int end, 928 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 929 throws com.liferay.portal.kernel.exception.SystemException { 930 return getPersistence() 931 .findByG_P(groupId, parentFolderId, start, end, 932 orderByComparator); 933 } 934 935 /** 936 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 937 * 938 * @param groupId the group ID 939 * @param parentFolderId the parent folder ID 940 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 941 * @return the first matching bookmarks folder 942 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 943 * @throws SystemException if a system exception occurred 944 */ 945 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_First( 946 long groupId, long parentFolderId, 947 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 948 throws com.liferay.portal.kernel.exception.SystemException, 949 com.liferay.portlet.bookmarks.NoSuchFolderException { 950 return getPersistence() 951 .findByG_P_First(groupId, parentFolderId, orderByComparator); 952 } 953 954 /** 955 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 956 * 957 * @param groupId the group ID 958 * @param parentFolderId the parent folder ID 959 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 960 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 961 * @throws SystemException if a system exception occurred 962 */ 963 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_First( 964 long groupId, long parentFolderId, 965 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 966 throws com.liferay.portal.kernel.exception.SystemException { 967 return getPersistence() 968 .fetchByG_P_First(groupId, parentFolderId, orderByComparator); 969 } 970 971 /** 972 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 973 * 974 * @param groupId the group ID 975 * @param parentFolderId the parent folder ID 976 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 977 * @return the last matching bookmarks folder 978 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 979 * @throws SystemException if a system exception occurred 980 */ 981 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_Last( 982 long groupId, long parentFolderId, 983 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 984 throws com.liferay.portal.kernel.exception.SystemException, 985 com.liferay.portlet.bookmarks.NoSuchFolderException { 986 return getPersistence() 987 .findByG_P_Last(groupId, parentFolderId, orderByComparator); 988 } 989 990 /** 991 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 992 * 993 * @param groupId the group ID 994 * @param parentFolderId the parent folder ID 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 997 * @throws SystemException if a system exception occurred 998 */ 999 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_Last( 1000 long groupId, long parentFolderId, 1001 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1002 throws com.liferay.portal.kernel.exception.SystemException { 1003 return getPersistence() 1004 .fetchByG_P_Last(groupId, parentFolderId, orderByComparator); 1005 } 1006 1007 /** 1008 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1009 * 1010 * @param folderId the primary key of the current bookmarks folder 1011 * @param groupId the group ID 1012 * @param parentFolderId the parent folder ID 1013 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1014 * @return the previous, current, and next bookmarks folder 1015 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1016 * @throws SystemException if a system exception occurred 1017 */ 1018 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_PrevAndNext( 1019 long folderId, long groupId, long parentFolderId, 1020 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1021 throws com.liferay.portal.kernel.exception.SystemException, 1022 com.liferay.portlet.bookmarks.NoSuchFolderException { 1023 return getPersistence() 1024 .findByG_P_PrevAndNext(folderId, groupId, parentFolderId, 1025 orderByComparator); 1026 } 1027 1028 /** 1029 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1030 * 1031 * @param groupId the group ID 1032 * @param parentFolderId the parent folder ID 1033 * @return the matching bookmarks folders that the user has permission to view 1034 * @throws SystemException if a system exception occurred 1035 */ 1036 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1037 long groupId, long parentFolderId) 1038 throws com.liferay.portal.kernel.exception.SystemException { 1039 return getPersistence().filterFindByG_P(groupId, parentFolderId); 1040 } 1041 1042 /** 1043 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1044 * 1045 * <p> 1046 * 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. 1047 * </p> 1048 * 1049 * @param groupId the group ID 1050 * @param parentFolderId the parent folder ID 1051 * @param start the lower bound of the range of bookmarks folders 1052 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1053 * @return the range of matching bookmarks folders that the user has permission to view 1054 * @throws SystemException if a system exception occurred 1055 */ 1056 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1057 long groupId, long parentFolderId, int start, int end) 1058 throws com.liferay.portal.kernel.exception.SystemException { 1059 return getPersistence() 1060 .filterFindByG_P(groupId, parentFolderId, start, end); 1061 } 1062 1063 /** 1064 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ?. 1065 * 1066 * <p> 1067 * 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. 1068 * </p> 1069 * 1070 * @param groupId the group ID 1071 * @param parentFolderId the parent folder ID 1072 * @param start the lower bound of the range of bookmarks folders 1073 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1075 * @return the ordered range of matching bookmarks folders that the user has permission to view 1076 * @throws SystemException if a system exception occurred 1077 */ 1078 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1079 long groupId, long parentFolderId, int start, int end, 1080 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1081 throws com.liferay.portal.kernel.exception.SystemException { 1082 return getPersistence() 1083 .filterFindByG_P(groupId, parentFolderId, start, end, 1084 orderByComparator); 1085 } 1086 1087 /** 1088 * 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 = ?. 1089 * 1090 * @param folderId the primary key of the current bookmarks folder 1091 * @param groupId the group ID 1092 * @param parentFolderId the parent folder ID 1093 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1094 * @return the previous, current, and next bookmarks folder 1095 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1096 * @throws SystemException if a system exception occurred 1097 */ 1098 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_PrevAndNext( 1099 long folderId, long groupId, long parentFolderId, 1100 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1101 throws com.liferay.portal.kernel.exception.SystemException, 1102 com.liferay.portlet.bookmarks.NoSuchFolderException { 1103 return getPersistence() 1104 .filterFindByG_P_PrevAndNext(folderId, groupId, 1105 parentFolderId, orderByComparator); 1106 } 1107 1108 /** 1109 * Returns all the bookmarks folders. 1110 * 1111 * @return the bookmarks folders 1112 * @throws SystemException if a system exception occurred 1113 */ 1114 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll() 1115 throws com.liferay.portal.kernel.exception.SystemException { 1116 return getPersistence().findAll(); 1117 } 1118 1119 /** 1120 * Returns a range of all the bookmarks folders. 1121 * 1122 * <p> 1123 * 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. 1124 * </p> 1125 * 1126 * @param start the lower bound of the range of bookmarks folders 1127 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1128 * @return the range of bookmarks folders 1129 * @throws SystemException if a system exception occurred 1130 */ 1131 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 1132 int start, int end) 1133 throws com.liferay.portal.kernel.exception.SystemException { 1134 return getPersistence().findAll(start, end); 1135 } 1136 1137 /** 1138 * Returns an ordered range of all the bookmarks folders. 1139 * 1140 * <p> 1141 * 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. 1142 * </p> 1143 * 1144 * @param start the lower bound of the range of bookmarks folders 1145 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1147 * @return the ordered range of bookmarks folders 1148 * @throws SystemException if a system exception occurred 1149 */ 1150 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 1151 int start, int end, 1152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1153 throws com.liferay.portal.kernel.exception.SystemException { 1154 return getPersistence().findAll(start, end, orderByComparator); 1155 } 1156 1157 /** 1158 * Removes all the bookmarks folders where resourceBlockId = ? from the database. 1159 * 1160 * @param resourceBlockId the resource block ID 1161 * @throws SystemException if a system exception occurred 1162 */ 1163 public static void removeByResourceBlockId(long resourceBlockId) 1164 throws com.liferay.portal.kernel.exception.SystemException { 1165 getPersistence().removeByResourceBlockId(resourceBlockId); 1166 } 1167 1168 /** 1169 * Removes all the bookmarks folders where uuid = ? from the database. 1170 * 1171 * @param uuid the uuid 1172 * @throws SystemException if a system exception occurred 1173 */ 1174 public static void removeByUuid(java.lang.String uuid) 1175 throws com.liferay.portal.kernel.exception.SystemException { 1176 getPersistence().removeByUuid(uuid); 1177 } 1178 1179 /** 1180 * Removes the bookmarks folder where uuid = ? and groupId = ? from the database. 1181 * 1182 * @param uuid the uuid 1183 * @param groupId the group ID 1184 * @return the bookmarks folder that was removed 1185 * @throws SystemException if a system exception occurred 1186 */ 1187 public static com.liferay.portlet.bookmarks.model.BookmarksFolder removeByUUID_G( 1188 java.lang.String uuid, long groupId) 1189 throws com.liferay.portal.kernel.exception.SystemException, 1190 com.liferay.portlet.bookmarks.NoSuchFolderException { 1191 return getPersistence().removeByUUID_G(uuid, groupId); 1192 } 1193 1194 /** 1195 * Removes all the bookmarks folders where groupId = ? from the database. 1196 * 1197 * @param groupId the group ID 1198 * @throws SystemException if a system exception occurred 1199 */ 1200 public static void removeByGroupId(long groupId) 1201 throws com.liferay.portal.kernel.exception.SystemException { 1202 getPersistence().removeByGroupId(groupId); 1203 } 1204 1205 /** 1206 * Removes all the bookmarks folders where companyId = ? from the database. 1207 * 1208 * @param companyId the company ID 1209 * @throws SystemException if a system exception occurred 1210 */ 1211 public static void removeByCompanyId(long companyId) 1212 throws com.liferay.portal.kernel.exception.SystemException { 1213 getPersistence().removeByCompanyId(companyId); 1214 } 1215 1216 /** 1217 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? from the database. 1218 * 1219 * @param groupId the group ID 1220 * @param parentFolderId the parent folder ID 1221 * @throws SystemException if a system exception occurred 1222 */ 1223 public static void removeByG_P(long groupId, long parentFolderId) 1224 throws com.liferay.portal.kernel.exception.SystemException { 1225 getPersistence().removeByG_P(groupId, parentFolderId); 1226 } 1227 1228 /** 1229 * Removes all the bookmarks folders from the database. 1230 * 1231 * @throws SystemException if a system exception occurred 1232 */ 1233 public static void removeAll() 1234 throws com.liferay.portal.kernel.exception.SystemException { 1235 getPersistence().removeAll(); 1236 } 1237 1238 /** 1239 * Returns the number of bookmarks folders where resourceBlockId = ?. 1240 * 1241 * @param resourceBlockId the resource block ID 1242 * @return the number of matching bookmarks folders 1243 * @throws SystemException if a system exception occurred 1244 */ 1245 public static int countByResourceBlockId(long resourceBlockId) 1246 throws com.liferay.portal.kernel.exception.SystemException { 1247 return getPersistence().countByResourceBlockId(resourceBlockId); 1248 } 1249 1250 /** 1251 * Returns the number of bookmarks folders where uuid = ?. 1252 * 1253 * @param uuid the uuid 1254 * @return the number of matching bookmarks folders 1255 * @throws SystemException if a system exception occurred 1256 */ 1257 public static int countByUuid(java.lang.String uuid) 1258 throws com.liferay.portal.kernel.exception.SystemException { 1259 return getPersistence().countByUuid(uuid); 1260 } 1261 1262 /** 1263 * Returns the number of bookmarks folders where uuid = ? and groupId = ?. 1264 * 1265 * @param uuid the uuid 1266 * @param groupId the group ID 1267 * @return the number of matching bookmarks folders 1268 * @throws SystemException if a system exception occurred 1269 */ 1270 public static int countByUUID_G(java.lang.String uuid, long groupId) 1271 throws com.liferay.portal.kernel.exception.SystemException { 1272 return getPersistence().countByUUID_G(uuid, groupId); 1273 } 1274 1275 /** 1276 * Returns the number of bookmarks folders where groupId = ?. 1277 * 1278 * @param groupId the group ID 1279 * @return the number of matching bookmarks folders 1280 * @throws SystemException if a system exception occurred 1281 */ 1282 public static int countByGroupId(long groupId) 1283 throws com.liferay.portal.kernel.exception.SystemException { 1284 return getPersistence().countByGroupId(groupId); 1285 } 1286 1287 /** 1288 * Returns the number of bookmarks folders that the user has permission to view where groupId = ?. 1289 * 1290 * @param groupId the group ID 1291 * @return the number of matching bookmarks folders that the user has permission to view 1292 * @throws SystemException if a system exception occurred 1293 */ 1294 public static int filterCountByGroupId(long groupId) 1295 throws com.liferay.portal.kernel.exception.SystemException { 1296 return getPersistence().filterCountByGroupId(groupId); 1297 } 1298 1299 /** 1300 * Returns the number of bookmarks folders where companyId = ?. 1301 * 1302 * @param companyId the company ID 1303 * @return the number of matching bookmarks folders 1304 * @throws SystemException if a system exception occurred 1305 */ 1306 public static int countByCompanyId(long companyId) 1307 throws com.liferay.portal.kernel.exception.SystemException { 1308 return getPersistence().countByCompanyId(companyId); 1309 } 1310 1311 /** 1312 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ?. 1313 * 1314 * @param groupId the group ID 1315 * @param parentFolderId the parent folder ID 1316 * @return the number of matching bookmarks folders 1317 * @throws SystemException if a system exception occurred 1318 */ 1319 public static int countByG_P(long groupId, long parentFolderId) 1320 throws com.liferay.portal.kernel.exception.SystemException { 1321 return getPersistence().countByG_P(groupId, parentFolderId); 1322 } 1323 1324 /** 1325 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1326 * 1327 * @param groupId the group ID 1328 * @param parentFolderId the parent folder ID 1329 * @return the number of matching bookmarks folders that the user has permission to view 1330 * @throws SystemException if a system exception occurred 1331 */ 1332 public static int filterCountByG_P(long groupId, long parentFolderId) 1333 throws com.liferay.portal.kernel.exception.SystemException { 1334 return getPersistence().filterCountByG_P(groupId, parentFolderId); 1335 } 1336 1337 /** 1338 * Returns the number of bookmarks folders. 1339 * 1340 * @return the number of bookmarks folders 1341 * @throws SystemException if a system exception occurred 1342 */ 1343 public static int countAll() 1344 throws com.liferay.portal.kernel.exception.SystemException { 1345 return getPersistence().countAll(); 1346 } 1347 1348 public static BookmarksFolderPersistence getPersistence() { 1349 if (_persistence == null) { 1350 _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName()); 1351 1352 ReferenceRegistry.registerReference(BookmarksFolderUtil.class, 1353 "_persistence"); 1354 } 1355 1356 return _persistence; 1357 } 1358 1359 /** 1360 * @deprecated 1361 */ 1362 public void setPersistence(BookmarksFolderPersistence persistence) { 1363 } 1364 1365 private static BookmarksFolderPersistence _persistence; 1366 }