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