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