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 static long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<BookmarksFolder> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<BookmarksFolder> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<BookmarksFolder> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static BookmarksFolder update(BookmarksFolder bookmarksFolder) 101 throws SystemException { 102 return getPersistence().update(bookmarksFolder); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static BookmarksFolder update(BookmarksFolder bookmarksFolder, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(bookmarksFolder, serviceContext); 111 } 112 113 /** 114 * Returns all the bookmarks folders where resourceBlockId = ?. 115 * 116 * @param resourceBlockId the resource block ID 117 * @return the matching bookmarks folders 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 121 long resourceBlockId) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByResourceBlockId(resourceBlockId); 124 } 125 126 /** 127 * Returns a range of all the bookmarks folders where resourceBlockId = ?. 128 * 129 * <p> 130 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 131 * </p> 132 * 133 * @param resourceBlockId the resource block ID 134 * @param start the lower bound of the range of bookmarks folders 135 * @param end the upper bound of the range of bookmarks folders (not inclusive) 136 * @return the range of matching bookmarks folders 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 140 long resourceBlockId, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence() 143 .findByResourceBlockId(resourceBlockId, start, end); 144 } 145 146 /** 147 * Returns an ordered range of all the bookmarks folders where resourceBlockId = ?. 148 * 149 * <p> 150 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 151 * </p> 152 * 153 * @param resourceBlockId the resource block ID 154 * @param start the lower bound of the range of bookmarks folders 155 * @param end the upper bound of the range of bookmarks folders (not inclusive) 156 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 157 * @return the ordered range of matching bookmarks folders 158 * @throws SystemException if a system exception occurred 159 */ 160 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 161 long resourceBlockId, int start, int end, 162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence() 165 .findByResourceBlockId(resourceBlockId, start, end, 166 orderByComparator); 167 } 168 169 /** 170 * Returns the first bookmarks folder in the ordered set where resourceBlockId = ?. 171 * 172 * @param resourceBlockId the resource block ID 173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 174 * @return the first matching bookmarks folder 175 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 176 * @throws SystemException if a system exception occurred 177 */ 178 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_First( 179 long resourceBlockId, 180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.bookmarks.NoSuchFolderException { 183 return getPersistence() 184 .findByResourceBlockId_First(resourceBlockId, 185 orderByComparator); 186 } 187 188 /** 189 * Returns the first bookmarks folder in the ordered set where resourceBlockId = ?. 190 * 191 * @param resourceBlockId the resource block ID 192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 193 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_First( 197 long resourceBlockId, 198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 199 throws com.liferay.portal.kernel.exception.SystemException { 200 return getPersistence() 201 .fetchByResourceBlockId_First(resourceBlockId, 202 orderByComparator); 203 } 204 205 /** 206 * Returns the last bookmarks folder in the ordered set where resourceBlockId = ?. 207 * 208 * @param resourceBlockId the resource block ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching bookmarks folder 211 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 212 * @throws SystemException if a system exception occurred 213 */ 214 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_Last( 215 long resourceBlockId, 216 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 217 throws com.liferay.portal.kernel.exception.SystemException, 218 com.liferay.portlet.bookmarks.NoSuchFolderException { 219 return getPersistence() 220 .findByResourceBlockId_Last(resourceBlockId, 221 orderByComparator); 222 } 223 224 /** 225 * Returns the last bookmarks folder in the ordered set where resourceBlockId = ?. 226 * 227 * @param resourceBlockId the resource block ID 228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 229 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 230 * @throws SystemException if a system exception occurred 231 */ 232 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_Last( 233 long resourceBlockId, 234 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 235 throws com.liferay.portal.kernel.exception.SystemException { 236 return getPersistence() 237 .fetchByResourceBlockId_Last(resourceBlockId, 238 orderByComparator); 239 } 240 241 /** 242 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where resourceBlockId = ?. 243 * 244 * @param folderId the primary key of the current bookmarks folder 245 * @param resourceBlockId the resource block ID 246 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 247 * @return the previous, current, and next bookmarks folder 248 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 249 * @throws SystemException if a system exception occurred 250 */ 251 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByResourceBlockId_PrevAndNext( 252 long folderId, long resourceBlockId, 253 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 254 throws com.liferay.portal.kernel.exception.SystemException, 255 com.liferay.portlet.bookmarks.NoSuchFolderException { 256 return getPersistence() 257 .findByResourceBlockId_PrevAndNext(folderId, 258 resourceBlockId, orderByComparator); 259 } 260 261 /** 262 * Removes all the bookmarks folders where resourceBlockId = ? from the database. 263 * 264 * @param resourceBlockId the resource block ID 265 * @throws SystemException if a system exception occurred 266 */ 267 public static void removeByResourceBlockId(long resourceBlockId) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 getPersistence().removeByResourceBlockId(resourceBlockId); 270 } 271 272 /** 273 * Returns the number of bookmarks folders where resourceBlockId = ?. 274 * 275 * @param resourceBlockId the resource block ID 276 * @return the number of matching bookmarks folders 277 * @throws SystemException if a system exception occurred 278 */ 279 public static int countByResourceBlockId(long resourceBlockId) 280 throws com.liferay.portal.kernel.exception.SystemException { 281 return getPersistence().countByResourceBlockId(resourceBlockId); 282 } 283 284 /** 285 * Returns all the bookmarks folders where uuid = ?. 286 * 287 * @param uuid the uuid 288 * @return the matching bookmarks folders 289 * @throws SystemException if a system exception occurred 290 */ 291 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 292 java.lang.String uuid) 293 throws com.liferay.portal.kernel.exception.SystemException { 294 return getPersistence().findByUuid(uuid); 295 } 296 297 /** 298 * Returns a range of all the bookmarks folders where uuid = ?. 299 * 300 * <p> 301 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 302 * </p> 303 * 304 * @param uuid the uuid 305 * @param start the lower bound of the range of bookmarks folders 306 * @param end the upper bound of the range of bookmarks folders (not inclusive) 307 * @return the range of matching bookmarks folders 308 * @throws SystemException if a system exception occurred 309 */ 310 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 311 java.lang.String uuid, int start, int end) 312 throws com.liferay.portal.kernel.exception.SystemException { 313 return getPersistence().findByUuid(uuid, start, end); 314 } 315 316 /** 317 * Returns an ordered range of all the bookmarks folders where uuid = ?. 318 * 319 * <p> 320 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 321 * </p> 322 * 323 * @param uuid the uuid 324 * @param start the lower bound of the range of bookmarks folders 325 * @param end the upper bound of the range of bookmarks folders (not inclusive) 326 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 327 * @return the ordered range of matching bookmarks folders 328 * @throws SystemException if a system exception occurred 329 */ 330 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 331 java.lang.String uuid, int start, int end, 332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 333 throws com.liferay.portal.kernel.exception.SystemException { 334 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 335 } 336 337 /** 338 * Returns the first bookmarks folder in the ordered set where uuid = ?. 339 * 340 * @param uuid the uuid 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the first matching bookmarks folder 343 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 344 * @throws SystemException if a system exception occurred 345 */ 346 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_First( 347 java.lang.String uuid, 348 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 349 throws com.liferay.portal.kernel.exception.SystemException, 350 com.liferay.portlet.bookmarks.NoSuchFolderException { 351 return getPersistence().findByUuid_First(uuid, orderByComparator); 352 } 353 354 /** 355 * Returns the first bookmarks folder in the ordered set where uuid = ?. 356 * 357 * @param uuid the uuid 358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 359 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 360 * @throws SystemException if a system exception occurred 361 */ 362 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_First( 363 java.lang.String uuid, 364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 365 throws com.liferay.portal.kernel.exception.SystemException { 366 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 367 } 368 369 /** 370 * Returns the last bookmarks folder in the ordered set where uuid = ?. 371 * 372 * @param uuid the uuid 373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 374 * @return the last matching bookmarks folder 375 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 376 * @throws SystemException if a system exception occurred 377 */ 378 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_Last( 379 java.lang.String uuid, 380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 381 throws com.liferay.portal.kernel.exception.SystemException, 382 com.liferay.portlet.bookmarks.NoSuchFolderException { 383 return getPersistence().findByUuid_Last(uuid, orderByComparator); 384 } 385 386 /** 387 * Returns the last bookmarks folder in the ordered set where uuid = ?. 388 * 389 * @param uuid the uuid 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the last matching bookmarks folder, or <code>null</code> 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 fetchByUuid_Last( 395 java.lang.String uuid, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 399 } 400 401 /** 402 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = ?. 403 * 404 * @param folderId the primary key of the current bookmarks folder 405 * @param uuid the uuid 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the previous, current, and next bookmarks folder 408 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 409 * @throws SystemException if a system exception occurred 410 */ 411 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_PrevAndNext( 412 long folderId, java.lang.String uuid, 413 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 414 throws com.liferay.portal.kernel.exception.SystemException, 415 com.liferay.portlet.bookmarks.NoSuchFolderException { 416 return getPersistence() 417 .findByUuid_PrevAndNext(folderId, uuid, orderByComparator); 418 } 419 420 /** 421 * Removes all the bookmarks folders where uuid = ? from the database. 422 * 423 * @param uuid the uuid 424 * @throws SystemException if a system exception occurred 425 */ 426 public static void removeByUuid(java.lang.String uuid) 427 throws com.liferay.portal.kernel.exception.SystemException { 428 getPersistence().removeByUuid(uuid); 429 } 430 431 /** 432 * Returns the number of bookmarks folders where uuid = ?. 433 * 434 * @param uuid the uuid 435 * @return the number of matching bookmarks folders 436 * @throws SystemException if a system exception occurred 437 */ 438 public static int countByUuid(java.lang.String uuid) 439 throws com.liferay.portal.kernel.exception.SystemException { 440 return getPersistence().countByUuid(uuid); 441 } 442 443 /** 444 * Returns the bookmarks folder where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 445 * 446 * @param uuid the uuid 447 * @param groupId the group ID 448 * @return the matching bookmarks folder 449 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException 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 findByUUID_G( 453 java.lang.String uuid, long groupId) 454 throws com.liferay.portal.kernel.exception.SystemException, 455 com.liferay.portlet.bookmarks.NoSuchFolderException { 456 return getPersistence().findByUUID_G(uuid, groupId); 457 } 458 459 /** 460 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 461 * 462 * @param uuid the uuid 463 * @param groupId the group ID 464 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 468 java.lang.String uuid, long groupId) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence().fetchByUUID_G(uuid, groupId); 471 } 472 473 /** 474 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 475 * 476 * @param uuid the uuid 477 * @param groupId the group ID 478 * @param retrieveFromCache whether to use the finder cache 479 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 480 * @throws SystemException if a system exception occurred 481 */ 482 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 483 java.lang.String uuid, long groupId, boolean retrieveFromCache) 484 throws com.liferay.portal.kernel.exception.SystemException { 485 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 486 } 487 488 /** 489 * Removes the bookmarks folder where uuid = ? and groupId = ? from the database. 490 * 491 * @param uuid the uuid 492 * @param groupId the group ID 493 * @return the bookmarks folder that was removed 494 * @throws SystemException if a system exception occurred 495 */ 496 public static com.liferay.portlet.bookmarks.model.BookmarksFolder removeByUUID_G( 497 java.lang.String uuid, long groupId) 498 throws com.liferay.portal.kernel.exception.SystemException, 499 com.liferay.portlet.bookmarks.NoSuchFolderException { 500 return getPersistence().removeByUUID_G(uuid, groupId); 501 } 502 503 /** 504 * Returns the number of bookmarks folders where uuid = ? and groupId = ?. 505 * 506 * @param uuid the uuid 507 * @param groupId the group ID 508 * @return the number of matching bookmarks folders 509 * @throws SystemException if a system exception occurred 510 */ 511 public static int countByUUID_G(java.lang.String uuid, long groupId) 512 throws com.liferay.portal.kernel.exception.SystemException { 513 return getPersistence().countByUUID_G(uuid, groupId); 514 } 515 516 /** 517 * Returns all the bookmarks folders where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @return the matching bookmarks folders 522 * @throws SystemException if a system exception occurred 523 */ 524 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C( 525 java.lang.String uuid, long companyId) 526 throws com.liferay.portal.kernel.exception.SystemException { 527 return getPersistence().findByUuid_C(uuid, companyId); 528 } 529 530 /** 531 * Returns a range of all the bookmarks folders where uuid = ? and companyId = ?. 532 * 533 * <p> 534 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 535 * </p> 536 * 537 * @param uuid the uuid 538 * @param companyId the company ID 539 * @param start the lower bound of the range of bookmarks folders 540 * @param end the upper bound of the range of bookmarks folders (not inclusive) 541 * @return the range of matching bookmarks folders 542 * @throws SystemException if a system exception occurred 543 */ 544 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C( 545 java.lang.String uuid, long companyId, int start, int end) 546 throws com.liferay.portal.kernel.exception.SystemException { 547 return getPersistence().findByUuid_C(uuid, companyId, start, end); 548 } 549 550 /** 551 * Returns an ordered range of all the bookmarks folders where uuid = ? and companyId = ?. 552 * 553 * <p> 554 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 555 * </p> 556 * 557 * @param uuid the uuid 558 * @param companyId the company ID 559 * @param start the lower bound of the range of bookmarks folders 560 * @param end the upper bound of the range of bookmarks folders (not inclusive) 561 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 562 * @return the ordered range of matching bookmarks folders 563 * @throws SystemException if a system exception occurred 564 */ 565 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C( 566 java.lang.String uuid, long companyId, int start, int end, 567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 568 throws com.liferay.portal.kernel.exception.SystemException { 569 return getPersistence() 570 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 571 } 572 573 /** 574 * Returns the first bookmarks folder in the ordered set where uuid = ? and companyId = ?. 575 * 576 * @param uuid the uuid 577 * @param companyId the company ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching bookmarks folder 580 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_C_First( 584 java.lang.String uuid, long companyId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.bookmarks.NoSuchFolderException { 588 return getPersistence() 589 .findByUuid_C_First(uuid, companyId, orderByComparator); 590 } 591 592 /** 593 * Returns the first bookmarks folder in the ordered set where uuid = ? and companyId = ?. 594 * 595 * @param uuid the uuid 596 * @param companyId the company ID 597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 598 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 599 * @throws SystemException if a system exception occurred 600 */ 601 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_C_First( 602 java.lang.String uuid, long companyId, 603 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 604 throws com.liferay.portal.kernel.exception.SystemException { 605 return getPersistence() 606 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 607 } 608 609 /** 610 * Returns the last bookmarks folder in the ordered set where uuid = ? and companyId = ?. 611 * 612 * @param uuid the uuid 613 * @param companyId the company ID 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the last matching bookmarks folder 616 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 617 * @throws SystemException if a system exception occurred 618 */ 619 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_C_Last( 620 java.lang.String uuid, long companyId, 621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 622 throws com.liferay.portal.kernel.exception.SystemException, 623 com.liferay.portlet.bookmarks.NoSuchFolderException { 624 return getPersistence() 625 .findByUuid_C_Last(uuid, companyId, orderByComparator); 626 } 627 628 /** 629 * Returns the last bookmarks folder in the ordered set where uuid = ? and companyId = ?. 630 * 631 * @param uuid the uuid 632 * @param companyId the company ID 633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 634 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 635 * @throws SystemException if a system exception occurred 636 */ 637 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_C_Last( 638 java.lang.String uuid, long companyId, 639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 640 throws com.liferay.portal.kernel.exception.SystemException { 641 return getPersistence() 642 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 643 } 644 645 /** 646 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = ? and companyId = ?. 647 * 648 * @param folderId the primary key of the current bookmarks folder 649 * @param uuid the uuid 650 * @param companyId the company ID 651 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 652 * @return the previous, current, and next bookmarks folder 653 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 654 * @throws SystemException if a system exception occurred 655 */ 656 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_C_PrevAndNext( 657 long folderId, java.lang.String uuid, long companyId, 658 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 659 throws com.liferay.portal.kernel.exception.SystemException, 660 com.liferay.portlet.bookmarks.NoSuchFolderException { 661 return getPersistence() 662 .findByUuid_C_PrevAndNext(folderId, uuid, companyId, 663 orderByComparator); 664 } 665 666 /** 667 * Removes all the bookmarks folders where uuid = ? and companyId = ? from the database. 668 * 669 * @param uuid the uuid 670 * @param companyId the company ID 671 * @throws SystemException if a system exception occurred 672 */ 673 public static void removeByUuid_C(java.lang.String uuid, long companyId) 674 throws com.liferay.portal.kernel.exception.SystemException { 675 getPersistence().removeByUuid_C(uuid, companyId); 676 } 677 678 /** 679 * Returns the number of bookmarks folders where uuid = ? and companyId = ?. 680 * 681 * @param uuid the uuid 682 * @param companyId the company ID 683 * @return the number of matching bookmarks folders 684 * @throws SystemException if a system exception occurred 685 */ 686 public static int countByUuid_C(java.lang.String uuid, long companyId) 687 throws com.liferay.portal.kernel.exception.SystemException { 688 return getPersistence().countByUuid_C(uuid, companyId); 689 } 690 691 /** 692 * Returns all the bookmarks folders where groupId = ?. 693 * 694 * @param groupId the group ID 695 * @return the matching bookmarks folders 696 * @throws SystemException if a system exception occurred 697 */ 698 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 699 long groupId) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence().findByGroupId(groupId); 702 } 703 704 /** 705 * Returns a range of all the bookmarks folders where groupId = ?. 706 * 707 * <p> 708 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 709 * </p> 710 * 711 * @param groupId the group ID 712 * @param start the lower bound of the range of bookmarks folders 713 * @param end the upper bound of the range of bookmarks folders (not inclusive) 714 * @return the range of matching bookmarks folders 715 * @throws SystemException if a system exception occurred 716 */ 717 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 718 long groupId, int start, int end) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().findByGroupId(groupId, start, end); 721 } 722 723 /** 724 * Returns an ordered range of all the bookmarks folders where groupId = ?. 725 * 726 * <p> 727 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 728 * </p> 729 * 730 * @param groupId the group ID 731 * @param start the lower bound of the range of bookmarks folders 732 * @param end the upper bound of the range of bookmarks folders (not inclusive) 733 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 734 * @return the ordered range of matching bookmarks folders 735 * @throws SystemException if a system exception occurred 736 */ 737 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 738 long groupId, int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence() 742 .findByGroupId(groupId, start, end, orderByComparator); 743 } 744 745 /** 746 * Returns the first bookmarks folder in the ordered set where groupId = ?. 747 * 748 * @param groupId the group ID 749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 750 * @return the first matching bookmarks folder 751 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 752 * @throws SystemException if a system exception occurred 753 */ 754 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_First( 755 long groupId, 756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 757 throws com.liferay.portal.kernel.exception.SystemException, 758 com.liferay.portlet.bookmarks.NoSuchFolderException { 759 return getPersistence().findByGroupId_First(groupId, orderByComparator); 760 } 761 762 /** 763 * Returns the first bookmarks folder in the ordered set where groupId = ?. 764 * 765 * @param groupId the group ID 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 768 * @throws SystemException if a system exception occurred 769 */ 770 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_First( 771 long groupId, 772 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 775 } 776 777 /** 778 * Returns the last bookmarks folder in the ordered set where groupId = ?. 779 * 780 * @param groupId the group ID 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the last matching bookmarks folder 783 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 784 * @throws SystemException if a system exception occurred 785 */ 786 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_Last( 787 long groupId, 788 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 789 throws com.liferay.portal.kernel.exception.SystemException, 790 com.liferay.portlet.bookmarks.NoSuchFolderException { 791 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 792 } 793 794 /** 795 * Returns the last bookmarks folder in the ordered set where groupId = ?. 796 * 797 * @param groupId the group ID 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_Last( 803 long groupId, 804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 805 throws com.liferay.portal.kernel.exception.SystemException { 806 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 807 } 808 809 /** 810 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ?. 811 * 812 * @param folderId the primary key of the current bookmarks folder 813 * @param groupId the group ID 814 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 815 * @return the previous, current, and next bookmarks folder 816 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 817 * @throws SystemException if a system exception occurred 818 */ 819 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByGroupId_PrevAndNext( 820 long folderId, long groupId, 821 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 822 throws com.liferay.portal.kernel.exception.SystemException, 823 com.liferay.portlet.bookmarks.NoSuchFolderException { 824 return getPersistence() 825 .findByGroupId_PrevAndNext(folderId, groupId, 826 orderByComparator); 827 } 828 829 /** 830 * Returns all the bookmarks folders that the user has permission to view where groupId = ?. 831 * 832 * @param groupId the group ID 833 * @return the matching bookmarks folders that the user has permission to view 834 * @throws SystemException if a system exception occurred 835 */ 836 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 837 long groupId) 838 throws com.liferay.portal.kernel.exception.SystemException { 839 return getPersistence().filterFindByGroupId(groupId); 840 } 841 842 /** 843 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ?. 844 * 845 * <p> 846 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 847 * </p> 848 * 849 * @param groupId the group ID 850 * @param start the lower bound of the range of bookmarks folders 851 * @param end the upper bound of the range of bookmarks folders (not inclusive) 852 * @return the range of matching bookmarks folders that the user has permission to view 853 * @throws SystemException if a system exception occurred 854 */ 855 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 856 long groupId, int start, int end) 857 throws com.liferay.portal.kernel.exception.SystemException { 858 return getPersistence().filterFindByGroupId(groupId, start, end); 859 } 860 861 /** 862 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ?. 863 * 864 * <p> 865 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 866 * </p> 867 * 868 * @param groupId the group ID 869 * @param start the lower bound of the range of bookmarks folders 870 * @param end the upper bound of the range of bookmarks folders (not inclusive) 871 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 872 * @return the ordered range of matching bookmarks folders that the user has permission to view 873 * @throws SystemException if a system exception occurred 874 */ 875 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 876 long groupId, int start, int end, 877 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 878 throws com.liferay.portal.kernel.exception.SystemException { 879 return getPersistence() 880 .filterFindByGroupId(groupId, start, end, orderByComparator); 881 } 882 883 /** 884 * 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 = ?. 885 * 886 * @param folderId the primary key of the current bookmarks folder 887 * @param groupId the group ID 888 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 889 * @return the previous, current, and next bookmarks folder 890 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 891 * @throws SystemException if a system exception occurred 892 */ 893 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByGroupId_PrevAndNext( 894 long folderId, long groupId, 895 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 896 throws com.liferay.portal.kernel.exception.SystemException, 897 com.liferay.portlet.bookmarks.NoSuchFolderException { 898 return getPersistence() 899 .filterFindByGroupId_PrevAndNext(folderId, groupId, 900 orderByComparator); 901 } 902 903 /** 904 * Removes all the bookmarks folders where groupId = ? from the database. 905 * 906 * @param groupId the group ID 907 * @throws SystemException if a system exception occurred 908 */ 909 public static void removeByGroupId(long groupId) 910 throws com.liferay.portal.kernel.exception.SystemException { 911 getPersistence().removeByGroupId(groupId); 912 } 913 914 /** 915 * Returns the number of bookmarks folders where groupId = ?. 916 * 917 * @param groupId the group ID 918 * @return the number of matching bookmarks folders 919 * @throws SystemException if a system exception occurred 920 */ 921 public static int countByGroupId(long groupId) 922 throws com.liferay.portal.kernel.exception.SystemException { 923 return getPersistence().countByGroupId(groupId); 924 } 925 926 /** 927 * Returns the number of bookmarks folders that the user has permission to view where groupId = ?. 928 * 929 * @param groupId the group ID 930 * @return the number of matching bookmarks folders that the user has permission to view 931 * @throws SystemException if a system exception occurred 932 */ 933 public static int filterCountByGroupId(long groupId) 934 throws com.liferay.portal.kernel.exception.SystemException { 935 return getPersistence().filterCountByGroupId(groupId); 936 } 937 938 /** 939 * Returns all the bookmarks folders where companyId = ?. 940 * 941 * @param companyId the company ID 942 * @return the matching bookmarks folders 943 * @throws SystemException if a system exception occurred 944 */ 945 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 946 long companyId) 947 throws com.liferay.portal.kernel.exception.SystemException { 948 return getPersistence().findByCompanyId(companyId); 949 } 950 951 /** 952 * Returns a range of all the bookmarks folders where companyId = ?. 953 * 954 * <p> 955 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 956 * </p> 957 * 958 * @param companyId the company 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 962 * @throws SystemException if a system exception occurred 963 */ 964 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 965 long companyId, int start, int end) 966 throws com.liferay.portal.kernel.exception.SystemException { 967 return getPersistence().findByCompanyId(companyId, start, end); 968 } 969 970 /** 971 * Returns an ordered range of all the bookmarks folders where companyId = ?. 972 * 973 * <p> 974 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 975 * </p> 976 * 977 * @param companyId the company ID 978 * @param start the lower bound of the range of bookmarks folders 979 * @param end the upper bound of the range of bookmarks folders (not inclusive) 980 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 981 * @return the ordered range of matching bookmarks folders 982 * @throws SystemException if a system exception occurred 983 */ 984 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 985 long companyId, int start, int end, 986 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 987 throws com.liferay.portal.kernel.exception.SystemException { 988 return getPersistence() 989 .findByCompanyId(companyId, start, end, orderByComparator); 990 } 991 992 /** 993 * Returns the first bookmarks folder in the ordered set where companyId = ?. 994 * 995 * @param companyId the company ID 996 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 997 * @return the first matching bookmarks folder 998 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 999 * @throws SystemException if a system exception occurred 1000 */ 1001 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_First( 1002 long companyId, 1003 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1004 throws com.liferay.portal.kernel.exception.SystemException, 1005 com.liferay.portlet.bookmarks.NoSuchFolderException { 1006 return getPersistence() 1007 .findByCompanyId_First(companyId, orderByComparator); 1008 } 1009 1010 /** 1011 * Returns the first bookmarks folder in the ordered set where companyId = ?. 1012 * 1013 * @param companyId the company ID 1014 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1015 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1016 * @throws SystemException if a system exception occurred 1017 */ 1018 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_First( 1019 long companyId, 1020 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1021 throws com.liferay.portal.kernel.exception.SystemException { 1022 return getPersistence() 1023 .fetchByCompanyId_First(companyId, orderByComparator); 1024 } 1025 1026 /** 1027 * Returns the last bookmarks folder in the ordered set where companyId = ?. 1028 * 1029 * @param companyId the company ID 1030 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1031 * @return the last matching bookmarks folder 1032 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1033 * @throws SystemException if a system exception occurred 1034 */ 1035 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_Last( 1036 long companyId, 1037 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1038 throws com.liferay.portal.kernel.exception.SystemException, 1039 com.liferay.portlet.bookmarks.NoSuchFolderException { 1040 return getPersistence() 1041 .findByCompanyId_Last(companyId, orderByComparator); 1042 } 1043 1044 /** 1045 * Returns the last bookmarks folder in the ordered set where companyId = ?. 1046 * 1047 * @param companyId the company ID 1048 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1049 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1050 * @throws SystemException if a system exception occurred 1051 */ 1052 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_Last( 1053 long companyId, 1054 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1055 throws com.liferay.portal.kernel.exception.SystemException { 1056 return getPersistence() 1057 .fetchByCompanyId_Last(companyId, orderByComparator); 1058 } 1059 1060 /** 1061 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = ?. 1062 * 1063 * @param folderId the primary key of the current bookmarks folder 1064 * @param companyId the company ID 1065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1066 * @return the previous, current, and next bookmarks folder 1067 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1068 * @throws SystemException if a system exception occurred 1069 */ 1070 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByCompanyId_PrevAndNext( 1071 long folderId, long companyId, 1072 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1073 throws com.liferay.portal.kernel.exception.SystemException, 1074 com.liferay.portlet.bookmarks.NoSuchFolderException { 1075 return getPersistence() 1076 .findByCompanyId_PrevAndNext(folderId, companyId, 1077 orderByComparator); 1078 } 1079 1080 /** 1081 * Removes all the bookmarks folders where companyId = ? from the database. 1082 * 1083 * @param companyId the company ID 1084 * @throws SystemException if a system exception occurred 1085 */ 1086 public static void removeByCompanyId(long companyId) 1087 throws com.liferay.portal.kernel.exception.SystemException { 1088 getPersistence().removeByCompanyId(companyId); 1089 } 1090 1091 /** 1092 * Returns the number of bookmarks folders where companyId = ?. 1093 * 1094 * @param companyId the company ID 1095 * @return the number of matching bookmarks folders 1096 * @throws SystemException if a system exception occurred 1097 */ 1098 public static int countByCompanyId(long companyId) 1099 throws com.liferay.portal.kernel.exception.SystemException { 1100 return getPersistence().countByCompanyId(companyId); 1101 } 1102 1103 /** 1104 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ?. 1105 * 1106 * @param groupId the group ID 1107 * @param parentFolderId the parent folder ID 1108 * @return the matching bookmarks folders 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 1112 long groupId, long parentFolderId) 1113 throws com.liferay.portal.kernel.exception.SystemException { 1114 return getPersistence().findByG_P(groupId, parentFolderId); 1115 } 1116 1117 /** 1118 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 1119 * 1120 * <p> 1121 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1122 * </p> 1123 * 1124 * @param groupId the group ID 1125 * @param parentFolderId the parent folder ID 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 matching bookmarks folders 1129 * @throws SystemException if a system exception occurred 1130 */ 1131 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 1132 long groupId, long parentFolderId, int start, int end) 1133 throws com.liferay.portal.kernel.exception.SystemException { 1134 return getPersistence().findByG_P(groupId, parentFolderId, start, end); 1135 } 1136 1137 /** 1138 * Returns an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1142 * </p> 1143 * 1144 * @param groupId the group ID 1145 * @param parentFolderId the parent folder ID 1146 * @param start the lower bound of the range of bookmarks folders 1147 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1149 * @return the ordered range of matching bookmarks folders 1150 * @throws SystemException if a system exception occurred 1151 */ 1152 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 1153 long groupId, long parentFolderId, int start, int end, 1154 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1155 throws com.liferay.portal.kernel.exception.SystemException { 1156 return getPersistence() 1157 .findByG_P(groupId, parentFolderId, start, end, 1158 orderByComparator); 1159 } 1160 1161 /** 1162 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1163 * 1164 * @param groupId the group ID 1165 * @param parentFolderId the parent folder ID 1166 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1167 * @return the first matching bookmarks folder 1168 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1169 * @throws SystemException if a system exception occurred 1170 */ 1171 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_First( 1172 long groupId, long parentFolderId, 1173 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1174 throws com.liferay.portal.kernel.exception.SystemException, 1175 com.liferay.portlet.bookmarks.NoSuchFolderException { 1176 return getPersistence() 1177 .findByG_P_First(groupId, parentFolderId, orderByComparator); 1178 } 1179 1180 /** 1181 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1182 * 1183 * @param groupId the group ID 1184 * @param parentFolderId the parent folder ID 1185 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1186 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1187 * @throws SystemException if a system exception occurred 1188 */ 1189 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_First( 1190 long groupId, long parentFolderId, 1191 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1192 throws com.liferay.portal.kernel.exception.SystemException { 1193 return getPersistence() 1194 .fetchByG_P_First(groupId, parentFolderId, orderByComparator); 1195 } 1196 1197 /** 1198 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1199 * 1200 * @param groupId the group ID 1201 * @param parentFolderId the parent folder ID 1202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1203 * @return the last matching bookmarks folder 1204 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1205 * @throws SystemException if a system exception occurred 1206 */ 1207 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_Last( 1208 long groupId, long parentFolderId, 1209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1210 throws com.liferay.portal.kernel.exception.SystemException, 1211 com.liferay.portlet.bookmarks.NoSuchFolderException { 1212 return getPersistence() 1213 .findByG_P_Last(groupId, parentFolderId, orderByComparator); 1214 } 1215 1216 /** 1217 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1218 * 1219 * @param groupId the group ID 1220 * @param parentFolderId the parent folder ID 1221 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1222 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1223 * @throws SystemException if a system exception occurred 1224 */ 1225 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_Last( 1226 long groupId, long parentFolderId, 1227 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1228 throws com.liferay.portal.kernel.exception.SystemException { 1229 return getPersistence() 1230 .fetchByG_P_Last(groupId, parentFolderId, orderByComparator); 1231 } 1232 1233 /** 1234 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1235 * 1236 * @param folderId the primary key of the current bookmarks folder 1237 * @param groupId the group ID 1238 * @param parentFolderId the parent folder ID 1239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1240 * @return the previous, current, and next bookmarks folder 1241 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1242 * @throws SystemException if a system exception occurred 1243 */ 1244 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_PrevAndNext( 1245 long folderId, long groupId, long parentFolderId, 1246 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1247 throws com.liferay.portal.kernel.exception.SystemException, 1248 com.liferay.portlet.bookmarks.NoSuchFolderException { 1249 return getPersistence() 1250 .findByG_P_PrevAndNext(folderId, groupId, parentFolderId, 1251 orderByComparator); 1252 } 1253 1254 /** 1255 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1256 * 1257 * @param groupId the group ID 1258 * @param parentFolderId the parent folder ID 1259 * @return the matching bookmarks folders that the user has permission to view 1260 * @throws SystemException if a system exception occurred 1261 */ 1262 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1263 long groupId, long parentFolderId) 1264 throws com.liferay.portal.kernel.exception.SystemException { 1265 return getPersistence().filterFindByG_P(groupId, parentFolderId); 1266 } 1267 1268 /** 1269 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1270 * 1271 * <p> 1272 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1273 * </p> 1274 * 1275 * @param groupId the group ID 1276 * @param parentFolderId the parent folder ID 1277 * @param start the lower bound of the range of bookmarks folders 1278 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1279 * @return the range of matching bookmarks folders that the user has permission to view 1280 * @throws SystemException if a system exception occurred 1281 */ 1282 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1283 long groupId, long parentFolderId, int start, int end) 1284 throws com.liferay.portal.kernel.exception.SystemException { 1285 return getPersistence() 1286 .filterFindByG_P(groupId, parentFolderId, start, end); 1287 } 1288 1289 /** 1290 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ?. 1291 * 1292 * <p> 1293 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1294 * </p> 1295 * 1296 * @param groupId the group ID 1297 * @param parentFolderId the parent folder ID 1298 * @param start the lower bound of the range of bookmarks folders 1299 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1300 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1301 * @return the ordered range of matching bookmarks folders that the user has permission to view 1302 * @throws SystemException if a system exception occurred 1303 */ 1304 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1305 long groupId, long parentFolderId, int start, int end, 1306 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1307 throws com.liferay.portal.kernel.exception.SystemException { 1308 return getPersistence() 1309 .filterFindByG_P(groupId, parentFolderId, start, end, 1310 orderByComparator); 1311 } 1312 1313 /** 1314 * 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 = ?. 1315 * 1316 * @param folderId the primary key of the current bookmarks folder 1317 * @param groupId the group ID 1318 * @param parentFolderId the parent folder ID 1319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1320 * @return the previous, current, and next bookmarks folder 1321 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1322 * @throws SystemException if a system exception occurred 1323 */ 1324 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_PrevAndNext( 1325 long folderId, long groupId, long parentFolderId, 1326 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1327 throws com.liferay.portal.kernel.exception.SystemException, 1328 com.liferay.portlet.bookmarks.NoSuchFolderException { 1329 return getPersistence() 1330 .filterFindByG_P_PrevAndNext(folderId, groupId, 1331 parentFolderId, orderByComparator); 1332 } 1333 1334 /** 1335 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? from the database. 1336 * 1337 * @param groupId the group ID 1338 * @param parentFolderId the parent folder ID 1339 * @throws SystemException if a system exception occurred 1340 */ 1341 public static void removeByG_P(long groupId, long parentFolderId) 1342 throws com.liferay.portal.kernel.exception.SystemException { 1343 getPersistence().removeByG_P(groupId, parentFolderId); 1344 } 1345 1346 /** 1347 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ?. 1348 * 1349 * @param groupId the group ID 1350 * @param parentFolderId the parent folder ID 1351 * @return the number of matching bookmarks folders 1352 * @throws SystemException if a system exception occurred 1353 */ 1354 public static int countByG_P(long groupId, long parentFolderId) 1355 throws com.liferay.portal.kernel.exception.SystemException { 1356 return getPersistence().countByG_P(groupId, parentFolderId); 1357 } 1358 1359 /** 1360 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1361 * 1362 * @param groupId the group ID 1363 * @param parentFolderId the parent folder ID 1364 * @return the number of matching bookmarks folders that the user has permission to view 1365 * @throws SystemException if a system exception occurred 1366 */ 1367 public static int filterCountByG_P(long groupId, long parentFolderId) 1368 throws com.liferay.portal.kernel.exception.SystemException { 1369 return getPersistence().filterCountByG_P(groupId, parentFolderId); 1370 } 1371 1372 /** 1373 * Returns all the bookmarks folders where companyId = ? and status ≠ ?. 1374 * 1375 * @param companyId the company ID 1376 * @param status the status 1377 * @return the matching bookmarks folders 1378 * @throws SystemException if a system exception occurred 1379 */ 1380 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS( 1381 long companyId, int status) 1382 throws com.liferay.portal.kernel.exception.SystemException { 1383 return getPersistence().findByC_NotS(companyId, status); 1384 } 1385 1386 /** 1387 * Returns a range of all the bookmarks folders where companyId = ? and status ≠ ?. 1388 * 1389 * <p> 1390 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1391 * </p> 1392 * 1393 * @param companyId the company ID 1394 * @param status the status 1395 * @param start the lower bound of the range of bookmarks folders 1396 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1397 * @return the range of matching bookmarks folders 1398 * @throws SystemException if a system exception occurred 1399 */ 1400 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS( 1401 long companyId, int status, int start, int end) 1402 throws com.liferay.portal.kernel.exception.SystemException { 1403 return getPersistence().findByC_NotS(companyId, status, start, end); 1404 } 1405 1406 /** 1407 * Returns an ordered range of all the bookmarks folders where companyId = ? and status ≠ ?. 1408 * 1409 * <p> 1410 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1411 * </p> 1412 * 1413 * @param companyId the company ID 1414 * @param status the status 1415 * @param start the lower bound of the range of bookmarks folders 1416 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1417 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1418 * @return the ordered range of matching bookmarks folders 1419 * @throws SystemException if a system exception occurred 1420 */ 1421 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS( 1422 long companyId, int status, int start, int end, 1423 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1424 throws com.liferay.portal.kernel.exception.SystemException { 1425 return getPersistence() 1426 .findByC_NotS(companyId, status, start, end, 1427 orderByComparator); 1428 } 1429 1430 /** 1431 * Returns the first bookmarks folder in the ordered set where companyId = ? and status ≠ ?. 1432 * 1433 * @param companyId the company ID 1434 * @param status the status 1435 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1436 * @return the first matching bookmarks folder 1437 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1438 * @throws SystemException if a system exception occurred 1439 */ 1440 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByC_NotS_First( 1441 long companyId, int status, 1442 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1443 throws com.liferay.portal.kernel.exception.SystemException, 1444 com.liferay.portlet.bookmarks.NoSuchFolderException { 1445 return getPersistence() 1446 .findByC_NotS_First(companyId, status, orderByComparator); 1447 } 1448 1449 /** 1450 * Returns the first bookmarks folder in the ordered set where companyId = ? and status ≠ ?. 1451 * 1452 * @param companyId the company ID 1453 * @param status the status 1454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1455 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1456 * @throws SystemException if a system exception occurred 1457 */ 1458 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByC_NotS_First( 1459 long companyId, int status, 1460 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1461 throws com.liferay.portal.kernel.exception.SystemException { 1462 return getPersistence() 1463 .fetchByC_NotS_First(companyId, status, orderByComparator); 1464 } 1465 1466 /** 1467 * Returns the last bookmarks folder in the ordered set where companyId = ? and status ≠ ?. 1468 * 1469 * @param companyId the company ID 1470 * @param status the status 1471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1472 * @return the last matching bookmarks folder 1473 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1474 * @throws SystemException if a system exception occurred 1475 */ 1476 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByC_NotS_Last( 1477 long companyId, int status, 1478 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1479 throws com.liferay.portal.kernel.exception.SystemException, 1480 com.liferay.portlet.bookmarks.NoSuchFolderException { 1481 return getPersistence() 1482 .findByC_NotS_Last(companyId, status, orderByComparator); 1483 } 1484 1485 /** 1486 * Returns the last bookmarks folder in the ordered set where companyId = ? and status ≠ ?. 1487 * 1488 * @param companyId the company ID 1489 * @param status the status 1490 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1491 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1492 * @throws SystemException if a system exception occurred 1493 */ 1494 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByC_NotS_Last( 1495 long companyId, int status, 1496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1497 throws com.liferay.portal.kernel.exception.SystemException { 1498 return getPersistence() 1499 .fetchByC_NotS_Last(companyId, status, orderByComparator); 1500 } 1501 1502 /** 1503 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = ? and status ≠ ?. 1504 * 1505 * @param folderId the primary key of the current bookmarks folder 1506 * @param companyId the company ID 1507 * @param status the status 1508 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1509 * @return the previous, current, and next bookmarks folder 1510 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1511 * @throws SystemException if a system exception occurred 1512 */ 1513 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByC_NotS_PrevAndNext( 1514 long folderId, long companyId, int status, 1515 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1516 throws com.liferay.portal.kernel.exception.SystemException, 1517 com.liferay.portlet.bookmarks.NoSuchFolderException { 1518 return getPersistence() 1519 .findByC_NotS_PrevAndNext(folderId, companyId, status, 1520 orderByComparator); 1521 } 1522 1523 /** 1524 * Removes all the bookmarks folders where companyId = ? and status ≠ ? from the database. 1525 * 1526 * @param companyId the company ID 1527 * @param status the status 1528 * @throws SystemException if a system exception occurred 1529 */ 1530 public static void removeByC_NotS(long companyId, int status) 1531 throws com.liferay.portal.kernel.exception.SystemException { 1532 getPersistence().removeByC_NotS(companyId, status); 1533 } 1534 1535 /** 1536 * Returns the number of bookmarks folders where companyId = ? and status ≠ ?. 1537 * 1538 * @param companyId the company ID 1539 * @param status the status 1540 * @return the number of matching bookmarks folders 1541 * @throws SystemException if a system exception occurred 1542 */ 1543 public static int countByC_NotS(long companyId, int status) 1544 throws com.liferay.portal.kernel.exception.SystemException { 1545 return getPersistence().countByC_NotS(companyId, status); 1546 } 1547 1548 /** 1549 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1550 * 1551 * @param groupId the group ID 1552 * @param parentFolderId the parent folder ID 1553 * @param status the status 1554 * @return the matching bookmarks folders 1555 * @throws SystemException if a system exception occurred 1556 */ 1557 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S( 1558 long groupId, long parentFolderId, int status) 1559 throws com.liferay.portal.kernel.exception.SystemException { 1560 return getPersistence().findByG_P_S(groupId, parentFolderId, status); 1561 } 1562 1563 /** 1564 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1565 * 1566 * <p> 1567 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1568 * </p> 1569 * 1570 * @param groupId the group ID 1571 * @param parentFolderId the parent folder ID 1572 * @param status the status 1573 * @param start the lower bound of the range of bookmarks folders 1574 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1575 * @return the range of matching bookmarks folders 1576 * @throws SystemException if a system exception occurred 1577 */ 1578 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S( 1579 long groupId, long parentFolderId, int status, int start, int end) 1580 throws com.liferay.portal.kernel.exception.SystemException { 1581 return getPersistence() 1582 .findByG_P_S(groupId, parentFolderId, status, start, end); 1583 } 1584 1585 /** 1586 * Returns an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1587 * 1588 * <p> 1589 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1590 * </p> 1591 * 1592 * @param groupId the group ID 1593 * @param parentFolderId the parent folder ID 1594 * @param status the status 1595 * @param start the lower bound of the range of bookmarks folders 1596 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1597 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1598 * @return the ordered range of matching bookmarks folders 1599 * @throws SystemException if a system exception occurred 1600 */ 1601 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S( 1602 long groupId, long parentFolderId, int status, int start, int end, 1603 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1604 throws com.liferay.portal.kernel.exception.SystemException { 1605 return getPersistence() 1606 .findByG_P_S(groupId, parentFolderId, status, start, end, 1607 orderByComparator); 1608 } 1609 1610 /** 1611 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1612 * 1613 * @param groupId the group ID 1614 * @param parentFolderId the parent folder ID 1615 * @param status the status 1616 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1617 * @return the first matching bookmarks folder 1618 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1619 * @throws SystemException if a system exception occurred 1620 */ 1621 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_First( 1622 long groupId, long parentFolderId, int status, 1623 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1624 throws com.liferay.portal.kernel.exception.SystemException, 1625 com.liferay.portlet.bookmarks.NoSuchFolderException { 1626 return getPersistence() 1627 .findByG_P_S_First(groupId, parentFolderId, status, 1628 orderByComparator); 1629 } 1630 1631 /** 1632 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1633 * 1634 * @param groupId the group ID 1635 * @param parentFolderId the parent folder ID 1636 * @param status the status 1637 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1638 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1639 * @throws SystemException if a system exception occurred 1640 */ 1641 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_First( 1642 long groupId, long parentFolderId, int status, 1643 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1644 throws com.liferay.portal.kernel.exception.SystemException { 1645 return getPersistence() 1646 .fetchByG_P_S_First(groupId, parentFolderId, status, 1647 orderByComparator); 1648 } 1649 1650 /** 1651 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1652 * 1653 * @param groupId the group ID 1654 * @param parentFolderId the parent folder ID 1655 * @param status the status 1656 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1657 * @return the last matching bookmarks folder 1658 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1659 * @throws SystemException if a system exception occurred 1660 */ 1661 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_Last( 1662 long groupId, long parentFolderId, int status, 1663 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1664 throws com.liferay.portal.kernel.exception.SystemException, 1665 com.liferay.portlet.bookmarks.NoSuchFolderException { 1666 return getPersistence() 1667 .findByG_P_S_Last(groupId, parentFolderId, status, 1668 orderByComparator); 1669 } 1670 1671 /** 1672 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1673 * 1674 * @param groupId the group ID 1675 * @param parentFolderId the parent folder ID 1676 * @param status the status 1677 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1678 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1679 * @throws SystemException if a system exception occurred 1680 */ 1681 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_Last( 1682 long groupId, long parentFolderId, int status, 1683 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1684 throws com.liferay.portal.kernel.exception.SystemException { 1685 return getPersistence() 1686 .fetchByG_P_S_Last(groupId, parentFolderId, status, 1687 orderByComparator); 1688 } 1689 1690 /** 1691 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1692 * 1693 * @param folderId the primary key of the current bookmarks folder 1694 * @param groupId the group ID 1695 * @param parentFolderId the parent folder ID 1696 * @param status the status 1697 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1698 * @return the previous, current, and next bookmarks folder 1699 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1700 * @throws SystemException if a system exception occurred 1701 */ 1702 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_S_PrevAndNext( 1703 long folderId, long groupId, long parentFolderId, int status, 1704 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1705 throws com.liferay.portal.kernel.exception.SystemException, 1706 com.liferay.portlet.bookmarks.NoSuchFolderException { 1707 return getPersistence() 1708 .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId, 1709 status, orderByComparator); 1710 } 1711 1712 /** 1713 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1714 * 1715 * @param groupId the group ID 1716 * @param parentFolderId the parent folder ID 1717 * @param status the status 1718 * @return the matching bookmarks folders that the user has permission to view 1719 * @throws SystemException if a system exception occurred 1720 */ 1721 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S( 1722 long groupId, long parentFolderId, int status) 1723 throws com.liferay.portal.kernel.exception.SystemException { 1724 return getPersistence() 1725 .filterFindByG_P_S(groupId, parentFolderId, status); 1726 } 1727 1728 /** 1729 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1730 * 1731 * <p> 1732 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1733 * </p> 1734 * 1735 * @param groupId the group ID 1736 * @param parentFolderId the parent folder ID 1737 * @param status the status 1738 * @param start the lower bound of the range of bookmarks folders 1739 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1740 * @return the range of matching bookmarks folders that the user has permission to view 1741 * @throws SystemException if a system exception occurred 1742 */ 1743 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S( 1744 long groupId, long parentFolderId, int status, int start, int end) 1745 throws com.liferay.portal.kernel.exception.SystemException { 1746 return getPersistence() 1747 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1748 end); 1749 } 1750 1751 /** 1752 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status = ?. 1753 * 1754 * <p> 1755 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1756 * </p> 1757 * 1758 * @param groupId the group ID 1759 * @param parentFolderId the parent folder ID 1760 * @param status the status 1761 * @param start the lower bound of the range of bookmarks folders 1762 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1763 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1764 * @return the ordered range of matching bookmarks folders that the user has permission to view 1765 * @throws SystemException if a system exception occurred 1766 */ 1767 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S( 1768 long groupId, long parentFolderId, int status, int start, int end, 1769 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1770 throws com.liferay.portal.kernel.exception.SystemException { 1771 return getPersistence() 1772 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1773 end, orderByComparator); 1774 } 1775 1776 /** 1777 * 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 = ? and status = ?. 1778 * 1779 * @param folderId the primary key of the current bookmarks folder 1780 * @param groupId the group ID 1781 * @param parentFolderId the parent folder ID 1782 * @param status the status 1783 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1784 * @return the previous, current, and next bookmarks folder 1785 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1786 * @throws SystemException if a system exception occurred 1787 */ 1788 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_S_PrevAndNext( 1789 long folderId, long groupId, long parentFolderId, int status, 1790 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1791 throws com.liferay.portal.kernel.exception.SystemException, 1792 com.liferay.portlet.bookmarks.NoSuchFolderException { 1793 return getPersistence() 1794 .filterFindByG_P_S_PrevAndNext(folderId, groupId, 1795 parentFolderId, status, orderByComparator); 1796 } 1797 1798 /** 1799 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ? from the database. 1800 * 1801 * @param groupId the group ID 1802 * @param parentFolderId the parent folder ID 1803 * @param status the status 1804 * @throws SystemException if a system exception occurred 1805 */ 1806 public static void removeByG_P_S(long groupId, long parentFolderId, 1807 int status) throws com.liferay.portal.kernel.exception.SystemException { 1808 getPersistence().removeByG_P_S(groupId, parentFolderId, status); 1809 } 1810 1811 /** 1812 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1813 * 1814 * @param groupId the group ID 1815 * @param parentFolderId the parent folder ID 1816 * @param status the status 1817 * @return the number of matching bookmarks folders 1818 * @throws SystemException if a system exception occurred 1819 */ 1820 public static int countByG_P_S(long groupId, long parentFolderId, int status) 1821 throws com.liferay.portal.kernel.exception.SystemException { 1822 return getPersistence().countByG_P_S(groupId, parentFolderId, status); 1823 } 1824 1825 /** 1826 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1827 * 1828 * @param groupId the group ID 1829 * @param parentFolderId the parent folder ID 1830 * @param status the status 1831 * @return the number of matching bookmarks folders that the user has permission to view 1832 * @throws SystemException if a system exception occurred 1833 */ 1834 public static int filterCountByG_P_S(long groupId, long parentFolderId, 1835 int status) throws com.liferay.portal.kernel.exception.SystemException { 1836 return getPersistence() 1837 .filterCountByG_P_S(groupId, parentFolderId, status); 1838 } 1839 1840 /** 1841 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1842 * 1843 * @param groupId the group ID 1844 * @param parentFolderId the parent folder ID 1845 * @param status the status 1846 * @return the matching bookmarks folders 1847 * @throws SystemException if a system exception occurred 1848 */ 1849 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS( 1850 long groupId, long parentFolderId, int status) 1851 throws com.liferay.portal.kernel.exception.SystemException { 1852 return getPersistence().findByG_P_NotS(groupId, parentFolderId, status); 1853 } 1854 1855 /** 1856 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1857 * 1858 * <p> 1859 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1860 * </p> 1861 * 1862 * @param groupId the group ID 1863 * @param parentFolderId the parent folder ID 1864 * @param status the status 1865 * @param start the lower bound of the range of bookmarks folders 1866 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1867 * @return the range of matching bookmarks folders 1868 * @throws SystemException if a system exception occurred 1869 */ 1870 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS( 1871 long groupId, long parentFolderId, int status, int start, int end) 1872 throws com.liferay.portal.kernel.exception.SystemException { 1873 return getPersistence() 1874 .findByG_P_NotS(groupId, parentFolderId, status, start, end); 1875 } 1876 1877 /** 1878 * Returns an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1879 * 1880 * <p> 1881 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1882 * </p> 1883 * 1884 * @param groupId the group ID 1885 * @param parentFolderId the parent folder ID 1886 * @param status the status 1887 * @param start the lower bound of the range of bookmarks folders 1888 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1889 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1890 * @return the ordered range of matching bookmarks folders 1891 * @throws SystemException if a system exception occurred 1892 */ 1893 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS( 1894 long groupId, long parentFolderId, int status, int start, int end, 1895 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1896 throws com.liferay.portal.kernel.exception.SystemException { 1897 return getPersistence() 1898 .findByG_P_NotS(groupId, parentFolderId, status, start, end, 1899 orderByComparator); 1900 } 1901 1902 /** 1903 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1904 * 1905 * @param groupId the group ID 1906 * @param parentFolderId the parent folder ID 1907 * @param status the status 1908 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1909 * @return the first matching bookmarks folder 1910 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1911 * @throws SystemException if a system exception occurred 1912 */ 1913 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_First( 1914 long groupId, long parentFolderId, int status, 1915 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1916 throws com.liferay.portal.kernel.exception.SystemException, 1917 com.liferay.portlet.bookmarks.NoSuchFolderException { 1918 return getPersistence() 1919 .findByG_P_NotS_First(groupId, parentFolderId, status, 1920 orderByComparator); 1921 } 1922 1923 /** 1924 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1925 * 1926 * @param groupId the group ID 1927 * @param parentFolderId the parent folder ID 1928 * @param status the status 1929 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1930 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1931 * @throws SystemException if a system exception occurred 1932 */ 1933 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_First( 1934 long groupId, long parentFolderId, int status, 1935 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1936 throws com.liferay.portal.kernel.exception.SystemException { 1937 return getPersistence() 1938 .fetchByG_P_NotS_First(groupId, parentFolderId, status, 1939 orderByComparator); 1940 } 1941 1942 /** 1943 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1944 * 1945 * @param groupId the group ID 1946 * @param parentFolderId the parent folder ID 1947 * @param status the status 1948 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1949 * @return the last matching bookmarks folder 1950 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1951 * @throws SystemException if a system exception occurred 1952 */ 1953 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_Last( 1954 long groupId, long parentFolderId, int status, 1955 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1956 throws com.liferay.portal.kernel.exception.SystemException, 1957 com.liferay.portlet.bookmarks.NoSuchFolderException { 1958 return getPersistence() 1959 .findByG_P_NotS_Last(groupId, parentFolderId, status, 1960 orderByComparator); 1961 } 1962 1963 /** 1964 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1965 * 1966 * @param groupId the group ID 1967 * @param parentFolderId the parent folder ID 1968 * @param status the status 1969 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1970 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1971 * @throws SystemException if a system exception occurred 1972 */ 1973 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_Last( 1974 long groupId, long parentFolderId, int status, 1975 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1976 throws com.liferay.portal.kernel.exception.SystemException { 1977 return getPersistence() 1978 .fetchByG_P_NotS_Last(groupId, parentFolderId, status, 1979 orderByComparator); 1980 } 1981 1982 /** 1983 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1984 * 1985 * @param folderId the primary key of the current bookmarks folder 1986 * @param groupId the group ID 1987 * @param parentFolderId the parent folder ID 1988 * @param status the status 1989 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1990 * @return the previous, current, and next bookmarks folder 1991 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1992 * @throws SystemException if a system exception occurred 1993 */ 1994 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_NotS_PrevAndNext( 1995 long folderId, long groupId, long parentFolderId, int status, 1996 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1997 throws com.liferay.portal.kernel.exception.SystemException, 1998 com.liferay.portlet.bookmarks.NoSuchFolderException { 1999 return getPersistence() 2000 .findByG_P_NotS_PrevAndNext(folderId, groupId, 2001 parentFolderId, status, orderByComparator); 2002 } 2003 2004 /** 2005 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 2006 * 2007 * @param groupId the group ID 2008 * @param parentFolderId the parent folder ID 2009 * @param status the status 2010 * @return the matching bookmarks folders that the user has permission to view 2011 * @throws SystemException if a system exception occurred 2012 */ 2013 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS( 2014 long groupId, long parentFolderId, int status) 2015 throws com.liferay.portal.kernel.exception.SystemException { 2016 return getPersistence() 2017 .filterFindByG_P_NotS(groupId, parentFolderId, status); 2018 } 2019 2020 /** 2021 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 2022 * 2023 * <p> 2024 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2025 * </p> 2026 * 2027 * @param groupId the group ID 2028 * @param parentFolderId the parent folder ID 2029 * @param status the status 2030 * @param start the lower bound of the range of bookmarks folders 2031 * @param end the upper bound of the range of bookmarks folders (not inclusive) 2032 * @return the range of matching bookmarks folders that the user has permission to view 2033 * @throws SystemException if a system exception occurred 2034 */ 2035 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS( 2036 long groupId, long parentFolderId, int status, int start, int end) 2037 throws com.liferay.portal.kernel.exception.SystemException { 2038 return getPersistence() 2039 .filterFindByG_P_NotS(groupId, parentFolderId, status, 2040 start, end); 2041 } 2042 2043 /** 2044 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status ≠ ?. 2045 * 2046 * <p> 2047 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2048 * </p> 2049 * 2050 * @param groupId the group ID 2051 * @param parentFolderId the parent folder ID 2052 * @param status the status 2053 * @param start the lower bound of the range of bookmarks folders 2054 * @param end the upper bound of the range of bookmarks folders (not inclusive) 2055 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2056 * @return the ordered range of matching bookmarks folders that the user has permission to view 2057 * @throws SystemException if a system exception occurred 2058 */ 2059 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS( 2060 long groupId, long parentFolderId, int status, int start, int end, 2061 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2062 throws com.liferay.portal.kernel.exception.SystemException { 2063 return getPersistence() 2064 .filterFindByG_P_NotS(groupId, parentFolderId, status, 2065 start, end, orderByComparator); 2066 } 2067 2068 /** 2069 * 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 = ? and status ≠ ?. 2070 * 2071 * @param folderId the primary key of the current bookmarks folder 2072 * @param groupId the group ID 2073 * @param parentFolderId the parent folder ID 2074 * @param status the status 2075 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2076 * @return the previous, current, and next bookmarks folder 2077 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 2078 * @throws SystemException if a system exception occurred 2079 */ 2080 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_NotS_PrevAndNext( 2081 long folderId, long groupId, long parentFolderId, int status, 2082 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2083 throws com.liferay.portal.kernel.exception.SystemException, 2084 com.liferay.portlet.bookmarks.NoSuchFolderException { 2085 return getPersistence() 2086 .filterFindByG_P_NotS_PrevAndNext(folderId, groupId, 2087 parentFolderId, status, orderByComparator); 2088 } 2089 2090 /** 2091 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ? from the database. 2092 * 2093 * @param groupId the group ID 2094 * @param parentFolderId the parent folder ID 2095 * @param status the status 2096 * @throws SystemException if a system exception occurred 2097 */ 2098 public static void removeByG_P_NotS(long groupId, long parentFolderId, 2099 int status) throws com.liferay.portal.kernel.exception.SystemException { 2100 getPersistence().removeByG_P_NotS(groupId, parentFolderId, status); 2101 } 2102 2103 /** 2104 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 2105 * 2106 * @param groupId the group ID 2107 * @param parentFolderId the parent folder ID 2108 * @param status the status 2109 * @return the number of matching bookmarks folders 2110 * @throws SystemException if a system exception occurred 2111 */ 2112 public static int countByG_P_NotS(long groupId, long parentFolderId, 2113 int status) throws com.liferay.portal.kernel.exception.SystemException { 2114 return getPersistence().countByG_P_NotS(groupId, parentFolderId, status); 2115 } 2116 2117 /** 2118 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 2119 * 2120 * @param groupId the group ID 2121 * @param parentFolderId the parent folder ID 2122 * @param status the status 2123 * @return the number of matching bookmarks folders that the user has permission to view 2124 * @throws SystemException if a system exception occurred 2125 */ 2126 public static int filterCountByG_P_NotS(long groupId, long parentFolderId, 2127 int status) throws com.liferay.portal.kernel.exception.SystemException { 2128 return getPersistence() 2129 .filterCountByG_P_NotS(groupId, parentFolderId, status); 2130 } 2131 2132 /** 2133 * Caches the bookmarks folder in the entity cache if it is enabled. 2134 * 2135 * @param bookmarksFolder the bookmarks folder 2136 */ 2137 public static void cacheResult( 2138 com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) { 2139 getPersistence().cacheResult(bookmarksFolder); 2140 } 2141 2142 /** 2143 * Caches the bookmarks folders in the entity cache if it is enabled. 2144 * 2145 * @param bookmarksFolders the bookmarks folders 2146 */ 2147 public static void cacheResult( 2148 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> bookmarksFolders) { 2149 getPersistence().cacheResult(bookmarksFolders); 2150 } 2151 2152 /** 2153 * Creates a new bookmarks folder with the primary key. Does not add the bookmarks folder to the database. 2154 * 2155 * @param folderId the primary key for the new bookmarks folder 2156 * @return the new bookmarks folder 2157 */ 2158 public static com.liferay.portlet.bookmarks.model.BookmarksFolder create( 2159 long folderId) { 2160 return getPersistence().create(folderId); 2161 } 2162 2163 /** 2164 * Removes the bookmarks folder with the primary key from the database. Also notifies the appropriate model listeners. 2165 * 2166 * @param folderId the primary key of the bookmarks folder 2167 * @return the bookmarks folder that was removed 2168 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 2169 * @throws SystemException if a system exception occurred 2170 */ 2171 public static com.liferay.portlet.bookmarks.model.BookmarksFolder remove( 2172 long folderId) 2173 throws com.liferay.portal.kernel.exception.SystemException, 2174 com.liferay.portlet.bookmarks.NoSuchFolderException { 2175 return getPersistence().remove(folderId); 2176 } 2177 2178 public static com.liferay.portlet.bookmarks.model.BookmarksFolder updateImpl( 2179 com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) 2180 throws com.liferay.portal.kernel.exception.SystemException { 2181 return getPersistence().updateImpl(bookmarksFolder); 2182 } 2183 2184 /** 2185 * Returns the bookmarks folder with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 2186 * 2187 * @param folderId the primary key of the bookmarks folder 2188 * @return the bookmarks folder 2189 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 2190 * @throws SystemException if a system exception occurred 2191 */ 2192 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByPrimaryKey( 2193 long folderId) 2194 throws com.liferay.portal.kernel.exception.SystemException, 2195 com.liferay.portlet.bookmarks.NoSuchFolderException { 2196 return getPersistence().findByPrimaryKey(folderId); 2197 } 2198 2199 /** 2200 * Returns the bookmarks folder with the primary key or returns <code>null</code> if it could not be found. 2201 * 2202 * @param folderId the primary key of the bookmarks folder 2203 * @return the bookmarks folder, or <code>null</code> if a bookmarks folder with the primary key could not be found 2204 * @throws SystemException if a system exception occurred 2205 */ 2206 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByPrimaryKey( 2207 long folderId) 2208 throws com.liferay.portal.kernel.exception.SystemException { 2209 return getPersistence().fetchByPrimaryKey(folderId); 2210 } 2211 2212 /** 2213 * Returns all the bookmarks folders. 2214 * 2215 * @return the bookmarks folders 2216 * @throws SystemException if a system exception occurred 2217 */ 2218 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll() 2219 throws com.liferay.portal.kernel.exception.SystemException { 2220 return getPersistence().findAll(); 2221 } 2222 2223 /** 2224 * Returns a range of all the bookmarks folders. 2225 * 2226 * <p> 2227 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2228 * </p> 2229 * 2230 * @param start the lower bound of the range of bookmarks folders 2231 * @param end the upper bound of the range of bookmarks folders (not inclusive) 2232 * @return the range of bookmarks folders 2233 * @throws SystemException if a system exception occurred 2234 */ 2235 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 2236 int start, int end) 2237 throws com.liferay.portal.kernel.exception.SystemException { 2238 return getPersistence().findAll(start, end); 2239 } 2240 2241 /** 2242 * Returns an ordered range of all the bookmarks folders. 2243 * 2244 * <p> 2245 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2246 * </p> 2247 * 2248 * @param start the lower bound of the range of bookmarks folders 2249 * @param end the upper bound of the range of bookmarks folders (not inclusive) 2250 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2251 * @return the ordered range of bookmarks folders 2252 * @throws SystemException if a system exception occurred 2253 */ 2254 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 2255 int start, int end, 2256 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2257 throws com.liferay.portal.kernel.exception.SystemException { 2258 return getPersistence().findAll(start, end, orderByComparator); 2259 } 2260 2261 /** 2262 * Removes all the bookmarks folders from the database. 2263 * 2264 * @throws SystemException if a system exception occurred 2265 */ 2266 public static void removeAll() 2267 throws com.liferay.portal.kernel.exception.SystemException { 2268 getPersistence().removeAll(); 2269 } 2270 2271 /** 2272 * Returns the number of bookmarks folders. 2273 * 2274 * @return the number of bookmarks folders 2275 * @throws SystemException if a system exception occurred 2276 */ 2277 public static int countAll() 2278 throws com.liferay.portal.kernel.exception.SystemException { 2279 return getPersistence().countAll(); 2280 } 2281 2282 public static BookmarksFolderPersistence getPersistence() { 2283 if (_persistence == null) { 2284 _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName()); 2285 2286 ReferenceRegistry.registerReference(BookmarksFolderUtil.class, 2287 "_persistence"); 2288 } 2289 2290 return _persistence; 2291 } 2292 2293 /** 2294 * @deprecated As of 6.2.0 2295 */ 2296 public void setPersistence(BookmarksFolderPersistence persistence) { 2297 } 2298 2299 private static BookmarksFolderPersistence _persistence; 2300 }