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