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 userId = ? and folderId = ? and status = ?. 2102 * 2103 * @param groupId the group ID 2104 * @param userId the user ID 2105 * @param folderId the folder ID 2106 * @param status the status 2107 * @return the matching bookmarks entries 2108 * @throws SystemException if a system exception occurred 2109 */ 2110 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2111 long groupId, long userId, long folderId, int status) 2112 throws com.liferay.portal.kernel.exception.SystemException { 2113 return getPersistence().findByG_U_F_S(groupId, userId, folderId, status); 2114 } 2115 2116 /** 2117 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2118 * 2119 * <p> 2120 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2121 * </p> 2122 * 2123 * @param groupId the group ID 2124 * @param userId the user ID 2125 * @param folderId the folder ID 2126 * @param status the status 2127 * @param start the lower bound of the range of bookmarks entries 2128 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2129 * @return the range of matching bookmarks entries 2130 * @throws SystemException if a system exception occurred 2131 */ 2132 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2133 long groupId, long userId, long folderId, int status, int start, int end) 2134 throws com.liferay.portal.kernel.exception.SystemException { 2135 return getPersistence() 2136 .findByG_U_F_S(groupId, userId, folderId, status, start, end); 2137 } 2138 2139 /** 2140 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2141 * 2142 * <p> 2143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2144 * </p> 2145 * 2146 * @param groupId the group ID 2147 * @param userId the user ID 2148 * @param folderId the folder ID 2149 * @param status the status 2150 * @param start the lower bound of the range of bookmarks entries 2151 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2152 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2153 * @return the ordered range of matching bookmarks entries 2154 * @throws SystemException if a system exception occurred 2155 */ 2156 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2157 long groupId, long userId, long folderId, int status, int start, 2158 int end, 2159 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2160 throws com.liferay.portal.kernel.exception.SystemException { 2161 return getPersistence() 2162 .findByG_U_F_S(groupId, userId, folderId, status, start, 2163 end, orderByComparator); 2164 } 2165 2166 /** 2167 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2168 * 2169 * @param groupId the group ID 2170 * @param userId the user ID 2171 * @param folderId the folder ID 2172 * @param status the status 2173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2174 * @return the first matching bookmarks entry 2175 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2176 * @throws SystemException if a system exception occurred 2177 */ 2178 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First( 2179 long groupId, long userId, long folderId, int status, 2180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2181 throws com.liferay.portal.kernel.exception.SystemException, 2182 com.liferay.portlet.bookmarks.NoSuchEntryException { 2183 return getPersistence() 2184 .findByG_U_F_S_First(groupId, userId, folderId, status, 2185 orderByComparator); 2186 } 2187 2188 /** 2189 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2190 * 2191 * @param groupId the group ID 2192 * @param userId the user ID 2193 * @param folderId the folder ID 2194 * @param status the status 2195 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2196 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2197 * @throws SystemException if a system exception occurred 2198 */ 2199 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First( 2200 long groupId, long userId, long folderId, int status, 2201 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2202 throws com.liferay.portal.kernel.exception.SystemException { 2203 return getPersistence() 2204 .fetchByG_U_F_S_First(groupId, userId, folderId, status, 2205 orderByComparator); 2206 } 2207 2208 /** 2209 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2210 * 2211 * @param groupId the group ID 2212 * @param userId the user ID 2213 * @param folderId the folder ID 2214 * @param status the status 2215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2216 * @return the last matching bookmarks entry 2217 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2218 * @throws SystemException if a system exception occurred 2219 */ 2220 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last( 2221 long groupId, long userId, long folderId, int status, 2222 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2223 throws com.liferay.portal.kernel.exception.SystemException, 2224 com.liferay.portlet.bookmarks.NoSuchEntryException { 2225 return getPersistence() 2226 .findByG_U_F_S_Last(groupId, userId, folderId, status, 2227 orderByComparator); 2228 } 2229 2230 /** 2231 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2232 * 2233 * @param groupId the group ID 2234 * @param userId the user ID 2235 * @param folderId the folder ID 2236 * @param status the status 2237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2238 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2239 * @throws SystemException if a system exception occurred 2240 */ 2241 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last( 2242 long groupId, long userId, long folderId, int status, 2243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2244 throws com.liferay.portal.kernel.exception.SystemException { 2245 return getPersistence() 2246 .fetchByG_U_F_S_Last(groupId, userId, folderId, status, 2247 orderByComparator); 2248 } 2249 2250 /** 2251 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2252 * 2253 * @param entryId the primary key of the current bookmarks entry 2254 * @param groupId the group ID 2255 * @param userId the user ID 2256 * @param folderId the folder ID 2257 * @param status the status 2258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2259 * @return the previous, current, and next bookmarks entry 2260 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2261 * @throws SystemException if a system exception occurred 2262 */ 2263 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext( 2264 long entryId, long groupId, long userId, long folderId, int status, 2265 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2266 throws com.liferay.portal.kernel.exception.SystemException, 2267 com.liferay.portlet.bookmarks.NoSuchEntryException { 2268 return getPersistence() 2269 .findByG_U_F_S_PrevAndNext(entryId, groupId, userId, 2270 folderId, status, orderByComparator); 2271 } 2272 2273 /** 2274 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2275 * 2276 * @param groupId the group ID 2277 * @param userId the user ID 2278 * @param folderId the folder ID 2279 * @param status the status 2280 * @return the matching bookmarks entries that the user has permission to view 2281 * @throws SystemException if a system exception occurred 2282 */ 2283 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2284 long groupId, long userId, long folderId, int status) 2285 throws com.liferay.portal.kernel.exception.SystemException { 2286 return getPersistence() 2287 .filterFindByG_U_F_S(groupId, userId, folderId, status); 2288 } 2289 2290 /** 2291 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2292 * 2293 * <p> 2294 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2295 * </p> 2296 * 2297 * @param groupId the group ID 2298 * @param userId the user ID 2299 * @param folderId the folder ID 2300 * @param status the status 2301 * @param start the lower bound of the range of bookmarks entries 2302 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2303 * @return the range of matching bookmarks entries that the user has permission to view 2304 * @throws SystemException if a system exception occurred 2305 */ 2306 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2307 long groupId, long userId, long folderId, int status, int start, int end) 2308 throws com.liferay.portal.kernel.exception.SystemException { 2309 return getPersistence() 2310 .filterFindByG_U_F_S(groupId, userId, folderId, status, 2311 start, end); 2312 } 2313 2314 /** 2315 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2316 * 2317 * <p> 2318 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2319 * </p> 2320 * 2321 * @param groupId the group ID 2322 * @param userId the user ID 2323 * @param folderId the folder ID 2324 * @param status the status 2325 * @param start the lower bound of the range of bookmarks entries 2326 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2327 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2328 * @return the ordered range of matching bookmarks entries that the user has permission to view 2329 * @throws SystemException if a system exception occurred 2330 */ 2331 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2332 long groupId, long userId, long folderId, int status, int start, 2333 int end, 2334 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2335 throws com.liferay.portal.kernel.exception.SystemException { 2336 return getPersistence() 2337 .filterFindByG_U_F_S(groupId, userId, folderId, status, 2338 start, end, orderByComparator); 2339 } 2340 2341 /** 2342 * 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 = ?. 2343 * 2344 * @param entryId the primary key of the current bookmarks entry 2345 * @param groupId the group ID 2346 * @param userId the user ID 2347 * @param folderId the folder ID 2348 * @param status the status 2349 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2350 * @return the previous, current, and next bookmarks entry 2351 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2352 * @throws SystemException if a system exception occurred 2353 */ 2354 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext( 2355 long entryId, long groupId, long userId, long folderId, int status, 2356 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2357 throws com.liferay.portal.kernel.exception.SystemException, 2358 com.liferay.portlet.bookmarks.NoSuchEntryException { 2359 return getPersistence() 2360 .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId, 2361 folderId, status, orderByComparator); 2362 } 2363 2364 /** 2365 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2366 * 2367 * @param groupId the group ID 2368 * @param userId the user ID 2369 * @param folderIds the folder IDs 2370 * @param status the status 2371 * @return the matching bookmarks entries that the user has permission to view 2372 * @throws SystemException if a system exception occurred 2373 */ 2374 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2375 long groupId, long userId, long[] folderIds, int status) 2376 throws com.liferay.portal.kernel.exception.SystemException { 2377 return getPersistence() 2378 .filterFindByG_U_F_S(groupId, userId, folderIds, status); 2379 } 2380 2381 /** 2382 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2383 * 2384 * <p> 2385 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2386 * </p> 2387 * 2388 * @param groupId the group ID 2389 * @param userId the user ID 2390 * @param folderIds the folder IDs 2391 * @param status the status 2392 * @param start the lower bound of the range of bookmarks entries 2393 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2394 * @return the range of matching bookmarks entries that the user has permission to view 2395 * @throws SystemException if a system exception occurred 2396 */ 2397 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2398 long groupId, long userId, long[] folderIds, int status, int start, 2399 int end) throws com.liferay.portal.kernel.exception.SystemException { 2400 return getPersistence() 2401 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 2402 start, end); 2403 } 2404 2405 /** 2406 * 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 = ?. 2407 * 2408 * <p> 2409 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2410 * </p> 2411 * 2412 * @param groupId the group ID 2413 * @param userId the user ID 2414 * @param folderIds the folder IDs 2415 * @param status the status 2416 * @param start the lower bound of the range of bookmarks entries 2417 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2418 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2419 * @return the ordered range of matching bookmarks entries that the user has permission to view 2420 * @throws SystemException if a system exception occurred 2421 */ 2422 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2423 long groupId, long userId, long[] folderIds, int status, int start, 2424 int end, 2425 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2426 throws com.liferay.portal.kernel.exception.SystemException { 2427 return getPersistence() 2428 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 2429 start, end, orderByComparator); 2430 } 2431 2432 /** 2433 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2434 * 2435 * <p> 2436 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2437 * </p> 2438 * 2439 * @param groupId the group ID 2440 * @param userId the user ID 2441 * @param folderIds the folder IDs 2442 * @param status the status 2443 * @return the matching bookmarks entries 2444 * @throws SystemException if a system exception occurred 2445 */ 2446 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2447 long groupId, long userId, long[] folderIds, int status) 2448 throws com.liferay.portal.kernel.exception.SystemException { 2449 return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status); 2450 } 2451 2452 /** 2453 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2454 * 2455 * <p> 2456 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2457 * </p> 2458 * 2459 * @param groupId the group ID 2460 * @param userId the user ID 2461 * @param folderIds the folder IDs 2462 * @param status the status 2463 * @param start the lower bound of the range of bookmarks entries 2464 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2465 * @return the range of matching bookmarks entries 2466 * @throws SystemException if a system exception occurred 2467 */ 2468 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2469 long groupId, long userId, long[] folderIds, int status, int start, 2470 int end) throws com.liferay.portal.kernel.exception.SystemException { 2471 return getPersistence() 2472 .findByG_U_F_S(groupId, userId, folderIds, status, start, end); 2473 } 2474 2475 /** 2476 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2477 * 2478 * <p> 2479 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2480 * </p> 2481 * 2482 * @param groupId the group ID 2483 * @param userId the user ID 2484 * @param folderIds the folder IDs 2485 * @param status the status 2486 * @param start the lower bound of the range of bookmarks entries 2487 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2488 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2489 * @return the ordered range of matching bookmarks entries 2490 * @throws SystemException if a system exception occurred 2491 */ 2492 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2493 long groupId, long userId, long[] folderIds, int status, int start, 2494 int end, 2495 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2496 throws com.liferay.portal.kernel.exception.SystemException { 2497 return getPersistence() 2498 .findByG_U_F_S(groupId, userId, folderIds, status, start, 2499 end, orderByComparator); 2500 } 2501 2502 /** 2503 * Removes all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ? from the database. 2504 * 2505 * @param groupId the group ID 2506 * @param userId the user ID 2507 * @param folderId the folder ID 2508 * @param status the status 2509 * @throws SystemException if a system exception occurred 2510 */ 2511 public static void removeByG_U_F_S(long groupId, long userId, 2512 long folderId, int status) 2513 throws com.liferay.portal.kernel.exception.SystemException { 2514 getPersistence().removeByG_U_F_S(groupId, userId, folderId, status); 2515 } 2516 2517 /** 2518 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2519 * 2520 * @param groupId the group ID 2521 * @param userId the user ID 2522 * @param folderId the folder ID 2523 * @param status the status 2524 * @return the number of matching bookmarks entries 2525 * @throws SystemException if a system exception occurred 2526 */ 2527 public static int countByG_U_F_S(long groupId, long userId, long folderId, 2528 int status) throws com.liferay.portal.kernel.exception.SystemException { 2529 return getPersistence().countByG_U_F_S(groupId, userId, folderId, status); 2530 } 2531 2532 /** 2533 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2534 * 2535 * @param groupId the group ID 2536 * @param userId the user ID 2537 * @param folderIds the folder IDs 2538 * @param status the status 2539 * @return the number of matching bookmarks entries 2540 * @throws SystemException if a system exception occurred 2541 */ 2542 public static int countByG_U_F_S(long groupId, long userId, 2543 long[] folderIds, int status) 2544 throws com.liferay.portal.kernel.exception.SystemException { 2545 return getPersistence() 2546 .countByG_U_F_S(groupId, userId, folderIds, status); 2547 } 2548 2549 /** 2550 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2551 * 2552 * @param groupId the group ID 2553 * @param userId the user ID 2554 * @param folderId the folder ID 2555 * @param status the status 2556 * @return the number of matching bookmarks entries that the user has permission to view 2557 * @throws SystemException if a system exception occurred 2558 */ 2559 public static int filterCountByG_U_F_S(long groupId, long userId, 2560 long folderId, int status) 2561 throws com.liferay.portal.kernel.exception.SystemException { 2562 return getPersistence() 2563 .filterCountByG_U_F_S(groupId, userId, folderId, status); 2564 } 2565 2566 /** 2567 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2568 * 2569 * @param groupId the group ID 2570 * @param userId the user ID 2571 * @param folderIds the folder IDs 2572 * @param status the status 2573 * @return the number of matching bookmarks entries that the user has permission to view 2574 * @throws SystemException if a system exception occurred 2575 */ 2576 public static int filterCountByG_U_F_S(long groupId, long userId, 2577 long[] folderIds, int status) 2578 throws com.liferay.portal.kernel.exception.SystemException { 2579 return getPersistence() 2580 .filterCountByG_U_F_S(groupId, userId, folderIds, status); 2581 } 2582 2583 /** 2584 * Caches the bookmarks entry in the entity cache if it is enabled. 2585 * 2586 * @param bookmarksEntry the bookmarks entry 2587 */ 2588 public static void cacheResult( 2589 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 2590 getPersistence().cacheResult(bookmarksEntry); 2591 } 2592 2593 /** 2594 * Caches the bookmarks entries in the entity cache if it is enabled. 2595 * 2596 * @param bookmarksEntries the bookmarks entries 2597 */ 2598 public static void cacheResult( 2599 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) { 2600 getPersistence().cacheResult(bookmarksEntries); 2601 } 2602 2603 /** 2604 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 2605 * 2606 * @param entryId the primary key for the new bookmarks entry 2607 * @return the new bookmarks entry 2608 */ 2609 public static com.liferay.portlet.bookmarks.model.BookmarksEntry create( 2610 long entryId) { 2611 return getPersistence().create(entryId); 2612 } 2613 2614 /** 2615 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 2616 * 2617 * @param entryId the primary key of the bookmarks entry 2618 * @return the bookmarks entry that was removed 2619 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2620 * @throws SystemException if a system exception occurred 2621 */ 2622 public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 2623 long entryId) 2624 throws com.liferay.portal.kernel.exception.SystemException, 2625 com.liferay.portlet.bookmarks.NoSuchEntryException { 2626 return getPersistence().remove(entryId); 2627 } 2628 2629 public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 2630 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 2631 throws com.liferay.portal.kernel.exception.SystemException { 2632 return getPersistence().updateImpl(bookmarksEntry); 2633 } 2634 2635 /** 2636 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 2637 * 2638 * @param entryId the primary key of the bookmarks entry 2639 * @return the bookmarks entry 2640 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2641 * @throws SystemException if a system exception occurred 2642 */ 2643 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 2644 long entryId) 2645 throws com.liferay.portal.kernel.exception.SystemException, 2646 com.liferay.portlet.bookmarks.NoSuchEntryException { 2647 return getPersistence().findByPrimaryKey(entryId); 2648 } 2649 2650 /** 2651 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 2652 * 2653 * @param entryId the primary key of the bookmarks entry 2654 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 2655 * @throws SystemException if a system exception occurred 2656 */ 2657 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 2658 long entryId) 2659 throws com.liferay.portal.kernel.exception.SystemException { 2660 return getPersistence().fetchByPrimaryKey(entryId); 2661 } 2662 2663 /** 2664 * Returns all the bookmarks entries. 2665 * 2666 * @return the bookmarks entries 2667 * @throws SystemException if a system exception occurred 2668 */ 2669 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 2670 throws com.liferay.portal.kernel.exception.SystemException { 2671 return getPersistence().findAll(); 2672 } 2673 2674 /** 2675 * Returns a range of all the bookmarks entries. 2676 * 2677 * <p> 2678 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2679 * </p> 2680 * 2681 * @param start the lower bound of the range of bookmarks entries 2682 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2683 * @return the range of bookmarks entries 2684 * @throws SystemException if a system exception occurred 2685 */ 2686 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2687 int start, int end) 2688 throws com.liferay.portal.kernel.exception.SystemException { 2689 return getPersistence().findAll(start, end); 2690 } 2691 2692 /** 2693 * Returns an ordered range of all the bookmarks entries. 2694 * 2695 * <p> 2696 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.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. 2697 * </p> 2698 * 2699 * @param start the lower bound of the range of bookmarks entries 2700 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2701 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2702 * @return the ordered range of bookmarks entries 2703 * @throws SystemException if a system exception occurred 2704 */ 2705 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2706 int start, int end, 2707 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2708 throws com.liferay.portal.kernel.exception.SystemException { 2709 return getPersistence().findAll(start, end, orderByComparator); 2710 } 2711 2712 /** 2713 * Removes all the bookmarks entries from the database. 2714 * 2715 * @throws SystemException if a system exception occurred 2716 */ 2717 public static void removeAll() 2718 throws com.liferay.portal.kernel.exception.SystemException { 2719 getPersistence().removeAll(); 2720 } 2721 2722 /** 2723 * Returns the number of bookmarks entries. 2724 * 2725 * @return the number of bookmarks entries 2726 * @throws SystemException if a system exception occurred 2727 */ 2728 public static int countAll() 2729 throws com.liferay.portal.kernel.exception.SystemException { 2730 return getPersistence().countAll(); 2731 } 2732 2733 public static BookmarksEntryPersistence getPersistence() { 2734 if (_persistence == null) { 2735 _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName()); 2736 2737 ReferenceRegistry.registerReference(BookmarksEntryUtil.class, 2738 "_persistence"); 2739 } 2740 2741 return _persistence; 2742 } 2743 2744 /** 2745 * @deprecated As of 6.2.0 2746 */ 2747 public void setPersistence(BookmarksEntryPersistence persistence) { 2748 } 2749 2750 private static BookmarksEntryPersistence _persistence; 2751 }