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 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 groupId = ? and folderId = ?. 693 * 694 * @param groupId the group ID 695 * @param folderId the folder ID 696 * @return the matching bookmarks entries 697 * @throws SystemException if a system exception occurred 698 */ 699 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 700 long groupId, long folderId) 701 throws com.liferay.portal.kernel.exception.SystemException { 702 return getPersistence().findByG_F(groupId, folderId); 703 } 704 705 /** 706 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 707 * 708 * <p> 709 * 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. 710 * </p> 711 * 712 * @param groupId the group ID 713 * @param folderId the folder ID 714 * @param start the lower bound of the range of bookmarks entries 715 * @param end the upper bound of the range of bookmarks entries (not inclusive) 716 * @return the range of matching bookmarks entries 717 * @throws SystemException if a system exception occurred 718 */ 719 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 720 long groupId, long folderId, int start, int end) 721 throws com.liferay.portal.kernel.exception.SystemException { 722 return getPersistence().findByG_F(groupId, folderId, start, end); 723 } 724 725 /** 726 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 727 * 728 * <p> 729 * 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. 730 * </p> 731 * 732 * @param groupId the group ID 733 * @param folderId the folder ID 734 * @param start the lower bound of the range of bookmarks entries 735 * @param end the upper bound of the range of bookmarks entries (not inclusive) 736 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 737 * @return the ordered range of matching bookmarks entries 738 * @throws SystemException if a system exception occurred 739 */ 740 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 741 long groupId, long folderId, int start, int end, 742 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 743 throws com.liferay.portal.kernel.exception.SystemException { 744 return getPersistence() 745 .findByG_F(groupId, folderId, start, end, orderByComparator); 746 } 747 748 /** 749 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 750 * 751 * @param groupId the group ID 752 * @param folderId the folder ID 753 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 754 * @return the first matching bookmarks entry 755 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 756 * @throws SystemException if a system exception occurred 757 */ 758 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 759 long groupId, long folderId, 760 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 761 throws com.liferay.portal.kernel.exception.SystemException, 762 com.liferay.portlet.bookmarks.NoSuchEntryException { 763 return getPersistence() 764 .findByG_F_First(groupId, folderId, orderByComparator); 765 } 766 767 /** 768 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 769 * 770 * @param groupId the group ID 771 * @param folderId the folder ID 772 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 773 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 774 * @throws SystemException if a system exception occurred 775 */ 776 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 777 long groupId, long folderId, 778 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 779 throws com.liferay.portal.kernel.exception.SystemException { 780 return getPersistence() 781 .fetchByG_F_First(groupId, folderId, orderByComparator); 782 } 783 784 /** 785 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 786 * 787 * @param groupId the group ID 788 * @param folderId the folder ID 789 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 790 * @return the last matching bookmarks entry 791 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 792 * @throws SystemException if a system exception occurred 793 */ 794 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 795 long groupId, long folderId, 796 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 797 throws com.liferay.portal.kernel.exception.SystemException, 798 com.liferay.portlet.bookmarks.NoSuchEntryException { 799 return getPersistence() 800 .findByG_F_Last(groupId, folderId, orderByComparator); 801 } 802 803 /** 804 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 805 * 806 * @param groupId the group ID 807 * @param folderId the folder ID 808 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 809 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 810 * @throws SystemException if a system exception occurred 811 */ 812 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 813 long groupId, long folderId, 814 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 815 throws com.liferay.portal.kernel.exception.SystemException { 816 return getPersistence() 817 .fetchByG_F_Last(groupId, folderId, orderByComparator); 818 } 819 820 /** 821 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 822 * 823 * @param entryId the primary key of the current bookmarks entry 824 * @param groupId the group ID 825 * @param folderId the folder ID 826 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 827 * @return the previous, current, and next bookmarks entry 828 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 829 * @throws SystemException if a system exception occurred 830 */ 831 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 832 long entryId, long groupId, long folderId, 833 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 834 throws com.liferay.portal.kernel.exception.SystemException, 835 com.liferay.portlet.bookmarks.NoSuchEntryException { 836 return getPersistence() 837 .findByG_F_PrevAndNext(entryId, groupId, folderId, 838 orderByComparator); 839 } 840 841 /** 842 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 843 * 844 * @param groupId the group ID 845 * @param folderId the folder ID 846 * @return the matching bookmarks entries that the user has permission to view 847 * @throws SystemException if a system exception occurred 848 */ 849 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 850 long groupId, long folderId) 851 throws com.liferay.portal.kernel.exception.SystemException { 852 return getPersistence().filterFindByG_F(groupId, folderId); 853 } 854 855 /** 856 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 857 * 858 * <p> 859 * 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. 860 * </p> 861 * 862 * @param groupId the group ID 863 * @param folderId the folder ID 864 * @param start the lower bound of the range of bookmarks entries 865 * @param end the upper bound of the range of bookmarks entries (not inclusive) 866 * @return the range of matching bookmarks entries that the user has permission to view 867 * @throws SystemException if a system exception occurred 868 */ 869 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 870 long groupId, long folderId, int start, int end) 871 throws com.liferay.portal.kernel.exception.SystemException { 872 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 873 } 874 875 /** 876 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 877 * 878 * <p> 879 * 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. 880 * </p> 881 * 882 * @param groupId the group ID 883 * @param folderId the folder ID 884 * @param start the lower bound of the range of bookmarks entries 885 * @param end the upper bound of the range of bookmarks entries (not inclusive) 886 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 887 * @return the ordered range of matching bookmarks entries that the user has permission to view 888 * @throws SystemException if a system exception occurred 889 */ 890 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 891 long groupId, long folderId, int start, int end, 892 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 893 throws com.liferay.portal.kernel.exception.SystemException { 894 return getPersistence() 895 .filterFindByG_F(groupId, folderId, start, end, 896 orderByComparator); 897 } 898 899 /** 900 * 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 = ?. 901 * 902 * @param entryId the primary key of the current bookmarks entry 903 * @param groupId the group ID 904 * @param folderId the folder ID 905 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 906 * @return the previous, current, and next bookmarks entry 907 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 908 * @throws SystemException if a system exception occurred 909 */ 910 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 911 long entryId, long groupId, long folderId, 912 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 913 throws com.liferay.portal.kernel.exception.SystemException, 914 com.liferay.portlet.bookmarks.NoSuchEntryException { 915 return getPersistence() 916 .filterFindByG_F_PrevAndNext(entryId, groupId, folderId, 917 orderByComparator); 918 } 919 920 /** 921 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 922 * 923 * @param groupId the group ID 924 * @param folderIds the folder IDs 925 * @return the matching bookmarks entries that the user has permission to view 926 * @throws SystemException if a system exception occurred 927 */ 928 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 929 long groupId, long[] folderIds) 930 throws com.liferay.portal.kernel.exception.SystemException { 931 return getPersistence().filterFindByG_F(groupId, folderIds); 932 } 933 934 /** 935 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 936 * 937 * <p> 938 * 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. 939 * </p> 940 * 941 * @param groupId the group ID 942 * @param folderIds the folder IDs 943 * @param start the lower bound of the range of bookmarks entries 944 * @param end the upper bound of the range of bookmarks entries (not inclusive) 945 * @return the range of matching bookmarks entries that the user has permission to view 946 * @throws SystemException if a system exception occurred 947 */ 948 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 949 long groupId, long[] folderIds, int start, int end) 950 throws com.liferay.portal.kernel.exception.SystemException { 951 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 952 } 953 954 /** 955 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 956 * 957 * <p> 958 * 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. 959 * </p> 960 * 961 * @param groupId the group ID 962 * @param folderIds the folder IDs 963 * @param start the lower bound of the range of bookmarks entries 964 * @param end the upper bound of the range of bookmarks entries (not inclusive) 965 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 966 * @return the ordered range of matching bookmarks entries that the user has permission to view 967 * @throws SystemException if a system exception occurred 968 */ 969 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 970 long groupId, long[] folderIds, int start, int end, 971 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 972 throws com.liferay.portal.kernel.exception.SystemException { 973 return getPersistence() 974 .filterFindByG_F(groupId, folderIds, start, end, 975 orderByComparator); 976 } 977 978 /** 979 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 980 * 981 * <p> 982 * 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. 983 * </p> 984 * 985 * @param groupId the group ID 986 * @param folderIds the folder IDs 987 * @return the matching bookmarks entries 988 * @throws SystemException if a system exception occurred 989 */ 990 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 991 long groupId, long[] folderIds) 992 throws com.liferay.portal.kernel.exception.SystemException { 993 return getPersistence().findByG_F(groupId, folderIds); 994 } 995 996 /** 997 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 998 * 999 * <p> 1000 * 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. 1001 * </p> 1002 * 1003 * @param groupId the group ID 1004 * @param folderIds the folder IDs 1005 * @param start the lower bound of the range of bookmarks entries 1006 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1007 * @return the range of matching bookmarks entries 1008 * @throws SystemException if a system exception occurred 1009 */ 1010 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1011 long groupId, long[] folderIds, int start, int end) 1012 throws com.liferay.portal.kernel.exception.SystemException { 1013 return getPersistence().findByG_F(groupId, folderIds, start, end); 1014 } 1015 1016 /** 1017 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 1018 * 1019 * <p> 1020 * 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. 1021 * </p> 1022 * 1023 * @param groupId the group ID 1024 * @param folderIds the folder IDs 1025 * @param start the lower bound of the range of bookmarks entries 1026 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1027 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1028 * @return the ordered range of matching bookmarks entries 1029 * @throws SystemException if a system exception occurred 1030 */ 1031 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1032 long groupId, long[] folderIds, int start, int end, 1033 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1034 throws com.liferay.portal.kernel.exception.SystemException { 1035 return getPersistence() 1036 .findByG_F(groupId, folderIds, start, end, orderByComparator); 1037 } 1038 1039 /** 1040 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 1041 * 1042 * @param groupId the group ID 1043 * @param folderId the folder ID 1044 * @throws SystemException if a system exception occurred 1045 */ 1046 public static void removeByG_F(long groupId, long folderId) 1047 throws com.liferay.portal.kernel.exception.SystemException { 1048 getPersistence().removeByG_F(groupId, folderId); 1049 } 1050 1051 /** 1052 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 1053 * 1054 * @param groupId the group ID 1055 * @param folderId the folder ID 1056 * @return the number of matching bookmarks entries 1057 * @throws SystemException if a system exception occurred 1058 */ 1059 public static int countByG_F(long groupId, long folderId) 1060 throws com.liferay.portal.kernel.exception.SystemException { 1061 return getPersistence().countByG_F(groupId, folderId); 1062 } 1063 1064 /** 1065 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 1066 * 1067 * @param groupId the group ID 1068 * @param folderIds the folder IDs 1069 * @return the number of matching bookmarks entries 1070 * @throws SystemException if a system exception occurred 1071 */ 1072 public static int countByG_F(long groupId, long[] folderIds) 1073 throws com.liferay.portal.kernel.exception.SystemException { 1074 return getPersistence().countByG_F(groupId, folderIds); 1075 } 1076 1077 /** 1078 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1079 * 1080 * @param groupId the group ID 1081 * @param folderId the folder ID 1082 * @return the number of matching bookmarks entries that the user has permission to view 1083 * @throws SystemException if a system exception occurred 1084 */ 1085 public static int filterCountByG_F(long groupId, long folderId) 1086 throws com.liferay.portal.kernel.exception.SystemException { 1087 return getPersistence().filterCountByG_F(groupId, folderId); 1088 } 1089 1090 /** 1091 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1092 * 1093 * @param groupId the group ID 1094 * @param folderIds the folder IDs 1095 * @return the number of matching bookmarks entries that the user has permission to view 1096 * @throws SystemException if a system exception occurred 1097 */ 1098 public static int filterCountByG_F(long groupId, long[] folderIds) 1099 throws com.liferay.portal.kernel.exception.SystemException { 1100 return getPersistence().filterCountByG_F(groupId, folderIds); 1101 } 1102 1103 /** 1104 * Returns all the bookmarks entries where groupId = ? and status = ?. 1105 * 1106 * @param groupId the group ID 1107 * @param status the status 1108 * @return the matching bookmarks entries 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1112 long groupId, int status) 1113 throws com.liferay.portal.kernel.exception.SystemException { 1114 return getPersistence().findByG_S(groupId, status); 1115 } 1116 1117 /** 1118 * Returns a range of all the bookmarks entries where groupId = ? and status = ?. 1119 * 1120 * <p> 1121 * 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. 1122 * </p> 1123 * 1124 * @param groupId the group ID 1125 * @param status the status 1126 * @param start the lower bound of the range of bookmarks entries 1127 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1128 * @return the range of matching bookmarks entries 1129 * @throws SystemException if a system exception occurred 1130 */ 1131 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1132 long groupId, int status, int start, int end) 1133 throws com.liferay.portal.kernel.exception.SystemException { 1134 return getPersistence().findByG_S(groupId, status, start, end); 1135 } 1136 1137 /** 1138 * Returns an ordered range of all the bookmarks entries where groupId = ? and status = ?. 1139 * 1140 * <p> 1141 * 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. 1142 * </p> 1143 * 1144 * @param groupId the group ID 1145 * @param status the status 1146 * @param start the lower bound of the range of bookmarks entries 1147 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1149 * @return the ordered range of matching bookmarks entries 1150 * @throws SystemException if a system exception occurred 1151 */ 1152 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1153 long groupId, int status, int start, int end, 1154 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1155 throws com.liferay.portal.kernel.exception.SystemException { 1156 return getPersistence() 1157 .findByG_S(groupId, status, start, end, orderByComparator); 1158 } 1159 1160 /** 1161 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1162 * 1163 * @param groupId the group ID 1164 * @param status the status 1165 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1166 * @return the first matching bookmarks entry 1167 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1168 * @throws SystemException if a system exception occurred 1169 */ 1170 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First( 1171 long groupId, int status, 1172 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1173 throws com.liferay.portal.kernel.exception.SystemException, 1174 com.liferay.portlet.bookmarks.NoSuchEntryException { 1175 return getPersistence() 1176 .findByG_S_First(groupId, status, orderByComparator); 1177 } 1178 1179 /** 1180 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1181 * 1182 * @param groupId the group ID 1183 * @param status the status 1184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1185 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1186 * @throws SystemException if a system exception occurred 1187 */ 1188 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First( 1189 long groupId, int status, 1190 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1191 throws com.liferay.portal.kernel.exception.SystemException { 1192 return getPersistence() 1193 .fetchByG_S_First(groupId, status, orderByComparator); 1194 } 1195 1196 /** 1197 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1198 * 1199 * @param groupId the group ID 1200 * @param status the status 1201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1202 * @return the last matching bookmarks entry 1203 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1204 * @throws SystemException if a system exception occurred 1205 */ 1206 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last( 1207 long groupId, int status, 1208 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1209 throws com.liferay.portal.kernel.exception.SystemException, 1210 com.liferay.portlet.bookmarks.NoSuchEntryException { 1211 return getPersistence() 1212 .findByG_S_Last(groupId, status, orderByComparator); 1213 } 1214 1215 /** 1216 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1217 * 1218 * @param groupId the group ID 1219 * @param status the status 1220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1221 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1222 * @throws SystemException if a system exception occurred 1223 */ 1224 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last( 1225 long groupId, int status, 1226 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1227 throws com.liferay.portal.kernel.exception.SystemException { 1228 return getPersistence() 1229 .fetchByG_S_Last(groupId, status, orderByComparator); 1230 } 1231 1232 /** 1233 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and status = ?. 1234 * 1235 * @param entryId the primary key of the current bookmarks entry 1236 * @param groupId the group ID 1237 * @param status the status 1238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1239 * @return the previous, current, and next bookmarks entry 1240 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1241 * @throws SystemException if a system exception occurred 1242 */ 1243 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext( 1244 long entryId, long groupId, int status, 1245 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1246 throws com.liferay.portal.kernel.exception.SystemException, 1247 com.liferay.portlet.bookmarks.NoSuchEntryException { 1248 return getPersistence() 1249 .findByG_S_PrevAndNext(entryId, groupId, status, 1250 orderByComparator); 1251 } 1252 1253 /** 1254 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1255 * 1256 * @param groupId the group ID 1257 * @param status the status 1258 * @return the matching bookmarks entries that the user has permission to view 1259 * @throws SystemException if a system exception occurred 1260 */ 1261 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1262 long groupId, int status) 1263 throws com.liferay.portal.kernel.exception.SystemException { 1264 return getPersistence().filterFindByG_S(groupId, status); 1265 } 1266 1267 /** 1268 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1269 * 1270 * <p> 1271 * 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. 1272 * </p> 1273 * 1274 * @param groupId the group ID 1275 * @param status the status 1276 * @param start the lower bound of the range of bookmarks entries 1277 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1278 * @return the range of matching bookmarks entries that the user has permission to view 1279 * @throws SystemException if a system exception occurred 1280 */ 1281 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1282 long groupId, int status, int start, int end) 1283 throws com.liferay.portal.kernel.exception.SystemException { 1284 return getPersistence().filterFindByG_S(groupId, status, start, end); 1285 } 1286 1287 /** 1288 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and status = ?. 1289 * 1290 * <p> 1291 * 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. 1292 * </p> 1293 * 1294 * @param groupId the group ID 1295 * @param status the status 1296 * @param start the lower bound of the range of bookmarks entries 1297 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1298 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1299 * @return the ordered range of matching bookmarks entries that the user has permission to view 1300 * @throws SystemException if a system exception occurred 1301 */ 1302 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1303 long groupId, int status, int start, int end, 1304 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1305 throws com.liferay.portal.kernel.exception.SystemException { 1306 return getPersistence() 1307 .filterFindByG_S(groupId, status, start, end, 1308 orderByComparator); 1309 } 1310 1311 /** 1312 * 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 = ?. 1313 * 1314 * @param entryId the primary key of the current bookmarks entry 1315 * @param groupId the group ID 1316 * @param status the status 1317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1318 * @return the previous, current, and next bookmarks entry 1319 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1320 * @throws SystemException if a system exception occurred 1321 */ 1322 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext( 1323 long entryId, long groupId, int status, 1324 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1325 throws com.liferay.portal.kernel.exception.SystemException, 1326 com.liferay.portlet.bookmarks.NoSuchEntryException { 1327 return getPersistence() 1328 .filterFindByG_S_PrevAndNext(entryId, groupId, status, 1329 orderByComparator); 1330 } 1331 1332 /** 1333 * Removes all the bookmarks entries where groupId = ? and status = ? from the database. 1334 * 1335 * @param groupId the group ID 1336 * @param status the status 1337 * @throws SystemException if a system exception occurred 1338 */ 1339 public static void removeByG_S(long groupId, int status) 1340 throws com.liferay.portal.kernel.exception.SystemException { 1341 getPersistence().removeByG_S(groupId, status); 1342 } 1343 1344 /** 1345 * Returns the number of bookmarks entries where groupId = ? and status = ?. 1346 * 1347 * @param groupId the group ID 1348 * @param status the status 1349 * @return the number of matching bookmarks entries 1350 * @throws SystemException if a system exception occurred 1351 */ 1352 public static int countByG_S(long groupId, int status) 1353 throws com.liferay.portal.kernel.exception.SystemException { 1354 return getPersistence().countByG_S(groupId, status); 1355 } 1356 1357 /** 1358 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1359 * 1360 * @param groupId the group ID 1361 * @param status the status 1362 * @return the number of matching bookmarks entries that the user has permission to view 1363 * @throws SystemException if a system exception occurred 1364 */ 1365 public static int filterCountByG_S(long groupId, int status) 1366 throws com.liferay.portal.kernel.exception.SystemException { 1367 return getPersistence().filterCountByG_S(groupId, status); 1368 } 1369 1370 /** 1371 * Returns all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1372 * 1373 * @param groupId the group ID 1374 * @param userId the user ID 1375 * @param status the status 1376 * @return the matching bookmarks entries 1377 * @throws SystemException if a system exception occurred 1378 */ 1379 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1380 long groupId, long userId, int status) 1381 throws com.liferay.portal.kernel.exception.SystemException { 1382 return getPersistence().findByG_U_S(groupId, userId, status); 1383 } 1384 1385 /** 1386 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1387 * 1388 * <p> 1389 * 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. 1390 * </p> 1391 * 1392 * @param groupId the group ID 1393 * @param userId the user ID 1394 * @param status the status 1395 * @param start the lower bound of the range of bookmarks entries 1396 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1397 * @return the range of matching bookmarks entries 1398 * @throws SystemException if a system exception occurred 1399 */ 1400 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1401 long groupId, long userId, int status, int start, int end) 1402 throws com.liferay.portal.kernel.exception.SystemException { 1403 return getPersistence().findByG_U_S(groupId, userId, status, start, end); 1404 } 1405 1406 /** 1407 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1408 * 1409 * <p> 1410 * 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. 1411 * </p> 1412 * 1413 * @param groupId the group ID 1414 * @param userId the user ID 1415 * @param status the status 1416 * @param start the lower bound of the range of bookmarks entries 1417 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1418 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1419 * @return the ordered range of matching bookmarks entries 1420 * @throws SystemException if a system exception occurred 1421 */ 1422 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1423 long groupId, long userId, int status, int start, int end, 1424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1425 throws com.liferay.portal.kernel.exception.SystemException { 1426 return getPersistence() 1427 .findByG_U_S(groupId, userId, status, start, end, 1428 orderByComparator); 1429 } 1430 1431 /** 1432 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1433 * 1434 * @param groupId the group ID 1435 * @param userId the user ID 1436 * @param status the status 1437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1438 * @return the first matching bookmarks entry 1439 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1440 * @throws SystemException if a system exception occurred 1441 */ 1442 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First( 1443 long groupId, long userId, int status, 1444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1445 throws com.liferay.portal.kernel.exception.SystemException, 1446 com.liferay.portlet.bookmarks.NoSuchEntryException { 1447 return getPersistence() 1448 .findByG_U_S_First(groupId, userId, status, orderByComparator); 1449 } 1450 1451 /** 1452 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1453 * 1454 * @param groupId the group ID 1455 * @param userId the user ID 1456 * @param status the status 1457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1458 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1459 * @throws SystemException if a system exception occurred 1460 */ 1461 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First( 1462 long groupId, long userId, int status, 1463 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1464 throws com.liferay.portal.kernel.exception.SystemException { 1465 return getPersistence() 1466 .fetchByG_U_S_First(groupId, userId, status, 1467 orderByComparator); 1468 } 1469 1470 /** 1471 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1472 * 1473 * @param groupId the group ID 1474 * @param userId the user ID 1475 * @param status the status 1476 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1477 * @return the last matching bookmarks entry 1478 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1479 * @throws SystemException if a system exception occurred 1480 */ 1481 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last( 1482 long groupId, long userId, int status, 1483 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1484 throws com.liferay.portal.kernel.exception.SystemException, 1485 com.liferay.portlet.bookmarks.NoSuchEntryException { 1486 return getPersistence() 1487 .findByG_U_S_Last(groupId, userId, status, orderByComparator); 1488 } 1489 1490 /** 1491 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1492 * 1493 * @param groupId the group ID 1494 * @param userId the user ID 1495 * @param status the status 1496 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1497 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1498 * @throws SystemException if a system exception occurred 1499 */ 1500 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last( 1501 long groupId, long userId, int status, 1502 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1503 throws com.liferay.portal.kernel.exception.SystemException { 1504 return getPersistence() 1505 .fetchByG_U_S_Last(groupId, userId, status, orderByComparator); 1506 } 1507 1508 /** 1509 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1510 * 1511 * @param entryId the primary key of the current bookmarks entry 1512 * @param groupId the group ID 1513 * @param userId the user ID 1514 * @param status the status 1515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1516 * @return the previous, current, and next bookmarks entry 1517 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1518 * @throws SystemException if a system exception occurred 1519 */ 1520 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext( 1521 long entryId, long groupId, long userId, int status, 1522 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1523 throws com.liferay.portal.kernel.exception.SystemException, 1524 com.liferay.portlet.bookmarks.NoSuchEntryException { 1525 return getPersistence() 1526 .findByG_U_S_PrevAndNext(entryId, groupId, userId, status, 1527 orderByComparator); 1528 } 1529 1530 /** 1531 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1532 * 1533 * @param groupId the group ID 1534 * @param userId the user ID 1535 * @param status the status 1536 * @return the matching bookmarks entries that the user has permission to view 1537 * @throws SystemException if a system exception occurred 1538 */ 1539 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1540 long groupId, long userId, int status) 1541 throws com.liferay.portal.kernel.exception.SystemException { 1542 return getPersistence().filterFindByG_U_S(groupId, userId, status); 1543 } 1544 1545 /** 1546 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1547 * 1548 * <p> 1549 * 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. 1550 * </p> 1551 * 1552 * @param groupId the group ID 1553 * @param userId the user ID 1554 * @param status the status 1555 * @param start the lower bound of the range of bookmarks entries 1556 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1557 * @return the range of matching bookmarks entries that the user has permission to view 1558 * @throws SystemException if a system exception occurred 1559 */ 1560 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1561 long groupId, long userId, int status, int start, int end) 1562 throws com.liferay.portal.kernel.exception.SystemException { 1563 return getPersistence() 1564 .filterFindByG_U_S(groupId, userId, status, start, end); 1565 } 1566 1567 /** 1568 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and status = ?. 1569 * 1570 * <p> 1571 * 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. 1572 * </p> 1573 * 1574 * @param groupId the group ID 1575 * @param userId the user ID 1576 * @param status the status 1577 * @param start the lower bound of the range of bookmarks entries 1578 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1579 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1580 * @return the ordered range of matching bookmarks entries that the user has permission to view 1581 * @throws SystemException if a system exception occurred 1582 */ 1583 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1584 long groupId, long userId, int status, int start, int end, 1585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1586 throws com.liferay.portal.kernel.exception.SystemException { 1587 return getPersistence() 1588 .filterFindByG_U_S(groupId, userId, status, start, end, 1589 orderByComparator); 1590 } 1591 1592 /** 1593 * 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 = ?. 1594 * 1595 * @param entryId the primary key of the current bookmarks entry 1596 * @param groupId the group ID 1597 * @param userId the user ID 1598 * @param status the status 1599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1600 * @return the previous, current, and next bookmarks entry 1601 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1602 * @throws SystemException if a system exception occurred 1603 */ 1604 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext( 1605 long entryId, long groupId, long userId, int status, 1606 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1607 throws com.liferay.portal.kernel.exception.SystemException, 1608 com.liferay.portlet.bookmarks.NoSuchEntryException { 1609 return getPersistence() 1610 .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId, 1611 status, orderByComparator); 1612 } 1613 1614 /** 1615 * Removes all the bookmarks entries where groupId = ? and userId = ? and status = ? from the database. 1616 * 1617 * @param groupId the group ID 1618 * @param userId the user ID 1619 * @param status the status 1620 * @throws SystemException if a system exception occurred 1621 */ 1622 public static void removeByG_U_S(long groupId, long userId, int status) 1623 throws com.liferay.portal.kernel.exception.SystemException { 1624 getPersistence().removeByG_U_S(groupId, userId, status); 1625 } 1626 1627 /** 1628 * Returns the number of bookmarks entries where groupId = ? and userId = ? and status = ?. 1629 * 1630 * @param groupId the group ID 1631 * @param userId the user ID 1632 * @param status the status 1633 * @return the number of matching bookmarks entries 1634 * @throws SystemException if a system exception occurred 1635 */ 1636 public static int countByG_U_S(long groupId, long userId, int status) 1637 throws com.liferay.portal.kernel.exception.SystemException { 1638 return getPersistence().countByG_U_S(groupId, userId, status); 1639 } 1640 1641 /** 1642 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1643 * 1644 * @param groupId the group ID 1645 * @param userId the user ID 1646 * @param status the status 1647 * @return the number of matching bookmarks entries that the user has permission to view 1648 * @throws SystemException if a system exception occurred 1649 */ 1650 public static int filterCountByG_U_S(long groupId, long userId, int status) 1651 throws com.liferay.portal.kernel.exception.SystemException { 1652 return getPersistence().filterCountByG_U_S(groupId, userId, status); 1653 } 1654 1655 /** 1656 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1657 * 1658 * @param groupId the group ID 1659 * @param folderId the folder ID 1660 * @param status the status 1661 * @return the matching bookmarks entries 1662 * @throws SystemException if a system exception occurred 1663 */ 1664 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1665 long groupId, long folderId, int status) 1666 throws com.liferay.portal.kernel.exception.SystemException { 1667 return getPersistence().findByG_F_S(groupId, folderId, status); 1668 } 1669 1670 /** 1671 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1672 * 1673 * <p> 1674 * 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. 1675 * </p> 1676 * 1677 * @param groupId the group ID 1678 * @param folderId the folder ID 1679 * @param status the status 1680 * @param start the lower bound of the range of bookmarks entries 1681 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1682 * @return the range of matching bookmarks entries 1683 * @throws SystemException if a system exception occurred 1684 */ 1685 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1686 long groupId, long folderId, int status, int start, int end) 1687 throws com.liferay.portal.kernel.exception.SystemException { 1688 return getPersistence() 1689 .findByG_F_S(groupId, folderId, status, start, end); 1690 } 1691 1692 /** 1693 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1694 * 1695 * <p> 1696 * 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. 1697 * </p> 1698 * 1699 * @param groupId the group ID 1700 * @param folderId the folder ID 1701 * @param status the status 1702 * @param start the lower bound of the range of bookmarks entries 1703 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1704 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1705 * @return the ordered range of matching bookmarks entries 1706 * @throws SystemException if a system exception occurred 1707 */ 1708 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1709 long groupId, long folderId, int status, int start, int end, 1710 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1711 throws com.liferay.portal.kernel.exception.SystemException { 1712 return getPersistence() 1713 .findByG_F_S(groupId, folderId, status, start, end, 1714 orderByComparator); 1715 } 1716 1717 /** 1718 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1719 * 1720 * @param groupId the group ID 1721 * @param folderId the folder ID 1722 * @param status the status 1723 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1724 * @return the first matching bookmarks entry 1725 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1726 * @throws SystemException if a system exception occurred 1727 */ 1728 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First( 1729 long groupId, long folderId, int status, 1730 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1731 throws com.liferay.portal.kernel.exception.SystemException, 1732 com.liferay.portlet.bookmarks.NoSuchEntryException { 1733 return getPersistence() 1734 .findByG_F_S_First(groupId, folderId, status, 1735 orderByComparator); 1736 } 1737 1738 /** 1739 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1740 * 1741 * @param groupId the group ID 1742 * @param folderId the folder ID 1743 * @param status the status 1744 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1745 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1746 * @throws SystemException if a system exception occurred 1747 */ 1748 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First( 1749 long groupId, long folderId, int status, 1750 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1751 throws com.liferay.portal.kernel.exception.SystemException { 1752 return getPersistence() 1753 .fetchByG_F_S_First(groupId, folderId, status, 1754 orderByComparator); 1755 } 1756 1757 /** 1758 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1759 * 1760 * @param groupId the group ID 1761 * @param folderId the folder ID 1762 * @param status the status 1763 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1764 * @return the last matching bookmarks entry 1765 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1766 * @throws SystemException if a system exception occurred 1767 */ 1768 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last( 1769 long groupId, long folderId, int status, 1770 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1771 throws com.liferay.portal.kernel.exception.SystemException, 1772 com.liferay.portlet.bookmarks.NoSuchEntryException { 1773 return getPersistence() 1774 .findByG_F_S_Last(groupId, folderId, status, 1775 orderByComparator); 1776 } 1777 1778 /** 1779 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1780 * 1781 * @param groupId the group ID 1782 * @param folderId the folder ID 1783 * @param status the status 1784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1785 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1786 * @throws SystemException if a system exception occurred 1787 */ 1788 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last( 1789 long groupId, long folderId, int status, 1790 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1791 throws com.liferay.portal.kernel.exception.SystemException { 1792 return getPersistence() 1793 .fetchByG_F_S_Last(groupId, folderId, status, 1794 orderByComparator); 1795 } 1796 1797 /** 1798 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1799 * 1800 * @param entryId the primary key of the current bookmarks entry 1801 * @param groupId the group ID 1802 * @param folderId the folder ID 1803 * @param status the status 1804 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1805 * @return the previous, current, and next bookmarks entry 1806 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1807 * @throws SystemException if a system exception occurred 1808 */ 1809 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext( 1810 long entryId, long groupId, long folderId, int status, 1811 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1812 throws com.liferay.portal.kernel.exception.SystemException, 1813 com.liferay.portlet.bookmarks.NoSuchEntryException { 1814 return getPersistence() 1815 .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status, 1816 orderByComparator); 1817 } 1818 1819 /** 1820 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1821 * 1822 * @param groupId the group ID 1823 * @param folderId the folder ID 1824 * @param status the status 1825 * @return the matching bookmarks entries that the user has permission to view 1826 * @throws SystemException if a system exception occurred 1827 */ 1828 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1829 long groupId, long folderId, int status) 1830 throws com.liferay.portal.kernel.exception.SystemException { 1831 return getPersistence().filterFindByG_F_S(groupId, folderId, status); 1832 } 1833 1834 /** 1835 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1836 * 1837 * <p> 1838 * 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. 1839 * </p> 1840 * 1841 * @param groupId the group ID 1842 * @param folderId the folder ID 1843 * @param status the status 1844 * @param start the lower bound of the range of bookmarks entries 1845 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1846 * @return the range of matching bookmarks entries that the user has permission to view 1847 * @throws SystemException if a system exception occurred 1848 */ 1849 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1850 long groupId, long folderId, int status, int start, int end) 1851 throws com.liferay.portal.kernel.exception.SystemException { 1852 return getPersistence() 1853 .filterFindByG_F_S(groupId, folderId, status, start, end); 1854 } 1855 1856 /** 1857 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 1858 * 1859 * <p> 1860 * 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. 1861 * </p> 1862 * 1863 * @param groupId the group ID 1864 * @param folderId the folder ID 1865 * @param status the status 1866 * @param start the lower bound of the range of bookmarks entries 1867 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1868 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1869 * @return the ordered range of matching bookmarks entries that the user has permission to view 1870 * @throws SystemException if a system exception occurred 1871 */ 1872 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1873 long groupId, long folderId, int status, int start, int end, 1874 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1875 throws com.liferay.portal.kernel.exception.SystemException { 1876 return getPersistence() 1877 .filterFindByG_F_S(groupId, folderId, status, start, end, 1878 orderByComparator); 1879 } 1880 1881 /** 1882 * 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 = ?. 1883 * 1884 * @param entryId the primary key of the current bookmarks entry 1885 * @param groupId the group ID 1886 * @param folderId the folder ID 1887 * @param status the status 1888 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1889 * @return the previous, current, and next bookmarks entry 1890 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1891 * @throws SystemException if a system exception occurred 1892 */ 1893 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext( 1894 long entryId, long groupId, long folderId, int status, 1895 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1896 throws com.liferay.portal.kernel.exception.SystemException, 1897 com.liferay.portlet.bookmarks.NoSuchEntryException { 1898 return getPersistence() 1899 .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId, 1900 status, orderByComparator); 1901 } 1902 1903 /** 1904 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1905 * 1906 * @param groupId the group ID 1907 * @param folderIds the folder IDs 1908 * @param status the status 1909 * @return the matching bookmarks entries that the user has permission to view 1910 * @throws SystemException if a system exception occurred 1911 */ 1912 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1913 long groupId, long[] folderIds, int status) 1914 throws com.liferay.portal.kernel.exception.SystemException { 1915 return getPersistence().filterFindByG_F_S(groupId, folderIds, status); 1916 } 1917 1918 /** 1919 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1920 * 1921 * <p> 1922 * 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. 1923 * </p> 1924 * 1925 * @param groupId the group ID 1926 * @param folderIds the folder IDs 1927 * @param status the status 1928 * @param start the lower bound of the range of bookmarks entries 1929 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1930 * @return the range of matching bookmarks entries that the user has permission to view 1931 * @throws SystemException if a system exception occurred 1932 */ 1933 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1934 long groupId, long[] folderIds, int status, int start, int end) 1935 throws com.liferay.portal.kernel.exception.SystemException { 1936 return getPersistence() 1937 .filterFindByG_F_S(groupId, folderIds, status, start, end); 1938 } 1939 1940 /** 1941 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1942 * 1943 * <p> 1944 * 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. 1945 * </p> 1946 * 1947 * @param groupId the group ID 1948 * @param folderIds the folder IDs 1949 * @param status the status 1950 * @param start the lower bound of the range of bookmarks entries 1951 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1952 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1953 * @return the ordered range of matching bookmarks entries that the user has permission to view 1954 * @throws SystemException if a system exception occurred 1955 */ 1956 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1957 long groupId, long[] folderIds, int status, int start, int end, 1958 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1959 throws com.liferay.portal.kernel.exception.SystemException { 1960 return getPersistence() 1961 .filterFindByG_F_S(groupId, folderIds, status, start, end, 1962 orderByComparator); 1963 } 1964 1965 /** 1966 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1967 * 1968 * <p> 1969 * 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. 1970 * </p> 1971 * 1972 * @param groupId the group ID 1973 * @param folderIds the folder IDs 1974 * @param status the status 1975 * @return the matching bookmarks entries 1976 * @throws SystemException if a system exception occurred 1977 */ 1978 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1979 long groupId, long[] folderIds, int status) 1980 throws com.liferay.portal.kernel.exception.SystemException { 1981 return getPersistence().findByG_F_S(groupId, folderIds, status); 1982 } 1983 1984 /** 1985 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1986 * 1987 * <p> 1988 * 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. 1989 * </p> 1990 * 1991 * @param groupId the group ID 1992 * @param folderIds the folder IDs 1993 * @param status the status 1994 * @param start the lower bound of the range of bookmarks entries 1995 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1996 * @return the range of matching bookmarks entries 1997 * @throws SystemException if a system exception occurred 1998 */ 1999 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2000 long groupId, long[] folderIds, int status, int start, int end) 2001 throws com.liferay.portal.kernel.exception.SystemException { 2002 return getPersistence() 2003 .findByG_F_S(groupId, folderIds, status, start, end); 2004 } 2005 2006 /** 2007 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2008 * 2009 * <p> 2010 * 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. 2011 * </p> 2012 * 2013 * @param groupId the group ID 2014 * @param folderIds the folder IDs 2015 * @param status the status 2016 * @param start the lower bound of the range of bookmarks entries 2017 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2018 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2019 * @return the ordered range of matching bookmarks entries 2020 * @throws SystemException if a system exception occurred 2021 */ 2022 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2023 long groupId, long[] folderIds, int status, int start, int end, 2024 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2025 throws com.liferay.portal.kernel.exception.SystemException { 2026 return getPersistence() 2027 .findByG_F_S(groupId, folderIds, status, start, end, 2028 orderByComparator); 2029 } 2030 2031 /** 2032 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status = ? from the database. 2033 * 2034 * @param groupId the group ID 2035 * @param folderId the folder ID 2036 * @param status the status 2037 * @throws SystemException if a system exception occurred 2038 */ 2039 public static void removeByG_F_S(long groupId, long folderId, int status) 2040 throws com.liferay.portal.kernel.exception.SystemException { 2041 getPersistence().removeByG_F_S(groupId, folderId, status); 2042 } 2043 2044 /** 2045 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status = ?. 2046 * 2047 * @param groupId the group ID 2048 * @param folderId the folder ID 2049 * @param status the status 2050 * @return the number of matching bookmarks entries 2051 * @throws SystemException if a system exception occurred 2052 */ 2053 public static int countByG_F_S(long groupId, long folderId, int status) 2054 throws com.liferay.portal.kernel.exception.SystemException { 2055 return getPersistence().countByG_F_S(groupId, folderId, status); 2056 } 2057 2058 /** 2059 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2060 * 2061 * @param groupId the group ID 2062 * @param folderIds the folder IDs 2063 * @param status the status 2064 * @return the number of matching bookmarks entries 2065 * @throws SystemException if a system exception occurred 2066 */ 2067 public static int countByG_F_S(long groupId, long[] folderIds, int status) 2068 throws com.liferay.portal.kernel.exception.SystemException { 2069 return getPersistence().countByG_F_S(groupId, folderIds, status); 2070 } 2071 2072 /** 2073 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2074 * 2075 * @param groupId the group ID 2076 * @param folderId the folder ID 2077 * @param status the status 2078 * @return the number of matching bookmarks entries that the user has permission to view 2079 * @throws SystemException if a system exception occurred 2080 */ 2081 public static int filterCountByG_F_S(long groupId, long folderId, int status) 2082 throws com.liferay.portal.kernel.exception.SystemException { 2083 return getPersistence().filterCountByG_F_S(groupId, folderId, status); 2084 } 2085 2086 /** 2087 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2088 * 2089 * @param groupId the group ID 2090 * @param folderIds the folder IDs 2091 * @param status the status 2092 * @return the number of matching bookmarks entries that the user has permission to view 2093 * @throws SystemException if a system exception occurred 2094 */ 2095 public static int filterCountByG_F_S(long groupId, long[] folderIds, 2096 int status) throws com.liferay.portal.kernel.exception.SystemException { 2097 return getPersistence().filterCountByG_F_S(groupId, folderIds, status); 2098 } 2099 2100 /** 2101 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2102 * 2103 * @param groupId the group ID 2104 * @param folderId the folder ID 2105 * @param status the status 2106 * @return the matching bookmarks entries 2107 * @throws SystemException if a system exception occurred 2108 */ 2109 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2110 long groupId, long folderId, int status) 2111 throws com.liferay.portal.kernel.exception.SystemException { 2112 return getPersistence().findByG_F_NotS(groupId, folderId, status); 2113 } 2114 2115 /** 2116 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2117 * 2118 * <p> 2119 * 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. 2120 * </p> 2121 * 2122 * @param groupId the group ID 2123 * @param folderId the folder ID 2124 * @param status the status 2125 * @param start the lower bound of the range of bookmarks entries 2126 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2127 * @return the range of matching bookmarks entries 2128 * @throws SystemException if a system exception occurred 2129 */ 2130 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2131 long groupId, long folderId, int status, int start, int end) 2132 throws com.liferay.portal.kernel.exception.SystemException { 2133 return getPersistence() 2134 .findByG_F_NotS(groupId, folderId, status, start, end); 2135 } 2136 2137 /** 2138 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2139 * 2140 * <p> 2141 * 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. 2142 * </p> 2143 * 2144 * @param groupId the group ID 2145 * @param folderId the folder ID 2146 * @param status the status 2147 * @param start the lower bound of the range of bookmarks entries 2148 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2150 * @return the ordered range of matching bookmarks entries 2151 * @throws SystemException if a system exception occurred 2152 */ 2153 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2154 long groupId, long folderId, int status, int start, int end, 2155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2156 throws com.liferay.portal.kernel.exception.SystemException { 2157 return getPersistence() 2158 .findByG_F_NotS(groupId, folderId, status, start, end, 2159 orderByComparator); 2160 } 2161 2162 /** 2163 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2164 * 2165 * @param groupId the group ID 2166 * @param folderId the folder ID 2167 * @param status the status 2168 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2169 * @return the first matching bookmarks entry 2170 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2171 * @throws SystemException if a system exception occurred 2172 */ 2173 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First( 2174 long groupId, long folderId, int status, 2175 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2176 throws com.liferay.portal.kernel.exception.SystemException, 2177 com.liferay.portlet.bookmarks.NoSuchEntryException { 2178 return getPersistence() 2179 .findByG_F_NotS_First(groupId, folderId, status, 2180 orderByComparator); 2181 } 2182 2183 /** 2184 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2185 * 2186 * @param groupId the group ID 2187 * @param folderId the folder ID 2188 * @param status the status 2189 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2190 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2191 * @throws SystemException if a system exception occurred 2192 */ 2193 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First( 2194 long groupId, long folderId, int status, 2195 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2196 throws com.liferay.portal.kernel.exception.SystemException { 2197 return getPersistence() 2198 .fetchByG_F_NotS_First(groupId, folderId, status, 2199 orderByComparator); 2200 } 2201 2202 /** 2203 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2204 * 2205 * @param groupId the group ID 2206 * @param folderId the folder ID 2207 * @param status the status 2208 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2209 * @return the last matching bookmarks entry 2210 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2211 * @throws SystemException if a system exception occurred 2212 */ 2213 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last( 2214 long groupId, long folderId, int status, 2215 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2216 throws com.liferay.portal.kernel.exception.SystemException, 2217 com.liferay.portlet.bookmarks.NoSuchEntryException { 2218 return getPersistence() 2219 .findByG_F_NotS_Last(groupId, folderId, status, 2220 orderByComparator); 2221 } 2222 2223 /** 2224 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2225 * 2226 * @param groupId the group ID 2227 * @param folderId the folder ID 2228 * @param status the status 2229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2230 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2231 * @throws SystemException if a system exception occurred 2232 */ 2233 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last( 2234 long groupId, long folderId, int status, 2235 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2236 throws com.liferay.portal.kernel.exception.SystemException { 2237 return getPersistence() 2238 .fetchByG_F_NotS_Last(groupId, folderId, status, 2239 orderByComparator); 2240 } 2241 2242 /** 2243 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2244 * 2245 * @param entryId the primary key of the current bookmarks entry 2246 * @param groupId the group ID 2247 * @param folderId the folder ID 2248 * @param status the status 2249 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2250 * @return the previous, current, and next bookmarks entry 2251 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2252 * @throws SystemException if a system exception occurred 2253 */ 2254 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext( 2255 long entryId, long groupId, long folderId, int status, 2256 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2257 throws com.liferay.portal.kernel.exception.SystemException, 2258 com.liferay.portlet.bookmarks.NoSuchEntryException { 2259 return getPersistence() 2260 .findByG_F_NotS_PrevAndNext(entryId, groupId, folderId, 2261 status, orderByComparator); 2262 } 2263 2264 /** 2265 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2266 * 2267 * @param groupId the group ID 2268 * @param folderId the folder ID 2269 * @param status the status 2270 * @return the matching bookmarks entries that the user has permission to view 2271 * @throws SystemException if a system exception occurred 2272 */ 2273 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2274 long groupId, long folderId, int status) 2275 throws com.liferay.portal.kernel.exception.SystemException { 2276 return getPersistence().filterFindByG_F_NotS(groupId, folderId, status); 2277 } 2278 2279 /** 2280 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2281 * 2282 * <p> 2283 * 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. 2284 * </p> 2285 * 2286 * @param groupId the group ID 2287 * @param folderId the folder ID 2288 * @param status the status 2289 * @param start the lower bound of the range of bookmarks entries 2290 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2291 * @return the range of matching bookmarks entries that the user has permission to view 2292 * @throws SystemException if a system exception occurred 2293 */ 2294 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2295 long groupId, long folderId, int status, int start, int end) 2296 throws com.liferay.portal.kernel.exception.SystemException { 2297 return getPersistence() 2298 .filterFindByG_F_NotS(groupId, folderId, status, start, end); 2299 } 2300 2301 /** 2302 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status ≠ ?. 2303 * 2304 * <p> 2305 * 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. 2306 * </p> 2307 * 2308 * @param groupId the group ID 2309 * @param folderId the folder ID 2310 * @param status the status 2311 * @param start the lower bound of the range of bookmarks entries 2312 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2313 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2314 * @return the ordered range of matching bookmarks entries that the user has permission to view 2315 * @throws SystemException if a system exception occurred 2316 */ 2317 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2318 long groupId, long folderId, int status, int start, int end, 2319 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2320 throws com.liferay.portal.kernel.exception.SystemException { 2321 return getPersistence() 2322 .filterFindByG_F_NotS(groupId, folderId, status, start, end, 2323 orderByComparator); 2324 } 2325 2326 /** 2327 * 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 ≠ ?. 2328 * 2329 * @param entryId the primary key of the current bookmarks entry 2330 * @param groupId the group ID 2331 * @param folderId the folder ID 2332 * @param status the status 2333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2334 * @return the previous, current, and next bookmarks entry 2335 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2336 * @throws SystemException if a system exception occurred 2337 */ 2338 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext( 2339 long entryId, long groupId, long folderId, int status, 2340 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2341 throws com.liferay.portal.kernel.exception.SystemException, 2342 com.liferay.portlet.bookmarks.NoSuchEntryException { 2343 return getPersistence() 2344 .filterFindByG_F_NotS_PrevAndNext(entryId, groupId, 2345 folderId, status, orderByComparator); 2346 } 2347 2348 /** 2349 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2350 * 2351 * @param groupId the group ID 2352 * @param folderIds the folder IDs 2353 * @param status the status 2354 * @return the matching bookmarks entries that the user has permission to view 2355 * @throws SystemException if a system exception occurred 2356 */ 2357 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2358 long groupId, long[] folderIds, int status) 2359 throws com.liferay.portal.kernel.exception.SystemException { 2360 return getPersistence().filterFindByG_F_NotS(groupId, folderIds, status); 2361 } 2362 2363 /** 2364 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2365 * 2366 * <p> 2367 * 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. 2368 * </p> 2369 * 2370 * @param groupId the group ID 2371 * @param folderIds the folder IDs 2372 * @param status the status 2373 * @param start the lower bound of the range of bookmarks entries 2374 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2375 * @return the range of matching bookmarks entries that the user has permission to view 2376 * @throws SystemException if a system exception occurred 2377 */ 2378 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2379 long groupId, long[] folderIds, int status, int start, int end) 2380 throws com.liferay.portal.kernel.exception.SystemException { 2381 return getPersistence() 2382 .filterFindByG_F_NotS(groupId, folderIds, status, start, end); 2383 } 2384 2385 /** 2386 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2387 * 2388 * <p> 2389 * 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. 2390 * </p> 2391 * 2392 * @param groupId the group ID 2393 * @param folderIds the folder IDs 2394 * @param status the status 2395 * @param start the lower bound of the range of bookmarks entries 2396 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2397 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2398 * @return the ordered range of matching bookmarks entries that the user has permission to view 2399 * @throws SystemException if a system exception occurred 2400 */ 2401 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2402 long groupId, long[] folderIds, int status, int start, int end, 2403 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2404 throws com.liferay.portal.kernel.exception.SystemException { 2405 return getPersistence() 2406 .filterFindByG_F_NotS(groupId, folderIds, status, start, 2407 end, orderByComparator); 2408 } 2409 2410 /** 2411 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2412 * 2413 * <p> 2414 * 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. 2415 * </p> 2416 * 2417 * @param groupId the group ID 2418 * @param folderIds the folder IDs 2419 * @param status the status 2420 * @return the matching bookmarks entries 2421 * @throws SystemException if a system exception occurred 2422 */ 2423 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2424 long groupId, long[] folderIds, int status) 2425 throws com.liferay.portal.kernel.exception.SystemException { 2426 return getPersistence().findByG_F_NotS(groupId, folderIds, status); 2427 } 2428 2429 /** 2430 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2431 * 2432 * <p> 2433 * 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. 2434 * </p> 2435 * 2436 * @param groupId the group ID 2437 * @param folderIds the folder IDs 2438 * @param status the status 2439 * @param start the lower bound of the range of bookmarks entries 2440 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2441 * @return the range of matching bookmarks entries 2442 * @throws SystemException if a system exception occurred 2443 */ 2444 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2445 long groupId, long[] folderIds, int status, int start, int end) 2446 throws com.liferay.portal.kernel.exception.SystemException { 2447 return getPersistence() 2448 .findByG_F_NotS(groupId, folderIds, status, start, end); 2449 } 2450 2451 /** 2452 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2453 * 2454 * <p> 2455 * 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. 2456 * </p> 2457 * 2458 * @param groupId the group ID 2459 * @param folderIds the folder IDs 2460 * @param status the status 2461 * @param start the lower bound of the range of bookmarks entries 2462 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2463 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2464 * @return the ordered range of matching bookmarks entries 2465 * @throws SystemException if a system exception occurred 2466 */ 2467 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2468 long groupId, long[] folderIds, int status, int start, int end, 2469 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2470 throws com.liferay.portal.kernel.exception.SystemException { 2471 return getPersistence() 2472 .findByG_F_NotS(groupId, folderIds, status, start, end, 2473 orderByComparator); 2474 } 2475 2476 /** 2477 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ? from the database. 2478 * 2479 * @param groupId the group ID 2480 * @param folderId the folder ID 2481 * @param status the status 2482 * @throws SystemException if a system exception occurred 2483 */ 2484 public static void removeByG_F_NotS(long groupId, long folderId, int status) 2485 throws com.liferay.portal.kernel.exception.SystemException { 2486 getPersistence().removeByG_F_NotS(groupId, folderId, status); 2487 } 2488 2489 /** 2490 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2491 * 2492 * @param groupId the group ID 2493 * @param folderId the folder ID 2494 * @param status the status 2495 * @return the number of matching bookmarks entries 2496 * @throws SystemException if a system exception occurred 2497 */ 2498 public static int countByG_F_NotS(long groupId, long folderId, int status) 2499 throws com.liferay.portal.kernel.exception.SystemException { 2500 return getPersistence().countByG_F_NotS(groupId, folderId, status); 2501 } 2502 2503 /** 2504 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2505 * 2506 * @param groupId the group ID 2507 * @param folderIds the folder IDs 2508 * @param status the status 2509 * @return the number of matching bookmarks entries 2510 * @throws SystemException if a system exception occurred 2511 */ 2512 public static int countByG_F_NotS(long groupId, long[] folderIds, int status) 2513 throws com.liferay.portal.kernel.exception.SystemException { 2514 return getPersistence().countByG_F_NotS(groupId, folderIds, status); 2515 } 2516 2517 /** 2518 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2519 * 2520 * @param groupId the group ID 2521 * @param folderId the folder ID 2522 * @param status the status 2523 * @return the number of matching bookmarks entries that the user has permission to view 2524 * @throws SystemException if a system exception occurred 2525 */ 2526 public static int filterCountByG_F_NotS(long groupId, long folderId, 2527 int status) throws com.liferay.portal.kernel.exception.SystemException { 2528 return getPersistence().filterCountByG_F_NotS(groupId, folderId, status); 2529 } 2530 2531 /** 2532 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2533 * 2534 * @param groupId the group ID 2535 * @param folderIds the folder IDs 2536 * @param status the status 2537 * @return the number of matching bookmarks entries that the user has permission to view 2538 * @throws SystemException if a system exception occurred 2539 */ 2540 public static int filterCountByG_F_NotS(long groupId, long[] folderIds, 2541 int status) throws com.liferay.portal.kernel.exception.SystemException { 2542 return getPersistence().filterCountByG_F_NotS(groupId, folderIds, status); 2543 } 2544 2545 /** 2546 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2547 * 2548 * @param groupId the group ID 2549 * @param userId the user ID 2550 * @param folderId the folder ID 2551 * @param status the status 2552 * @return the matching bookmarks entries 2553 * @throws SystemException if a system exception occurred 2554 */ 2555 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2556 long groupId, long userId, long folderId, int status) 2557 throws com.liferay.portal.kernel.exception.SystemException { 2558 return getPersistence().findByG_U_F_S(groupId, userId, folderId, status); 2559 } 2560 2561 /** 2562 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2563 * 2564 * <p> 2565 * 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. 2566 * </p> 2567 * 2568 * @param groupId the group ID 2569 * @param userId the user ID 2570 * @param folderId the folder ID 2571 * @param status the status 2572 * @param start the lower bound of the range of bookmarks entries 2573 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2574 * @return the range of matching bookmarks entries 2575 * @throws SystemException if a system exception occurred 2576 */ 2577 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2578 long groupId, long userId, long folderId, int status, int start, int end) 2579 throws com.liferay.portal.kernel.exception.SystemException { 2580 return getPersistence() 2581 .findByG_U_F_S(groupId, userId, folderId, status, start, end); 2582 } 2583 2584 /** 2585 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2586 * 2587 * <p> 2588 * 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. 2589 * </p> 2590 * 2591 * @param groupId the group ID 2592 * @param userId the user ID 2593 * @param folderId the folder ID 2594 * @param status the status 2595 * @param start the lower bound of the range of bookmarks entries 2596 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2597 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2598 * @return the ordered range of matching bookmarks entries 2599 * @throws SystemException if a system exception occurred 2600 */ 2601 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2602 long groupId, long userId, long folderId, int status, int start, 2603 int end, 2604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2605 throws com.liferay.portal.kernel.exception.SystemException { 2606 return getPersistence() 2607 .findByG_U_F_S(groupId, userId, folderId, status, start, 2608 end, orderByComparator); 2609 } 2610 2611 /** 2612 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2613 * 2614 * @param groupId the group ID 2615 * @param userId the user ID 2616 * @param folderId the folder ID 2617 * @param status the status 2618 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2619 * @return the first matching bookmarks entry 2620 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2621 * @throws SystemException if a system exception occurred 2622 */ 2623 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First( 2624 long groupId, long userId, long folderId, int status, 2625 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2626 throws com.liferay.portal.kernel.exception.SystemException, 2627 com.liferay.portlet.bookmarks.NoSuchEntryException { 2628 return getPersistence() 2629 .findByG_U_F_S_First(groupId, userId, folderId, status, 2630 orderByComparator); 2631 } 2632 2633 /** 2634 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2635 * 2636 * @param groupId the group ID 2637 * @param userId the user ID 2638 * @param folderId the folder ID 2639 * @param status the status 2640 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2641 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2642 * @throws SystemException if a system exception occurred 2643 */ 2644 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First( 2645 long groupId, long userId, long folderId, int status, 2646 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2647 throws com.liferay.portal.kernel.exception.SystemException { 2648 return getPersistence() 2649 .fetchByG_U_F_S_First(groupId, userId, folderId, status, 2650 orderByComparator); 2651 } 2652 2653 /** 2654 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2655 * 2656 * @param groupId the group ID 2657 * @param userId the user 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_U_F_S_Last( 2666 long groupId, long userId, 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_U_F_S_Last(groupId, userId, folderId, status, 2672 orderByComparator); 2673 } 2674 2675 /** 2676 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2677 * 2678 * @param groupId the group ID 2679 * @param userId the user ID 2680 * @param folderId the folder ID 2681 * @param status the status 2682 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2683 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2684 * @throws SystemException if a system exception occurred 2685 */ 2686 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last( 2687 long groupId, long userId, long folderId, int status, 2688 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2689 throws com.liferay.portal.kernel.exception.SystemException { 2690 return getPersistence() 2691 .fetchByG_U_F_S_Last(groupId, userId, folderId, status, 2692 orderByComparator); 2693 } 2694 2695 /** 2696 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2697 * 2698 * @param entryId the primary key of the current bookmarks entry 2699 * @param groupId the group ID 2700 * @param userId the user ID 2701 * @param folderId the folder ID 2702 * @param status the status 2703 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2704 * @return the previous, current, and next bookmarks entry 2705 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2706 * @throws SystemException if a system exception occurred 2707 */ 2708 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext( 2709 long entryId, long groupId, long userId, long folderId, int status, 2710 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2711 throws com.liferay.portal.kernel.exception.SystemException, 2712 com.liferay.portlet.bookmarks.NoSuchEntryException { 2713 return getPersistence() 2714 .findByG_U_F_S_PrevAndNext(entryId, groupId, userId, 2715 folderId, status, orderByComparator); 2716 } 2717 2718 /** 2719 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2720 * 2721 * @param groupId the group ID 2722 * @param userId the user ID 2723 * @param folderId the folder ID 2724 * @param status the status 2725 * @return the matching bookmarks entries that the user has permission to view 2726 * @throws SystemException if a system exception occurred 2727 */ 2728 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2729 long groupId, long userId, long folderId, int status) 2730 throws com.liferay.portal.kernel.exception.SystemException { 2731 return getPersistence() 2732 .filterFindByG_U_F_S(groupId, userId, folderId, status); 2733 } 2734 2735 /** 2736 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2737 * 2738 * <p> 2739 * 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. 2740 * </p> 2741 * 2742 * @param groupId the group ID 2743 * @param userId the user ID 2744 * @param folderId the folder ID 2745 * @param status the status 2746 * @param start the lower bound of the range of bookmarks entries 2747 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2748 * @return the range of matching bookmarks entries that the user has permission to view 2749 * @throws SystemException if a system exception occurred 2750 */ 2751 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2752 long groupId, long userId, long folderId, int status, int start, int end) 2753 throws com.liferay.portal.kernel.exception.SystemException { 2754 return getPersistence() 2755 .filterFindByG_U_F_S(groupId, userId, folderId, status, 2756 start, end); 2757 } 2758 2759 /** 2760 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2761 * 2762 * <p> 2763 * 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. 2764 * </p> 2765 * 2766 * @param groupId the group ID 2767 * @param userId the user ID 2768 * @param folderId the folder ID 2769 * @param status the status 2770 * @param start the lower bound of the range of bookmarks entries 2771 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2772 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2773 * @return the ordered range of matching bookmarks entries that the user has permission to view 2774 * @throws SystemException if a system exception occurred 2775 */ 2776 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2777 long groupId, long userId, long folderId, int status, int start, 2778 int end, 2779 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2780 throws com.liferay.portal.kernel.exception.SystemException { 2781 return getPersistence() 2782 .filterFindByG_U_F_S(groupId, userId, folderId, status, 2783 start, end, orderByComparator); 2784 } 2785 2786 /** 2787 * 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 = ?. 2788 * 2789 * @param entryId the primary key of the current bookmarks entry 2790 * @param groupId the group ID 2791 * @param userId the user ID 2792 * @param folderId the folder ID 2793 * @param status the status 2794 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2795 * @return the previous, current, and next bookmarks entry 2796 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2797 * @throws SystemException if a system exception occurred 2798 */ 2799 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext( 2800 long entryId, long groupId, long userId, long folderId, int status, 2801 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2802 throws com.liferay.portal.kernel.exception.SystemException, 2803 com.liferay.portlet.bookmarks.NoSuchEntryException { 2804 return getPersistence() 2805 .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId, 2806 folderId, status, orderByComparator); 2807 } 2808 2809 /** 2810 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2811 * 2812 * @param groupId the group ID 2813 * @param userId the user ID 2814 * @param folderIds the folder IDs 2815 * @param status the status 2816 * @return the matching bookmarks entries that the user has permission to view 2817 * @throws SystemException if a system exception occurred 2818 */ 2819 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2820 long groupId, long userId, long[] folderIds, int status) 2821 throws com.liferay.portal.kernel.exception.SystemException { 2822 return getPersistence() 2823 .filterFindByG_U_F_S(groupId, userId, folderIds, status); 2824 } 2825 2826 /** 2827 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2828 * 2829 * <p> 2830 * 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. 2831 * </p> 2832 * 2833 * @param groupId the group ID 2834 * @param userId the user ID 2835 * @param folderIds the folder IDs 2836 * @param status the status 2837 * @param start the lower bound of the range of bookmarks entries 2838 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2839 * @return the range of matching bookmarks entries that the user has permission to view 2840 * @throws SystemException if a system exception occurred 2841 */ 2842 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2843 long groupId, long userId, long[] folderIds, int status, int start, 2844 int end) throws com.liferay.portal.kernel.exception.SystemException { 2845 return getPersistence() 2846 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 2847 start, end); 2848 } 2849 2850 /** 2851 * 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 = ?. 2852 * 2853 * <p> 2854 * 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. 2855 * </p> 2856 * 2857 * @param groupId the group ID 2858 * @param userId the user ID 2859 * @param folderIds the folder IDs 2860 * @param status the status 2861 * @param start the lower bound of the range of bookmarks entries 2862 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2863 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2864 * @return the ordered range of matching bookmarks entries that the user has permission to view 2865 * @throws SystemException if a system exception occurred 2866 */ 2867 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2868 long groupId, long userId, long[] folderIds, int status, int start, 2869 int end, 2870 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2871 throws com.liferay.portal.kernel.exception.SystemException { 2872 return getPersistence() 2873 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 2874 start, end, orderByComparator); 2875 } 2876 2877 /** 2878 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2879 * 2880 * <p> 2881 * 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. 2882 * </p> 2883 * 2884 * @param groupId the group ID 2885 * @param userId the user ID 2886 * @param folderIds the folder IDs 2887 * @param status the status 2888 * @return the matching bookmarks entries 2889 * @throws SystemException if a system exception occurred 2890 */ 2891 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2892 long groupId, long userId, long[] folderIds, int status) 2893 throws com.liferay.portal.kernel.exception.SystemException { 2894 return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status); 2895 } 2896 2897 /** 2898 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2899 * 2900 * <p> 2901 * 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. 2902 * </p> 2903 * 2904 * @param groupId the group ID 2905 * @param userId the user ID 2906 * @param folderIds the folder IDs 2907 * @param status the status 2908 * @param start the lower bound of the range of bookmarks entries 2909 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2910 * @return the range of matching bookmarks entries 2911 * @throws SystemException if a system exception occurred 2912 */ 2913 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2914 long groupId, long userId, long[] folderIds, int status, int start, 2915 int end) throws com.liferay.portal.kernel.exception.SystemException { 2916 return getPersistence() 2917 .findByG_U_F_S(groupId, userId, folderIds, status, start, end); 2918 } 2919 2920 /** 2921 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2922 * 2923 * <p> 2924 * 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. 2925 * </p> 2926 * 2927 * @param groupId the group ID 2928 * @param userId the user ID 2929 * @param folderIds the folder IDs 2930 * @param status the status 2931 * @param start the lower bound of the range of bookmarks entries 2932 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2933 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2934 * @return the ordered range of matching bookmarks entries 2935 * @throws SystemException if a system exception occurred 2936 */ 2937 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2938 long groupId, long userId, long[] folderIds, int status, int start, 2939 int end, 2940 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2941 throws com.liferay.portal.kernel.exception.SystemException { 2942 return getPersistence() 2943 .findByG_U_F_S(groupId, userId, folderIds, status, start, 2944 end, orderByComparator); 2945 } 2946 2947 /** 2948 * Removes all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ? from the database. 2949 * 2950 * @param groupId the group ID 2951 * @param userId the user ID 2952 * @param folderId the folder ID 2953 * @param status the status 2954 * @throws SystemException if a system exception occurred 2955 */ 2956 public static void removeByG_U_F_S(long groupId, long userId, 2957 long folderId, int status) 2958 throws com.liferay.portal.kernel.exception.SystemException { 2959 getPersistence().removeByG_U_F_S(groupId, userId, folderId, status); 2960 } 2961 2962 /** 2963 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2964 * 2965 * @param groupId the group ID 2966 * @param userId the user ID 2967 * @param folderId the folder ID 2968 * @param status the status 2969 * @return the number of matching bookmarks entries 2970 * @throws SystemException if a system exception occurred 2971 */ 2972 public static int countByG_U_F_S(long groupId, long userId, long folderId, 2973 int status) throws com.liferay.portal.kernel.exception.SystemException { 2974 return getPersistence().countByG_U_F_S(groupId, userId, folderId, status); 2975 } 2976 2977 /** 2978 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2979 * 2980 * @param groupId the group ID 2981 * @param userId the user ID 2982 * @param folderIds the folder IDs 2983 * @param status the status 2984 * @return the number of matching bookmarks entries 2985 * @throws SystemException if a system exception occurred 2986 */ 2987 public static int countByG_U_F_S(long groupId, long userId, 2988 long[] folderIds, int status) 2989 throws com.liferay.portal.kernel.exception.SystemException { 2990 return getPersistence() 2991 .countByG_U_F_S(groupId, userId, folderIds, status); 2992 } 2993 2994 /** 2995 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2996 * 2997 * @param groupId the group ID 2998 * @param userId the user ID 2999 * @param folderId the folder ID 3000 * @param status the status 3001 * @return the number of matching bookmarks entries that the user has permission to view 3002 * @throws SystemException if a system exception occurred 3003 */ 3004 public static int filterCountByG_U_F_S(long groupId, long userId, 3005 long folderId, int status) 3006 throws com.liferay.portal.kernel.exception.SystemException { 3007 return getPersistence() 3008 .filterCountByG_U_F_S(groupId, userId, folderId, status); 3009 } 3010 3011 /** 3012 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3013 * 3014 * @param groupId the group ID 3015 * @param userId the user ID 3016 * @param folderIds the folder IDs 3017 * @param status the status 3018 * @return the number of matching bookmarks entries that the user has permission to view 3019 * @throws SystemException if a system exception occurred 3020 */ 3021 public static int filterCountByG_U_F_S(long groupId, long userId, 3022 long[] folderIds, int status) 3023 throws com.liferay.portal.kernel.exception.SystemException { 3024 return getPersistence() 3025 .filterCountByG_U_F_S(groupId, userId, folderIds, status); 3026 } 3027 3028 /** 3029 * Caches the bookmarks entry in the entity cache if it is enabled. 3030 * 3031 * @param bookmarksEntry the bookmarks entry 3032 */ 3033 public static void cacheResult( 3034 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 3035 getPersistence().cacheResult(bookmarksEntry); 3036 } 3037 3038 /** 3039 * Caches the bookmarks entries in the entity cache if it is enabled. 3040 * 3041 * @param bookmarksEntries the bookmarks entries 3042 */ 3043 public static void cacheResult( 3044 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) { 3045 getPersistence().cacheResult(bookmarksEntries); 3046 } 3047 3048 /** 3049 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 3050 * 3051 * @param entryId the primary key for the new bookmarks entry 3052 * @return the new bookmarks entry 3053 */ 3054 public static com.liferay.portlet.bookmarks.model.BookmarksEntry create( 3055 long entryId) { 3056 return getPersistence().create(entryId); 3057 } 3058 3059 /** 3060 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 3061 * 3062 * @param entryId the primary key of the bookmarks entry 3063 * @return the bookmarks entry that was removed 3064 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3065 * @throws SystemException if a system exception occurred 3066 */ 3067 public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 3068 long entryId) 3069 throws com.liferay.portal.kernel.exception.SystemException, 3070 com.liferay.portlet.bookmarks.NoSuchEntryException { 3071 return getPersistence().remove(entryId); 3072 } 3073 3074 public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 3075 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 3076 throws com.liferay.portal.kernel.exception.SystemException { 3077 return getPersistence().updateImpl(bookmarksEntry); 3078 } 3079 3080 /** 3081 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 3082 * 3083 * @param entryId the primary key of the bookmarks entry 3084 * @return the bookmarks entry 3085 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3086 * @throws SystemException if a system exception occurred 3087 */ 3088 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 3089 long entryId) 3090 throws com.liferay.portal.kernel.exception.SystemException, 3091 com.liferay.portlet.bookmarks.NoSuchEntryException { 3092 return getPersistence().findByPrimaryKey(entryId); 3093 } 3094 3095 /** 3096 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 3097 * 3098 * @param entryId the primary key of the bookmarks entry 3099 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 3100 * @throws SystemException if a system exception occurred 3101 */ 3102 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 3103 long entryId) 3104 throws com.liferay.portal.kernel.exception.SystemException { 3105 return getPersistence().fetchByPrimaryKey(entryId); 3106 } 3107 3108 /** 3109 * Returns all the bookmarks entries. 3110 * 3111 * @return the bookmarks entries 3112 * @throws SystemException if a system exception occurred 3113 */ 3114 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 3115 throws com.liferay.portal.kernel.exception.SystemException { 3116 return getPersistence().findAll(); 3117 } 3118 3119 /** 3120 * Returns a range of all the bookmarks entries. 3121 * 3122 * <p> 3123 * 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. 3124 * </p> 3125 * 3126 * @param start the lower bound of the range of bookmarks entries 3127 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3128 * @return the range of bookmarks entries 3129 * @throws SystemException if a system exception occurred 3130 */ 3131 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 3132 int start, int end) 3133 throws com.liferay.portal.kernel.exception.SystemException { 3134 return getPersistence().findAll(start, end); 3135 } 3136 3137 /** 3138 * Returns an ordered range of all the bookmarks entries. 3139 * 3140 * <p> 3141 * 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. 3142 * </p> 3143 * 3144 * @param start the lower bound of the range of bookmarks entries 3145 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3147 * @return the ordered range of bookmarks entries 3148 * @throws SystemException if a system exception occurred 3149 */ 3150 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 3151 int start, int end, 3152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3153 throws com.liferay.portal.kernel.exception.SystemException { 3154 return getPersistence().findAll(start, end, orderByComparator); 3155 } 3156 3157 /** 3158 * Removes all the bookmarks entries from the database. 3159 * 3160 * @throws SystemException if a system exception occurred 3161 */ 3162 public static void removeAll() 3163 throws com.liferay.portal.kernel.exception.SystemException { 3164 getPersistence().removeAll(); 3165 } 3166 3167 /** 3168 * Returns the number of bookmarks entries. 3169 * 3170 * @return the number of bookmarks entries 3171 * @throws SystemException if a system exception occurred 3172 */ 3173 public static int countAll() 3174 throws com.liferay.portal.kernel.exception.SystemException { 3175 return getPersistence().countAll(); 3176 } 3177 3178 public static BookmarksEntryPersistence getPersistence() { 3179 if (_persistence == null) { 3180 _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName()); 3181 3182 ReferenceRegistry.registerReference(BookmarksEntryUtil.class, 3183 "_persistence"); 3184 } 3185 3186 return _persistence; 3187 } 3188 3189 /** 3190 * @deprecated As of 6.2.0 3191 */ 3192 public void setPersistence(BookmarksEntryPersistence persistence) { 3193 } 3194 3195 private static BookmarksEntryPersistence _persistence; 3196 }