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