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