001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.bookmarks.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.bookmarks.model.BookmarksEntry; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the bookmarks entry service. This utility wraps {@link BookmarksEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see BookmarksEntryPersistence 037 * @see BookmarksEntryPersistenceImpl 038 * @generated 039 */ 040 public class BookmarksEntryUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(BookmarksEntry bookmarksEntry) { 058 getPersistence().clearCache(bookmarksEntry); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<BookmarksEntry> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<BookmarksEntry> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<BookmarksEntry> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static BookmarksEntry update(BookmarksEntry bookmarksEntry) 101 throws SystemException { 102 return getPersistence().update(bookmarksEntry); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static BookmarksEntry update(BookmarksEntry bookmarksEntry, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(bookmarksEntry, serviceContext); 111 } 112 113 /** 114 * Returns all the bookmarks entries where resourceBlockId = ?. 115 * 116 * @param resourceBlockId the resource block ID 117 * @return the matching bookmarks entries 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 121 long resourceBlockId) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByResourceBlockId(resourceBlockId); 124 } 125 126 /** 127 * Returns a range of all the bookmarks entries where resourceBlockId = ?. 128 * 129 * <p> 130 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 131 * </p> 132 * 133 * @param resourceBlockId the resource block ID 134 * @param start the lower bound of the range of bookmarks entries 135 * @param end the upper bound of the range of bookmarks entries (not inclusive) 136 * @return the range of matching bookmarks entries 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 140 long resourceBlockId, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence() 143 .findByResourceBlockId(resourceBlockId, start, end); 144 } 145 146 /** 147 * Returns an ordered range of all the bookmarks entries where resourceBlockId = ?. 148 * 149 * <p> 150 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 151 * </p> 152 * 153 * @param resourceBlockId the resource block ID 154 * @param start the lower bound of the range of bookmarks entries 155 * @param end the upper bound of the range of bookmarks entries (not inclusive) 156 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 157 * @return the ordered range of matching bookmarks entries 158 * @throws SystemException if a system exception occurred 159 */ 160 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 161 long resourceBlockId, int start, int end, 162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence() 165 .findByResourceBlockId(resourceBlockId, start, end, 166 orderByComparator); 167 } 168 169 /** 170 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 171 * 172 * @param resourceBlockId the resource block ID 173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 174 * @return the first matching bookmarks entry 175 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 176 * @throws SystemException if a system exception occurred 177 */ 178 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First( 179 long resourceBlockId, 180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.bookmarks.NoSuchEntryException { 183 return getPersistence() 184 .findByResourceBlockId_First(resourceBlockId, 185 orderByComparator); 186 } 187 188 /** 189 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 190 * 191 * @param resourceBlockId the resource block ID 192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 193 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First( 197 long resourceBlockId, 198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 199 throws com.liferay.portal.kernel.exception.SystemException { 200 return getPersistence() 201 .fetchByResourceBlockId_First(resourceBlockId, 202 orderByComparator); 203 } 204 205 /** 206 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 207 * 208 * @param resourceBlockId the resource block ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching bookmarks entry 211 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 212 * @throws SystemException if a system exception occurred 213 */ 214 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last( 215 long resourceBlockId, 216 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 217 throws com.liferay.portal.kernel.exception.SystemException, 218 com.liferay.portlet.bookmarks.NoSuchEntryException { 219 return getPersistence() 220 .findByResourceBlockId_Last(resourceBlockId, 221 orderByComparator); 222 } 223 224 /** 225 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 226 * 227 * @param resourceBlockId the resource block ID 228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 229 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 230 * @throws SystemException if a system exception occurred 231 */ 232 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last( 233 long resourceBlockId, 234 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 235 throws com.liferay.portal.kernel.exception.SystemException { 236 return getPersistence() 237 .fetchByResourceBlockId_Last(resourceBlockId, 238 orderByComparator); 239 } 240 241 /** 242 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = ?. 243 * 244 * @param entryId the primary key of the current bookmarks entry 245 * @param resourceBlockId the resource block ID 246 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 247 * @return the previous, current, and next bookmarks entry 248 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 249 * @throws SystemException if a system exception occurred 250 */ 251 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext( 252 long entryId, long resourceBlockId, 253 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 254 throws com.liferay.portal.kernel.exception.SystemException, 255 com.liferay.portlet.bookmarks.NoSuchEntryException { 256 return getPersistence() 257 .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId, 258 orderByComparator); 259 } 260 261 /** 262 * Removes all the bookmarks entries where resourceBlockId = ? from the database. 263 * 264 * @param resourceBlockId the resource block ID 265 * @throws SystemException if a system exception occurred 266 */ 267 public static void removeByResourceBlockId(long resourceBlockId) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 getPersistence().removeByResourceBlockId(resourceBlockId); 270 } 271 272 /** 273 * Returns the number of bookmarks entries where resourceBlockId = ?. 274 * 275 * @param resourceBlockId the resource block ID 276 * @return the number of matching bookmarks entries 277 * @throws SystemException if a system exception occurred 278 */ 279 public static int countByResourceBlockId(long resourceBlockId) 280 throws com.liferay.portal.kernel.exception.SystemException { 281 return getPersistence().countByResourceBlockId(resourceBlockId); 282 } 283 284 /** 285 * Returns all the bookmarks entries where uuid = ?. 286 * 287 * @param uuid the uuid 288 * @return the matching bookmarks entries 289 * @throws SystemException if a system exception occurred 290 */ 291 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 292 java.lang.String uuid) 293 throws com.liferay.portal.kernel.exception.SystemException { 294 return getPersistence().findByUuid(uuid); 295 } 296 297 /** 298 * Returns a range of all the bookmarks entries where uuid = ?. 299 * 300 * <p> 301 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 302 * </p> 303 * 304 * @param uuid the uuid 305 * @param start the lower bound of the range of bookmarks entries 306 * @param end the upper bound of the range of bookmarks entries (not inclusive) 307 * @return the range of matching bookmarks entries 308 * @throws SystemException if a system exception occurred 309 */ 310 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 311 java.lang.String uuid, int start, int end) 312 throws com.liferay.portal.kernel.exception.SystemException { 313 return getPersistence().findByUuid(uuid, start, end); 314 } 315 316 /** 317 * Returns an ordered range of all the bookmarks entries where uuid = ?. 318 * 319 * <p> 320 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 321 * </p> 322 * 323 * @param uuid the uuid 324 * @param start the lower bound of the range of bookmarks entries 325 * @param end the upper bound of the range of bookmarks entries (not inclusive) 326 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 327 * @return the ordered range of matching bookmarks entries 328 * @throws SystemException if a system exception occurred 329 */ 330 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 331 java.lang.String uuid, int start, int end, 332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 333 throws com.liferay.portal.kernel.exception.SystemException { 334 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 335 } 336 337 /** 338 * Returns the first bookmarks entry in the ordered set where uuid = ?. 339 * 340 * @param uuid the uuid 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the first matching bookmarks entry 343 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 344 * @throws SystemException if a system exception occurred 345 */ 346 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First( 347 java.lang.String uuid, 348 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 349 throws com.liferay.portal.kernel.exception.SystemException, 350 com.liferay.portlet.bookmarks.NoSuchEntryException { 351 return getPersistence().findByUuid_First(uuid, orderByComparator); 352 } 353 354 /** 355 * Returns the first bookmarks entry in the ordered set where uuid = ?. 356 * 357 * @param uuid the uuid 358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 359 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 360 * @throws SystemException if a system exception occurred 361 */ 362 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First( 363 java.lang.String uuid, 364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 365 throws com.liferay.portal.kernel.exception.SystemException { 366 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 367 } 368 369 /** 370 * Returns the last bookmarks entry in the ordered set where uuid = ?. 371 * 372 * @param uuid the uuid 373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 374 * @return the last matching bookmarks entry 375 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 376 * @throws SystemException if a system exception occurred 377 */ 378 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last( 379 java.lang.String uuid, 380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 381 throws com.liferay.portal.kernel.exception.SystemException, 382 com.liferay.portlet.bookmarks.NoSuchEntryException { 383 return getPersistence().findByUuid_Last(uuid, orderByComparator); 384 } 385 386 /** 387 * Returns the last bookmarks entry in the ordered set where uuid = ?. 388 * 389 * @param uuid the uuid 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 392 * @throws SystemException if a system exception occurred 393 */ 394 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last( 395 java.lang.String uuid, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 399 } 400 401 /** 402 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ?. 403 * 404 * @param entryId the primary key of the current bookmarks entry 405 * @param uuid the uuid 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the previous, current, and next bookmarks entry 408 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 409 * @throws SystemException if a system exception occurred 410 */ 411 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext( 412 long entryId, java.lang.String uuid, 413 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 414 throws com.liferay.portal.kernel.exception.SystemException, 415 com.liferay.portlet.bookmarks.NoSuchEntryException { 416 return getPersistence() 417 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 418 } 419 420 /** 421 * Removes all the bookmarks entries where uuid = ? from the database. 422 * 423 * @param uuid the uuid 424 * @throws SystemException if a system exception occurred 425 */ 426 public static void removeByUuid(java.lang.String uuid) 427 throws com.liferay.portal.kernel.exception.SystemException { 428 getPersistence().removeByUuid(uuid); 429 } 430 431 /** 432 * Returns the number of bookmarks entries where uuid = ?. 433 * 434 * @param uuid the uuid 435 * @return the number of matching bookmarks entries 436 * @throws SystemException if a system exception occurred 437 */ 438 public static int countByUuid(java.lang.String uuid) 439 throws com.liferay.portal.kernel.exception.SystemException { 440 return getPersistence().countByUuid(uuid); 441 } 442 443 /** 444 * Returns the bookmarks entry where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 445 * 446 * @param uuid the uuid 447 * @param groupId the group ID 448 * @return the matching bookmarks entry 449 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 450 * @throws SystemException if a system exception occurred 451 */ 452 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G( 453 java.lang.String uuid, long groupId) 454 throws com.liferay.portal.kernel.exception.SystemException, 455 com.liferay.portlet.bookmarks.NoSuchEntryException { 456 return getPersistence().findByUUID_G(uuid, groupId); 457 } 458 459 /** 460 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 461 * 462 * @param uuid the uuid 463 * @param groupId the group ID 464 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 468 java.lang.String uuid, long groupId) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence().fetchByUUID_G(uuid, groupId); 471 } 472 473 /** 474 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 475 * 476 * @param uuid the uuid 477 * @param groupId the group ID 478 * @param retrieveFromCache whether to use the finder cache 479 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 480 * @throws SystemException if a system exception occurred 481 */ 482 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 483 java.lang.String uuid, long groupId, boolean retrieveFromCache) 484 throws com.liferay.portal.kernel.exception.SystemException { 485 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 486 } 487 488 /** 489 * Removes the bookmarks entry where uuid = ? and groupId = ? from the database. 490 * 491 * @param uuid the uuid 492 * @param groupId the group ID 493 * @return the bookmarks entry that was removed 494 * @throws SystemException if a system exception occurred 495 */ 496 public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G( 497 java.lang.String uuid, long groupId) 498 throws com.liferay.portal.kernel.exception.SystemException, 499 com.liferay.portlet.bookmarks.NoSuchEntryException { 500 return getPersistence().removeByUUID_G(uuid, groupId); 501 } 502 503 /** 504 * Returns the number of bookmarks entries where uuid = ? and groupId = ?. 505 * 506 * @param uuid the uuid 507 * @param groupId the group ID 508 * @return the number of matching bookmarks entries 509 * @throws SystemException if a system exception occurred 510 */ 511 public static int countByUUID_G(java.lang.String uuid, long groupId) 512 throws com.liferay.portal.kernel.exception.SystemException { 513 return getPersistence().countByUUID_G(uuid, groupId); 514 } 515 516 /** 517 * Returns all the bookmarks entries where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @return the matching bookmarks entries 522 * @throws SystemException if a system exception occurred 523 */ 524 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 525 java.lang.String uuid, long companyId) 526 throws com.liferay.portal.kernel.exception.SystemException { 527 return getPersistence().findByUuid_C(uuid, companyId); 528 } 529 530 /** 531 * Returns a range of all the bookmarks entries where uuid = ? and companyId = ?. 532 * 533 * <p> 534 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 535 * </p> 536 * 537 * @param uuid the uuid 538 * @param companyId the company ID 539 * @param start the lower bound of the range of bookmarks entries 540 * @param end the upper bound of the range of bookmarks entries (not inclusive) 541 * @return the range of matching bookmarks entries 542 * @throws SystemException if a system exception occurred 543 */ 544 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 545 java.lang.String uuid, long companyId, int start, int end) 546 throws com.liferay.portal.kernel.exception.SystemException { 547 return getPersistence().findByUuid_C(uuid, companyId, start, end); 548 } 549 550 /** 551 * Returns an ordered range of all the bookmarks entries where uuid = ? and companyId = ?. 552 * 553 * <p> 554 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 555 * </p> 556 * 557 * @param uuid the uuid 558 * @param companyId the company ID 559 * @param start the lower bound of the range of bookmarks entries 560 * @param end the upper bound of the range of bookmarks entries (not inclusive) 561 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 562 * @return the ordered range of matching bookmarks entries 563 * @throws SystemException if a system exception occurred 564 */ 565 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 566 java.lang.String uuid, long companyId, int start, int end, 567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 568 throws com.liferay.portal.kernel.exception.SystemException { 569 return getPersistence() 570 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 571 } 572 573 /** 574 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 575 * 576 * @param uuid the uuid 577 * @param companyId the company ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching bookmarks entry 580 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First( 584 java.lang.String uuid, long companyId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.bookmarks.NoSuchEntryException { 588 return getPersistence() 589 .findByUuid_C_First(uuid, companyId, orderByComparator); 590 } 591 592 /** 593 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 594 * 595 * @param uuid the uuid 596 * @param companyId the company ID 597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 598 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 599 * @throws SystemException if a system exception occurred 600 */ 601 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First( 602 java.lang.String uuid, long companyId, 603 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 604 throws com.liferay.portal.kernel.exception.SystemException { 605 return getPersistence() 606 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 607 } 608 609 /** 610 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 611 * 612 * @param uuid the uuid 613 * @param companyId the company ID 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the last matching bookmarks entry 616 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 617 * @throws SystemException if a system exception occurred 618 */ 619 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last( 620 java.lang.String uuid, long companyId, 621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 622 throws com.liferay.portal.kernel.exception.SystemException, 623 com.liferay.portlet.bookmarks.NoSuchEntryException { 624 return getPersistence() 625 .findByUuid_C_Last(uuid, companyId, orderByComparator); 626 } 627 628 /** 629 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 630 * 631 * @param uuid the uuid 632 * @param companyId the company ID 633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 634 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 635 * @throws SystemException if a system exception occurred 636 */ 637 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last( 638 java.lang.String uuid, long companyId, 639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 640 throws com.liferay.portal.kernel.exception.SystemException { 641 return getPersistence() 642 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 643 } 644 645 /** 646 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ? and companyId = ?. 647 * 648 * @param entryId the primary key of the current bookmarks entry 649 * @param uuid the uuid 650 * @param companyId the company ID 651 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 652 * @return the previous, current, and next bookmarks entry 653 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 654 * @throws SystemException if a system exception occurred 655 */ 656 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext( 657 long entryId, java.lang.String uuid, long companyId, 658 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 659 throws com.liferay.portal.kernel.exception.SystemException, 660 com.liferay.portlet.bookmarks.NoSuchEntryException { 661 return getPersistence() 662 .findByUuid_C_PrevAndNext(entryId, uuid, companyId, 663 orderByComparator); 664 } 665 666 /** 667 * Removes all the bookmarks entries where uuid = ? and companyId = ? from the database. 668 * 669 * @param uuid the uuid 670 * @param companyId the company ID 671 * @throws SystemException if a system exception occurred 672 */ 673 public static void removeByUuid_C(java.lang.String uuid, long companyId) 674 throws com.liferay.portal.kernel.exception.SystemException { 675 getPersistence().removeByUuid_C(uuid, companyId); 676 } 677 678 /** 679 * Returns the number of bookmarks entries where uuid = ? and companyId = ?. 680 * 681 * @param uuid the uuid 682 * @param companyId the company ID 683 * @return the number of matching bookmarks entries 684 * @throws SystemException if a system exception occurred 685 */ 686 public static int countByUuid_C(java.lang.String uuid, long companyId) 687 throws com.liferay.portal.kernel.exception.SystemException { 688 return getPersistence().countByUuid_C(uuid, companyId); 689 } 690 691 /** 692 * Returns all the bookmarks entries where companyId = ?. 693 * 694 * @param companyId the company ID 695 * @return the matching bookmarks entries 696 * @throws SystemException if a system exception occurred 697 */ 698 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 699 long companyId) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence().findByCompanyId(companyId); 702 } 703 704 /** 705 * Returns a range of all the bookmarks entries where companyId = ?. 706 * 707 * <p> 708 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 709 * </p> 710 * 711 * @param companyId the company ID 712 * @param start the lower bound of the range of bookmarks entries 713 * @param end the upper bound of the range of bookmarks entries (not inclusive) 714 * @return the range of matching bookmarks entries 715 * @throws SystemException if a system exception occurred 716 */ 717 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 718 long companyId, int start, int end) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().findByCompanyId(companyId, start, end); 721 } 722 723 /** 724 * Returns an ordered range of all the bookmarks entries where companyId = ?. 725 * 726 * <p> 727 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 728 * </p> 729 * 730 * @param companyId the company ID 731 * @param start the lower bound of the range of bookmarks entries 732 * @param end the upper bound of the range of bookmarks entries (not inclusive) 733 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 734 * @return the ordered range of matching bookmarks entries 735 * @throws SystemException if a system exception occurred 736 */ 737 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 738 long companyId, int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence() 742 .findByCompanyId(companyId, start, end, orderByComparator); 743 } 744 745 /** 746 * Returns the first bookmarks entry in the ordered set where companyId = ?. 747 * 748 * @param companyId the company ID 749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 750 * @return the first matching bookmarks entry 751 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 752 * @throws SystemException if a system exception occurred 753 */ 754 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_First( 755 long companyId, 756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 757 throws com.liferay.portal.kernel.exception.SystemException, 758 com.liferay.portlet.bookmarks.NoSuchEntryException { 759 return getPersistence() 760 .findByCompanyId_First(companyId, orderByComparator); 761 } 762 763 /** 764 * Returns the first bookmarks entry in the ordered set where companyId = ?. 765 * 766 * @param companyId the company ID 767 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 768 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 769 * @throws SystemException if a system exception occurred 770 */ 771 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_First( 772 long companyId, 773 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 774 throws com.liferay.portal.kernel.exception.SystemException { 775 return getPersistence() 776 .fetchByCompanyId_First(companyId, orderByComparator); 777 } 778 779 /** 780 * Returns the last bookmarks entry in the ordered set where companyId = ?. 781 * 782 * @param companyId the company ID 783 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 784 * @return the last matching bookmarks entry 785 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 786 * @throws SystemException if a system exception occurred 787 */ 788 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_Last( 789 long companyId, 790 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 791 throws com.liferay.portal.kernel.exception.SystemException, 792 com.liferay.portlet.bookmarks.NoSuchEntryException { 793 return getPersistence() 794 .findByCompanyId_Last(companyId, orderByComparator); 795 } 796 797 /** 798 * Returns the last bookmarks entry in the ordered set where companyId = ?. 799 * 800 * @param companyId the company ID 801 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 802 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 803 * @throws SystemException if a system exception occurred 804 */ 805 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_Last( 806 long companyId, 807 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 808 throws com.liferay.portal.kernel.exception.SystemException { 809 return getPersistence() 810 .fetchByCompanyId_Last(companyId, orderByComparator); 811 } 812 813 /** 814 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = ?. 815 * 816 * @param entryId the primary key of the current bookmarks entry 817 * @param companyId the company ID 818 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 819 * @return the previous, current, and next bookmarks entry 820 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 821 * @throws SystemException if a system exception occurred 822 */ 823 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByCompanyId_PrevAndNext( 824 long entryId, long companyId, 825 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 826 throws com.liferay.portal.kernel.exception.SystemException, 827 com.liferay.portlet.bookmarks.NoSuchEntryException { 828 return getPersistence() 829 .findByCompanyId_PrevAndNext(entryId, companyId, 830 orderByComparator); 831 } 832 833 /** 834 * Removes all the bookmarks entries where companyId = ? from the database. 835 * 836 * @param companyId the company ID 837 * @throws SystemException if a system exception occurred 838 */ 839 public static void removeByCompanyId(long companyId) 840 throws com.liferay.portal.kernel.exception.SystemException { 841 getPersistence().removeByCompanyId(companyId); 842 } 843 844 /** 845 * Returns the number of bookmarks entries where companyId = ?. 846 * 847 * @param companyId the company ID 848 * @return the number of matching bookmarks entries 849 * @throws SystemException if a system exception occurred 850 */ 851 public static int countByCompanyId(long companyId) 852 throws com.liferay.portal.kernel.exception.SystemException { 853 return getPersistence().countByCompanyId(companyId); 854 } 855 856 /** 857 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 858 * 859 * @param groupId the group ID 860 * @param folderId the folder ID 861 * @return the matching bookmarks entries 862 * @throws SystemException if a system exception occurred 863 */ 864 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 865 long groupId, long folderId) 866 throws com.liferay.portal.kernel.exception.SystemException { 867 return getPersistence().findByG_F(groupId, folderId); 868 } 869 870 /** 871 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 872 * 873 * <p> 874 * 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.BookmarksEntryModelImpl}. 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. 875 * </p> 876 * 877 * @param groupId the group ID 878 * @param folderId the folder ID 879 * @param start the lower bound of the range of bookmarks entries 880 * @param end the upper bound of the range of bookmarks entries (not inclusive) 881 * @return the range of matching bookmarks entries 882 * @throws SystemException if a system exception occurred 883 */ 884 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 885 long groupId, long folderId, int start, int end) 886 throws com.liferay.portal.kernel.exception.SystemException { 887 return getPersistence().findByG_F(groupId, folderId, start, end); 888 } 889 890 /** 891 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 892 * 893 * <p> 894 * 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.BookmarksEntryModelImpl}. 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. 895 * </p> 896 * 897 * @param groupId the group ID 898 * @param folderId the folder ID 899 * @param start the lower bound of the range of bookmarks entries 900 * @param end the upper bound of the range of bookmarks entries (not inclusive) 901 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 902 * @return the ordered range of matching bookmarks entries 903 * @throws SystemException if a system exception occurred 904 */ 905 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 906 long groupId, long folderId, int start, int end, 907 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 908 throws com.liferay.portal.kernel.exception.SystemException { 909 return getPersistence() 910 .findByG_F(groupId, folderId, start, end, orderByComparator); 911 } 912 913 /** 914 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 915 * 916 * @param groupId the group ID 917 * @param folderId the folder ID 918 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 919 * @return the first matching bookmarks entry 920 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 921 * @throws SystemException if a system exception occurred 922 */ 923 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 924 long groupId, long folderId, 925 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 926 throws com.liferay.portal.kernel.exception.SystemException, 927 com.liferay.portlet.bookmarks.NoSuchEntryException { 928 return getPersistence() 929 .findByG_F_First(groupId, folderId, orderByComparator); 930 } 931 932 /** 933 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 934 * 935 * @param groupId the group ID 936 * @param folderId the folder ID 937 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 938 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 939 * @throws SystemException if a system exception occurred 940 */ 941 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 942 long groupId, long folderId, 943 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 944 throws com.liferay.portal.kernel.exception.SystemException { 945 return getPersistence() 946 .fetchByG_F_First(groupId, folderId, orderByComparator); 947 } 948 949 /** 950 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 951 * 952 * @param groupId the group ID 953 * @param folderId the folder ID 954 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 955 * @return the last matching bookmarks entry 956 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 957 * @throws SystemException if a system exception occurred 958 */ 959 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 960 long groupId, long folderId, 961 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 962 throws com.liferay.portal.kernel.exception.SystemException, 963 com.liferay.portlet.bookmarks.NoSuchEntryException { 964 return getPersistence() 965 .findByG_F_Last(groupId, folderId, orderByComparator); 966 } 967 968 /** 969 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 970 * 971 * @param groupId the group ID 972 * @param folderId the folder ID 973 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 974 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 975 * @throws SystemException if a system exception occurred 976 */ 977 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 978 long groupId, long folderId, 979 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 980 throws com.liferay.portal.kernel.exception.SystemException { 981 return getPersistence() 982 .fetchByG_F_Last(groupId, folderId, orderByComparator); 983 } 984 985 /** 986 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 987 * 988 * @param entryId the primary key of the current bookmarks entry 989 * @param groupId the group ID 990 * @param folderId the folder ID 991 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 992 * @return the previous, current, and next bookmarks entry 993 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 994 * @throws SystemException if a system exception occurred 995 */ 996 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 997 long entryId, long groupId, long folderId, 998 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 999 throws com.liferay.portal.kernel.exception.SystemException, 1000 com.liferay.portlet.bookmarks.NoSuchEntryException { 1001 return getPersistence() 1002 .findByG_F_PrevAndNext(entryId, groupId, folderId, 1003 orderByComparator); 1004 } 1005 1006 /** 1007 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1008 * 1009 * @param groupId the group ID 1010 * @param folderId the folder ID 1011 * @return the matching bookmarks entries that the user has permission to view 1012 * @throws SystemException if a system exception occurred 1013 */ 1014 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1015 long groupId, long folderId) 1016 throws com.liferay.portal.kernel.exception.SystemException { 1017 return getPersistence().filterFindByG_F(groupId, folderId); 1018 } 1019 1020 /** 1021 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1022 * 1023 * <p> 1024 * 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.BookmarksEntryModelImpl}. 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. 1025 * </p> 1026 * 1027 * @param groupId the group ID 1028 * @param folderId the folder ID 1029 * @param start the lower bound of the range of bookmarks entries 1030 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1031 * @return the range of matching bookmarks entries that the user has permission to view 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1035 long groupId, long folderId, int start, int end) 1036 throws com.liferay.portal.kernel.exception.SystemException { 1037 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 1038 } 1039 1040 /** 1041 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 1042 * 1043 * <p> 1044 * 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.BookmarksEntryModelImpl}. 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. 1045 * </p> 1046 * 1047 * @param groupId the group ID 1048 * @param folderId the folder ID 1049 * @param start the lower bound of the range of bookmarks entries 1050 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1051 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1052 * @return the ordered range of matching bookmarks entries that the user has permission to view 1053 * @throws SystemException if a system exception occurred 1054 */ 1055 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1056 long groupId, long folderId, int start, int end, 1057 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1058 throws com.liferay.portal.kernel.exception.SystemException { 1059 return getPersistence() 1060 .filterFindByG_F(groupId, folderId, start, end, 1061 orderByComparator); 1062 } 1063 1064 /** 1065 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1066 * 1067 * @param entryId the primary key of the current bookmarks entry 1068 * @param groupId the group ID 1069 * @param folderId the folder ID 1070 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1071 * @return the previous, current, and next bookmarks entry 1072 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1073 * @throws SystemException if a system exception occurred 1074 */ 1075 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 1076 long entryId, long groupId, long folderId, 1077 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1078 throws com.liferay.portal.kernel.exception.SystemException, 1079 com.liferay.portlet.bookmarks.NoSuchEntryException { 1080 return getPersistence() 1081 .filterFindByG_F_PrevAndNext(entryId, groupId, folderId, 1082 orderByComparator); 1083 } 1084 1085 /** 1086 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1087 * 1088 * @param groupId the group ID 1089 * @param folderIds the folder IDs 1090 * @return the matching bookmarks entries that the user has permission to view 1091 * @throws SystemException if a system exception occurred 1092 */ 1093 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1094 long groupId, long[] folderIds) 1095 throws com.liferay.portal.kernel.exception.SystemException { 1096 return getPersistence().filterFindByG_F(groupId, folderIds); 1097 } 1098 1099 /** 1100 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1101 * 1102 * <p> 1103 * 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.BookmarksEntryModelImpl}. 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. 1104 * </p> 1105 * 1106 * @param groupId the group ID 1107 * @param folderIds the folder IDs 1108 * @param start the lower bound of the range of bookmarks entries 1109 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1110 * @return the range of matching bookmarks entries that the user has permission to view 1111 * @throws SystemException if a system exception occurred 1112 */ 1113 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1114 long groupId, long[] folderIds, int start, int end) 1115 throws com.liferay.portal.kernel.exception.SystemException { 1116 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 1117 } 1118 1119 /** 1120 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1121 * 1122 * <p> 1123 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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.BookmarksEntryModelImpl}. 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. 1124 * </p> 1125 * 1126 * @param groupId the group ID 1127 * @param folderIds the folder IDs 1128 * @param start the lower bound of the range of bookmarks entries 1129 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1130 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1131 * @return the ordered range of matching bookmarks entries that the user has permission to view 1132 * @throws SystemException if a system exception occurred 1133 */ 1134 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1135 long groupId, long[] folderIds, int start, int end, 1136 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1137 throws com.liferay.portal.kernel.exception.SystemException { 1138 return getPersistence() 1139 .filterFindByG_F(groupId, folderIds, start, end, 1140 orderByComparator); 1141 } 1142 1143 /** 1144 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 1145 * 1146 * <p> 1147 * 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.BookmarksEntryModelImpl}. 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. 1148 * </p> 1149 * 1150 * @param groupId the group ID 1151 * @param folderIds the folder IDs 1152 * @return the matching bookmarks entries 1153 * @throws SystemException if a system exception occurred 1154 */ 1155 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1156 long groupId, long[] folderIds) 1157 throws com.liferay.portal.kernel.exception.SystemException { 1158 return getPersistence().findByG_F(groupId, folderIds); 1159 } 1160 1161 /** 1162 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 1163 * 1164 * <p> 1165 * 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.BookmarksEntryModelImpl}. 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. 1166 * </p> 1167 * 1168 * @param groupId the group ID 1169 * @param folderIds the folder IDs 1170 * @param start the lower bound of the range of bookmarks entries 1171 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1172 * @return the range of matching bookmarks entries 1173 * @throws SystemException if a system exception occurred 1174 */ 1175 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1176 long groupId, long[] folderIds, int start, int end) 1177 throws com.liferay.portal.kernel.exception.SystemException { 1178 return getPersistence().findByG_F(groupId, folderIds, start, end); 1179 } 1180 1181 /** 1182 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 1183 * 1184 * <p> 1185 * 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.BookmarksEntryModelImpl}. 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. 1186 * </p> 1187 * 1188 * @param groupId the group ID 1189 * @param folderIds the folder IDs 1190 * @param start the lower bound of the range of bookmarks entries 1191 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1192 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1193 * @return the ordered range of matching bookmarks entries 1194 * @throws SystemException if a system exception occurred 1195 */ 1196 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1197 long groupId, long[] folderIds, int start, int end, 1198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1199 throws com.liferay.portal.kernel.exception.SystemException { 1200 return getPersistence() 1201 .findByG_F(groupId, folderIds, start, end, orderByComparator); 1202 } 1203 1204 /** 1205 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 1206 * 1207 * @param groupId the group ID 1208 * @param folderId the folder ID 1209 * @throws SystemException if a system exception occurred 1210 */ 1211 public static void removeByG_F(long groupId, long folderId) 1212 throws com.liferay.portal.kernel.exception.SystemException { 1213 getPersistence().removeByG_F(groupId, folderId); 1214 } 1215 1216 /** 1217 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 1218 * 1219 * @param groupId the group ID 1220 * @param folderId the folder ID 1221 * @return the number of matching bookmarks entries 1222 * @throws SystemException if a system exception occurred 1223 */ 1224 public static int countByG_F(long groupId, long folderId) 1225 throws com.liferay.portal.kernel.exception.SystemException { 1226 return getPersistence().countByG_F(groupId, folderId); 1227 } 1228 1229 /** 1230 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 1231 * 1232 * @param groupId the group ID 1233 * @param folderIds the folder IDs 1234 * @return the number of matching bookmarks entries 1235 * @throws SystemException if a system exception occurred 1236 */ 1237 public static int countByG_F(long groupId, long[] folderIds) 1238 throws com.liferay.portal.kernel.exception.SystemException { 1239 return getPersistence().countByG_F(groupId, folderIds); 1240 } 1241 1242 /** 1243 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1244 * 1245 * @param groupId the group ID 1246 * @param folderId the folder ID 1247 * @return the number of matching bookmarks entries that the user has permission to view 1248 * @throws SystemException if a system exception occurred 1249 */ 1250 public static int filterCountByG_F(long groupId, long folderId) 1251 throws com.liferay.portal.kernel.exception.SystemException { 1252 return getPersistence().filterCountByG_F(groupId, folderId); 1253 } 1254 1255 /** 1256 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1257 * 1258 * @param groupId the group ID 1259 * @param folderIds the folder IDs 1260 * @return the number of matching bookmarks entries that the user has permission to view 1261 * @throws SystemException if a system exception occurred 1262 */ 1263 public static int filterCountByG_F(long groupId, long[] folderIds) 1264 throws com.liferay.portal.kernel.exception.SystemException { 1265 return getPersistence().filterCountByG_F(groupId, folderIds); 1266 } 1267 1268 /** 1269 * Returns all the bookmarks entries where groupId = ? and status = ?. 1270 * 1271 * @param groupId the group ID 1272 * @param status the status 1273 * @return the matching bookmarks entries 1274 * @throws SystemException if a system exception occurred 1275 */ 1276 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1277 long groupId, int status) 1278 throws com.liferay.portal.kernel.exception.SystemException { 1279 return getPersistence().findByG_S(groupId, status); 1280 } 1281 1282 /** 1283 * Returns a range of all the bookmarks entries where groupId = ? and status = ?. 1284 * 1285 * <p> 1286 * 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.BookmarksEntryModelImpl}. 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. 1287 * </p> 1288 * 1289 * @param groupId the group ID 1290 * @param status the status 1291 * @param start the lower bound of the range of bookmarks entries 1292 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1293 * @return the range of matching bookmarks entries 1294 * @throws SystemException if a system exception occurred 1295 */ 1296 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1297 long groupId, int status, int start, int end) 1298 throws com.liferay.portal.kernel.exception.SystemException { 1299 return getPersistence().findByG_S(groupId, status, start, end); 1300 } 1301 1302 /** 1303 * Returns an ordered range of all the bookmarks entries where groupId = ? and status = ?. 1304 * 1305 * <p> 1306 * 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.BookmarksEntryModelImpl}. 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. 1307 * </p> 1308 * 1309 * @param groupId the group ID 1310 * @param status the status 1311 * @param start the lower bound of the range of bookmarks entries 1312 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1313 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1314 * @return the ordered range of matching bookmarks entries 1315 * @throws SystemException if a system exception occurred 1316 */ 1317 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1318 long groupId, int status, int start, int end, 1319 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1320 throws com.liferay.portal.kernel.exception.SystemException { 1321 return getPersistence() 1322 .findByG_S(groupId, status, start, end, orderByComparator); 1323 } 1324 1325 /** 1326 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1327 * 1328 * @param groupId the group ID 1329 * @param status the status 1330 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1331 * @return the first matching bookmarks entry 1332 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1333 * @throws SystemException if a system exception occurred 1334 */ 1335 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First( 1336 long groupId, int status, 1337 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1338 throws com.liferay.portal.kernel.exception.SystemException, 1339 com.liferay.portlet.bookmarks.NoSuchEntryException { 1340 return getPersistence() 1341 .findByG_S_First(groupId, status, orderByComparator); 1342 } 1343 1344 /** 1345 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1346 * 1347 * @param groupId the group ID 1348 * @param status the status 1349 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1350 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1351 * @throws SystemException if a system exception occurred 1352 */ 1353 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First( 1354 long groupId, int status, 1355 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1356 throws com.liferay.portal.kernel.exception.SystemException { 1357 return getPersistence() 1358 .fetchByG_S_First(groupId, status, orderByComparator); 1359 } 1360 1361 /** 1362 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1363 * 1364 * @param groupId the group ID 1365 * @param status the status 1366 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1367 * @return the last matching bookmarks entry 1368 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1369 * @throws SystemException if a system exception occurred 1370 */ 1371 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last( 1372 long groupId, int status, 1373 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1374 throws com.liferay.portal.kernel.exception.SystemException, 1375 com.liferay.portlet.bookmarks.NoSuchEntryException { 1376 return getPersistence() 1377 .findByG_S_Last(groupId, status, orderByComparator); 1378 } 1379 1380 /** 1381 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1382 * 1383 * @param groupId the group ID 1384 * @param status the status 1385 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1386 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1387 * @throws SystemException if a system exception occurred 1388 */ 1389 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last( 1390 long groupId, int status, 1391 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1392 throws com.liferay.portal.kernel.exception.SystemException { 1393 return getPersistence() 1394 .fetchByG_S_Last(groupId, status, orderByComparator); 1395 } 1396 1397 /** 1398 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and status = ?. 1399 * 1400 * @param entryId the primary key of the current bookmarks entry 1401 * @param groupId the group ID 1402 * @param status the status 1403 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1404 * @return the previous, current, and next bookmarks entry 1405 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1406 * @throws SystemException if a system exception occurred 1407 */ 1408 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext( 1409 long entryId, long groupId, int status, 1410 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1411 throws com.liferay.portal.kernel.exception.SystemException, 1412 com.liferay.portlet.bookmarks.NoSuchEntryException { 1413 return getPersistence() 1414 .findByG_S_PrevAndNext(entryId, groupId, status, 1415 orderByComparator); 1416 } 1417 1418 /** 1419 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1420 * 1421 * @param groupId the group ID 1422 * @param status the status 1423 * @return the matching bookmarks entries that the user has permission to view 1424 * @throws SystemException if a system exception occurred 1425 */ 1426 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1427 long groupId, int status) 1428 throws com.liferay.portal.kernel.exception.SystemException { 1429 return getPersistence().filterFindByG_S(groupId, status); 1430 } 1431 1432 /** 1433 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1434 * 1435 * <p> 1436 * 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.BookmarksEntryModelImpl}. 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. 1437 * </p> 1438 * 1439 * @param groupId the group ID 1440 * @param status the status 1441 * @param start the lower bound of the range of bookmarks entries 1442 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1443 * @return the range of matching bookmarks entries that the user has permission to view 1444 * @throws SystemException if a system exception occurred 1445 */ 1446 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1447 long groupId, int status, int start, int end) 1448 throws com.liferay.portal.kernel.exception.SystemException { 1449 return getPersistence().filterFindByG_S(groupId, status, start, end); 1450 } 1451 1452 /** 1453 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and status = ?. 1454 * 1455 * <p> 1456 * 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.BookmarksEntryModelImpl}. 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. 1457 * </p> 1458 * 1459 * @param groupId the group ID 1460 * @param status the status 1461 * @param start the lower bound of the range of bookmarks entries 1462 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1463 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1464 * @return the ordered range of matching bookmarks entries that the user has permission to view 1465 * @throws SystemException if a system exception occurred 1466 */ 1467 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1468 long groupId, int status, int start, int end, 1469 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1470 throws com.liferay.portal.kernel.exception.SystemException { 1471 return getPersistence() 1472 .filterFindByG_S(groupId, status, start, end, 1473 orderByComparator); 1474 } 1475 1476 /** 1477 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1478 * 1479 * @param entryId the primary key of the current bookmarks entry 1480 * @param groupId the group ID 1481 * @param status the status 1482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1483 * @return the previous, current, and next bookmarks entry 1484 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1485 * @throws SystemException if a system exception occurred 1486 */ 1487 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext( 1488 long entryId, long groupId, int status, 1489 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1490 throws com.liferay.portal.kernel.exception.SystemException, 1491 com.liferay.portlet.bookmarks.NoSuchEntryException { 1492 return getPersistence() 1493 .filterFindByG_S_PrevAndNext(entryId, groupId, status, 1494 orderByComparator); 1495 } 1496 1497 /** 1498 * Removes all the bookmarks entries where groupId = ? and status = ? from the database. 1499 * 1500 * @param groupId the group ID 1501 * @param status the status 1502 * @throws SystemException if a system exception occurred 1503 */ 1504 public static void removeByG_S(long groupId, int status) 1505 throws com.liferay.portal.kernel.exception.SystemException { 1506 getPersistence().removeByG_S(groupId, status); 1507 } 1508 1509 /** 1510 * Returns the number of bookmarks entries where groupId = ? and status = ?. 1511 * 1512 * @param groupId the group ID 1513 * @param status the status 1514 * @return the number of matching bookmarks entries 1515 * @throws SystemException if a system exception occurred 1516 */ 1517 public static int countByG_S(long groupId, int status) 1518 throws com.liferay.portal.kernel.exception.SystemException { 1519 return getPersistence().countByG_S(groupId, status); 1520 } 1521 1522 /** 1523 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1524 * 1525 * @param groupId the group ID 1526 * @param status the status 1527 * @return the number of matching bookmarks entries that the user has permission to view 1528 * @throws SystemException if a system exception occurred 1529 */ 1530 public static int filterCountByG_S(long groupId, int status) 1531 throws com.liferay.portal.kernel.exception.SystemException { 1532 return getPersistence().filterCountByG_S(groupId, status); 1533 } 1534 1535 /** 1536 * Returns all the bookmarks entries where companyId = ? and status ≠ ?. 1537 * 1538 * @param companyId the company ID 1539 * @param status the status 1540 * @return the matching bookmarks entries 1541 * @throws SystemException if a system exception occurred 1542 */ 1543 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1544 long companyId, int status) 1545 throws com.liferay.portal.kernel.exception.SystemException { 1546 return getPersistence().findByC_NotS(companyId, status); 1547 } 1548 1549 /** 1550 * Returns a range of all the bookmarks entries where companyId = ? and status ≠ ?. 1551 * 1552 * <p> 1553 * 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.BookmarksEntryModelImpl}. 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. 1554 * </p> 1555 * 1556 * @param companyId the company ID 1557 * @param status the status 1558 * @param start the lower bound of the range of bookmarks entries 1559 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1560 * @return the range of matching bookmarks entries 1561 * @throws SystemException if a system exception occurred 1562 */ 1563 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1564 long companyId, int status, int start, int end) 1565 throws com.liferay.portal.kernel.exception.SystemException { 1566 return getPersistence().findByC_NotS(companyId, status, start, end); 1567 } 1568 1569 /** 1570 * Returns an ordered range of all the bookmarks entries where companyId = ? and status ≠ ?. 1571 * 1572 * <p> 1573 * 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.BookmarksEntryModelImpl}. 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. 1574 * </p> 1575 * 1576 * @param companyId the company ID 1577 * @param status the status 1578 * @param start the lower bound of the range of bookmarks entries 1579 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1580 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1581 * @return the ordered range of matching bookmarks entries 1582 * @throws SystemException if a system exception occurred 1583 */ 1584 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1585 long companyId, int status, int start, int end, 1586 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1587 throws com.liferay.portal.kernel.exception.SystemException { 1588 return getPersistence() 1589 .findByC_NotS(companyId, status, start, end, 1590 orderByComparator); 1591 } 1592 1593 /** 1594 * Returns the first bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1595 * 1596 * @param companyId the company ID 1597 * @param status the status 1598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1599 * @return the first matching bookmarks entry 1600 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1601 * @throws SystemException if a system exception occurred 1602 */ 1603 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_First( 1604 long companyId, int status, 1605 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1606 throws com.liferay.portal.kernel.exception.SystemException, 1607 com.liferay.portlet.bookmarks.NoSuchEntryException { 1608 return getPersistence() 1609 .findByC_NotS_First(companyId, status, orderByComparator); 1610 } 1611 1612 /** 1613 * Returns the first bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1614 * 1615 * @param companyId the company ID 1616 * @param status the status 1617 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1618 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1619 * @throws SystemException if a system exception occurred 1620 */ 1621 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_First( 1622 long companyId, int status, 1623 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1624 throws com.liferay.portal.kernel.exception.SystemException { 1625 return getPersistence() 1626 .fetchByC_NotS_First(companyId, status, orderByComparator); 1627 } 1628 1629 /** 1630 * Returns the last bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1631 * 1632 * @param companyId the company ID 1633 * @param status the status 1634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1635 * @return the last matching bookmarks entry 1636 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1637 * @throws SystemException if a system exception occurred 1638 */ 1639 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_Last( 1640 long companyId, int status, 1641 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1642 throws com.liferay.portal.kernel.exception.SystemException, 1643 com.liferay.portlet.bookmarks.NoSuchEntryException { 1644 return getPersistence() 1645 .findByC_NotS_Last(companyId, status, orderByComparator); 1646 } 1647 1648 /** 1649 * Returns the last bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1650 * 1651 * @param companyId the company ID 1652 * @param status the status 1653 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1654 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1655 * @throws SystemException if a system exception occurred 1656 */ 1657 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_Last( 1658 long companyId, int status, 1659 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1660 throws com.liferay.portal.kernel.exception.SystemException { 1661 return getPersistence() 1662 .fetchByC_NotS_Last(companyId, status, orderByComparator); 1663 } 1664 1665 /** 1666 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1667 * 1668 * @param entryId the primary key of the current bookmarks entry 1669 * @param companyId the company ID 1670 * @param status the status 1671 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1672 * @return the previous, current, and next bookmarks entry 1673 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1674 * @throws SystemException if a system exception occurred 1675 */ 1676 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByC_NotS_PrevAndNext( 1677 long entryId, long companyId, int status, 1678 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1679 throws com.liferay.portal.kernel.exception.SystemException, 1680 com.liferay.portlet.bookmarks.NoSuchEntryException { 1681 return getPersistence() 1682 .findByC_NotS_PrevAndNext(entryId, companyId, status, 1683 orderByComparator); 1684 } 1685 1686 /** 1687 * Removes all the bookmarks entries where companyId = ? and status ≠ ? from the database. 1688 * 1689 * @param companyId the company ID 1690 * @param status the status 1691 * @throws SystemException if a system exception occurred 1692 */ 1693 public static void removeByC_NotS(long companyId, int status) 1694 throws com.liferay.portal.kernel.exception.SystemException { 1695 getPersistence().removeByC_NotS(companyId, status); 1696 } 1697 1698 /** 1699 * Returns the number of bookmarks entries where companyId = ? and status ≠ ?. 1700 * 1701 * @param companyId the company ID 1702 * @param status the status 1703 * @return the number of matching bookmarks entries 1704 * @throws SystemException if a system exception occurred 1705 */ 1706 public static int countByC_NotS(long companyId, int status) 1707 throws com.liferay.portal.kernel.exception.SystemException { 1708 return getPersistence().countByC_NotS(companyId, status); 1709 } 1710 1711 /** 1712 * Returns all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1713 * 1714 * @param groupId the group ID 1715 * @param userId the user ID 1716 * @param status the status 1717 * @return the matching bookmarks entries 1718 * @throws SystemException if a system exception occurred 1719 */ 1720 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1721 long groupId, long userId, int status) 1722 throws com.liferay.portal.kernel.exception.SystemException { 1723 return getPersistence().findByG_U_S(groupId, userId, status); 1724 } 1725 1726 /** 1727 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1728 * 1729 * <p> 1730 * 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.BookmarksEntryModelImpl}. 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. 1731 * </p> 1732 * 1733 * @param groupId the group ID 1734 * @param userId the user ID 1735 * @param status the status 1736 * @param start the lower bound of the range of bookmarks entries 1737 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1738 * @return the range of matching bookmarks entries 1739 * @throws SystemException if a system exception occurred 1740 */ 1741 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1742 long groupId, long userId, int status, int start, int end) 1743 throws com.liferay.portal.kernel.exception.SystemException { 1744 return getPersistence().findByG_U_S(groupId, userId, status, start, end); 1745 } 1746 1747 /** 1748 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1749 * 1750 * <p> 1751 * 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.BookmarksEntryModelImpl}. 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. 1752 * </p> 1753 * 1754 * @param groupId the group ID 1755 * @param userId the user ID 1756 * @param status the status 1757 * @param start the lower bound of the range of bookmarks entries 1758 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1759 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1760 * @return the ordered range of matching bookmarks entries 1761 * @throws SystemException if a system exception occurred 1762 */ 1763 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1764 long groupId, long userId, int status, int start, int end, 1765 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1766 throws com.liferay.portal.kernel.exception.SystemException { 1767 return getPersistence() 1768 .findByG_U_S(groupId, userId, status, start, end, 1769 orderByComparator); 1770 } 1771 1772 /** 1773 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1774 * 1775 * @param groupId the group ID 1776 * @param userId the user ID 1777 * @param status the status 1778 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1779 * @return the first matching bookmarks entry 1780 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1781 * @throws SystemException if a system exception occurred 1782 */ 1783 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First( 1784 long groupId, long userId, int status, 1785 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1786 throws com.liferay.portal.kernel.exception.SystemException, 1787 com.liferay.portlet.bookmarks.NoSuchEntryException { 1788 return getPersistence() 1789 .findByG_U_S_First(groupId, userId, status, orderByComparator); 1790 } 1791 1792 /** 1793 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1794 * 1795 * @param groupId the group ID 1796 * @param userId the user ID 1797 * @param status the status 1798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1799 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1800 * @throws SystemException if a system exception occurred 1801 */ 1802 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First( 1803 long groupId, long userId, int status, 1804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1805 throws com.liferay.portal.kernel.exception.SystemException { 1806 return getPersistence() 1807 .fetchByG_U_S_First(groupId, userId, status, 1808 orderByComparator); 1809 } 1810 1811 /** 1812 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1813 * 1814 * @param groupId the group ID 1815 * @param userId the user ID 1816 * @param status the status 1817 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1818 * @return the last matching bookmarks entry 1819 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1820 * @throws SystemException if a system exception occurred 1821 */ 1822 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last( 1823 long groupId, long userId, int status, 1824 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1825 throws com.liferay.portal.kernel.exception.SystemException, 1826 com.liferay.portlet.bookmarks.NoSuchEntryException { 1827 return getPersistence() 1828 .findByG_U_S_Last(groupId, userId, status, orderByComparator); 1829 } 1830 1831 /** 1832 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1833 * 1834 * @param groupId the group ID 1835 * @param userId the user ID 1836 * @param status the status 1837 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1838 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1839 * @throws SystemException if a system exception occurred 1840 */ 1841 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last( 1842 long groupId, long userId, int status, 1843 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1844 throws com.liferay.portal.kernel.exception.SystemException { 1845 return getPersistence() 1846 .fetchByG_U_S_Last(groupId, userId, status, orderByComparator); 1847 } 1848 1849 /** 1850 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1851 * 1852 * @param entryId the primary key of the current bookmarks entry 1853 * @param groupId the group ID 1854 * @param userId the user ID 1855 * @param status the status 1856 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1857 * @return the previous, current, and next bookmarks entry 1858 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1859 * @throws SystemException if a system exception occurred 1860 */ 1861 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext( 1862 long entryId, long groupId, long userId, int status, 1863 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1864 throws com.liferay.portal.kernel.exception.SystemException, 1865 com.liferay.portlet.bookmarks.NoSuchEntryException { 1866 return getPersistence() 1867 .findByG_U_S_PrevAndNext(entryId, groupId, userId, status, 1868 orderByComparator); 1869 } 1870 1871 /** 1872 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1873 * 1874 * @param groupId the group ID 1875 * @param userId the user ID 1876 * @param status the status 1877 * @return the matching bookmarks entries that the user has permission to view 1878 * @throws SystemException if a system exception occurred 1879 */ 1880 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1881 long groupId, long userId, int status) 1882 throws com.liferay.portal.kernel.exception.SystemException { 1883 return getPersistence().filterFindByG_U_S(groupId, userId, status); 1884 } 1885 1886 /** 1887 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1888 * 1889 * <p> 1890 * 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.BookmarksEntryModelImpl}. 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. 1891 * </p> 1892 * 1893 * @param groupId the group ID 1894 * @param userId the user ID 1895 * @param status the status 1896 * @param start the lower bound of the range of bookmarks entries 1897 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1898 * @return the range of matching bookmarks entries that the user has permission to view 1899 * @throws SystemException if a system exception occurred 1900 */ 1901 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1902 long groupId, long userId, int status, int start, int end) 1903 throws com.liferay.portal.kernel.exception.SystemException { 1904 return getPersistence() 1905 .filterFindByG_U_S(groupId, userId, status, start, end); 1906 } 1907 1908 /** 1909 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and status = ?. 1910 * 1911 * <p> 1912 * 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.BookmarksEntryModelImpl}. 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. 1913 * </p> 1914 * 1915 * @param groupId the group ID 1916 * @param userId the user ID 1917 * @param status the status 1918 * @param start the lower bound of the range of bookmarks entries 1919 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1920 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1921 * @return the ordered range of matching bookmarks entries that the user has permission to view 1922 * @throws SystemException if a system exception occurred 1923 */ 1924 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1925 long groupId, long userId, int status, int start, int end, 1926 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1927 throws com.liferay.portal.kernel.exception.SystemException { 1928 return getPersistence() 1929 .filterFindByG_U_S(groupId, userId, status, start, end, 1930 orderByComparator); 1931 } 1932 1933 /** 1934 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1935 * 1936 * @param entryId the primary key of the current bookmarks entry 1937 * @param groupId the group ID 1938 * @param userId the user ID 1939 * @param status the status 1940 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1941 * @return the previous, current, and next bookmarks entry 1942 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1943 * @throws SystemException if a system exception occurred 1944 */ 1945 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext( 1946 long entryId, long groupId, long userId, int status, 1947 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1948 throws com.liferay.portal.kernel.exception.SystemException, 1949 com.liferay.portlet.bookmarks.NoSuchEntryException { 1950 return getPersistence() 1951 .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId, 1952 status, orderByComparator); 1953 } 1954 1955 /** 1956 * Removes all the bookmarks entries where groupId = ? and userId = ? and status = ? from the database. 1957 * 1958 * @param groupId the group ID 1959 * @param userId the user ID 1960 * @param status the status 1961 * @throws SystemException if a system exception occurred 1962 */ 1963 public static void removeByG_U_S(long groupId, long userId, int status) 1964 throws com.liferay.portal.kernel.exception.SystemException { 1965 getPersistence().removeByG_U_S(groupId, userId, status); 1966 } 1967 1968 /** 1969 * Returns the number of bookmarks entries where groupId = ? and userId = ? and status = ?. 1970 * 1971 * @param groupId the group ID 1972 * @param userId the user ID 1973 * @param status the status 1974 * @return the number of matching bookmarks entries 1975 * @throws SystemException if a system exception occurred 1976 */ 1977 public static int countByG_U_S(long groupId, long userId, int status) 1978 throws com.liferay.portal.kernel.exception.SystemException { 1979 return getPersistence().countByG_U_S(groupId, userId, status); 1980 } 1981 1982 /** 1983 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1984 * 1985 * @param groupId the group ID 1986 * @param userId the user ID 1987 * @param status the status 1988 * @return the number of matching bookmarks entries that the user has permission to view 1989 * @throws SystemException if a system exception occurred 1990 */ 1991 public static int filterCountByG_U_S(long groupId, long userId, int status) 1992 throws com.liferay.portal.kernel.exception.SystemException { 1993 return getPersistence().filterCountByG_U_S(groupId, userId, status); 1994 } 1995 1996 /** 1997 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1998 * 1999 * @param groupId the group ID 2000 * @param folderId the folder ID 2001 * @param status the status 2002 * @return the matching bookmarks entries 2003 * @throws SystemException if a system exception occurred 2004 */ 2005 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2006 long groupId, long folderId, int status) 2007 throws com.liferay.portal.kernel.exception.SystemException { 2008 return getPersistence().findByG_F_S(groupId, folderId, status); 2009 } 2010 2011 /** 2012 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 2013 * 2014 * <p> 2015 * 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.BookmarksEntryModelImpl}. 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. 2016 * </p> 2017 * 2018 * @param groupId the group ID 2019 * @param folderId the folder ID 2020 * @param status the status 2021 * @param start the lower bound of the range of bookmarks entries 2022 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2023 * @return the range of matching bookmarks entries 2024 * @throws SystemException if a system exception occurred 2025 */ 2026 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2027 long groupId, long folderId, int status, int start, int end) 2028 throws com.liferay.portal.kernel.exception.SystemException { 2029 return getPersistence() 2030 .findByG_F_S(groupId, folderId, status, start, end); 2031 } 2032 2033 /** 2034 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 2035 * 2036 * <p> 2037 * 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.BookmarksEntryModelImpl}. 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. 2038 * </p> 2039 * 2040 * @param groupId the group ID 2041 * @param folderId the folder ID 2042 * @param status the status 2043 * @param start the lower bound of the range of bookmarks entries 2044 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2045 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2046 * @return the ordered range of matching bookmarks entries 2047 * @throws SystemException if a system exception occurred 2048 */ 2049 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2050 long groupId, long folderId, int status, int start, int end, 2051 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2052 throws com.liferay.portal.kernel.exception.SystemException { 2053 return getPersistence() 2054 .findByG_F_S(groupId, folderId, status, start, end, 2055 orderByComparator); 2056 } 2057 2058 /** 2059 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2060 * 2061 * @param groupId the group ID 2062 * @param folderId the folder ID 2063 * @param status the status 2064 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2065 * @return the first matching bookmarks entry 2066 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2067 * @throws SystemException if a system exception occurred 2068 */ 2069 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First( 2070 long groupId, long folderId, int status, 2071 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2072 throws com.liferay.portal.kernel.exception.SystemException, 2073 com.liferay.portlet.bookmarks.NoSuchEntryException { 2074 return getPersistence() 2075 .findByG_F_S_First(groupId, folderId, status, 2076 orderByComparator); 2077 } 2078 2079 /** 2080 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2081 * 2082 * @param groupId the group ID 2083 * @param folderId the folder ID 2084 * @param status the status 2085 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2086 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2087 * @throws SystemException if a system exception occurred 2088 */ 2089 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First( 2090 long groupId, long folderId, int status, 2091 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2092 throws com.liferay.portal.kernel.exception.SystemException { 2093 return getPersistence() 2094 .fetchByG_F_S_First(groupId, folderId, status, 2095 orderByComparator); 2096 } 2097 2098 /** 2099 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2100 * 2101 * @param groupId the group ID 2102 * @param folderId the folder ID 2103 * @param status the status 2104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2105 * @return the last matching bookmarks entry 2106 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2107 * @throws SystemException if a system exception occurred 2108 */ 2109 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last( 2110 long groupId, long folderId, int status, 2111 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2112 throws com.liferay.portal.kernel.exception.SystemException, 2113 com.liferay.portlet.bookmarks.NoSuchEntryException { 2114 return getPersistence() 2115 .findByG_F_S_Last(groupId, folderId, status, 2116 orderByComparator); 2117 } 2118 2119 /** 2120 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2121 * 2122 * @param groupId the group ID 2123 * @param folderId the folder ID 2124 * @param status the status 2125 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2126 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2127 * @throws SystemException if a system exception occurred 2128 */ 2129 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last( 2130 long groupId, long folderId, int status, 2131 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2132 throws com.liferay.portal.kernel.exception.SystemException { 2133 return getPersistence() 2134 .fetchByG_F_S_Last(groupId, folderId, status, 2135 orderByComparator); 2136 } 2137 2138 /** 2139 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2140 * 2141 * @param entryId the primary key of the current bookmarks entry 2142 * @param groupId the group ID 2143 * @param folderId the folder ID 2144 * @param status the status 2145 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2146 * @return the previous, current, and next bookmarks entry 2147 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2148 * @throws SystemException if a system exception occurred 2149 */ 2150 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext( 2151 long entryId, long groupId, long folderId, int status, 2152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2153 throws com.liferay.portal.kernel.exception.SystemException, 2154 com.liferay.portlet.bookmarks.NoSuchEntryException { 2155 return getPersistence() 2156 .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status, 2157 orderByComparator); 2158 } 2159 2160 /** 2161 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2162 * 2163 * @param groupId the group ID 2164 * @param folderId the folder ID 2165 * @param status the status 2166 * @return the matching bookmarks entries that the user has permission to view 2167 * @throws SystemException if a system exception occurred 2168 */ 2169 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2170 long groupId, long folderId, int status) 2171 throws com.liferay.portal.kernel.exception.SystemException { 2172 return getPersistence().filterFindByG_F_S(groupId, folderId, status); 2173 } 2174 2175 /** 2176 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2177 * 2178 * <p> 2179 * 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.BookmarksEntryModelImpl}. 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. 2180 * </p> 2181 * 2182 * @param groupId the group ID 2183 * @param folderId the folder ID 2184 * @param status the status 2185 * @param start the lower bound of the range of bookmarks entries 2186 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2187 * @return the range of matching bookmarks entries that the user has permission to view 2188 * @throws SystemException if a system exception occurred 2189 */ 2190 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2191 long groupId, long folderId, int status, int start, int end) 2192 throws com.liferay.portal.kernel.exception.SystemException { 2193 return getPersistence() 2194 .filterFindByG_F_S(groupId, folderId, status, start, end); 2195 } 2196 2197 /** 2198 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 2199 * 2200 * <p> 2201 * 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.BookmarksEntryModelImpl}. 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. 2202 * </p> 2203 * 2204 * @param groupId the group ID 2205 * @param folderId the folder ID 2206 * @param status the status 2207 * @param start the lower bound of the range of bookmarks entries 2208 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2209 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2210 * @return the ordered range of matching bookmarks entries that the user has permission to view 2211 * @throws SystemException if a system exception occurred 2212 */ 2213 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2214 long groupId, long folderId, int status, int start, int end, 2215 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2216 throws com.liferay.portal.kernel.exception.SystemException { 2217 return getPersistence() 2218 .filterFindByG_F_S(groupId, folderId, status, start, end, 2219 orderByComparator); 2220 } 2221 2222 /** 2223 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2224 * 2225 * @param entryId the primary key of the current bookmarks entry 2226 * @param groupId the group ID 2227 * @param folderId the folder ID 2228 * @param status the status 2229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2230 * @return the previous, current, and next bookmarks entry 2231 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2232 * @throws SystemException if a system exception occurred 2233 */ 2234 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext( 2235 long entryId, long groupId, long folderId, int status, 2236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2237 throws com.liferay.portal.kernel.exception.SystemException, 2238 com.liferay.portlet.bookmarks.NoSuchEntryException { 2239 return getPersistence() 2240 .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId, 2241 status, orderByComparator); 2242 } 2243 2244 /** 2245 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2246 * 2247 * @param groupId the group ID 2248 * @param folderIds the folder IDs 2249 * @param status the status 2250 * @return the matching bookmarks entries that the user has permission to view 2251 * @throws SystemException if a system exception occurred 2252 */ 2253 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2254 long groupId, long[] folderIds, int status) 2255 throws com.liferay.portal.kernel.exception.SystemException { 2256 return getPersistence().filterFindByG_F_S(groupId, folderIds, status); 2257 } 2258 2259 /** 2260 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2261 * 2262 * <p> 2263 * 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.BookmarksEntryModelImpl}. 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. 2264 * </p> 2265 * 2266 * @param groupId the group ID 2267 * @param folderIds the folder IDs 2268 * @param status the status 2269 * @param start the lower bound of the range of bookmarks entries 2270 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2271 * @return the range of matching bookmarks entries that the user has permission to view 2272 * @throws SystemException if a system exception occurred 2273 */ 2274 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2275 long groupId, long[] folderIds, int status, int start, int end) 2276 throws com.liferay.portal.kernel.exception.SystemException { 2277 return getPersistence() 2278 .filterFindByG_F_S(groupId, folderIds, status, start, end); 2279 } 2280 2281 /** 2282 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2283 * 2284 * <p> 2285 * 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.BookmarksEntryModelImpl}. 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. 2286 * </p> 2287 * 2288 * @param groupId the group ID 2289 * @param folderIds the folder IDs 2290 * @param status the status 2291 * @param start the lower bound of the range of bookmarks entries 2292 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2293 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2294 * @return the ordered range of matching bookmarks entries that the user has permission to view 2295 * @throws SystemException if a system exception occurred 2296 */ 2297 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2298 long groupId, long[] folderIds, int status, int start, int end, 2299 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2300 throws com.liferay.portal.kernel.exception.SystemException { 2301 return getPersistence() 2302 .filterFindByG_F_S(groupId, folderIds, status, start, end, 2303 orderByComparator); 2304 } 2305 2306 /** 2307 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2308 * 2309 * <p> 2310 * 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.BookmarksEntryModelImpl}. 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. 2311 * </p> 2312 * 2313 * @param groupId the group ID 2314 * @param folderIds the folder IDs 2315 * @param status the status 2316 * @return the matching bookmarks entries 2317 * @throws SystemException if a system exception occurred 2318 */ 2319 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2320 long groupId, long[] folderIds, int status) 2321 throws com.liferay.portal.kernel.exception.SystemException { 2322 return getPersistence().findByG_F_S(groupId, folderIds, status); 2323 } 2324 2325 /** 2326 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2327 * 2328 * <p> 2329 * 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.BookmarksEntryModelImpl}. 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. 2330 * </p> 2331 * 2332 * @param groupId the group ID 2333 * @param folderIds the folder IDs 2334 * @param status the status 2335 * @param start the lower bound of the range of bookmarks entries 2336 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2337 * @return the range of matching bookmarks entries 2338 * @throws SystemException if a system exception occurred 2339 */ 2340 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2341 long groupId, long[] folderIds, int status, int start, int end) 2342 throws com.liferay.portal.kernel.exception.SystemException { 2343 return getPersistence() 2344 .findByG_F_S(groupId, folderIds, status, start, end); 2345 } 2346 2347 /** 2348 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2349 * 2350 * <p> 2351 * 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.BookmarksEntryModelImpl}. 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. 2352 * </p> 2353 * 2354 * @param groupId the group ID 2355 * @param folderIds the folder IDs 2356 * @param status the status 2357 * @param start the lower bound of the range of bookmarks entries 2358 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2359 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2360 * @return the ordered range of matching bookmarks entries 2361 * @throws SystemException if a system exception occurred 2362 */ 2363 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2364 long groupId, long[] folderIds, int status, int start, int end, 2365 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2366 throws com.liferay.portal.kernel.exception.SystemException { 2367 return getPersistence() 2368 .findByG_F_S(groupId, folderIds, status, start, end, 2369 orderByComparator); 2370 } 2371 2372 /** 2373 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status = ? from the database. 2374 * 2375 * @param groupId the group ID 2376 * @param folderId the folder ID 2377 * @param status the status 2378 * @throws SystemException if a system exception occurred 2379 */ 2380 public static void removeByG_F_S(long groupId, long folderId, int status) 2381 throws com.liferay.portal.kernel.exception.SystemException { 2382 getPersistence().removeByG_F_S(groupId, folderId, status); 2383 } 2384 2385 /** 2386 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status = ?. 2387 * 2388 * @param groupId the group ID 2389 * @param folderId the folder ID 2390 * @param status the status 2391 * @return the number of matching bookmarks entries 2392 * @throws SystemException if a system exception occurred 2393 */ 2394 public static int countByG_F_S(long groupId, long folderId, int status) 2395 throws com.liferay.portal.kernel.exception.SystemException { 2396 return getPersistence().countByG_F_S(groupId, folderId, status); 2397 } 2398 2399 /** 2400 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2401 * 2402 * @param groupId the group ID 2403 * @param folderIds the folder IDs 2404 * @param status the status 2405 * @return the number of matching bookmarks entries 2406 * @throws SystemException if a system exception occurred 2407 */ 2408 public static int countByG_F_S(long groupId, long[] folderIds, int status) 2409 throws com.liferay.portal.kernel.exception.SystemException { 2410 return getPersistence().countByG_F_S(groupId, folderIds, status); 2411 } 2412 2413 /** 2414 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2415 * 2416 * @param groupId the group ID 2417 * @param folderId the folder ID 2418 * @param status the status 2419 * @return the number of matching bookmarks entries that the user has permission to view 2420 * @throws SystemException if a system exception occurred 2421 */ 2422 public static int filterCountByG_F_S(long groupId, long folderId, int status) 2423 throws com.liferay.portal.kernel.exception.SystemException { 2424 return getPersistence().filterCountByG_F_S(groupId, folderId, status); 2425 } 2426 2427 /** 2428 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2429 * 2430 * @param groupId the group ID 2431 * @param folderIds the folder IDs 2432 * @param status the status 2433 * @return the number of matching bookmarks entries that the user has permission to view 2434 * @throws SystemException if a system exception occurred 2435 */ 2436 public static int filterCountByG_F_S(long groupId, long[] folderIds, 2437 int status) throws com.liferay.portal.kernel.exception.SystemException { 2438 return getPersistence().filterCountByG_F_S(groupId, folderIds, status); 2439 } 2440 2441 /** 2442 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2443 * 2444 * @param groupId the group ID 2445 * @param folderId the folder ID 2446 * @param status the status 2447 * @return the matching bookmarks entries 2448 * @throws SystemException if a system exception occurred 2449 */ 2450 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2451 long groupId, long folderId, int status) 2452 throws com.liferay.portal.kernel.exception.SystemException { 2453 return getPersistence().findByG_F_NotS(groupId, folderId, status); 2454 } 2455 2456 /** 2457 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2458 * 2459 * <p> 2460 * 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.BookmarksEntryModelImpl}. 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. 2461 * </p> 2462 * 2463 * @param groupId the group ID 2464 * @param folderId the folder ID 2465 * @param status the status 2466 * @param start the lower bound of the range of bookmarks entries 2467 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2468 * @return the range of matching bookmarks entries 2469 * @throws SystemException if a system exception occurred 2470 */ 2471 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2472 long groupId, long folderId, int status, int start, int end) 2473 throws com.liferay.portal.kernel.exception.SystemException { 2474 return getPersistence() 2475 .findByG_F_NotS(groupId, folderId, status, start, end); 2476 } 2477 2478 /** 2479 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2480 * 2481 * <p> 2482 * 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.BookmarksEntryModelImpl}. 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. 2483 * </p> 2484 * 2485 * @param groupId the group ID 2486 * @param folderId the folder ID 2487 * @param status the status 2488 * @param start the lower bound of the range of bookmarks entries 2489 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2490 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2491 * @return the ordered range of matching bookmarks entries 2492 * @throws SystemException if a system exception occurred 2493 */ 2494 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2495 long groupId, long folderId, int status, int start, int end, 2496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2497 throws com.liferay.portal.kernel.exception.SystemException { 2498 return getPersistence() 2499 .findByG_F_NotS(groupId, folderId, status, start, end, 2500 orderByComparator); 2501 } 2502 2503 /** 2504 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2505 * 2506 * @param groupId the group ID 2507 * @param folderId the folder ID 2508 * @param status the status 2509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2510 * @return the first matching bookmarks entry 2511 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2512 * @throws SystemException if a system exception occurred 2513 */ 2514 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First( 2515 long groupId, long folderId, int status, 2516 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2517 throws com.liferay.portal.kernel.exception.SystemException, 2518 com.liferay.portlet.bookmarks.NoSuchEntryException { 2519 return getPersistence() 2520 .findByG_F_NotS_First(groupId, folderId, status, 2521 orderByComparator); 2522 } 2523 2524 /** 2525 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2526 * 2527 * @param groupId the group ID 2528 * @param folderId the folder ID 2529 * @param status the status 2530 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2531 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2532 * @throws SystemException if a system exception occurred 2533 */ 2534 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First( 2535 long groupId, long folderId, int status, 2536 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2537 throws com.liferay.portal.kernel.exception.SystemException { 2538 return getPersistence() 2539 .fetchByG_F_NotS_First(groupId, folderId, status, 2540 orderByComparator); 2541 } 2542 2543 /** 2544 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2545 * 2546 * @param groupId the group ID 2547 * @param folderId the folder ID 2548 * @param status the status 2549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2550 * @return the last matching bookmarks entry 2551 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2552 * @throws SystemException if a system exception occurred 2553 */ 2554 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last( 2555 long groupId, long folderId, int status, 2556 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2557 throws com.liferay.portal.kernel.exception.SystemException, 2558 com.liferay.portlet.bookmarks.NoSuchEntryException { 2559 return getPersistence() 2560 .findByG_F_NotS_Last(groupId, folderId, status, 2561 orderByComparator); 2562 } 2563 2564 /** 2565 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2566 * 2567 * @param groupId the group ID 2568 * @param folderId the folder ID 2569 * @param status the status 2570 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2571 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2572 * @throws SystemException if a system exception occurred 2573 */ 2574 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last( 2575 long groupId, long folderId, int status, 2576 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2577 throws com.liferay.portal.kernel.exception.SystemException { 2578 return getPersistence() 2579 .fetchByG_F_NotS_Last(groupId, folderId, status, 2580 orderByComparator); 2581 } 2582 2583 /** 2584 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2585 * 2586 * @param entryId the primary key of the current bookmarks entry 2587 * @param groupId the group ID 2588 * @param folderId the folder ID 2589 * @param status the status 2590 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2591 * @return the previous, current, and next bookmarks entry 2592 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2593 * @throws SystemException if a system exception occurred 2594 */ 2595 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext( 2596 long entryId, long groupId, long folderId, int status, 2597 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2598 throws com.liferay.portal.kernel.exception.SystemException, 2599 com.liferay.portlet.bookmarks.NoSuchEntryException { 2600 return getPersistence() 2601 .findByG_F_NotS_PrevAndNext(entryId, groupId, folderId, 2602 status, orderByComparator); 2603 } 2604 2605 /** 2606 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2607 * 2608 * @param groupId the group ID 2609 * @param folderId the folder ID 2610 * @param status the status 2611 * @return the matching bookmarks entries that the user has permission to view 2612 * @throws SystemException if a system exception occurred 2613 */ 2614 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2615 long groupId, long folderId, int status) 2616 throws com.liferay.portal.kernel.exception.SystemException { 2617 return getPersistence().filterFindByG_F_NotS(groupId, folderId, status); 2618 } 2619 2620 /** 2621 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2622 * 2623 * <p> 2624 * 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.BookmarksEntryModelImpl}. 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. 2625 * </p> 2626 * 2627 * @param groupId the group ID 2628 * @param folderId the folder ID 2629 * @param status the status 2630 * @param start the lower bound of the range of bookmarks entries 2631 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2632 * @return the range of matching bookmarks entries that the user has permission to view 2633 * @throws SystemException if a system exception occurred 2634 */ 2635 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2636 long groupId, long folderId, int status, int start, int end) 2637 throws com.liferay.portal.kernel.exception.SystemException { 2638 return getPersistence() 2639 .filterFindByG_F_NotS(groupId, folderId, status, start, end); 2640 } 2641 2642 /** 2643 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status ≠ ?. 2644 * 2645 * <p> 2646 * 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.BookmarksEntryModelImpl}. 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. 2647 * </p> 2648 * 2649 * @param groupId the group ID 2650 * @param folderId the folder ID 2651 * @param status the status 2652 * @param start the lower bound of the range of bookmarks entries 2653 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2654 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2655 * @return the ordered range of matching bookmarks entries that the user has permission to view 2656 * @throws SystemException if a system exception occurred 2657 */ 2658 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2659 long groupId, long folderId, int status, int start, int end, 2660 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2661 throws com.liferay.portal.kernel.exception.SystemException { 2662 return getPersistence() 2663 .filterFindByG_F_NotS(groupId, folderId, status, start, end, 2664 orderByComparator); 2665 } 2666 2667 /** 2668 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2669 * 2670 * @param entryId the primary key of the current bookmarks entry 2671 * @param groupId the group ID 2672 * @param folderId the folder ID 2673 * @param status the status 2674 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2675 * @return the previous, current, and next bookmarks entry 2676 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2677 * @throws SystemException if a system exception occurred 2678 */ 2679 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext( 2680 long entryId, long groupId, long folderId, int status, 2681 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2682 throws com.liferay.portal.kernel.exception.SystemException, 2683 com.liferay.portlet.bookmarks.NoSuchEntryException { 2684 return getPersistence() 2685 .filterFindByG_F_NotS_PrevAndNext(entryId, groupId, 2686 folderId, status, orderByComparator); 2687 } 2688 2689 /** 2690 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2691 * 2692 * @param groupId the group ID 2693 * @param folderIds the folder IDs 2694 * @param status the status 2695 * @return the matching bookmarks entries that the user has permission to view 2696 * @throws SystemException if a system exception occurred 2697 */ 2698 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2699 long groupId, long[] folderIds, int status) 2700 throws com.liferay.portal.kernel.exception.SystemException { 2701 return getPersistence().filterFindByG_F_NotS(groupId, folderIds, status); 2702 } 2703 2704 /** 2705 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2706 * 2707 * <p> 2708 * 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.BookmarksEntryModelImpl}. 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. 2709 * </p> 2710 * 2711 * @param groupId the group ID 2712 * @param folderIds the folder IDs 2713 * @param status the status 2714 * @param start the lower bound of the range of bookmarks entries 2715 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2716 * @return the range of matching bookmarks entries that the user has permission to view 2717 * @throws SystemException if a system exception occurred 2718 */ 2719 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2720 long groupId, long[] folderIds, int status, int start, int end) 2721 throws com.liferay.portal.kernel.exception.SystemException { 2722 return getPersistence() 2723 .filterFindByG_F_NotS(groupId, folderIds, status, start, end); 2724 } 2725 2726 /** 2727 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2728 * 2729 * <p> 2730 * 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.BookmarksEntryModelImpl}. 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. 2731 * </p> 2732 * 2733 * @param groupId the group ID 2734 * @param folderIds the folder IDs 2735 * @param status the status 2736 * @param start the lower bound of the range of bookmarks entries 2737 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2738 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2739 * @return the ordered range of matching bookmarks entries that the user has permission to view 2740 * @throws SystemException if a system exception occurred 2741 */ 2742 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2743 long groupId, long[] folderIds, int status, int start, int end, 2744 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2745 throws com.liferay.portal.kernel.exception.SystemException { 2746 return getPersistence() 2747 .filterFindByG_F_NotS(groupId, folderIds, status, start, 2748 end, orderByComparator); 2749 } 2750 2751 /** 2752 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2753 * 2754 * <p> 2755 * 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.BookmarksEntryModelImpl}. 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. 2756 * </p> 2757 * 2758 * @param groupId the group ID 2759 * @param folderIds the folder IDs 2760 * @param status the status 2761 * @return the matching bookmarks entries 2762 * @throws SystemException if a system exception occurred 2763 */ 2764 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2765 long groupId, long[] folderIds, int status) 2766 throws com.liferay.portal.kernel.exception.SystemException { 2767 return getPersistence().findByG_F_NotS(groupId, folderIds, status); 2768 } 2769 2770 /** 2771 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2772 * 2773 * <p> 2774 * 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.BookmarksEntryModelImpl}. 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. 2775 * </p> 2776 * 2777 * @param groupId the group ID 2778 * @param folderIds the folder IDs 2779 * @param status the status 2780 * @param start the lower bound of the range of bookmarks entries 2781 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2782 * @return the range of matching bookmarks entries 2783 * @throws SystemException if a system exception occurred 2784 */ 2785 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2786 long groupId, long[] folderIds, int status, int start, int end) 2787 throws com.liferay.portal.kernel.exception.SystemException { 2788 return getPersistence() 2789 .findByG_F_NotS(groupId, folderIds, status, start, end); 2790 } 2791 2792 /** 2793 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2794 * 2795 * <p> 2796 * 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.BookmarksEntryModelImpl}. 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. 2797 * </p> 2798 * 2799 * @param groupId the group ID 2800 * @param folderIds the folder IDs 2801 * @param status the status 2802 * @param start the lower bound of the range of bookmarks entries 2803 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2804 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2805 * @return the ordered range of matching bookmarks entries 2806 * @throws SystemException if a system exception occurred 2807 */ 2808 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2809 long groupId, long[] folderIds, int status, int start, int end, 2810 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2811 throws com.liferay.portal.kernel.exception.SystemException { 2812 return getPersistence() 2813 .findByG_F_NotS(groupId, folderIds, status, start, end, 2814 orderByComparator); 2815 } 2816 2817 /** 2818 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ? from the database. 2819 * 2820 * @param groupId the group ID 2821 * @param folderId the folder ID 2822 * @param status the status 2823 * @throws SystemException if a system exception occurred 2824 */ 2825 public static void removeByG_F_NotS(long groupId, long folderId, int status) 2826 throws com.liferay.portal.kernel.exception.SystemException { 2827 getPersistence().removeByG_F_NotS(groupId, folderId, status); 2828 } 2829 2830 /** 2831 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2832 * 2833 * @param groupId the group ID 2834 * @param folderId the folder ID 2835 * @param status the status 2836 * @return the number of matching bookmarks entries 2837 * @throws SystemException if a system exception occurred 2838 */ 2839 public static int countByG_F_NotS(long groupId, long folderId, int status) 2840 throws com.liferay.portal.kernel.exception.SystemException { 2841 return getPersistence().countByG_F_NotS(groupId, folderId, status); 2842 } 2843 2844 /** 2845 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2846 * 2847 * @param groupId the group ID 2848 * @param folderIds the folder IDs 2849 * @param status the status 2850 * @return the number of matching bookmarks entries 2851 * @throws SystemException if a system exception occurred 2852 */ 2853 public static int countByG_F_NotS(long groupId, long[] folderIds, int status) 2854 throws com.liferay.portal.kernel.exception.SystemException { 2855 return getPersistence().countByG_F_NotS(groupId, folderIds, status); 2856 } 2857 2858 /** 2859 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2860 * 2861 * @param groupId the group ID 2862 * @param folderId the folder ID 2863 * @param status the status 2864 * @return the number of matching bookmarks entries that the user has permission to view 2865 * @throws SystemException if a system exception occurred 2866 */ 2867 public static int filterCountByG_F_NotS(long groupId, long folderId, 2868 int status) throws com.liferay.portal.kernel.exception.SystemException { 2869 return getPersistence().filterCountByG_F_NotS(groupId, folderId, status); 2870 } 2871 2872 /** 2873 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2874 * 2875 * @param groupId the group ID 2876 * @param folderIds the folder IDs 2877 * @param status the status 2878 * @return the number of matching bookmarks entries that the user has permission to view 2879 * @throws SystemException if a system exception occurred 2880 */ 2881 public static int filterCountByG_F_NotS(long groupId, long[] folderIds, 2882 int status) throws com.liferay.portal.kernel.exception.SystemException { 2883 return getPersistence().filterCountByG_F_NotS(groupId, folderIds, status); 2884 } 2885 2886 /** 2887 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2888 * 2889 * @param groupId the group ID 2890 * @param userId the user ID 2891 * @param folderId the folder ID 2892 * @param status the status 2893 * @return the matching bookmarks entries 2894 * @throws SystemException if a system exception occurred 2895 */ 2896 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2897 long groupId, long userId, long folderId, int status) 2898 throws com.liferay.portal.kernel.exception.SystemException { 2899 return getPersistence().findByG_U_F_S(groupId, userId, folderId, status); 2900 } 2901 2902 /** 2903 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2904 * 2905 * <p> 2906 * 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.BookmarksEntryModelImpl}. 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. 2907 * </p> 2908 * 2909 * @param groupId the group ID 2910 * @param userId the user ID 2911 * @param folderId the folder ID 2912 * @param status the status 2913 * @param start the lower bound of the range of bookmarks entries 2914 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2915 * @return the range of matching bookmarks entries 2916 * @throws SystemException if a system exception occurred 2917 */ 2918 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2919 long groupId, long userId, long folderId, int status, int start, int end) 2920 throws com.liferay.portal.kernel.exception.SystemException { 2921 return getPersistence() 2922 .findByG_U_F_S(groupId, userId, folderId, status, start, end); 2923 } 2924 2925 /** 2926 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2927 * 2928 * <p> 2929 * 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.BookmarksEntryModelImpl}. 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. 2930 * </p> 2931 * 2932 * @param groupId the group ID 2933 * @param userId the user ID 2934 * @param folderId the folder ID 2935 * @param status the status 2936 * @param start the lower bound of the range of bookmarks entries 2937 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2938 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2939 * @return the ordered range of matching bookmarks entries 2940 * @throws SystemException if a system exception occurred 2941 */ 2942 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2943 long groupId, long userId, long folderId, int status, int start, 2944 int end, 2945 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2946 throws com.liferay.portal.kernel.exception.SystemException { 2947 return getPersistence() 2948 .findByG_U_F_S(groupId, userId, folderId, status, start, 2949 end, orderByComparator); 2950 } 2951 2952 /** 2953 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2954 * 2955 * @param groupId the group ID 2956 * @param userId the user ID 2957 * @param folderId the folder ID 2958 * @param status the status 2959 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2960 * @return the first matching bookmarks entry 2961 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2962 * @throws SystemException if a system exception occurred 2963 */ 2964 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First( 2965 long groupId, long userId, long folderId, int status, 2966 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2967 throws com.liferay.portal.kernel.exception.SystemException, 2968 com.liferay.portlet.bookmarks.NoSuchEntryException { 2969 return getPersistence() 2970 .findByG_U_F_S_First(groupId, userId, folderId, status, 2971 orderByComparator); 2972 } 2973 2974 /** 2975 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2976 * 2977 * @param groupId the group ID 2978 * @param userId the user ID 2979 * @param folderId the folder ID 2980 * @param status the status 2981 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2982 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2983 * @throws SystemException if a system exception occurred 2984 */ 2985 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First( 2986 long groupId, long userId, long folderId, int status, 2987 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2988 throws com.liferay.portal.kernel.exception.SystemException { 2989 return getPersistence() 2990 .fetchByG_U_F_S_First(groupId, userId, folderId, status, 2991 orderByComparator); 2992 } 2993 2994 /** 2995 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2996 * 2997 * @param groupId the group ID 2998 * @param userId the user ID 2999 * @param folderId the folder ID 3000 * @param status the status 3001 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3002 * @return the last matching bookmarks entry 3003 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 3004 * @throws SystemException if a system exception occurred 3005 */ 3006 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last( 3007 long groupId, long userId, long folderId, int status, 3008 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3009 throws com.liferay.portal.kernel.exception.SystemException, 3010 com.liferay.portlet.bookmarks.NoSuchEntryException { 3011 return getPersistence() 3012 .findByG_U_F_S_Last(groupId, userId, folderId, status, 3013 orderByComparator); 3014 } 3015 3016 /** 3017 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 3018 * 3019 * @param groupId the group ID 3020 * @param userId the user ID 3021 * @param folderId the folder ID 3022 * @param status the status 3023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3024 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 3025 * @throws SystemException if a system exception occurred 3026 */ 3027 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last( 3028 long groupId, long userId, long folderId, int status, 3029 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3030 throws com.liferay.portal.kernel.exception.SystemException { 3031 return getPersistence() 3032 .fetchByG_U_F_S_Last(groupId, userId, folderId, status, 3033 orderByComparator); 3034 } 3035 3036 /** 3037 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 3038 * 3039 * @param entryId the primary key of the current bookmarks entry 3040 * @param groupId the group ID 3041 * @param userId the user ID 3042 * @param folderId the folder ID 3043 * @param status the status 3044 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3045 * @return the previous, current, and next bookmarks entry 3046 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3047 * @throws SystemException if a system exception occurred 3048 */ 3049 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext( 3050 long entryId, long groupId, long userId, long folderId, int status, 3051 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3052 throws com.liferay.portal.kernel.exception.SystemException, 3053 com.liferay.portlet.bookmarks.NoSuchEntryException { 3054 return getPersistence() 3055 .findByG_U_F_S_PrevAndNext(entryId, groupId, userId, 3056 folderId, status, orderByComparator); 3057 } 3058 3059 /** 3060 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3061 * 3062 * @param groupId the group ID 3063 * @param userId the user ID 3064 * @param folderId the folder ID 3065 * @param status the status 3066 * @return the matching bookmarks entries that the user has permission to view 3067 * @throws SystemException if a system exception occurred 3068 */ 3069 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3070 long groupId, long userId, long folderId, int status) 3071 throws com.liferay.portal.kernel.exception.SystemException { 3072 return getPersistence() 3073 .filterFindByG_U_F_S(groupId, userId, folderId, status); 3074 } 3075 3076 /** 3077 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3078 * 3079 * <p> 3080 * 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.BookmarksEntryModelImpl}. 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. 3081 * </p> 3082 * 3083 * @param groupId the group ID 3084 * @param userId the user ID 3085 * @param folderId the folder ID 3086 * @param status the status 3087 * @param start the lower bound of the range of bookmarks entries 3088 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3089 * @return the range of matching bookmarks entries that the user has permission to view 3090 * @throws SystemException if a system exception occurred 3091 */ 3092 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3093 long groupId, long userId, long folderId, int status, int start, int end) 3094 throws com.liferay.portal.kernel.exception.SystemException { 3095 return getPersistence() 3096 .filterFindByG_U_F_S(groupId, userId, folderId, status, 3097 start, end); 3098 } 3099 3100 /** 3101 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3102 * 3103 * <p> 3104 * 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.BookmarksEntryModelImpl}. 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. 3105 * </p> 3106 * 3107 * @param groupId the group ID 3108 * @param userId the user ID 3109 * @param folderId the folder ID 3110 * @param status the status 3111 * @param start the lower bound of the range of bookmarks entries 3112 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3113 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3114 * @return the ordered range of matching bookmarks entries that the user has permission to view 3115 * @throws SystemException if a system exception occurred 3116 */ 3117 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3118 long groupId, long userId, long folderId, int status, int start, 3119 int end, 3120 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3121 throws com.liferay.portal.kernel.exception.SystemException { 3122 return getPersistence() 3123 .filterFindByG_U_F_S(groupId, userId, folderId, status, 3124 start, end, orderByComparator); 3125 } 3126 3127 /** 3128 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3129 * 3130 * @param entryId the primary key of the current bookmarks entry 3131 * @param groupId the group ID 3132 * @param userId the user ID 3133 * @param folderId the folder ID 3134 * @param status the status 3135 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3136 * @return the previous, current, and next bookmarks entry 3137 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3138 * @throws SystemException if a system exception occurred 3139 */ 3140 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext( 3141 long entryId, long groupId, long userId, long folderId, int status, 3142 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3143 throws com.liferay.portal.kernel.exception.SystemException, 3144 com.liferay.portlet.bookmarks.NoSuchEntryException { 3145 return getPersistence() 3146 .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId, 3147 folderId, status, orderByComparator); 3148 } 3149 3150 /** 3151 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3152 * 3153 * @param groupId the group ID 3154 * @param userId the user ID 3155 * @param folderIds the folder IDs 3156 * @param status the status 3157 * @return the matching bookmarks entries that the user has permission to view 3158 * @throws SystemException if a system exception occurred 3159 */ 3160 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3161 long groupId, long userId, long[] folderIds, int status) 3162 throws com.liferay.portal.kernel.exception.SystemException { 3163 return getPersistence() 3164 .filterFindByG_U_F_S(groupId, userId, folderIds, status); 3165 } 3166 3167 /** 3168 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3169 * 3170 * <p> 3171 * 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.BookmarksEntryModelImpl}. 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. 3172 * </p> 3173 * 3174 * @param groupId the group ID 3175 * @param userId the user ID 3176 * @param folderIds the folder IDs 3177 * @param status the status 3178 * @param start the lower bound of the range of bookmarks entries 3179 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3180 * @return the range of matching bookmarks entries that the user has permission to view 3181 * @throws SystemException if a system exception occurred 3182 */ 3183 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3184 long groupId, long userId, long[] folderIds, int status, int start, 3185 int end) throws com.liferay.portal.kernel.exception.SystemException { 3186 return getPersistence() 3187 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 3188 start, end); 3189 } 3190 3191 /** 3192 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3193 * 3194 * <p> 3195 * 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.BookmarksEntryModelImpl}. 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. 3196 * </p> 3197 * 3198 * @param groupId the group ID 3199 * @param userId the user ID 3200 * @param folderIds the folder IDs 3201 * @param status the status 3202 * @param start the lower bound of the range of bookmarks entries 3203 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3204 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3205 * @return the ordered range of matching bookmarks entries that the user has permission to view 3206 * @throws SystemException if a system exception occurred 3207 */ 3208 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3209 long groupId, long userId, long[] folderIds, int status, int start, 3210 int end, 3211 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3212 throws com.liferay.portal.kernel.exception.SystemException { 3213 return getPersistence() 3214 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 3215 start, end, orderByComparator); 3216 } 3217 3218 /** 3219 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3220 * 3221 * <p> 3222 * 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.BookmarksEntryModelImpl}. 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. 3223 * </p> 3224 * 3225 * @param groupId the group ID 3226 * @param userId the user ID 3227 * @param folderIds the folder IDs 3228 * @param status the status 3229 * @return the matching bookmarks entries 3230 * @throws SystemException if a system exception occurred 3231 */ 3232 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3233 long groupId, long userId, long[] folderIds, int status) 3234 throws com.liferay.portal.kernel.exception.SystemException { 3235 return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status); 3236 } 3237 3238 /** 3239 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3240 * 3241 * <p> 3242 * 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.BookmarksEntryModelImpl}. 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. 3243 * </p> 3244 * 3245 * @param groupId the group ID 3246 * @param userId the user ID 3247 * @param folderIds the folder IDs 3248 * @param status the status 3249 * @param start the lower bound of the range of bookmarks entries 3250 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3251 * @return the range of matching bookmarks entries 3252 * @throws SystemException if a system exception occurred 3253 */ 3254 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3255 long groupId, long userId, long[] folderIds, int status, int start, 3256 int end) throws com.liferay.portal.kernel.exception.SystemException { 3257 return getPersistence() 3258 .findByG_U_F_S(groupId, userId, folderIds, status, start, end); 3259 } 3260 3261 /** 3262 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3263 * 3264 * <p> 3265 * 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.BookmarksEntryModelImpl}. 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. 3266 * </p> 3267 * 3268 * @param groupId the group ID 3269 * @param userId the user ID 3270 * @param folderIds the folder IDs 3271 * @param status the status 3272 * @param start the lower bound of the range of bookmarks entries 3273 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3274 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3275 * @return the ordered range of matching bookmarks entries 3276 * @throws SystemException if a system exception occurred 3277 */ 3278 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3279 long groupId, long userId, long[] folderIds, int status, int start, 3280 int end, 3281 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3282 throws com.liferay.portal.kernel.exception.SystemException { 3283 return getPersistence() 3284 .findByG_U_F_S(groupId, userId, folderIds, status, start, 3285 end, orderByComparator); 3286 } 3287 3288 /** 3289 * Removes all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ? from the database. 3290 * 3291 * @param groupId the group ID 3292 * @param userId the user ID 3293 * @param folderId the folder ID 3294 * @param status the status 3295 * @throws SystemException if a system exception occurred 3296 */ 3297 public static void removeByG_U_F_S(long groupId, long userId, 3298 long folderId, int status) 3299 throws com.liferay.portal.kernel.exception.SystemException { 3300 getPersistence().removeByG_U_F_S(groupId, userId, folderId, status); 3301 } 3302 3303 /** 3304 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 3305 * 3306 * @param groupId the group ID 3307 * @param userId the user ID 3308 * @param folderId the folder ID 3309 * @param status the status 3310 * @return the number of matching bookmarks entries 3311 * @throws SystemException if a system exception occurred 3312 */ 3313 public static int countByG_U_F_S(long groupId, long userId, long folderId, 3314 int status) throws com.liferay.portal.kernel.exception.SystemException { 3315 return getPersistence().countByG_U_F_S(groupId, userId, folderId, status); 3316 } 3317 3318 /** 3319 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3320 * 3321 * @param groupId the group ID 3322 * @param userId the user ID 3323 * @param folderIds the folder IDs 3324 * @param status the status 3325 * @return the number of matching bookmarks entries 3326 * @throws SystemException if a system exception occurred 3327 */ 3328 public static int countByG_U_F_S(long groupId, long userId, 3329 long[] folderIds, int status) 3330 throws com.liferay.portal.kernel.exception.SystemException { 3331 return getPersistence() 3332 .countByG_U_F_S(groupId, userId, folderIds, status); 3333 } 3334 3335 /** 3336 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3337 * 3338 * @param groupId the group ID 3339 * @param userId the user ID 3340 * @param folderId the folder ID 3341 * @param status the status 3342 * @return the number of matching bookmarks entries that the user has permission to view 3343 * @throws SystemException if a system exception occurred 3344 */ 3345 public static int filterCountByG_U_F_S(long groupId, long userId, 3346 long folderId, int status) 3347 throws com.liferay.portal.kernel.exception.SystemException { 3348 return getPersistence() 3349 .filterCountByG_U_F_S(groupId, userId, folderId, status); 3350 } 3351 3352 /** 3353 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3354 * 3355 * @param groupId the group ID 3356 * @param userId the user ID 3357 * @param folderIds the folder IDs 3358 * @param status the status 3359 * @return the number of matching bookmarks entries that the user has permission to view 3360 * @throws SystemException if a system exception occurred 3361 */ 3362 public static int filterCountByG_U_F_S(long groupId, long userId, 3363 long[] folderIds, int status) 3364 throws com.liferay.portal.kernel.exception.SystemException { 3365 return getPersistence() 3366 .filterCountByG_U_F_S(groupId, userId, folderIds, status); 3367 } 3368 3369 /** 3370 * Caches the bookmarks entry in the entity cache if it is enabled. 3371 * 3372 * @param bookmarksEntry the bookmarks entry 3373 */ 3374 public static void cacheResult( 3375 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 3376 getPersistence().cacheResult(bookmarksEntry); 3377 } 3378 3379 /** 3380 * Caches the bookmarks entries in the entity cache if it is enabled. 3381 * 3382 * @param bookmarksEntries the bookmarks entries 3383 */ 3384 public static void cacheResult( 3385 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) { 3386 getPersistence().cacheResult(bookmarksEntries); 3387 } 3388 3389 /** 3390 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 3391 * 3392 * @param entryId the primary key for the new bookmarks entry 3393 * @return the new bookmarks entry 3394 */ 3395 public static com.liferay.portlet.bookmarks.model.BookmarksEntry create( 3396 long entryId) { 3397 return getPersistence().create(entryId); 3398 } 3399 3400 /** 3401 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 3402 * 3403 * @param entryId the primary key of the bookmarks entry 3404 * @return the bookmarks entry that was removed 3405 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3406 * @throws SystemException if a system exception occurred 3407 */ 3408 public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 3409 long entryId) 3410 throws com.liferay.portal.kernel.exception.SystemException, 3411 com.liferay.portlet.bookmarks.NoSuchEntryException { 3412 return getPersistence().remove(entryId); 3413 } 3414 3415 public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 3416 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 3417 throws com.liferay.portal.kernel.exception.SystemException { 3418 return getPersistence().updateImpl(bookmarksEntry); 3419 } 3420 3421 /** 3422 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 3423 * 3424 * @param entryId the primary key of the bookmarks entry 3425 * @return the bookmarks entry 3426 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3427 * @throws SystemException if a system exception occurred 3428 */ 3429 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 3430 long entryId) 3431 throws com.liferay.portal.kernel.exception.SystemException, 3432 com.liferay.portlet.bookmarks.NoSuchEntryException { 3433 return getPersistence().findByPrimaryKey(entryId); 3434 } 3435 3436 /** 3437 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 3438 * 3439 * @param entryId the primary key of the bookmarks entry 3440 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 3441 * @throws SystemException if a system exception occurred 3442 */ 3443 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 3444 long entryId) 3445 throws com.liferay.portal.kernel.exception.SystemException { 3446 return getPersistence().fetchByPrimaryKey(entryId); 3447 } 3448 3449 /** 3450 * Returns all the bookmarks entries. 3451 * 3452 * @return the bookmarks entries 3453 * @throws SystemException if a system exception occurred 3454 */ 3455 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 3456 throws com.liferay.portal.kernel.exception.SystemException { 3457 return getPersistence().findAll(); 3458 } 3459 3460 /** 3461 * Returns a range of all the bookmarks entries. 3462 * 3463 * <p> 3464 * 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.BookmarksEntryModelImpl}. 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. 3465 * </p> 3466 * 3467 * @param start the lower bound of the range of bookmarks entries 3468 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3469 * @return the range of bookmarks entries 3470 * @throws SystemException if a system exception occurred 3471 */ 3472 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 3473 int start, int end) 3474 throws com.liferay.portal.kernel.exception.SystemException { 3475 return getPersistence().findAll(start, end); 3476 } 3477 3478 /** 3479 * Returns an ordered range of all the bookmarks entries. 3480 * 3481 * <p> 3482 * 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.BookmarksEntryModelImpl}. 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. 3483 * </p> 3484 * 3485 * @param start the lower bound of the range of bookmarks entries 3486 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3487 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3488 * @return the ordered range of bookmarks entries 3489 * @throws SystemException if a system exception occurred 3490 */ 3491 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 3492 int start, int end, 3493 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3494 throws com.liferay.portal.kernel.exception.SystemException { 3495 return getPersistence().findAll(start, end, orderByComparator); 3496 } 3497 3498 /** 3499 * Removes all the bookmarks entries from the database. 3500 * 3501 * @throws SystemException if a system exception occurred 3502 */ 3503 public static void removeAll() 3504 throws com.liferay.portal.kernel.exception.SystemException { 3505 getPersistence().removeAll(); 3506 } 3507 3508 /** 3509 * Returns the number of bookmarks entries. 3510 * 3511 * @return the number of bookmarks entries 3512 * @throws SystemException if a system exception occurred 3513 */ 3514 public static int countAll() 3515 throws com.liferay.portal.kernel.exception.SystemException { 3516 return getPersistence().countAll(); 3517 } 3518 3519 public static BookmarksEntryPersistence getPersistence() { 3520 if (_persistence == null) { 3521 _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName()); 3522 3523 ReferenceRegistry.registerReference(BookmarksEntryUtil.class, 3524 "_persistence"); 3525 } 3526 3527 return _persistence; 3528 } 3529 3530 /** 3531 * @deprecated As of 6.2.0 3532 */ 3533 public void setPersistence(BookmarksEntryPersistence persistence) { 3534 } 3535 3536 private static BookmarksEntryPersistence _persistence; 3537 }