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