001 /** 002 * Copyright (c) 2000-2012 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 * Caches the bookmarks entry in the entity cache if it is enabled. 115 * 116 * @param bookmarksEntry the bookmarks entry 117 */ 118 public static void cacheResult( 119 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 120 getPersistence().cacheResult(bookmarksEntry); 121 } 122 123 /** 124 * Caches the bookmarks entries in the entity cache if it is enabled. 125 * 126 * @param bookmarksEntries the bookmarks entries 127 */ 128 public static void cacheResult( 129 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) { 130 getPersistence().cacheResult(bookmarksEntries); 131 } 132 133 /** 134 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 135 * 136 * @param entryId the primary key for the new bookmarks entry 137 * @return the new bookmarks entry 138 */ 139 public static com.liferay.portlet.bookmarks.model.BookmarksEntry create( 140 long entryId) { 141 return getPersistence().create(entryId); 142 } 143 144 /** 145 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 146 * 147 * @param entryId the primary key of the bookmarks entry 148 * @return the bookmarks entry that was removed 149 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 150 * @throws SystemException if a system exception occurred 151 */ 152 public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 153 long entryId) 154 throws com.liferay.portal.kernel.exception.SystemException, 155 com.liferay.portlet.bookmarks.NoSuchEntryException { 156 return getPersistence().remove(entryId); 157 } 158 159 public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 160 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 161 throws com.liferay.portal.kernel.exception.SystemException { 162 return getPersistence().updateImpl(bookmarksEntry); 163 } 164 165 /** 166 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 167 * 168 * @param entryId the primary key of the bookmarks entry 169 * @return the bookmarks entry 170 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 171 * @throws SystemException if a system exception occurred 172 */ 173 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 174 long entryId) 175 throws com.liferay.portal.kernel.exception.SystemException, 176 com.liferay.portlet.bookmarks.NoSuchEntryException { 177 return getPersistence().findByPrimaryKey(entryId); 178 } 179 180 /** 181 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 182 * 183 * @param entryId the primary key of the bookmarks entry 184 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 185 * @throws SystemException if a system exception occurred 186 */ 187 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 188 long entryId) 189 throws com.liferay.portal.kernel.exception.SystemException { 190 return getPersistence().fetchByPrimaryKey(entryId); 191 } 192 193 /** 194 * Returns all the bookmarks entries where resourceBlockId = ?. 195 * 196 * @param resourceBlockId the resource block ID 197 * @return the matching bookmarks entries 198 * @throws SystemException if a system exception occurred 199 */ 200 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 201 long resourceBlockId) 202 throws com.liferay.portal.kernel.exception.SystemException { 203 return getPersistence().findByResourceBlockId(resourceBlockId); 204 } 205 206 /** 207 * Returns a range of all the bookmarks entries where resourceBlockId = ?. 208 * 209 * <p> 210 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 211 * </p> 212 * 213 * @param resourceBlockId the resource block ID 214 * @param start the lower bound of the range of bookmarks entries 215 * @param end the upper bound of the range of bookmarks entries (not inclusive) 216 * @return the range of matching bookmarks entries 217 * @throws SystemException if a system exception occurred 218 */ 219 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 220 long resourceBlockId, int start, int end) 221 throws com.liferay.portal.kernel.exception.SystemException { 222 return getPersistence() 223 .findByResourceBlockId(resourceBlockId, start, end); 224 } 225 226 /** 227 * Returns an ordered range of all the bookmarks entries where resourceBlockId = ?. 228 * 229 * <p> 230 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 231 * </p> 232 * 233 * @param resourceBlockId the resource block ID 234 * @param start the lower bound of the range of bookmarks entries 235 * @param end the upper bound of the range of bookmarks entries (not inclusive) 236 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 237 * @return the ordered range of matching bookmarks entries 238 * @throws SystemException if a system exception occurred 239 */ 240 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 241 long resourceBlockId, int start, int end, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException { 244 return getPersistence() 245 .findByResourceBlockId(resourceBlockId, start, end, 246 orderByComparator); 247 } 248 249 /** 250 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 251 * 252 * @param resourceBlockId the resource block ID 253 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 254 * @return the first matching bookmarks entry 255 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 256 * @throws SystemException if a system exception occurred 257 */ 258 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First( 259 long resourceBlockId, 260 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 261 throws com.liferay.portal.kernel.exception.SystemException, 262 com.liferay.portlet.bookmarks.NoSuchEntryException { 263 return getPersistence() 264 .findByResourceBlockId_First(resourceBlockId, 265 orderByComparator); 266 } 267 268 /** 269 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 270 * 271 * @param resourceBlockId the resource block ID 272 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 273 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 274 * @throws SystemException if a system exception occurred 275 */ 276 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First( 277 long resourceBlockId, 278 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 279 throws com.liferay.portal.kernel.exception.SystemException { 280 return getPersistence() 281 .fetchByResourceBlockId_First(resourceBlockId, 282 orderByComparator); 283 } 284 285 /** 286 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 287 * 288 * @param resourceBlockId the resource block ID 289 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 290 * @return the last matching bookmarks entry 291 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 292 * @throws SystemException if a system exception occurred 293 */ 294 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last( 295 long resourceBlockId, 296 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 297 throws com.liferay.portal.kernel.exception.SystemException, 298 com.liferay.portlet.bookmarks.NoSuchEntryException { 299 return getPersistence() 300 .findByResourceBlockId_Last(resourceBlockId, 301 orderByComparator); 302 } 303 304 /** 305 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 306 * 307 * @param resourceBlockId the resource block ID 308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 309 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 310 * @throws SystemException if a system exception occurred 311 */ 312 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last( 313 long resourceBlockId, 314 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 315 throws com.liferay.portal.kernel.exception.SystemException { 316 return getPersistence() 317 .fetchByResourceBlockId_Last(resourceBlockId, 318 orderByComparator); 319 } 320 321 /** 322 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = ?. 323 * 324 * @param entryId the primary key of the current bookmarks entry 325 * @param resourceBlockId the resource block ID 326 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 327 * @return the previous, current, and next bookmarks entry 328 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 329 * @throws SystemException if a system exception occurred 330 */ 331 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext( 332 long entryId, long resourceBlockId, 333 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 334 throws com.liferay.portal.kernel.exception.SystemException, 335 com.liferay.portlet.bookmarks.NoSuchEntryException { 336 return getPersistence() 337 .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId, 338 orderByComparator); 339 } 340 341 /** 342 * Returns all the bookmarks entries where uuid = ?. 343 * 344 * @param uuid the uuid 345 * @return the matching bookmarks entries 346 * @throws SystemException if a system exception occurred 347 */ 348 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 349 java.lang.String uuid) 350 throws com.liferay.portal.kernel.exception.SystemException { 351 return getPersistence().findByUuid(uuid); 352 } 353 354 /** 355 * Returns a range of all the bookmarks entries where uuid = ?. 356 * 357 * <p> 358 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 359 * </p> 360 * 361 * @param uuid the uuid 362 * @param start the lower bound of the range of bookmarks entries 363 * @param end the upper bound of the range of bookmarks entries (not inclusive) 364 * @return the range of matching bookmarks entries 365 * @throws SystemException if a system exception occurred 366 */ 367 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 368 java.lang.String uuid, int start, int end) 369 throws com.liferay.portal.kernel.exception.SystemException { 370 return getPersistence().findByUuid(uuid, start, end); 371 } 372 373 /** 374 * Returns an ordered range of all the bookmarks entries where uuid = ?. 375 * 376 * <p> 377 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 378 * </p> 379 * 380 * @param uuid the uuid 381 * @param start the lower bound of the range of bookmarks entries 382 * @param end the upper bound of the range of bookmarks entries (not inclusive) 383 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 384 * @return the ordered range of matching bookmarks entries 385 * @throws SystemException if a system exception occurred 386 */ 387 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 388 java.lang.String uuid, int start, int end, 389 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 390 throws com.liferay.portal.kernel.exception.SystemException { 391 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 392 } 393 394 /** 395 * Returns the first bookmarks entry in the ordered set where uuid = ?. 396 * 397 * @param uuid the uuid 398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 399 * @return the first matching bookmarks entry 400 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 401 * @throws SystemException if a system exception occurred 402 */ 403 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First( 404 java.lang.String uuid, 405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 406 throws com.liferay.portal.kernel.exception.SystemException, 407 com.liferay.portlet.bookmarks.NoSuchEntryException { 408 return getPersistence().findByUuid_First(uuid, orderByComparator); 409 } 410 411 /** 412 * Returns the first bookmarks entry in the ordered set where uuid = ?. 413 * 414 * @param uuid the uuid 415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 416 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 417 * @throws SystemException if a system exception occurred 418 */ 419 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First( 420 java.lang.String uuid, 421 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 422 throws com.liferay.portal.kernel.exception.SystemException { 423 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 424 } 425 426 /** 427 * Returns the last bookmarks entry in the ordered set where uuid = ?. 428 * 429 * @param uuid the uuid 430 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 431 * @return the last matching bookmarks entry 432 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 433 * @throws SystemException if a system exception occurred 434 */ 435 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last( 436 java.lang.String uuid, 437 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 438 throws com.liferay.portal.kernel.exception.SystemException, 439 com.liferay.portlet.bookmarks.NoSuchEntryException { 440 return getPersistence().findByUuid_Last(uuid, orderByComparator); 441 } 442 443 /** 444 * Returns the last bookmarks entry in the ordered set where uuid = ?. 445 * 446 * @param uuid the uuid 447 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 448 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 449 * @throws SystemException if a system exception occurred 450 */ 451 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last( 452 java.lang.String uuid, 453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 454 throws com.liferay.portal.kernel.exception.SystemException { 455 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 456 } 457 458 /** 459 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ?. 460 * 461 * @param entryId the primary key of the current bookmarks entry 462 * @param uuid the uuid 463 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 464 * @return the previous, current, and next bookmarks entry 465 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 466 * @throws SystemException if a system exception occurred 467 */ 468 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext( 469 long entryId, java.lang.String uuid, 470 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 471 throws com.liferay.portal.kernel.exception.SystemException, 472 com.liferay.portlet.bookmarks.NoSuchEntryException { 473 return getPersistence() 474 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 475 } 476 477 /** 478 * Returns the bookmarks entry where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 479 * 480 * @param uuid the uuid 481 * @param groupId the group ID 482 * @return the matching bookmarks entry 483 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 484 * @throws SystemException if a system exception occurred 485 */ 486 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G( 487 java.lang.String uuid, long groupId) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.bookmarks.NoSuchEntryException { 490 return getPersistence().findByUUID_G(uuid, groupId); 491 } 492 493 /** 494 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 495 * 496 * @param uuid the uuid 497 * @param groupId the group ID 498 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 499 * @throws SystemException if a system exception occurred 500 */ 501 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 502 java.lang.String uuid, long groupId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 return getPersistence().fetchByUUID_G(uuid, groupId); 505 } 506 507 /** 508 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 509 * 510 * @param uuid the uuid 511 * @param groupId the group ID 512 * @param retrieveFromCache whether to use the finder cache 513 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 514 * @throws SystemException if a system exception occurred 515 */ 516 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 517 java.lang.String uuid, long groupId, boolean retrieveFromCache) 518 throws com.liferay.portal.kernel.exception.SystemException { 519 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 520 } 521 522 /** 523 * Returns all the bookmarks entries where uuid = ? and companyId = ?. 524 * 525 * @param uuid the uuid 526 * @param companyId the company ID 527 * @return the matching bookmarks entries 528 * @throws SystemException if a system exception occurred 529 */ 530 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 531 java.lang.String uuid, long companyId) 532 throws com.liferay.portal.kernel.exception.SystemException { 533 return getPersistence().findByUuid_C(uuid, companyId); 534 } 535 536 /** 537 * Returns a range of all the bookmarks entries where uuid = ? and companyId = ?. 538 * 539 * <p> 540 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 541 * </p> 542 * 543 * @param uuid the uuid 544 * @param companyId the company ID 545 * @param start the lower bound of the range of bookmarks entries 546 * @param end the upper bound of the range of bookmarks entries (not inclusive) 547 * @return the range of matching bookmarks entries 548 * @throws SystemException if a system exception occurred 549 */ 550 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 551 java.lang.String uuid, long companyId, int start, int end) 552 throws com.liferay.portal.kernel.exception.SystemException { 553 return getPersistence().findByUuid_C(uuid, companyId, start, end); 554 } 555 556 /** 557 * Returns an ordered range of all the bookmarks entries where uuid = ? and companyId = ?. 558 * 559 * <p> 560 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 561 * </p> 562 * 563 * @param uuid the uuid 564 * @param companyId the company ID 565 * @param start the lower bound of the range of bookmarks entries 566 * @param end the upper bound of the range of bookmarks entries (not inclusive) 567 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 568 * @return the ordered range of matching bookmarks entries 569 * @throws SystemException if a system exception occurred 570 */ 571 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 572 java.lang.String uuid, long companyId, int start, int end, 573 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 574 throws com.liferay.portal.kernel.exception.SystemException { 575 return getPersistence() 576 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 577 } 578 579 /** 580 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 581 * 582 * @param uuid the uuid 583 * @param companyId the company ID 584 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 585 * @return the first matching bookmarks entry 586 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 587 * @throws SystemException if a system exception occurred 588 */ 589 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First( 590 java.lang.String uuid, long companyId, 591 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 592 throws com.liferay.portal.kernel.exception.SystemException, 593 com.liferay.portlet.bookmarks.NoSuchEntryException { 594 return getPersistence() 595 .findByUuid_C_First(uuid, companyId, orderByComparator); 596 } 597 598 /** 599 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 600 * 601 * @param uuid the uuid 602 * @param companyId the company ID 603 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 604 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 605 * @throws SystemException if a system exception occurred 606 */ 607 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First( 608 java.lang.String uuid, long companyId, 609 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 610 throws com.liferay.portal.kernel.exception.SystemException { 611 return getPersistence() 612 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 613 } 614 615 /** 616 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 617 * 618 * @param uuid the uuid 619 * @param companyId the company ID 620 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 621 * @return the last matching bookmarks entry 622 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 623 * @throws SystemException if a system exception occurred 624 */ 625 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last( 626 java.lang.String uuid, long companyId, 627 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 628 throws com.liferay.portal.kernel.exception.SystemException, 629 com.liferay.portlet.bookmarks.NoSuchEntryException { 630 return getPersistence() 631 .findByUuid_C_Last(uuid, companyId, orderByComparator); 632 } 633 634 /** 635 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 636 * 637 * @param uuid the uuid 638 * @param companyId the company ID 639 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 640 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 641 * @throws SystemException if a system exception occurred 642 */ 643 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last( 644 java.lang.String uuid, long companyId, 645 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 646 throws com.liferay.portal.kernel.exception.SystemException { 647 return getPersistence() 648 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 649 } 650 651 /** 652 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ? and companyId = ?. 653 * 654 * @param entryId the primary key of the current bookmarks entry 655 * @param uuid the uuid 656 * @param companyId the company ID 657 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 658 * @return the previous, current, and next bookmarks entry 659 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 660 * @throws SystemException if a system exception occurred 661 */ 662 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext( 663 long entryId, java.lang.String uuid, long companyId, 664 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 665 throws com.liferay.portal.kernel.exception.SystemException, 666 com.liferay.portlet.bookmarks.NoSuchEntryException { 667 return getPersistence() 668 .findByUuid_C_PrevAndNext(entryId, uuid, companyId, 669 orderByComparator); 670 } 671 672 /** 673 * Returns all the bookmarks entries where groupId = ?. 674 * 675 * @param groupId the group ID 676 * @return the matching bookmarks entries 677 * @throws SystemException if a system exception occurred 678 */ 679 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 680 long groupId) 681 throws com.liferay.portal.kernel.exception.SystemException { 682 return getPersistence().findByGroupId(groupId); 683 } 684 685 /** 686 * Returns a range of all the bookmarks entries where groupId = ?. 687 * 688 * <p> 689 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 690 * </p> 691 * 692 * @param groupId the group ID 693 * @param start the lower bound of the range of bookmarks entries 694 * @param end the upper bound of the range of bookmarks entries (not inclusive) 695 * @return the range of matching bookmarks entries 696 * @throws SystemException if a system exception occurred 697 */ 698 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 699 long groupId, int start, int end) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence().findByGroupId(groupId, start, end); 702 } 703 704 /** 705 * Returns an ordered range of all the bookmarks entries where groupId = ?. 706 * 707 * <p> 708 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 709 * </p> 710 * 711 * @param groupId the group ID 712 * @param start the lower bound of the range of bookmarks entries 713 * @param end the upper bound of the range of bookmarks entries (not inclusive) 714 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 715 * @return the ordered range of matching bookmarks entries 716 * @throws SystemException if a system exception occurred 717 */ 718 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 719 long groupId, int start, int end, 720 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 721 throws com.liferay.portal.kernel.exception.SystemException { 722 return getPersistence() 723 .findByGroupId(groupId, start, end, orderByComparator); 724 } 725 726 /** 727 * Returns the first bookmarks entry in the ordered set where groupId = ?. 728 * 729 * @param groupId the group ID 730 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 731 * @return the first matching bookmarks entry 732 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 733 * @throws SystemException if a system exception occurred 734 */ 735 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_First( 736 long groupId, 737 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 738 throws com.liferay.portal.kernel.exception.SystemException, 739 com.liferay.portlet.bookmarks.NoSuchEntryException { 740 return getPersistence().findByGroupId_First(groupId, orderByComparator); 741 } 742 743 /** 744 * Returns the first bookmarks entry in the ordered set where groupId = ?. 745 * 746 * @param groupId the group ID 747 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 748 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 749 * @throws SystemException if a system exception occurred 750 */ 751 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_First( 752 long groupId, 753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 754 throws com.liferay.portal.kernel.exception.SystemException { 755 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 756 } 757 758 /** 759 * Returns the last bookmarks entry in the ordered set where groupId = ?. 760 * 761 * @param groupId the group ID 762 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 763 * @return the last matching bookmarks entry 764 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 765 * @throws SystemException if a system exception occurred 766 */ 767 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_Last( 768 long groupId, 769 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 770 throws com.liferay.portal.kernel.exception.SystemException, 771 com.liferay.portlet.bookmarks.NoSuchEntryException { 772 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 773 } 774 775 /** 776 * Returns the last bookmarks entry in the ordered set where groupId = ?. 777 * 778 * @param groupId the group ID 779 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 780 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 781 * @throws SystemException if a system exception occurred 782 */ 783 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_Last( 784 long groupId, 785 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 786 throws com.liferay.portal.kernel.exception.SystemException { 787 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 788 } 789 790 /** 791 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ?. 792 * 793 * @param entryId the primary key of the current bookmarks entry 794 * @param groupId the group ID 795 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 796 * @return the previous, current, and next bookmarks entry 797 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 798 * @throws SystemException if a system exception occurred 799 */ 800 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByGroupId_PrevAndNext( 801 long entryId, long groupId, 802 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 803 throws com.liferay.portal.kernel.exception.SystemException, 804 com.liferay.portlet.bookmarks.NoSuchEntryException { 805 return getPersistence() 806 .findByGroupId_PrevAndNext(entryId, groupId, 807 orderByComparator); 808 } 809 810 /** 811 * Returns all the bookmarks entries that the user has permission to view where groupId = ?. 812 * 813 * @param groupId the group ID 814 * @return the matching bookmarks entries that the user has permission to view 815 * @throws SystemException if a system exception occurred 816 */ 817 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 818 long groupId) 819 throws com.liferay.portal.kernel.exception.SystemException { 820 return getPersistence().filterFindByGroupId(groupId); 821 } 822 823 /** 824 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ?. 825 * 826 * <p> 827 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 828 * </p> 829 * 830 * @param groupId the group ID 831 * @param start the lower bound of the range of bookmarks entries 832 * @param end the upper bound of the range of bookmarks entries (not inclusive) 833 * @return the range of matching bookmarks entries that the user has permission to view 834 * @throws SystemException if a system exception occurred 835 */ 836 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 837 long groupId, int start, int end) 838 throws com.liferay.portal.kernel.exception.SystemException { 839 return getPersistence().filterFindByGroupId(groupId, start, end); 840 } 841 842 /** 843 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ?. 844 * 845 * <p> 846 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 847 * </p> 848 * 849 * @param groupId the group ID 850 * @param start the lower bound of the range of bookmarks entries 851 * @param end the upper bound of the range of bookmarks entries (not inclusive) 852 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 853 * @return the ordered range of matching bookmarks entries that the user has permission to view 854 * @throws SystemException if a system exception occurred 855 */ 856 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 857 long groupId, int start, int end, 858 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 859 throws com.liferay.portal.kernel.exception.SystemException { 860 return getPersistence() 861 .filterFindByGroupId(groupId, start, end, orderByComparator); 862 } 863 864 /** 865 * 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 = ?. 866 * 867 * @param entryId the primary key of the current bookmarks entry 868 * @param groupId the group ID 869 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 870 * @return the previous, current, and next bookmarks entry 871 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 872 * @throws SystemException if a system exception occurred 873 */ 874 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByGroupId_PrevAndNext( 875 long entryId, long groupId, 876 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 877 throws com.liferay.portal.kernel.exception.SystemException, 878 com.liferay.portlet.bookmarks.NoSuchEntryException { 879 return getPersistence() 880 .filterFindByGroupId_PrevAndNext(entryId, groupId, 881 orderByComparator); 882 } 883 884 /** 885 * Returns all the bookmarks entries where groupId = ? and userId = ?. 886 * 887 * @param groupId the group ID 888 * @param userId the user ID 889 * @return the matching bookmarks entries 890 * @throws SystemException if a system exception occurred 891 */ 892 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 893 long groupId, long userId) 894 throws com.liferay.portal.kernel.exception.SystemException { 895 return getPersistence().findByG_U(groupId, userId); 896 } 897 898 /** 899 * Returns a range of all the bookmarks entries where groupId = ? and userId = ?. 900 * 901 * <p> 902 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 903 * </p> 904 * 905 * @param groupId the group ID 906 * @param userId the user ID 907 * @param start the lower bound of the range of bookmarks entries 908 * @param end the upper bound of the range of bookmarks entries (not inclusive) 909 * @return the range of matching bookmarks entries 910 * @throws SystemException if a system exception occurred 911 */ 912 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 913 long groupId, long userId, int start, int end) 914 throws com.liferay.portal.kernel.exception.SystemException { 915 return getPersistence().findByG_U(groupId, userId, start, end); 916 } 917 918 /** 919 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ?. 920 * 921 * <p> 922 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 923 * </p> 924 * 925 * @param groupId the group ID 926 * @param userId the user ID 927 * @param start the lower bound of the range of bookmarks entries 928 * @param end the upper bound of the range of bookmarks entries (not inclusive) 929 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 930 * @return the ordered range of matching bookmarks entries 931 * @throws SystemException if a system exception occurred 932 */ 933 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 934 long groupId, long userId, int start, int end, 935 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 936 throws com.liferay.portal.kernel.exception.SystemException { 937 return getPersistence() 938 .findByG_U(groupId, userId, start, end, orderByComparator); 939 } 940 941 /** 942 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ?. 943 * 944 * @param groupId the group ID 945 * @param userId the user ID 946 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 947 * @return the first matching bookmarks entry 948 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 949 * @throws SystemException if a system exception occurred 950 */ 951 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_First( 952 long groupId, long userId, 953 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 954 throws com.liferay.portal.kernel.exception.SystemException, 955 com.liferay.portlet.bookmarks.NoSuchEntryException { 956 return getPersistence() 957 .findByG_U_First(groupId, userId, orderByComparator); 958 } 959 960 /** 961 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ?. 962 * 963 * @param groupId the group ID 964 * @param userId the user ID 965 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 966 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 967 * @throws SystemException if a system exception occurred 968 */ 969 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_First( 970 long groupId, long userId, 971 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 972 throws com.liferay.portal.kernel.exception.SystemException { 973 return getPersistence() 974 .fetchByG_U_First(groupId, userId, orderByComparator); 975 } 976 977 /** 978 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ?. 979 * 980 * @param groupId the group ID 981 * @param userId the user ID 982 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 983 * @return the last matching bookmarks entry 984 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 985 * @throws SystemException if a system exception occurred 986 */ 987 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_Last( 988 long groupId, long userId, 989 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 990 throws com.liferay.portal.kernel.exception.SystemException, 991 com.liferay.portlet.bookmarks.NoSuchEntryException { 992 return getPersistence() 993 .findByG_U_Last(groupId, userId, orderByComparator); 994 } 995 996 /** 997 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ?. 998 * 999 * @param groupId the group ID 1000 * @param userId the user ID 1001 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1002 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1003 * @throws SystemException if a system exception occurred 1004 */ 1005 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_Last( 1006 long groupId, long userId, 1007 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1008 throws com.liferay.portal.kernel.exception.SystemException { 1009 return getPersistence() 1010 .fetchByG_U_Last(groupId, userId, orderByComparator); 1011 } 1012 1013 /** 1014 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ?. 1015 * 1016 * @param entryId the primary key of the current bookmarks entry 1017 * @param groupId the group ID 1018 * @param userId the user ID 1019 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1020 * @return the previous, current, and next bookmarks entry 1021 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1022 * @throws SystemException if a system exception occurred 1023 */ 1024 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_PrevAndNext( 1025 long entryId, long groupId, long userId, 1026 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1027 throws com.liferay.portal.kernel.exception.SystemException, 1028 com.liferay.portlet.bookmarks.NoSuchEntryException { 1029 return getPersistence() 1030 .findByG_U_PrevAndNext(entryId, groupId, userId, 1031 orderByComparator); 1032 } 1033 1034 /** 1035 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 1036 * 1037 * @param groupId the group ID 1038 * @param userId the user ID 1039 * @return the matching bookmarks entries that the user has permission to view 1040 * @throws SystemException if a system exception occurred 1041 */ 1042 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 1043 long groupId, long userId) 1044 throws com.liferay.portal.kernel.exception.SystemException { 1045 return getPersistence().filterFindByG_U(groupId, userId); 1046 } 1047 1048 /** 1049 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 1050 * 1051 * <p> 1052 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1053 * </p> 1054 * 1055 * @param groupId the group ID 1056 * @param userId the user ID 1057 * @param start the lower bound of the range of bookmarks entries 1058 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1059 * @return the range of matching bookmarks entries that the user has permission to view 1060 * @throws SystemException if a system exception occurred 1061 */ 1062 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 1063 long groupId, long userId, int start, int end) 1064 throws com.liferay.portal.kernel.exception.SystemException { 1065 return getPersistence().filterFindByG_U(groupId, userId, start, end); 1066 } 1067 1068 /** 1069 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ?. 1070 * 1071 * <p> 1072 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1073 * </p> 1074 * 1075 * @param groupId the group ID 1076 * @param userId the user ID 1077 * @param start the lower bound of the range of bookmarks entries 1078 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1079 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1080 * @return the ordered range of matching bookmarks entries that the user has permission to view 1081 * @throws SystemException if a system exception occurred 1082 */ 1083 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 1084 long groupId, long userId, int start, int end, 1085 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1086 throws com.liferay.portal.kernel.exception.SystemException { 1087 return getPersistence() 1088 .filterFindByG_U(groupId, userId, start, end, 1089 orderByComparator); 1090 } 1091 1092 /** 1093 * 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 = ?. 1094 * 1095 * @param entryId the primary key of the current bookmarks entry 1096 * @param groupId the group ID 1097 * @param userId the user ID 1098 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1099 * @return the previous, current, and next bookmarks entry 1100 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1101 * @throws SystemException if a system exception occurred 1102 */ 1103 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_PrevAndNext( 1104 long entryId, long groupId, long userId, 1105 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1106 throws com.liferay.portal.kernel.exception.SystemException, 1107 com.liferay.portlet.bookmarks.NoSuchEntryException { 1108 return getPersistence() 1109 .filterFindByG_U_PrevAndNext(entryId, groupId, userId, 1110 orderByComparator); 1111 } 1112 1113 /** 1114 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 1115 * 1116 * @param groupId the group ID 1117 * @param folderId the folder ID 1118 * @return the matching bookmarks entries 1119 * @throws SystemException if a system exception occurred 1120 */ 1121 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1122 long groupId, long folderId) 1123 throws com.liferay.portal.kernel.exception.SystemException { 1124 return getPersistence().findByG_F(groupId, folderId); 1125 } 1126 1127 /** 1128 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 1129 * 1130 * <p> 1131 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1132 * </p> 1133 * 1134 * @param groupId the group ID 1135 * @param folderId the folder ID 1136 * @param start the lower bound of the range of bookmarks entries 1137 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1138 * @return the range of matching bookmarks entries 1139 * @throws SystemException if a system exception occurred 1140 */ 1141 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1142 long groupId, long folderId, int start, int end) 1143 throws com.liferay.portal.kernel.exception.SystemException { 1144 return getPersistence().findByG_F(groupId, folderId, start, end); 1145 } 1146 1147 /** 1148 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 1149 * 1150 * <p> 1151 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1152 * </p> 1153 * 1154 * @param groupId the group ID 1155 * @param folderId the folder ID 1156 * @param start the lower bound of the range of bookmarks entries 1157 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1158 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1159 * @return the ordered range of matching bookmarks entries 1160 * @throws SystemException if a system exception occurred 1161 */ 1162 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1163 long groupId, long folderId, int start, int end, 1164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1165 throws com.liferay.portal.kernel.exception.SystemException { 1166 return getPersistence() 1167 .findByG_F(groupId, folderId, start, end, orderByComparator); 1168 } 1169 1170 /** 1171 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1172 * 1173 * @param groupId the group ID 1174 * @param folderId the folder ID 1175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1176 * @return the first matching bookmarks entry 1177 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1178 * @throws SystemException if a system exception occurred 1179 */ 1180 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 1181 long groupId, long folderId, 1182 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1183 throws com.liferay.portal.kernel.exception.SystemException, 1184 com.liferay.portlet.bookmarks.NoSuchEntryException { 1185 return getPersistence() 1186 .findByG_F_First(groupId, folderId, orderByComparator); 1187 } 1188 1189 /** 1190 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1191 * 1192 * @param groupId the group ID 1193 * @param folderId the folder ID 1194 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1195 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1196 * @throws SystemException if a system exception occurred 1197 */ 1198 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 1199 long groupId, long folderId, 1200 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1201 throws com.liferay.portal.kernel.exception.SystemException { 1202 return getPersistence() 1203 .fetchByG_F_First(groupId, folderId, orderByComparator); 1204 } 1205 1206 /** 1207 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1208 * 1209 * @param groupId the group ID 1210 * @param folderId the folder ID 1211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1212 * @return the last matching bookmarks entry 1213 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1214 * @throws SystemException if a system exception occurred 1215 */ 1216 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 1217 long groupId, long folderId, 1218 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1219 throws com.liferay.portal.kernel.exception.SystemException, 1220 com.liferay.portlet.bookmarks.NoSuchEntryException { 1221 return getPersistence() 1222 .findByG_F_Last(groupId, folderId, orderByComparator); 1223 } 1224 1225 /** 1226 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1227 * 1228 * @param groupId the group ID 1229 * @param folderId the folder ID 1230 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1231 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1232 * @throws SystemException if a system exception occurred 1233 */ 1234 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 1235 long groupId, long folderId, 1236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1237 throws com.liferay.portal.kernel.exception.SystemException { 1238 return getPersistence() 1239 .fetchByG_F_Last(groupId, folderId, orderByComparator); 1240 } 1241 1242 /** 1243 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1244 * 1245 * @param entryId the primary key of the current bookmarks entry 1246 * @param groupId the group ID 1247 * @param folderId the folder ID 1248 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1249 * @return the previous, current, and next bookmarks entry 1250 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1251 * @throws SystemException if a system exception occurred 1252 */ 1253 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 1254 long entryId, long groupId, long folderId, 1255 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1256 throws com.liferay.portal.kernel.exception.SystemException, 1257 com.liferay.portlet.bookmarks.NoSuchEntryException { 1258 return getPersistence() 1259 .findByG_F_PrevAndNext(entryId, groupId, folderId, 1260 orderByComparator); 1261 } 1262 1263 /** 1264 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 1265 * 1266 * <p> 1267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1268 * </p> 1269 * 1270 * @param groupId the group ID 1271 * @param folderIds the folder IDs 1272 * @return the matching bookmarks entries 1273 * @throws SystemException if a system exception occurred 1274 */ 1275 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1276 long groupId, long[] folderIds) 1277 throws com.liferay.portal.kernel.exception.SystemException { 1278 return getPersistence().findByG_F(groupId, folderIds); 1279 } 1280 1281 /** 1282 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 1283 * 1284 * <p> 1285 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1286 * </p> 1287 * 1288 * @param groupId the group ID 1289 * @param folderIds the folder IDs 1290 * @param start the lower bound of the range of bookmarks entries 1291 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1292 * @return the range of matching bookmarks entries 1293 * @throws SystemException if a system exception occurred 1294 */ 1295 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1296 long groupId, long[] folderIds, int start, int end) 1297 throws com.liferay.portal.kernel.exception.SystemException { 1298 return getPersistence().findByG_F(groupId, folderIds, start, end); 1299 } 1300 1301 /** 1302 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 1303 * 1304 * <p> 1305 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1306 * </p> 1307 * 1308 * @param groupId the group ID 1309 * @param folderIds the folder IDs 1310 * @param start the lower bound of the range of bookmarks entries 1311 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1312 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1313 * @return the ordered range of matching bookmarks entries 1314 * @throws SystemException if a system exception occurred 1315 */ 1316 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1317 long groupId, long[] folderIds, int start, int end, 1318 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1319 throws com.liferay.portal.kernel.exception.SystemException { 1320 return getPersistence() 1321 .findByG_F(groupId, folderIds, start, end, orderByComparator); 1322 } 1323 1324 /** 1325 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1326 * 1327 * @param groupId the group ID 1328 * @param folderId the folder ID 1329 * @return the matching bookmarks entries that the user has permission to view 1330 * @throws SystemException if a system exception occurred 1331 */ 1332 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1333 long groupId, long folderId) 1334 throws com.liferay.portal.kernel.exception.SystemException { 1335 return getPersistence().filterFindByG_F(groupId, folderId); 1336 } 1337 1338 /** 1339 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1340 * 1341 * <p> 1342 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1343 * </p> 1344 * 1345 * @param groupId the group ID 1346 * @param folderId the folder ID 1347 * @param start the lower bound of the range of bookmarks entries 1348 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1349 * @return the range of matching bookmarks entries that the user has permission to view 1350 * @throws SystemException if a system exception occurred 1351 */ 1352 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1353 long groupId, long folderId, int start, int end) 1354 throws com.liferay.portal.kernel.exception.SystemException { 1355 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 1356 } 1357 1358 /** 1359 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 1360 * 1361 * <p> 1362 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1363 * </p> 1364 * 1365 * @param groupId the group ID 1366 * @param folderId the folder ID 1367 * @param start the lower bound of the range of bookmarks entries 1368 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1369 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1370 * @return the ordered range of matching bookmarks entries that the user has permission to view 1371 * @throws SystemException if a system exception occurred 1372 */ 1373 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1374 long groupId, long folderId, int start, int end, 1375 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1376 throws com.liferay.portal.kernel.exception.SystemException { 1377 return getPersistence() 1378 .filterFindByG_F(groupId, folderId, start, end, 1379 orderByComparator); 1380 } 1381 1382 /** 1383 * 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 = ?. 1384 * 1385 * @param entryId the primary key of the current bookmarks entry 1386 * @param groupId the group ID 1387 * @param folderId the folder ID 1388 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1389 * @return the previous, current, and next bookmarks entry 1390 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1391 * @throws SystemException if a system exception occurred 1392 */ 1393 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 1394 long entryId, long groupId, long folderId, 1395 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1396 throws com.liferay.portal.kernel.exception.SystemException, 1397 com.liferay.portlet.bookmarks.NoSuchEntryException { 1398 return getPersistence() 1399 .filterFindByG_F_PrevAndNext(entryId, groupId, folderId, 1400 orderByComparator); 1401 } 1402 1403 /** 1404 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1405 * 1406 * @param groupId the group ID 1407 * @param folderIds the folder IDs 1408 * @return the matching bookmarks entries that the user has permission to view 1409 * @throws SystemException if a system exception occurred 1410 */ 1411 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1412 long groupId, long[] folderIds) 1413 throws com.liferay.portal.kernel.exception.SystemException { 1414 return getPersistence().filterFindByG_F(groupId, folderIds); 1415 } 1416 1417 /** 1418 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1419 * 1420 * <p> 1421 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1422 * </p> 1423 * 1424 * @param groupId the group ID 1425 * @param folderIds the folder IDs 1426 * @param start the lower bound of the range of bookmarks entries 1427 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1428 * @return the range of matching bookmarks entries that the user has permission to view 1429 * @throws SystemException if a system exception occurred 1430 */ 1431 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1432 long groupId, long[] folderIds, int start, int end) 1433 throws com.liferay.portal.kernel.exception.SystemException { 1434 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 1435 } 1436 1437 /** 1438 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1439 * 1440 * <p> 1441 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1442 * </p> 1443 * 1444 * @param groupId the group ID 1445 * @param folderIds the folder IDs 1446 * @param start the lower bound of the range of bookmarks entries 1447 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1448 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1449 * @return the ordered range of matching bookmarks entries that the user has permission to view 1450 * @throws SystemException if a system exception occurred 1451 */ 1452 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1453 long groupId, long[] folderIds, int start, int end, 1454 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1455 throws com.liferay.portal.kernel.exception.SystemException { 1456 return getPersistence() 1457 .filterFindByG_F(groupId, folderIds, start, end, 1458 orderByComparator); 1459 } 1460 1461 /** 1462 * Returns all the bookmarks entries. 1463 * 1464 * @return the bookmarks entries 1465 * @throws SystemException if a system exception occurred 1466 */ 1467 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 1468 throws com.liferay.portal.kernel.exception.SystemException { 1469 return getPersistence().findAll(); 1470 } 1471 1472 /** 1473 * Returns a range of all the bookmarks entries. 1474 * 1475 * <p> 1476 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1477 * </p> 1478 * 1479 * @param start the lower bound of the range of bookmarks entries 1480 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1481 * @return the range of bookmarks entries 1482 * @throws SystemException if a system exception occurred 1483 */ 1484 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1485 int start, int end) 1486 throws com.liferay.portal.kernel.exception.SystemException { 1487 return getPersistence().findAll(start, end); 1488 } 1489 1490 /** 1491 * Returns an ordered range of all the bookmarks entries. 1492 * 1493 * <p> 1494 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1495 * </p> 1496 * 1497 * @param start the lower bound of the range of bookmarks entries 1498 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1499 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1500 * @return the ordered range of bookmarks entries 1501 * @throws SystemException if a system exception occurred 1502 */ 1503 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1504 int start, int end, 1505 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1506 throws com.liferay.portal.kernel.exception.SystemException { 1507 return getPersistence().findAll(start, end, orderByComparator); 1508 } 1509 1510 /** 1511 * Removes all the bookmarks entries where resourceBlockId = ? from the database. 1512 * 1513 * @param resourceBlockId the resource block ID 1514 * @throws SystemException if a system exception occurred 1515 */ 1516 public static void removeByResourceBlockId(long resourceBlockId) 1517 throws com.liferay.portal.kernel.exception.SystemException { 1518 getPersistence().removeByResourceBlockId(resourceBlockId); 1519 } 1520 1521 /** 1522 * Removes all the bookmarks entries where uuid = ? from the database. 1523 * 1524 * @param uuid the uuid 1525 * @throws SystemException if a system exception occurred 1526 */ 1527 public static void removeByUuid(java.lang.String uuid) 1528 throws com.liferay.portal.kernel.exception.SystemException { 1529 getPersistence().removeByUuid(uuid); 1530 } 1531 1532 /** 1533 * Removes the bookmarks entry where uuid = ? and groupId = ? from the database. 1534 * 1535 * @param uuid the uuid 1536 * @param groupId the group ID 1537 * @return the bookmarks entry that was removed 1538 * @throws SystemException if a system exception occurred 1539 */ 1540 public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G( 1541 java.lang.String uuid, long groupId) 1542 throws com.liferay.portal.kernel.exception.SystemException, 1543 com.liferay.portlet.bookmarks.NoSuchEntryException { 1544 return getPersistence().removeByUUID_G(uuid, groupId); 1545 } 1546 1547 /** 1548 * Removes all the bookmarks entries where uuid = ? and companyId = ? from the database. 1549 * 1550 * @param uuid the uuid 1551 * @param companyId the company ID 1552 * @throws SystemException if a system exception occurred 1553 */ 1554 public static void removeByUuid_C(java.lang.String uuid, long companyId) 1555 throws com.liferay.portal.kernel.exception.SystemException { 1556 getPersistence().removeByUuid_C(uuid, companyId); 1557 } 1558 1559 /** 1560 * Removes all the bookmarks entries where groupId = ? from the database. 1561 * 1562 * @param groupId the group ID 1563 * @throws SystemException if a system exception occurred 1564 */ 1565 public static void removeByGroupId(long groupId) 1566 throws com.liferay.portal.kernel.exception.SystemException { 1567 getPersistence().removeByGroupId(groupId); 1568 } 1569 1570 /** 1571 * Removes all the bookmarks entries where groupId = ? and userId = ? from the database. 1572 * 1573 * @param groupId the group ID 1574 * @param userId the user ID 1575 * @throws SystemException if a system exception occurred 1576 */ 1577 public static void removeByG_U(long groupId, long userId) 1578 throws com.liferay.portal.kernel.exception.SystemException { 1579 getPersistence().removeByG_U(groupId, userId); 1580 } 1581 1582 /** 1583 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 1584 * 1585 * @param groupId the group ID 1586 * @param folderId the folder ID 1587 * @throws SystemException if a system exception occurred 1588 */ 1589 public static void removeByG_F(long groupId, long folderId) 1590 throws com.liferay.portal.kernel.exception.SystemException { 1591 getPersistence().removeByG_F(groupId, folderId); 1592 } 1593 1594 /** 1595 * Removes all the bookmarks entries from the database. 1596 * 1597 * @throws SystemException if a system exception occurred 1598 */ 1599 public static void removeAll() 1600 throws com.liferay.portal.kernel.exception.SystemException { 1601 getPersistence().removeAll(); 1602 } 1603 1604 /** 1605 * Returns the number of bookmarks entries where resourceBlockId = ?. 1606 * 1607 * @param resourceBlockId the resource block ID 1608 * @return the number of matching bookmarks entries 1609 * @throws SystemException if a system exception occurred 1610 */ 1611 public static int countByResourceBlockId(long resourceBlockId) 1612 throws com.liferay.portal.kernel.exception.SystemException { 1613 return getPersistence().countByResourceBlockId(resourceBlockId); 1614 } 1615 1616 /** 1617 * Returns the number of bookmarks entries where uuid = ?. 1618 * 1619 * @param uuid the uuid 1620 * @return the number of matching bookmarks entries 1621 * @throws SystemException if a system exception occurred 1622 */ 1623 public static int countByUuid(java.lang.String uuid) 1624 throws com.liferay.portal.kernel.exception.SystemException { 1625 return getPersistence().countByUuid(uuid); 1626 } 1627 1628 /** 1629 * Returns the number of bookmarks entries where uuid = ? and groupId = ?. 1630 * 1631 * @param uuid the uuid 1632 * @param groupId the group ID 1633 * @return the number of matching bookmarks entries 1634 * @throws SystemException if a system exception occurred 1635 */ 1636 public static int countByUUID_G(java.lang.String uuid, long groupId) 1637 throws com.liferay.portal.kernel.exception.SystemException { 1638 return getPersistence().countByUUID_G(uuid, groupId); 1639 } 1640 1641 /** 1642 * Returns the number of bookmarks entries where uuid = ? and companyId = ?. 1643 * 1644 * @param uuid the uuid 1645 * @param companyId the company ID 1646 * @return the number of matching bookmarks entries 1647 * @throws SystemException if a system exception occurred 1648 */ 1649 public static int countByUuid_C(java.lang.String uuid, long companyId) 1650 throws com.liferay.portal.kernel.exception.SystemException { 1651 return getPersistence().countByUuid_C(uuid, companyId); 1652 } 1653 1654 /** 1655 * Returns the number of bookmarks entries where groupId = ?. 1656 * 1657 * @param groupId the group ID 1658 * @return the number of matching bookmarks entries 1659 * @throws SystemException if a system exception occurred 1660 */ 1661 public static int countByGroupId(long groupId) 1662 throws com.liferay.portal.kernel.exception.SystemException { 1663 return getPersistence().countByGroupId(groupId); 1664 } 1665 1666 /** 1667 * Returns the number of bookmarks entries that the user has permission to view where groupId = ?. 1668 * 1669 * @param groupId the group ID 1670 * @return the number of matching bookmarks entries that the user has permission to view 1671 * @throws SystemException if a system exception occurred 1672 */ 1673 public static int filterCountByGroupId(long groupId) 1674 throws com.liferay.portal.kernel.exception.SystemException { 1675 return getPersistence().filterCountByGroupId(groupId); 1676 } 1677 1678 /** 1679 * Returns the number of bookmarks entries where groupId = ? and userId = ?. 1680 * 1681 * @param groupId the group ID 1682 * @param userId the user ID 1683 * @return the number of matching bookmarks entries 1684 * @throws SystemException if a system exception occurred 1685 */ 1686 public static int countByG_U(long groupId, long userId) 1687 throws com.liferay.portal.kernel.exception.SystemException { 1688 return getPersistence().countByG_U(groupId, userId); 1689 } 1690 1691 /** 1692 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 1693 * 1694 * @param groupId the group ID 1695 * @param userId the user ID 1696 * @return the number of matching bookmarks entries that the user has permission to view 1697 * @throws SystemException if a system exception occurred 1698 */ 1699 public static int filterCountByG_U(long groupId, long userId) 1700 throws com.liferay.portal.kernel.exception.SystemException { 1701 return getPersistence().filterCountByG_U(groupId, userId); 1702 } 1703 1704 /** 1705 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 1706 * 1707 * @param groupId the group ID 1708 * @param folderId the folder ID 1709 * @return the number of matching bookmarks entries 1710 * @throws SystemException if a system exception occurred 1711 */ 1712 public static int countByG_F(long groupId, long folderId) 1713 throws com.liferay.portal.kernel.exception.SystemException { 1714 return getPersistence().countByG_F(groupId, folderId); 1715 } 1716 1717 /** 1718 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 1719 * 1720 * @param groupId the group ID 1721 * @param folderIds the folder IDs 1722 * @return the number of matching bookmarks entries 1723 * @throws SystemException if a system exception occurred 1724 */ 1725 public static int countByG_F(long groupId, long[] folderIds) 1726 throws com.liferay.portal.kernel.exception.SystemException { 1727 return getPersistence().countByG_F(groupId, folderIds); 1728 } 1729 1730 /** 1731 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1732 * 1733 * @param groupId the group ID 1734 * @param folderId the folder ID 1735 * @return the number of matching bookmarks entries that the user has permission to view 1736 * @throws SystemException if a system exception occurred 1737 */ 1738 public static int filterCountByG_F(long groupId, long folderId) 1739 throws com.liferay.portal.kernel.exception.SystemException { 1740 return getPersistence().filterCountByG_F(groupId, folderId); 1741 } 1742 1743 /** 1744 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1745 * 1746 * @param groupId the group ID 1747 * @param folderIds the folder IDs 1748 * @return the number of matching bookmarks entries that the user has permission to view 1749 * @throws SystemException if a system exception occurred 1750 */ 1751 public static int filterCountByG_F(long groupId, long[] folderIds) 1752 throws com.liferay.portal.kernel.exception.SystemException { 1753 return getPersistence().filterCountByG_F(groupId, folderIds); 1754 } 1755 1756 /** 1757 * Returns the number of bookmarks entries. 1758 * 1759 * @return the number of bookmarks entries 1760 * @throws SystemException if a system exception occurred 1761 */ 1762 public static int countAll() 1763 throws com.liferay.portal.kernel.exception.SystemException { 1764 return getPersistence().countAll(); 1765 } 1766 1767 public static BookmarksEntryPersistence getPersistence() { 1768 if (_persistence == null) { 1769 _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName()); 1770 1771 ReferenceRegistry.registerReference(BookmarksEntryUtil.class, 1772 "_persistence"); 1773 } 1774 1775 return _persistence; 1776 } 1777 1778 /** 1779 * @deprecated 1780 */ 1781 public void setPersistence(BookmarksEntryPersistence persistence) { 1782 } 1783 1784 private static BookmarksEntryPersistence _persistence; 1785 }