001 /** 002 * Copyright (c) 2000-2010 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.service.ServiceContext; 022 023 import com.liferay.portlet.bookmarks.model.BookmarksEntry; 024 025 import java.util.List; 026 027 /** 028 * 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. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 032 * </p> 033 * 034 * <p> 035 * Caching information and settings can be found in <code>portal.properties</code> 036 * </p> 037 * 038 * @author Brian Wing Shun Chan 039 * @see BookmarksEntryPersistence 040 * @see BookmarksEntryPersistenceImpl 041 * @generated 042 */ 043 public class BookmarksEntryUtil { 044 /** 045 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 046 */ 047 public static void clearCache() { 048 getPersistence().clearCache(); 049 } 050 051 /** 052 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 053 */ 054 public static void clearCache(BookmarksEntry bookmarksEntry) { 055 getPersistence().clearCache(bookmarksEntry); 056 } 057 058 /** 059 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 060 */ 061 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 062 throws SystemException { 063 return getPersistence().countWithDynamicQuery(dynamicQuery); 064 } 065 066 /** 067 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 068 */ 069 public static List<BookmarksEntry> findWithDynamicQuery( 070 DynamicQuery dynamicQuery) throws SystemException { 071 return getPersistence().findWithDynamicQuery(dynamicQuery); 072 } 073 074 /** 075 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 076 */ 077 public static List<BookmarksEntry> findWithDynamicQuery( 078 DynamicQuery dynamicQuery, int start, int end) 079 throws SystemException { 080 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 081 } 082 083 /** 084 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 085 */ 086 public static List<BookmarksEntry> findWithDynamicQuery( 087 DynamicQuery dynamicQuery, int start, int end, 088 OrderByComparator orderByComparator) throws SystemException { 089 return getPersistence() 090 .findWithDynamicQuery(dynamicQuery, start, end, 091 orderByComparator); 092 } 093 094 /** 095 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 096 */ 097 public static BookmarksEntry remove(BookmarksEntry bookmarksEntry) 098 throws SystemException { 099 return getPersistence().remove(bookmarksEntry); 100 } 101 102 /** 103 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 104 */ 105 public static BookmarksEntry update(BookmarksEntry bookmarksEntry, 106 boolean merge) throws SystemException { 107 return getPersistence().update(bookmarksEntry, merge); 108 } 109 110 /** 111 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 112 */ 113 public static BookmarksEntry update(BookmarksEntry bookmarksEntry, 114 boolean merge, ServiceContext serviceContext) throws SystemException { 115 return getPersistence().update(bookmarksEntry, merge, serviceContext); 116 } 117 118 /** 119 * Caches the bookmarks entry in the entity cache if it is enabled. 120 * 121 * @param bookmarksEntry the bookmarks entry to cache 122 */ 123 public static void cacheResult( 124 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 125 getPersistence().cacheResult(bookmarksEntry); 126 } 127 128 /** 129 * Caches the bookmarks entries in the entity cache if it is enabled. 130 * 131 * @param bookmarksEntries the bookmarks entries to cache 132 */ 133 public static void cacheResult( 134 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) { 135 getPersistence().cacheResult(bookmarksEntries); 136 } 137 138 /** 139 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 140 * 141 * @param entryId the primary key for the new bookmarks entry 142 * @return the new bookmarks entry 143 */ 144 public static com.liferay.portlet.bookmarks.model.BookmarksEntry create( 145 long entryId) { 146 return getPersistence().create(entryId); 147 } 148 149 /** 150 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 151 * 152 * @param entryId the primary key of the bookmarks entry to remove 153 * @return the bookmarks entry that was removed 154 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 155 * @throws SystemException if a system exception occurred 156 */ 157 public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 158 long entryId) 159 throws com.liferay.portal.kernel.exception.SystemException, 160 com.liferay.portlet.bookmarks.NoSuchEntryException { 161 return getPersistence().remove(entryId); 162 } 163 164 public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 165 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry, 166 boolean merge) 167 throws com.liferay.portal.kernel.exception.SystemException { 168 return getPersistence().updateImpl(bookmarksEntry, merge); 169 } 170 171 /** 172 * Finds the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 173 * 174 * @param entryId the primary key of the bookmarks entry to find 175 * @return the bookmarks entry 176 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 177 * @throws SystemException if a system exception occurred 178 */ 179 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 180 long entryId) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.bookmarks.NoSuchEntryException { 183 return getPersistence().findByPrimaryKey(entryId); 184 } 185 186 /** 187 * Finds the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 188 * 189 * @param entryId the primary key of the bookmarks entry to find 190 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 191 * @throws SystemException if a system exception occurred 192 */ 193 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 194 long entryId) 195 throws com.liferay.portal.kernel.exception.SystemException { 196 return getPersistence().fetchByPrimaryKey(entryId); 197 } 198 199 /** 200 * Finds all the bookmarks entries where uuid = ?. 201 * 202 * @param uuid the uuid to search with 203 * @return the matching bookmarks entries 204 * @throws SystemException if a system exception occurred 205 */ 206 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 207 java.lang.String uuid) 208 throws com.liferay.portal.kernel.exception.SystemException { 209 return getPersistence().findByUuid(uuid); 210 } 211 212 /** 213 * Finds a range of all the bookmarks entries where uuid = ?. 214 * 215 * <p> 216 * 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. 217 * </p> 218 * 219 * @param uuid the uuid to search with 220 * @param start the lower bound of the range of bookmarks entries to return 221 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 222 * @return the range of matching bookmarks entries 223 * @throws SystemException if a system exception occurred 224 */ 225 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 226 java.lang.String uuid, int start, int end) 227 throws com.liferay.portal.kernel.exception.SystemException { 228 return getPersistence().findByUuid(uuid, start, end); 229 } 230 231 /** 232 * Finds an ordered range of all the bookmarks entries where uuid = ?. 233 * 234 * <p> 235 * 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. 236 * </p> 237 * 238 * @param uuid the uuid to search with 239 * @param start the lower bound of the range of bookmarks entries to return 240 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 241 * @param orderByComparator the comparator to order the results by 242 * @return the ordered range of matching bookmarks entries 243 * @throws SystemException if a system exception occurred 244 */ 245 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 246 java.lang.String uuid, int start, int end, 247 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 248 throws com.liferay.portal.kernel.exception.SystemException { 249 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 250 } 251 252 /** 253 * Finds the first bookmarks entry in the ordered set where uuid = ?. 254 * 255 * <p> 256 * 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. 257 * </p> 258 * 259 * @param uuid the uuid to search with 260 * @param orderByComparator the comparator to order the set by 261 * @return the first matching bookmarks entry 262 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 263 * @throws SystemException if a system exception occurred 264 */ 265 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First( 266 java.lang.String uuid, 267 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 268 throws com.liferay.portal.kernel.exception.SystemException, 269 com.liferay.portlet.bookmarks.NoSuchEntryException { 270 return getPersistence().findByUuid_First(uuid, orderByComparator); 271 } 272 273 /** 274 * Finds the last bookmarks entry in the ordered set where uuid = ?. 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 uuid the uuid to search with 281 * @param orderByComparator the comparator to order the set by 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 findByUuid_Last( 287 java.lang.String uuid, 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().findByUuid_Last(uuid, orderByComparator); 292 } 293 294 /** 295 * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ?. 296 * 297 * <p> 298 * 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. 299 * </p> 300 * 301 * @param entryId the primary key of the current bookmarks entry 302 * @param uuid the uuid to search with 303 * @param orderByComparator the comparator to order the set by 304 * @return the previous, current, and next bookmarks entry 305 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 306 * @throws SystemException if a system exception occurred 307 */ 308 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext( 309 long entryId, java.lang.String uuid, 310 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 311 throws com.liferay.portal.kernel.exception.SystemException, 312 com.liferay.portlet.bookmarks.NoSuchEntryException { 313 return getPersistence() 314 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 315 } 316 317 /** 318 * Finds the bookmarks entry where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 319 * 320 * @param uuid the uuid to search with 321 * @param groupId the group id to search with 322 * @return the matching bookmarks entry 323 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 324 * @throws SystemException if a system exception occurred 325 */ 326 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G( 327 java.lang.String uuid, long groupId) 328 throws com.liferay.portal.kernel.exception.SystemException, 329 com.liferay.portlet.bookmarks.NoSuchEntryException { 330 return getPersistence().findByUUID_G(uuid, groupId); 331 } 332 333 /** 334 * Finds the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 335 * 336 * @param uuid the uuid to search with 337 * @param groupId the group id to search with 338 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 339 * @throws SystemException if a system exception occurred 340 */ 341 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 342 java.lang.String uuid, long groupId) 343 throws com.liferay.portal.kernel.exception.SystemException { 344 return getPersistence().fetchByUUID_G(uuid, groupId); 345 } 346 347 /** 348 * Finds the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 349 * 350 * @param uuid the uuid to search with 351 * @param groupId the group id to search with 352 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 353 * @throws SystemException if a system exception occurred 354 */ 355 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 356 java.lang.String uuid, long groupId, boolean retrieveFromCache) 357 throws com.liferay.portal.kernel.exception.SystemException { 358 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 359 } 360 361 /** 362 * Finds all the bookmarks entries where groupId = ?. 363 * 364 * @param groupId the group id to search with 365 * @return the matching bookmarks entries 366 * @throws SystemException if a system exception occurred 367 */ 368 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 369 long groupId) 370 throws com.liferay.portal.kernel.exception.SystemException { 371 return getPersistence().findByGroupId(groupId); 372 } 373 374 /** 375 * Finds a range of all the bookmarks entries where groupId = ?. 376 * 377 * <p> 378 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 379 * </p> 380 * 381 * @param groupId the group id to search with 382 * @param start the lower bound of the range of bookmarks entries to return 383 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 384 * @return the range of matching bookmarks entries 385 * @throws SystemException if a system exception occurred 386 */ 387 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 388 long groupId, int start, int end) 389 throws com.liferay.portal.kernel.exception.SystemException { 390 return getPersistence().findByGroupId(groupId, start, end); 391 } 392 393 /** 394 * Finds an ordered range of all the bookmarks entries where groupId = ?. 395 * 396 * <p> 397 * 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. 398 * </p> 399 * 400 * @param groupId the group id to search with 401 * @param start the lower bound of the range of bookmarks entries to return 402 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 403 * @param orderByComparator the comparator to order the results by 404 * @return the ordered range of matching bookmarks entries 405 * @throws SystemException if a system exception occurred 406 */ 407 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 408 long groupId, int start, int end, 409 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 410 throws com.liferay.portal.kernel.exception.SystemException { 411 return getPersistence() 412 .findByGroupId(groupId, start, end, orderByComparator); 413 } 414 415 /** 416 * Finds the first bookmarks entry in the ordered set where groupId = ?. 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 groupId the group id to search with 423 * @param orderByComparator the comparator to order the set by 424 * @return the first matching bookmarks entry 425 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 426 * @throws SystemException if a system exception occurred 427 */ 428 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_First( 429 long groupId, 430 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 431 throws com.liferay.portal.kernel.exception.SystemException, 432 com.liferay.portlet.bookmarks.NoSuchEntryException { 433 return getPersistence().findByGroupId_First(groupId, orderByComparator); 434 } 435 436 /** 437 * Finds the last bookmarks entry in the ordered set where groupId = ?. 438 * 439 * <p> 440 * 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. 441 * </p> 442 * 443 * @param groupId the group id to search with 444 * @param orderByComparator the comparator to order the set by 445 * @return the last matching bookmarks entry 446 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 447 * @throws SystemException if a system exception occurred 448 */ 449 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_Last( 450 long groupId, 451 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 452 throws com.liferay.portal.kernel.exception.SystemException, 453 com.liferay.portlet.bookmarks.NoSuchEntryException { 454 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 455 } 456 457 /** 458 * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ?. 459 * 460 * <p> 461 * 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. 462 * </p> 463 * 464 * @param entryId the primary key of the current bookmarks entry 465 * @param groupId the group id to search with 466 * @param orderByComparator the comparator to order the set by 467 * @return the previous, current, and next bookmarks entry 468 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 469 * @throws SystemException if a system exception occurred 470 */ 471 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByGroupId_PrevAndNext( 472 long entryId, long groupId, 473 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 474 throws com.liferay.portal.kernel.exception.SystemException, 475 com.liferay.portlet.bookmarks.NoSuchEntryException { 476 return getPersistence() 477 .findByGroupId_PrevAndNext(entryId, groupId, 478 orderByComparator); 479 } 480 481 /** 482 * Filters by the user's permissions and finds all the bookmarks entries where groupId = ?. 483 * 484 * @param groupId the group id to search with 485 * @return the matching bookmarks entries that the user has permission to view 486 * @throws SystemException if a system exception occurred 487 */ 488 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 489 long groupId) 490 throws com.liferay.portal.kernel.exception.SystemException { 491 return getPersistence().filterFindByGroupId(groupId); 492 } 493 494 /** 495 * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = ?. 496 * 497 * <p> 498 * 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. 499 * </p> 500 * 501 * @param groupId the group id to search with 502 * @param start the lower bound of the range of bookmarks entries to return 503 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 504 * @return the range of matching bookmarks entries that the user has permission to view 505 * @throws SystemException if a system exception occurred 506 */ 507 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 508 long groupId, int start, int end) 509 throws com.liferay.portal.kernel.exception.SystemException { 510 return getPersistence().filterFindByGroupId(groupId, start, end); 511 } 512 513 /** 514 * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = ?. 515 * 516 * <p> 517 * 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. 518 * </p> 519 * 520 * @param groupId the group id to search with 521 * @param start the lower bound of the range of bookmarks entries to return 522 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 523 * @param orderByComparator the comparator to order the results by 524 * @return the ordered range of matching bookmarks entries that the user has permission to view 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 528 long groupId, int start, int end, 529 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 530 throws com.liferay.portal.kernel.exception.SystemException { 531 return getPersistence() 532 .filterFindByGroupId(groupId, start, end, orderByComparator); 533 } 534 535 /** 536 * Finds all the bookmarks entries where groupId = ? and userId = ?. 537 * 538 * @param groupId the group id to search with 539 * @param userId the user id to search with 540 * @return the matching bookmarks entries 541 * @throws SystemException if a system exception occurred 542 */ 543 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 544 long groupId, long userId) 545 throws com.liferay.portal.kernel.exception.SystemException { 546 return getPersistence().findByG_U(groupId, userId); 547 } 548 549 /** 550 * Finds a range of all the bookmarks entries where groupId = ? and userId = ?. 551 * 552 * <p> 553 * 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. 554 * </p> 555 * 556 * @param groupId the group id to search with 557 * @param userId the user id to search with 558 * @param start the lower bound of the range of bookmarks entries to return 559 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 560 * @return the range of matching bookmarks entries 561 * @throws SystemException if a system exception occurred 562 */ 563 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 564 long groupId, long userId, int start, int end) 565 throws com.liferay.portal.kernel.exception.SystemException { 566 return getPersistence().findByG_U(groupId, userId, start, end); 567 } 568 569 /** 570 * Finds an ordered range of all the bookmarks entries where groupId = ? and userId = ?. 571 * 572 * <p> 573 * 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. 574 * </p> 575 * 576 * @param groupId the group id to search with 577 * @param userId the user id to search with 578 * @param start the lower bound of the range of bookmarks entries to return 579 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 580 * @param orderByComparator the comparator to order the results by 581 * @return the ordered range of matching bookmarks entries 582 * @throws SystemException if a system exception occurred 583 */ 584 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 585 long groupId, long userId, int start, int end, 586 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 587 throws com.liferay.portal.kernel.exception.SystemException { 588 return getPersistence() 589 .findByG_U(groupId, userId, start, end, orderByComparator); 590 } 591 592 /** 593 * Finds the first bookmarks entry in the ordered set where groupId = ? and userId = ?. 594 * 595 * <p> 596 * 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. 597 * </p> 598 * 599 * @param groupId the group id to search with 600 * @param userId the user id to search with 601 * @param orderByComparator the comparator to order the set by 602 * @return the first matching bookmarks entry 603 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 604 * @throws SystemException if a system exception occurred 605 */ 606 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_First( 607 long groupId, long userId, 608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 609 throws com.liferay.portal.kernel.exception.SystemException, 610 com.liferay.portlet.bookmarks.NoSuchEntryException { 611 return getPersistence() 612 .findByG_U_First(groupId, userId, orderByComparator); 613 } 614 615 /** 616 * Finds the last bookmarks entry in the ordered set where groupId = ? and userId = ?. 617 * 618 * <p> 619 * 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. 620 * </p> 621 * 622 * @param groupId the group id to search with 623 * @param userId the user id to search with 624 * @param orderByComparator the comparator to order the set by 625 * @return the last matching bookmarks entry 626 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 627 * @throws SystemException if a system exception occurred 628 */ 629 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_Last( 630 long groupId, long userId, 631 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 632 throws com.liferay.portal.kernel.exception.SystemException, 633 com.liferay.portlet.bookmarks.NoSuchEntryException { 634 return getPersistence() 635 .findByG_U_Last(groupId, userId, orderByComparator); 636 } 637 638 /** 639 * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ?. 640 * 641 * <p> 642 * 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. 643 * </p> 644 * 645 * @param entryId the primary key of the current bookmarks entry 646 * @param groupId the group id to search with 647 * @param userId the user id to search with 648 * @param orderByComparator the comparator to order the set by 649 * @return the previous, current, and next bookmarks entry 650 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 651 * @throws SystemException if a system exception occurred 652 */ 653 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_PrevAndNext( 654 long entryId, long groupId, long userId, 655 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 656 throws com.liferay.portal.kernel.exception.SystemException, 657 com.liferay.portlet.bookmarks.NoSuchEntryException { 658 return getPersistence() 659 .findByG_U_PrevAndNext(entryId, groupId, userId, 660 orderByComparator); 661 } 662 663 /** 664 * Filters by the user's permissions and finds all the bookmarks entries where groupId = ? and userId = ?. 665 * 666 * @param groupId the group id to search with 667 * @param userId the user id to search with 668 * @return the matching bookmarks entries that the user has permission to view 669 * @throws SystemException if a system exception occurred 670 */ 671 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 672 long groupId, long userId) 673 throws com.liferay.portal.kernel.exception.SystemException { 674 return getPersistence().filterFindByG_U(groupId, userId); 675 } 676 677 /** 678 * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = ? and userId = ?. 679 * 680 * <p> 681 * 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. 682 * </p> 683 * 684 * @param groupId the group id to search with 685 * @param userId the user id to search with 686 * @param start the lower bound of the range of bookmarks entries to return 687 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 688 * @return the range of matching bookmarks entries that the user has permission to view 689 * @throws SystemException if a system exception occurred 690 */ 691 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 692 long groupId, long userId, int start, int end) 693 throws com.liferay.portal.kernel.exception.SystemException { 694 return getPersistence().filterFindByG_U(groupId, userId, start, end); 695 } 696 697 /** 698 * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = ? and userId = ?. 699 * 700 * <p> 701 * 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. 702 * </p> 703 * 704 * @param groupId the group id to search with 705 * @param userId the user id to search with 706 * @param start the lower bound of the range of bookmarks entries to return 707 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 708 * @param orderByComparator the comparator to order the results by 709 * @return the ordered range of matching bookmarks entries that the user has permission to view 710 * @throws SystemException if a system exception occurred 711 */ 712 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 713 long groupId, long userId, int start, int end, 714 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 715 throws com.liferay.portal.kernel.exception.SystemException { 716 return getPersistence() 717 .filterFindByG_U(groupId, userId, start, end, 718 orderByComparator); 719 } 720 721 /** 722 * Finds all the bookmarks entries where groupId = ? and folderId = ?. 723 * 724 * @param groupId the group id to search with 725 * @param folderId the folder id to search with 726 * @return the matching bookmarks entries 727 * @throws SystemException if a system exception occurred 728 */ 729 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 730 long groupId, long folderId) 731 throws com.liferay.portal.kernel.exception.SystemException { 732 return getPersistence().findByG_F(groupId, folderId); 733 } 734 735 /** 736 * Finds a range of all the bookmarks entries where groupId = ? and folderId = ?. 737 * 738 * <p> 739 * 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. 740 * </p> 741 * 742 * @param groupId the group id to search with 743 * @param folderId the folder id to search with 744 * @param start the lower bound of the range of bookmarks entries to return 745 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 746 * @return the range of matching bookmarks entries 747 * @throws SystemException if a system exception occurred 748 */ 749 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 750 long groupId, long folderId, int start, int end) 751 throws com.liferay.portal.kernel.exception.SystemException { 752 return getPersistence().findByG_F(groupId, folderId, start, end); 753 } 754 755 /** 756 * Finds an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 757 * 758 * <p> 759 * 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. 760 * </p> 761 * 762 * @param groupId the group id to search with 763 * @param folderId the folder id to search with 764 * @param start the lower bound of the range of bookmarks entries to return 765 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 766 * @param orderByComparator the comparator to order the results by 767 * @return the ordered range of matching bookmarks entries 768 * @throws SystemException if a system exception occurred 769 */ 770 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 771 long groupId, long folderId, int start, int end, 772 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence() 775 .findByG_F(groupId, folderId, start, end, orderByComparator); 776 } 777 778 /** 779 * Finds the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 780 * 781 * <p> 782 * 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. 783 * </p> 784 * 785 * @param groupId the group id to search with 786 * @param folderId the folder id to search with 787 * @param orderByComparator the comparator to order the set by 788 * @return the first matching bookmarks entry 789 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 790 * @throws SystemException if a system exception occurred 791 */ 792 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 793 long groupId, long folderId, 794 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 795 throws com.liferay.portal.kernel.exception.SystemException, 796 com.liferay.portlet.bookmarks.NoSuchEntryException { 797 return getPersistence() 798 .findByG_F_First(groupId, folderId, orderByComparator); 799 } 800 801 /** 802 * Finds the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 803 * 804 * <p> 805 * 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. 806 * </p> 807 * 808 * @param groupId the group id to search with 809 * @param folderId the folder id to search with 810 * @param orderByComparator the comparator to order the set by 811 * @return the last matching bookmarks entry 812 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 813 * @throws SystemException if a system exception occurred 814 */ 815 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 816 long groupId, long folderId, 817 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 818 throws com.liferay.portal.kernel.exception.SystemException, 819 com.liferay.portlet.bookmarks.NoSuchEntryException { 820 return getPersistence() 821 .findByG_F_Last(groupId, folderId, orderByComparator); 822 } 823 824 /** 825 * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 826 * 827 * <p> 828 * 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. 829 * </p> 830 * 831 * @param entryId the primary key of the current bookmarks entry 832 * @param groupId the group id to search with 833 * @param folderId the folder id to search with 834 * @param orderByComparator the comparator to order the set by 835 * @return the previous, current, and next bookmarks entry 836 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 837 * @throws SystemException if a system exception occurred 838 */ 839 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 840 long entryId, long groupId, long folderId, 841 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 842 throws com.liferay.portal.kernel.exception.SystemException, 843 com.liferay.portlet.bookmarks.NoSuchEntryException { 844 return getPersistence() 845 .findByG_F_PrevAndNext(entryId, groupId, folderId, 846 orderByComparator); 847 } 848 849 /** 850 * Finds all the bookmarks entries where groupId = ? and folderId = any ?. 851 * 852 * <p> 853 * 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. 854 * </p> 855 * 856 * @param groupId the group id to search with 857 * @param folderIds the folder ids to search with 858 * @return the matching bookmarks entries 859 * @throws SystemException if a system exception occurred 860 */ 861 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 862 long groupId, long[] folderIds) 863 throws com.liferay.portal.kernel.exception.SystemException { 864 return getPersistence().findByG_F(groupId, folderIds); 865 } 866 867 /** 868 * Finds a range of all the bookmarks entries where groupId = ? and folderId = any ?. 869 * 870 * <p> 871 * 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. 872 * </p> 873 * 874 * @param groupId the group id to search with 875 * @param folderIds the folder ids to search with 876 * @param start the lower bound of the range of bookmarks entries to return 877 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 878 * @return the range of matching bookmarks entries 879 * @throws SystemException if a system exception occurred 880 */ 881 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 882 long groupId, long[] folderIds, int start, int end) 883 throws com.liferay.portal.kernel.exception.SystemException { 884 return getPersistence().findByG_F(groupId, folderIds, start, end); 885 } 886 887 /** 888 * Finds an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 889 * 890 * <p> 891 * 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. 892 * </p> 893 * 894 * @param groupId the group id to search with 895 * @param folderIds the folder ids to search with 896 * @param start the lower bound of the range of bookmarks entries to return 897 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 898 * @param orderByComparator the comparator to order the results by 899 * @return the ordered range of matching bookmarks entries 900 * @throws SystemException if a system exception occurred 901 */ 902 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 903 long groupId, long[] folderIds, int start, int end, 904 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 905 throws com.liferay.portal.kernel.exception.SystemException { 906 return getPersistence() 907 .findByG_F(groupId, folderIds, start, end, orderByComparator); 908 } 909 910 /** 911 * Filters by the user's permissions and finds all the bookmarks entries where groupId = ? and folderId = ?. 912 * 913 * @param groupId the group id to search with 914 * @param folderId the folder id to search with 915 * @return the matching bookmarks entries that the user has permission to view 916 * @throws SystemException if a system exception occurred 917 */ 918 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 919 long groupId, long folderId) 920 throws com.liferay.portal.kernel.exception.SystemException { 921 return getPersistence().filterFindByG_F(groupId, folderId); 922 } 923 924 /** 925 * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = ? and folderId = ?. 926 * 927 * <p> 928 * 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. 929 * </p> 930 * 931 * @param groupId the group id to search with 932 * @param folderId the folder id to search with 933 * @param start the lower bound of the range of bookmarks entries to return 934 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 935 * @return the range of matching bookmarks entries that the user has permission to view 936 * @throws SystemException if a system exception occurred 937 */ 938 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 939 long groupId, long folderId, int start, int end) 940 throws com.liferay.portal.kernel.exception.SystemException { 941 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 942 } 943 944 /** 945 * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 946 * 947 * <p> 948 * 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. 949 * </p> 950 * 951 * @param groupId the group id to search with 952 * @param folderId the folder id to search with 953 * @param start the lower bound of the range of bookmarks entries to return 954 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 955 * @param orderByComparator the comparator to order the results by 956 * @return the ordered range of matching bookmarks entries that the user has permission to view 957 * @throws SystemException if a system exception occurred 958 */ 959 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 960 long groupId, long folderId, int start, int end, 961 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 962 throws com.liferay.portal.kernel.exception.SystemException { 963 return getPersistence() 964 .filterFindByG_F(groupId, folderId, start, end, 965 orderByComparator); 966 } 967 968 /** 969 * Filters by the user's permissions and finds all the bookmarks entries where groupId = ? and folderId = any ?. 970 * 971 * <p> 972 * 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. 973 * </p> 974 * 975 * @param groupId the group id to search with 976 * @param folderIds the folder ids to search with 977 * @return the matching bookmarks entries that the user has permission to view 978 * @throws SystemException if a system exception occurred 979 */ 980 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 981 long groupId, long[] folderIds) 982 throws com.liferay.portal.kernel.exception.SystemException { 983 return getPersistence().filterFindByG_F(groupId, folderIds); 984 } 985 986 /** 987 * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = ? and folderId = any ?. 988 * 989 * <p> 990 * 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. 991 * </p> 992 * 993 * @param groupId the group id to search with 994 * @param folderIds the folder ids to search with 995 * @param start the lower bound of the range of bookmarks entries to return 996 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 997 * @return the range of matching bookmarks entries that the user has permission to view 998 * @throws SystemException if a system exception occurred 999 */ 1000 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1001 long groupId, long[] folderIds, int start, int end) 1002 throws com.liferay.portal.kernel.exception.SystemException { 1003 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 1004 } 1005 1006 /** 1007 * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 1008 * 1009 * <p> 1010 * 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. 1011 * </p> 1012 * 1013 * @param groupId the group id to search with 1014 * @param folderIds the folder ids to search with 1015 * @param start the lower bound of the range of bookmarks entries to return 1016 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 1017 * @param orderByComparator the comparator to order the results by 1018 * @return the ordered range of matching bookmarks entries that the user has permission to view 1019 * @throws SystemException if a system exception occurred 1020 */ 1021 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1022 long groupId, long[] folderIds, int start, int end, 1023 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1024 throws com.liferay.portal.kernel.exception.SystemException { 1025 return getPersistence() 1026 .filterFindByG_F(groupId, folderIds, start, end, 1027 orderByComparator); 1028 } 1029 1030 /** 1031 * Finds all the bookmarks entries. 1032 * 1033 * @return the bookmarks entries 1034 * @throws SystemException if a system exception occurred 1035 */ 1036 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 1037 throws com.liferay.portal.kernel.exception.SystemException { 1038 return getPersistence().findAll(); 1039 } 1040 1041 /** 1042 * Finds a range of all the bookmarks entries. 1043 * 1044 * <p> 1045 * 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. 1046 * </p> 1047 * 1048 * @param start the lower bound of the range of bookmarks entries to return 1049 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 1050 * @return the range of bookmarks entries 1051 * @throws SystemException if a system exception occurred 1052 */ 1053 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1054 int start, int end) 1055 throws com.liferay.portal.kernel.exception.SystemException { 1056 return getPersistence().findAll(start, end); 1057 } 1058 1059 /** 1060 * Finds an ordered range of all the bookmarks entries. 1061 * 1062 * <p> 1063 * 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. 1064 * </p> 1065 * 1066 * @param start the lower bound of the range of bookmarks entries to return 1067 * @param end the upper bound of the range of bookmarks entries to return (not inclusive) 1068 * @param orderByComparator the comparator to order the results by 1069 * @return the ordered range of bookmarks entries 1070 * @throws SystemException if a system exception occurred 1071 */ 1072 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1073 int start, int end, 1074 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1075 throws com.liferay.portal.kernel.exception.SystemException { 1076 return getPersistence().findAll(start, end, orderByComparator); 1077 } 1078 1079 /** 1080 * Removes all the bookmarks entries where uuid = ? from the database. 1081 * 1082 * @param uuid the uuid to search with 1083 * @throws SystemException if a system exception occurred 1084 */ 1085 public static void removeByUuid(java.lang.String uuid) 1086 throws com.liferay.portal.kernel.exception.SystemException { 1087 getPersistence().removeByUuid(uuid); 1088 } 1089 1090 /** 1091 * Removes the bookmarks entry where uuid = ? and groupId = ? from the database. 1092 * 1093 * @param uuid the uuid to search with 1094 * @param groupId the group id to search with 1095 * @throws SystemException if a system exception occurred 1096 */ 1097 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1098 throws com.liferay.portal.kernel.exception.SystemException, 1099 com.liferay.portlet.bookmarks.NoSuchEntryException { 1100 getPersistence().removeByUUID_G(uuid, groupId); 1101 } 1102 1103 /** 1104 * Removes all the bookmarks entries where groupId = ? from the database. 1105 * 1106 * @param groupId the group id to search with 1107 * @throws SystemException if a system exception occurred 1108 */ 1109 public static void removeByGroupId(long groupId) 1110 throws com.liferay.portal.kernel.exception.SystemException { 1111 getPersistence().removeByGroupId(groupId); 1112 } 1113 1114 /** 1115 * Removes all the bookmarks entries where groupId = ? and userId = ? from the database. 1116 * 1117 * @param groupId the group id to search with 1118 * @param userId the user id to search with 1119 * @throws SystemException if a system exception occurred 1120 */ 1121 public static void removeByG_U(long groupId, long userId) 1122 throws com.liferay.portal.kernel.exception.SystemException { 1123 getPersistence().removeByG_U(groupId, userId); 1124 } 1125 1126 /** 1127 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 1128 * 1129 * @param groupId the group id to search with 1130 * @param folderId the folder id to search with 1131 * @throws SystemException if a system exception occurred 1132 */ 1133 public static void removeByG_F(long groupId, long folderId) 1134 throws com.liferay.portal.kernel.exception.SystemException { 1135 getPersistence().removeByG_F(groupId, folderId); 1136 } 1137 1138 /** 1139 * Removes all the bookmarks entries from the database. 1140 * 1141 * @throws SystemException if a system exception occurred 1142 */ 1143 public static void removeAll() 1144 throws com.liferay.portal.kernel.exception.SystemException { 1145 getPersistence().removeAll(); 1146 } 1147 1148 /** 1149 * Counts all the bookmarks entries where uuid = ?. 1150 * 1151 * @param uuid the uuid to search with 1152 * @return the number of matching bookmarks entries 1153 * @throws SystemException if a system exception occurred 1154 */ 1155 public static int countByUuid(java.lang.String uuid) 1156 throws com.liferay.portal.kernel.exception.SystemException { 1157 return getPersistence().countByUuid(uuid); 1158 } 1159 1160 /** 1161 * Counts all the bookmarks entries where uuid = ? and groupId = ?. 1162 * 1163 * @param uuid the uuid to search with 1164 * @param groupId the group id to search with 1165 * @return the number of matching bookmarks entries 1166 * @throws SystemException if a system exception occurred 1167 */ 1168 public static int countByUUID_G(java.lang.String uuid, long groupId) 1169 throws com.liferay.portal.kernel.exception.SystemException { 1170 return getPersistence().countByUUID_G(uuid, groupId); 1171 } 1172 1173 /** 1174 * Counts all the bookmarks entries where groupId = ?. 1175 * 1176 * @param groupId the group id to search with 1177 * @return the number of matching bookmarks entries 1178 * @throws SystemException if a system exception occurred 1179 */ 1180 public static int countByGroupId(long groupId) 1181 throws com.liferay.portal.kernel.exception.SystemException { 1182 return getPersistence().countByGroupId(groupId); 1183 } 1184 1185 /** 1186 * Filters by the user's permissions and counts all the bookmarks entries where groupId = ?. 1187 * 1188 * @param groupId the group id to search with 1189 * @return the number of matching bookmarks entries that the user has permission to view 1190 * @throws SystemException if a system exception occurred 1191 */ 1192 public static int filterCountByGroupId(long groupId) 1193 throws com.liferay.portal.kernel.exception.SystemException { 1194 return getPersistence().filterCountByGroupId(groupId); 1195 } 1196 1197 /** 1198 * Counts all the bookmarks entries where groupId = ? and userId = ?. 1199 * 1200 * @param groupId the group id to search with 1201 * @param userId the user id to search with 1202 * @return the number of matching bookmarks entries 1203 * @throws SystemException if a system exception occurred 1204 */ 1205 public static int countByG_U(long groupId, long userId) 1206 throws com.liferay.portal.kernel.exception.SystemException { 1207 return getPersistence().countByG_U(groupId, userId); 1208 } 1209 1210 /** 1211 * Filters by the user's permissions and counts all the bookmarks entries where groupId = ? and userId = ?. 1212 * 1213 * @param groupId the group id to search with 1214 * @param userId the user id to search with 1215 * @return the number of matching bookmarks entries that the user has permission to view 1216 * @throws SystemException if a system exception occurred 1217 */ 1218 public static int filterCountByG_U(long groupId, long userId) 1219 throws com.liferay.portal.kernel.exception.SystemException { 1220 return getPersistence().filterCountByG_U(groupId, userId); 1221 } 1222 1223 /** 1224 * Counts all the bookmarks entries where groupId = ? and folderId = ?. 1225 * 1226 * @param groupId the group id to search with 1227 * @param folderId the folder id to search with 1228 * @return the number of matching bookmarks entries 1229 * @throws SystemException if a system exception occurred 1230 */ 1231 public static int countByG_F(long groupId, long folderId) 1232 throws com.liferay.portal.kernel.exception.SystemException { 1233 return getPersistence().countByG_F(groupId, folderId); 1234 } 1235 1236 /** 1237 * Counts all the bookmarks entries where groupId = ? and folderId = any ?. 1238 * 1239 * @param groupId the group id to search with 1240 * @param folderIds the folder ids to search with 1241 * @return the number of matching bookmarks entries 1242 * @throws SystemException if a system exception occurred 1243 */ 1244 public static int countByG_F(long groupId, long[] folderIds) 1245 throws com.liferay.portal.kernel.exception.SystemException { 1246 return getPersistence().countByG_F(groupId, folderIds); 1247 } 1248 1249 /** 1250 * Filters by the user's permissions and counts all the bookmarks entries where groupId = ? and folderId = ?. 1251 * 1252 * @param groupId the group id to search with 1253 * @param folderId the folder id to search with 1254 * @return the number of matching bookmarks entries that the user has permission to view 1255 * @throws SystemException if a system exception occurred 1256 */ 1257 public static int filterCountByG_F(long groupId, long folderId) 1258 throws com.liferay.portal.kernel.exception.SystemException { 1259 return getPersistence().filterCountByG_F(groupId, folderId); 1260 } 1261 1262 /** 1263 * Filters by the user's permissions and counts all the bookmarks entries where groupId = ? and folderId = any ?. 1264 * 1265 * @param groupId the group id to search with 1266 * @param folderIds the folder ids to search with 1267 * @return the number of matching bookmarks entries that the user has permission to view 1268 * @throws SystemException if a system exception occurred 1269 */ 1270 public static int filterCountByG_F(long groupId, long[] folderIds) 1271 throws com.liferay.portal.kernel.exception.SystemException { 1272 return getPersistence().filterCountByG_F(groupId, folderIds); 1273 } 1274 1275 /** 1276 * Counts all the bookmarks entries. 1277 * 1278 * @return the number of bookmarks entries 1279 * @throws SystemException if a system exception occurred 1280 */ 1281 public static int countAll() 1282 throws com.liferay.portal.kernel.exception.SystemException { 1283 return getPersistence().countAll(); 1284 } 1285 1286 public static BookmarksEntryPersistence getPersistence() { 1287 if (_persistence == null) { 1288 _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName()); 1289 } 1290 1291 return _persistence; 1292 } 1293 1294 public void setPersistence(BookmarksEntryPersistence persistence) { 1295 _persistence = persistence; 1296 } 1297 1298 private static BookmarksEntryPersistence _persistence; 1299 }