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