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