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