001 /** 002 * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.bookmarks.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.bookmarks.model.BookmarksEntry; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the bookmarks entry service. This utility wraps {@link BookmarksEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see BookmarksEntryPersistence 037 * @see BookmarksEntryPersistenceImpl 038 * @generated 039 */ 040 public class BookmarksEntryUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(BookmarksEntry bookmarksEntry) { 058 getPersistence().clearCache(bookmarksEntry); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<BookmarksEntry> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<BookmarksEntry> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<BookmarksEntry> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static BookmarksEntry update(BookmarksEntry bookmarksEntry) 101 throws SystemException { 102 return getPersistence().update(bookmarksEntry); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static BookmarksEntry update(BookmarksEntry bookmarksEntry, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(bookmarksEntry, serviceContext); 111 } 112 113 /** 114 * Returns all the bookmarks entries where resourceBlockId = ?. 115 * 116 * @param resourceBlockId the resource block ID 117 * @return the matching bookmarks entries 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 121 long resourceBlockId) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByResourceBlockId(resourceBlockId); 124 } 125 126 /** 127 * Returns a range of all the bookmarks entries where resourceBlockId = ?. 128 * 129 * <p> 130 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 131 * </p> 132 * 133 * @param resourceBlockId the resource block ID 134 * @param start the lower bound of the range of bookmarks entries 135 * @param end the upper bound of the range of bookmarks entries (not inclusive) 136 * @return the range of matching bookmarks entries 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 140 long resourceBlockId, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence() 143 .findByResourceBlockId(resourceBlockId, start, end); 144 } 145 146 /** 147 * Returns an ordered range of all the bookmarks entries where resourceBlockId = ?. 148 * 149 * <p> 150 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 151 * </p> 152 * 153 * @param resourceBlockId the resource block ID 154 * @param start the lower bound of the range of bookmarks entries 155 * @param end the upper bound of the range of bookmarks entries (not inclusive) 156 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 157 * @return the ordered range of matching bookmarks entries 158 * @throws SystemException if a system exception occurred 159 */ 160 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 161 long resourceBlockId, int start, int end, 162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence() 165 .findByResourceBlockId(resourceBlockId, start, end, 166 orderByComparator); 167 } 168 169 /** 170 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 171 * 172 * @param resourceBlockId the resource block ID 173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 174 * @return the first matching bookmarks entry 175 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 176 * @throws SystemException if a system exception occurred 177 */ 178 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First( 179 long resourceBlockId, 180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.bookmarks.NoSuchEntryException { 183 return getPersistence() 184 .findByResourceBlockId_First(resourceBlockId, 185 orderByComparator); 186 } 187 188 /** 189 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 190 * 191 * @param resourceBlockId the resource block ID 192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 193 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First( 197 long resourceBlockId, 198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 199 throws com.liferay.portal.kernel.exception.SystemException { 200 return getPersistence() 201 .fetchByResourceBlockId_First(resourceBlockId, 202 orderByComparator); 203 } 204 205 /** 206 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 207 * 208 * @param resourceBlockId the resource block ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching bookmarks entry 211 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 212 * @throws SystemException if a system exception occurred 213 */ 214 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last( 215 long resourceBlockId, 216 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 217 throws com.liferay.portal.kernel.exception.SystemException, 218 com.liferay.portlet.bookmarks.NoSuchEntryException { 219 return getPersistence() 220 .findByResourceBlockId_Last(resourceBlockId, 221 orderByComparator); 222 } 223 224 /** 225 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 226 * 227 * @param resourceBlockId the resource block ID 228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 229 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 230 * @throws SystemException if a system exception occurred 231 */ 232 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last( 233 long resourceBlockId, 234 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 235 throws com.liferay.portal.kernel.exception.SystemException { 236 return getPersistence() 237 .fetchByResourceBlockId_Last(resourceBlockId, 238 orderByComparator); 239 } 240 241 /** 242 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = ?. 243 * 244 * @param entryId the primary key of the current bookmarks entry 245 * @param resourceBlockId the resource block ID 246 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 247 * @return the previous, current, and next bookmarks entry 248 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 249 * @throws SystemException if a system exception occurred 250 */ 251 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext( 252 long entryId, long resourceBlockId, 253 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 254 throws com.liferay.portal.kernel.exception.SystemException, 255 com.liferay.portlet.bookmarks.NoSuchEntryException { 256 return getPersistence() 257 .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId, 258 orderByComparator); 259 } 260 261 /** 262 * Removes all the bookmarks entries where resourceBlockId = ? from the database. 263 * 264 * @param resourceBlockId the resource block ID 265 * @throws SystemException if a system exception occurred 266 */ 267 public static void removeByResourceBlockId(long resourceBlockId) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 getPersistence().removeByResourceBlockId(resourceBlockId); 270 } 271 272 /** 273 * Returns the number of bookmarks entries where resourceBlockId = ?. 274 * 275 * @param resourceBlockId the resource block ID 276 * @return the number of matching bookmarks entries 277 * @throws SystemException if a system exception occurred 278 */ 279 public static int countByResourceBlockId(long resourceBlockId) 280 throws com.liferay.portal.kernel.exception.SystemException { 281 return getPersistence().countByResourceBlockId(resourceBlockId); 282 } 283 284 /** 285 * Returns all the bookmarks entries where uuid = ?. 286 * 287 * @param uuid the uuid 288 * @return the matching bookmarks entries 289 * @throws SystemException if a system exception occurred 290 */ 291 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 292 java.lang.String uuid) 293 throws com.liferay.portal.kernel.exception.SystemException { 294 return getPersistence().findByUuid(uuid); 295 } 296 297 /** 298 * Returns a range of all the bookmarks entries 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 302 * </p> 303 * 304 * @param uuid the uuid 305 * @param start the lower bound of the range of bookmarks entries 306 * @param end the upper bound of the range of bookmarks entries (not inclusive) 307 * @return the range of matching bookmarks entries 308 * @throws SystemException if a system exception occurred 309 */ 310 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 311 java.lang.String uuid, int start, int end) 312 throws com.liferay.portal.kernel.exception.SystemException { 313 return getPersistence().findByUuid(uuid, start, end); 314 } 315 316 /** 317 * Returns an ordered range of all the bookmarks entries where uuid = ?. 318 * 319 * <p> 320 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 321 * </p> 322 * 323 * @param uuid the uuid 324 * @param start the lower bound of the range of bookmarks entries 325 * @param end the upper bound of the range of bookmarks entries (not inclusive) 326 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 327 * @return the ordered range of matching bookmarks entries 328 * @throws SystemException if a system exception occurred 329 */ 330 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 331 java.lang.String uuid, int start, int end, 332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 333 throws com.liferay.portal.kernel.exception.SystemException { 334 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 335 } 336 337 /** 338 * Returns the first bookmarks entry in the ordered set where uuid = ?. 339 * 340 * @param uuid the uuid 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the first matching bookmarks entry 343 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 344 * @throws SystemException if a system exception occurred 345 */ 346 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First( 347 java.lang.String uuid, 348 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 349 throws com.liferay.portal.kernel.exception.SystemException, 350 com.liferay.portlet.bookmarks.NoSuchEntryException { 351 return getPersistence().findByUuid_First(uuid, orderByComparator); 352 } 353 354 /** 355 * Returns the first bookmarks entry in the ordered set where uuid = ?. 356 * 357 * @param uuid the uuid 358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 359 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 360 * @throws SystemException if a system exception occurred 361 */ 362 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First( 363 java.lang.String uuid, 364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 365 throws com.liferay.portal.kernel.exception.SystemException { 366 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 367 } 368 369 /** 370 * Returns the last bookmarks entry in the ordered set where uuid = ?. 371 * 372 * @param uuid the uuid 373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 374 * @return the last matching bookmarks entry 375 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 376 * @throws SystemException if a system exception occurred 377 */ 378 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last( 379 java.lang.String uuid, 380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 381 throws com.liferay.portal.kernel.exception.SystemException, 382 com.liferay.portlet.bookmarks.NoSuchEntryException { 383 return getPersistence().findByUuid_Last(uuid, orderByComparator); 384 } 385 386 /** 387 * Returns the last bookmarks entry in the ordered set where uuid = ?. 388 * 389 * @param uuid the uuid 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 392 * @throws SystemException if a system exception occurred 393 */ 394 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last( 395 java.lang.String uuid, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 399 } 400 401 /** 402 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ?. 403 * 404 * @param entryId the primary key of the current bookmarks entry 405 * @param uuid the uuid 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the previous, current, and next bookmarks entry 408 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 409 * @throws SystemException if a system exception occurred 410 */ 411 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext( 412 long entryId, java.lang.String uuid, 413 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 414 throws com.liferay.portal.kernel.exception.SystemException, 415 com.liferay.portlet.bookmarks.NoSuchEntryException { 416 return getPersistence() 417 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 418 } 419 420 /** 421 * Removes all the bookmarks entries where uuid = ? from the database. 422 * 423 * @param uuid the uuid 424 * @throws SystemException if a system exception occurred 425 */ 426 public static void removeByUuid(java.lang.String uuid) 427 throws com.liferay.portal.kernel.exception.SystemException { 428 getPersistence().removeByUuid(uuid); 429 } 430 431 /** 432 * Returns the number of bookmarks entries where uuid = ?. 433 * 434 * @param uuid the uuid 435 * @return the number of matching bookmarks entries 436 * @throws SystemException if a system exception occurred 437 */ 438 public static int countByUuid(java.lang.String uuid) 439 throws com.liferay.portal.kernel.exception.SystemException { 440 return getPersistence().countByUuid(uuid); 441 } 442 443 /** 444 * Returns the bookmarks entry where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 445 * 446 * @param uuid the uuid 447 * @param groupId the group ID 448 * @return the 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 findByUUID_G( 453 java.lang.String uuid, long groupId) 454 throws com.liferay.portal.kernel.exception.SystemException, 455 com.liferay.portlet.bookmarks.NoSuchEntryException { 456 return getPersistence().findByUUID_G(uuid, groupId); 457 } 458 459 /** 460 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 461 * 462 * @param uuid the uuid 463 * @param groupId the group ID 464 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 468 java.lang.String uuid, long groupId) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence().fetchByUUID_G(uuid, groupId); 471 } 472 473 /** 474 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 475 * 476 * @param uuid the uuid 477 * @param groupId the group ID 478 * @param retrieveFromCache whether to use the finder cache 479 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 480 * @throws SystemException if a system exception occurred 481 */ 482 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 483 java.lang.String uuid, long groupId, boolean retrieveFromCache) 484 throws com.liferay.portal.kernel.exception.SystemException { 485 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 486 } 487 488 /** 489 * Removes the bookmarks entry where uuid = ? and groupId = ? from the database. 490 * 491 * @param uuid the uuid 492 * @param groupId the group ID 493 * @return the bookmarks entry that was removed 494 * @throws SystemException if a system exception occurred 495 */ 496 public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G( 497 java.lang.String uuid, long groupId) 498 throws com.liferay.portal.kernel.exception.SystemException, 499 com.liferay.portlet.bookmarks.NoSuchEntryException { 500 return getPersistence().removeByUUID_G(uuid, groupId); 501 } 502 503 /** 504 * Returns the number of bookmarks entries where uuid = ? and groupId = ?. 505 * 506 * @param uuid the uuid 507 * @param groupId the group ID 508 * @return the number of matching bookmarks entries 509 * @throws SystemException if a system exception occurred 510 */ 511 public static int countByUUID_G(java.lang.String uuid, long groupId) 512 throws com.liferay.portal.kernel.exception.SystemException { 513 return getPersistence().countByUUID_G(uuid, groupId); 514 } 515 516 /** 517 * Returns all the bookmarks entries where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @return the matching bookmarks entries 522 * @throws SystemException if a system exception occurred 523 */ 524 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 525 java.lang.String uuid, long companyId) 526 throws com.liferay.portal.kernel.exception.SystemException { 527 return getPersistence().findByUuid_C(uuid, companyId); 528 } 529 530 /** 531 * Returns a range of all the bookmarks entries where uuid = ? and companyId = ?. 532 * 533 * <p> 534 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 535 * </p> 536 * 537 * @param uuid the uuid 538 * @param companyId the company ID 539 * @param start the lower bound of the range of bookmarks entries 540 * @param end the upper bound of the range of bookmarks entries (not inclusive) 541 * @return the range of matching bookmarks entries 542 * @throws SystemException if a system exception occurred 543 */ 544 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 545 java.lang.String uuid, long companyId, int start, int end) 546 throws com.liferay.portal.kernel.exception.SystemException { 547 return getPersistence().findByUuid_C(uuid, companyId, start, end); 548 } 549 550 /** 551 * Returns an ordered range of all the bookmarks entries where uuid = ? and companyId = ?. 552 * 553 * <p> 554 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 555 * </p> 556 * 557 * @param uuid the uuid 558 * @param companyId the company ID 559 * @param start the lower bound of the range of bookmarks entries 560 * @param end the upper bound of the range of bookmarks entries (not inclusive) 561 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 562 * @return the ordered range of matching bookmarks entries 563 * @throws SystemException if a system exception occurred 564 */ 565 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 566 java.lang.String uuid, long companyId, int start, int end, 567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 568 throws com.liferay.portal.kernel.exception.SystemException { 569 return getPersistence() 570 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 571 } 572 573 /** 574 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 575 * 576 * @param uuid the uuid 577 * @param companyId the company ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching bookmarks entry 580 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First( 584 java.lang.String uuid, long companyId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.bookmarks.NoSuchEntryException { 588 return getPersistence() 589 .findByUuid_C_First(uuid, companyId, orderByComparator); 590 } 591 592 /** 593 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 594 * 595 * @param uuid the uuid 596 * @param companyId the company ID 597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 598 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 599 * @throws SystemException if a system exception occurred 600 */ 601 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First( 602 java.lang.String uuid, long companyId, 603 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 604 throws com.liferay.portal.kernel.exception.SystemException { 605 return getPersistence() 606 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 607 } 608 609 /** 610 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 611 * 612 * @param uuid the uuid 613 * @param companyId the company ID 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the last matching bookmarks entry 616 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 617 * @throws SystemException if a system exception occurred 618 */ 619 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last( 620 java.lang.String uuid, long companyId, 621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 622 throws com.liferay.portal.kernel.exception.SystemException, 623 com.liferay.portlet.bookmarks.NoSuchEntryException { 624 return getPersistence() 625 .findByUuid_C_Last(uuid, companyId, orderByComparator); 626 } 627 628 /** 629 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 630 * 631 * @param uuid the uuid 632 * @param companyId the company ID 633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 634 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 635 * @throws SystemException if a system exception occurred 636 */ 637 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last( 638 java.lang.String uuid, long companyId, 639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 640 throws com.liferay.portal.kernel.exception.SystemException { 641 return getPersistence() 642 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 643 } 644 645 /** 646 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ? and companyId = ?. 647 * 648 * @param entryId the primary key of the current bookmarks entry 649 * @param uuid the uuid 650 * @param companyId the company ID 651 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 652 * @return the previous, current, and next bookmarks entry 653 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 654 * @throws SystemException if a system exception occurred 655 */ 656 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext( 657 long entryId, java.lang.String uuid, long companyId, 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 .findByUuid_C_PrevAndNext(entryId, uuid, companyId, 663 orderByComparator); 664 } 665 666 /** 667 * Removes all the bookmarks entries where uuid = ? and companyId = ? from the database. 668 * 669 * @param uuid the uuid 670 * @param companyId the company ID 671 * @throws SystemException if a system exception occurred 672 */ 673 public static void removeByUuid_C(java.lang.String uuid, long companyId) 674 throws com.liferay.portal.kernel.exception.SystemException { 675 getPersistence().removeByUuid_C(uuid, companyId); 676 } 677 678 /** 679 * Returns the number of bookmarks entries where uuid = ? and companyId = ?. 680 * 681 * @param uuid the uuid 682 * @param companyId the company ID 683 * @return the number of matching bookmarks entries 684 * @throws SystemException if a system exception occurred 685 */ 686 public static int countByUuid_C(java.lang.String uuid, long companyId) 687 throws com.liferay.portal.kernel.exception.SystemException { 688 return getPersistence().countByUuid_C(uuid, companyId); 689 } 690 691 /** 692 * Returns all the bookmarks entries where groupId = ?. 693 * 694 * @param groupId the group ID 695 * @return the matching bookmarks entries 696 * @throws SystemException if a system exception occurred 697 */ 698 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 699 long groupId) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence().findByGroupId(groupId); 702 } 703 704 /** 705 * Returns a range of all the bookmarks entries where groupId = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 709 * </p> 710 * 711 * @param groupId the group ID 712 * @param start the lower bound of the range of bookmarks entries 713 * @param end the upper bound of the range of bookmarks entries (not inclusive) 714 * @return the range of matching bookmarks entries 715 * @throws SystemException if a system exception occurred 716 */ 717 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 718 long groupId, int start, int end) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().findByGroupId(groupId, start, end); 721 } 722 723 /** 724 * Returns an ordered range of all the bookmarks entries where groupId = ?. 725 * 726 * <p> 727 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 728 * </p> 729 * 730 * @param groupId the group ID 731 * @param start the lower bound of the range of bookmarks entries 732 * @param end the upper bound of the range of bookmarks entries (not inclusive) 733 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 734 * @return the ordered range of matching bookmarks entries 735 * @throws SystemException if a system exception occurred 736 */ 737 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 738 long groupId, int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence() 742 .findByGroupId(groupId, start, end, orderByComparator); 743 } 744 745 /** 746 * Returns the first bookmarks entry in the ordered set where groupId = ?. 747 * 748 * @param groupId the group ID 749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 750 * @return the first matching bookmarks entry 751 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 752 * @throws SystemException if a system exception occurred 753 */ 754 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_First( 755 long groupId, 756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 757 throws com.liferay.portal.kernel.exception.SystemException, 758 com.liferay.portlet.bookmarks.NoSuchEntryException { 759 return getPersistence().findByGroupId_First(groupId, orderByComparator); 760 } 761 762 /** 763 * Returns the first bookmarks entry in the ordered set where groupId = ?. 764 * 765 * @param groupId the group ID 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 768 * @throws SystemException if a system exception occurred 769 */ 770 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_First( 771 long groupId, 772 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 775 } 776 777 /** 778 * Returns the last bookmarks entry in the ordered set where groupId = ?. 779 * 780 * @param groupId the group ID 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the last matching bookmarks entry 783 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 784 * @throws SystemException if a system exception occurred 785 */ 786 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_Last( 787 long groupId, 788 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 789 throws com.liferay.portal.kernel.exception.SystemException, 790 com.liferay.portlet.bookmarks.NoSuchEntryException { 791 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 792 } 793 794 /** 795 * Returns the last bookmarks entry in the ordered set where groupId = ?. 796 * 797 * @param groupId the group ID 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_Last( 803 long groupId, 804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 805 throws com.liferay.portal.kernel.exception.SystemException { 806 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 807 } 808 809 /** 810 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ?. 811 * 812 * @param entryId the primary key of the current bookmarks entry 813 * @param groupId the group ID 814 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 815 * @return the previous, current, and next bookmarks entry 816 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 817 * @throws SystemException if a system exception occurred 818 */ 819 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByGroupId_PrevAndNext( 820 long entryId, long groupId, 821 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 822 throws com.liferay.portal.kernel.exception.SystemException, 823 com.liferay.portlet.bookmarks.NoSuchEntryException { 824 return getPersistence() 825 .findByGroupId_PrevAndNext(entryId, groupId, 826 orderByComparator); 827 } 828 829 /** 830 * Returns all the bookmarks entries that the user has permission to view where groupId = ?. 831 * 832 * @param groupId the group ID 833 * @return the matching bookmarks entries that the user has permission to view 834 * @throws SystemException if a system exception occurred 835 */ 836 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 837 long groupId) 838 throws com.liferay.portal.kernel.exception.SystemException { 839 return getPersistence().filterFindByGroupId(groupId); 840 } 841 842 /** 843 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ?. 844 * 845 * <p> 846 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 847 * </p> 848 * 849 * @param groupId the group ID 850 * @param start the lower bound of the range of bookmarks entries 851 * @param end the upper bound of the range of bookmarks entries (not inclusive) 852 * @return the range of matching bookmarks entries that the user has permission to view 853 * @throws SystemException if a system exception occurred 854 */ 855 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 856 long groupId, int start, int end) 857 throws com.liferay.portal.kernel.exception.SystemException { 858 return getPersistence().filterFindByGroupId(groupId, start, end); 859 } 860 861 /** 862 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ?. 863 * 864 * <p> 865 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 866 * </p> 867 * 868 * @param groupId the group ID 869 * @param start the lower bound of the range of bookmarks entries 870 * @param end the upper bound of the range of bookmarks entries (not inclusive) 871 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 872 * @return the ordered range of matching bookmarks entries that the user has permission to view 873 * @throws SystemException if a system exception occurred 874 */ 875 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 876 long groupId, int start, int end, 877 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 878 throws com.liferay.portal.kernel.exception.SystemException { 879 return getPersistence() 880 .filterFindByGroupId(groupId, start, end, orderByComparator); 881 } 882 883 /** 884 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ?. 885 * 886 * @param entryId the primary key of the current bookmarks entry 887 * @param groupId the group ID 888 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 889 * @return the previous, current, and next bookmarks entry 890 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 891 * @throws SystemException if a system exception occurred 892 */ 893 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByGroupId_PrevAndNext( 894 long entryId, long groupId, 895 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 896 throws com.liferay.portal.kernel.exception.SystemException, 897 com.liferay.portlet.bookmarks.NoSuchEntryException { 898 return getPersistence() 899 .filterFindByGroupId_PrevAndNext(entryId, groupId, 900 orderByComparator); 901 } 902 903 /** 904 * Removes all the bookmarks entries where groupId = ? from the database. 905 * 906 * @param groupId the group ID 907 * @throws SystemException if a system exception occurred 908 */ 909 public static void removeByGroupId(long groupId) 910 throws com.liferay.portal.kernel.exception.SystemException { 911 getPersistence().removeByGroupId(groupId); 912 } 913 914 /** 915 * Returns the number of bookmarks entries where groupId = ?. 916 * 917 * @param groupId the group ID 918 * @return the number of matching bookmarks entries 919 * @throws SystemException if a system exception occurred 920 */ 921 public static int countByGroupId(long groupId) 922 throws com.liferay.portal.kernel.exception.SystemException { 923 return getPersistence().countByGroupId(groupId); 924 } 925 926 /** 927 * Returns the number of bookmarks entries that the user has permission to view where groupId = ?. 928 * 929 * @param groupId the group ID 930 * @return the number of matching bookmarks entries that the user has permission to view 931 * @throws SystemException if a system exception occurred 932 */ 933 public static int filterCountByGroupId(long groupId) 934 throws com.liferay.portal.kernel.exception.SystemException { 935 return getPersistence().filterCountByGroupId(groupId); 936 } 937 938 /** 939 * Returns all the bookmarks entries where groupId = ? and userId = ?. 940 * 941 * @param groupId the group ID 942 * @param userId the user ID 943 * @return the matching bookmarks entries 944 * @throws SystemException if a system exception occurred 945 */ 946 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 947 long groupId, long userId) 948 throws com.liferay.portal.kernel.exception.SystemException { 949 return getPersistence().findByG_U(groupId, userId); 950 } 951 952 /** 953 * Returns a range of all the bookmarks entries where groupId = ? and userId = ?. 954 * 955 * <p> 956 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 957 * </p> 958 * 959 * @param groupId the group ID 960 * @param userId the user ID 961 * @param start the lower bound of the range of bookmarks entries 962 * @param end the upper bound of the range of bookmarks entries (not inclusive) 963 * @return the range of matching bookmarks entries 964 * @throws SystemException if a system exception occurred 965 */ 966 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 967 long groupId, long userId, int start, int end) 968 throws com.liferay.portal.kernel.exception.SystemException { 969 return getPersistence().findByG_U(groupId, userId, start, end); 970 } 971 972 /** 973 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ?. 974 * 975 * <p> 976 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 977 * </p> 978 * 979 * @param groupId the group ID 980 * @param userId the user ID 981 * @param start the lower bound of the range of bookmarks entries 982 * @param end the upper bound of the range of bookmarks entries (not inclusive) 983 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 984 * @return the ordered range of matching bookmarks entries 985 * @throws SystemException if a system exception occurred 986 */ 987 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 988 long groupId, long userId, int start, int end, 989 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 990 throws com.liferay.portal.kernel.exception.SystemException { 991 return getPersistence() 992 .findByG_U(groupId, userId, start, end, orderByComparator); 993 } 994 995 /** 996 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ?. 997 * 998 * @param groupId the group ID 999 * @param userId the user ID 1000 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1001 * @return the first matching bookmarks entry 1002 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1003 * @throws SystemException if a system exception occurred 1004 */ 1005 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_First( 1006 long groupId, long userId, 1007 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1008 throws com.liferay.portal.kernel.exception.SystemException, 1009 com.liferay.portlet.bookmarks.NoSuchEntryException { 1010 return getPersistence() 1011 .findByG_U_First(groupId, userId, orderByComparator); 1012 } 1013 1014 /** 1015 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ?. 1016 * 1017 * @param groupId the group ID 1018 * @param userId the user ID 1019 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1020 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1021 * @throws SystemException if a system exception occurred 1022 */ 1023 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_First( 1024 long groupId, long userId, 1025 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1026 throws com.liferay.portal.kernel.exception.SystemException { 1027 return getPersistence() 1028 .fetchByG_U_First(groupId, userId, orderByComparator); 1029 } 1030 1031 /** 1032 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ?. 1033 * 1034 * @param groupId the group ID 1035 * @param userId the user ID 1036 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1037 * @return the last matching bookmarks entry 1038 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1039 * @throws SystemException if a system exception occurred 1040 */ 1041 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_Last( 1042 long groupId, long userId, 1043 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1044 throws com.liferay.portal.kernel.exception.SystemException, 1045 com.liferay.portlet.bookmarks.NoSuchEntryException { 1046 return getPersistence() 1047 .findByG_U_Last(groupId, userId, orderByComparator); 1048 } 1049 1050 /** 1051 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ?. 1052 * 1053 * @param groupId the group ID 1054 * @param userId the user ID 1055 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1056 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1057 * @throws SystemException if a system exception occurred 1058 */ 1059 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_Last( 1060 long groupId, long userId, 1061 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1062 throws com.liferay.portal.kernel.exception.SystemException { 1063 return getPersistence() 1064 .fetchByG_U_Last(groupId, userId, orderByComparator); 1065 } 1066 1067 /** 1068 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ?. 1069 * 1070 * @param entryId the primary key of the current bookmarks entry 1071 * @param groupId the group ID 1072 * @param userId the user ID 1073 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1074 * @return the previous, current, and next bookmarks entry 1075 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1076 * @throws SystemException if a system exception occurred 1077 */ 1078 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_PrevAndNext( 1079 long entryId, long groupId, long userId, 1080 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1081 throws com.liferay.portal.kernel.exception.SystemException, 1082 com.liferay.portlet.bookmarks.NoSuchEntryException { 1083 return getPersistence() 1084 .findByG_U_PrevAndNext(entryId, groupId, userId, 1085 orderByComparator); 1086 } 1087 1088 /** 1089 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 1090 * 1091 * @param groupId the group ID 1092 * @param userId the user ID 1093 * @return the matching bookmarks entries that the user has permission to view 1094 * @throws SystemException if a system exception occurred 1095 */ 1096 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 1097 long groupId, long userId) 1098 throws com.liferay.portal.kernel.exception.SystemException { 1099 return getPersistence().filterFindByG_U(groupId, userId); 1100 } 1101 1102 /** 1103 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 1104 * 1105 * <p> 1106 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1107 * </p> 1108 * 1109 * @param groupId the group ID 1110 * @param userId the user ID 1111 * @param start the lower bound of the range of bookmarks entries 1112 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1113 * @return the range of matching bookmarks entries that the user has permission to view 1114 * @throws SystemException if a system exception occurred 1115 */ 1116 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 1117 long groupId, long userId, int start, int end) 1118 throws com.liferay.portal.kernel.exception.SystemException { 1119 return getPersistence().filterFindByG_U(groupId, userId, start, end); 1120 } 1121 1122 /** 1123 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ?. 1124 * 1125 * <p> 1126 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1127 * </p> 1128 * 1129 * @param groupId the group ID 1130 * @param userId the user ID 1131 * @param start the lower bound of the range of bookmarks entries 1132 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1133 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1134 * @return the ordered range of matching bookmarks entries that the user has permission to view 1135 * @throws SystemException if a system exception occurred 1136 */ 1137 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 1138 long groupId, long userId, int start, int end, 1139 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1140 throws com.liferay.portal.kernel.exception.SystemException { 1141 return getPersistence() 1142 .filterFindByG_U(groupId, userId, start, end, 1143 orderByComparator); 1144 } 1145 1146 /** 1147 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 1148 * 1149 * @param entryId the primary key of the current bookmarks entry 1150 * @param groupId the group ID 1151 * @param userId the user ID 1152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1153 * @return the previous, current, and next bookmarks entry 1154 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1155 * @throws SystemException if a system exception occurred 1156 */ 1157 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_PrevAndNext( 1158 long entryId, long groupId, long userId, 1159 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1160 throws com.liferay.portal.kernel.exception.SystemException, 1161 com.liferay.portlet.bookmarks.NoSuchEntryException { 1162 return getPersistence() 1163 .filterFindByG_U_PrevAndNext(entryId, groupId, userId, 1164 orderByComparator); 1165 } 1166 1167 /** 1168 * Removes all the bookmarks entries where groupId = ? and userId = ? from the database. 1169 * 1170 * @param groupId the group ID 1171 * @param userId the user ID 1172 * @throws SystemException if a system exception occurred 1173 */ 1174 public static void removeByG_U(long groupId, long userId) 1175 throws com.liferay.portal.kernel.exception.SystemException { 1176 getPersistence().removeByG_U(groupId, userId); 1177 } 1178 1179 /** 1180 * Returns the number of bookmarks entries where groupId = ? and userId = ?. 1181 * 1182 * @param groupId the group ID 1183 * @param userId the user ID 1184 * @return the number of matching bookmarks entries 1185 * @throws SystemException if a system exception occurred 1186 */ 1187 public static int countByG_U(long groupId, long userId) 1188 throws com.liferay.portal.kernel.exception.SystemException { 1189 return getPersistence().countByG_U(groupId, userId); 1190 } 1191 1192 /** 1193 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 1194 * 1195 * @param groupId the group ID 1196 * @param userId the user ID 1197 * @return the number of matching bookmarks entries that the user has permission to view 1198 * @throws SystemException if a system exception occurred 1199 */ 1200 public static int filterCountByG_U(long groupId, long userId) 1201 throws com.liferay.portal.kernel.exception.SystemException { 1202 return getPersistence().filterCountByG_U(groupId, userId); 1203 } 1204 1205 /** 1206 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 1207 * 1208 * @param groupId the group ID 1209 * @param folderId the folder ID 1210 * @return the matching bookmarks entries 1211 * @throws SystemException if a system exception occurred 1212 */ 1213 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1214 long groupId, long folderId) 1215 throws com.liferay.portal.kernel.exception.SystemException { 1216 return getPersistence().findByG_F(groupId, folderId); 1217 } 1218 1219 /** 1220 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 1221 * 1222 * <p> 1223 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1224 * </p> 1225 * 1226 * @param groupId the group ID 1227 * @param folderId the folder ID 1228 * @param start the lower bound of the range of bookmarks entries 1229 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1230 * @return the range of matching bookmarks entries 1231 * @throws SystemException if a system exception occurred 1232 */ 1233 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1234 long groupId, long folderId, int start, int end) 1235 throws com.liferay.portal.kernel.exception.SystemException { 1236 return getPersistence().findByG_F(groupId, folderId, start, end); 1237 } 1238 1239 /** 1240 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 1241 * 1242 * <p> 1243 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1244 * </p> 1245 * 1246 * @param groupId the group ID 1247 * @param folderId the folder ID 1248 * @param start the lower bound of the range of bookmarks entries 1249 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1250 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1251 * @return the ordered range of matching bookmarks entries 1252 * @throws SystemException if a system exception occurred 1253 */ 1254 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1255 long groupId, long folderId, int start, int end, 1256 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1257 throws com.liferay.portal.kernel.exception.SystemException { 1258 return getPersistence() 1259 .findByG_F(groupId, folderId, start, end, orderByComparator); 1260 } 1261 1262 /** 1263 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1264 * 1265 * @param groupId the group ID 1266 * @param folderId the folder ID 1267 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1268 * @return the first matching bookmarks entry 1269 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1270 * @throws SystemException if a system exception occurred 1271 */ 1272 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 1273 long groupId, long folderId, 1274 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1275 throws com.liferay.portal.kernel.exception.SystemException, 1276 com.liferay.portlet.bookmarks.NoSuchEntryException { 1277 return getPersistence() 1278 .findByG_F_First(groupId, folderId, orderByComparator); 1279 } 1280 1281 /** 1282 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1283 * 1284 * @param groupId the group ID 1285 * @param folderId the folder ID 1286 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1287 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1288 * @throws SystemException if a system exception occurred 1289 */ 1290 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 1291 long groupId, long folderId, 1292 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1293 throws com.liferay.portal.kernel.exception.SystemException { 1294 return getPersistence() 1295 .fetchByG_F_First(groupId, folderId, orderByComparator); 1296 } 1297 1298 /** 1299 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1300 * 1301 * @param groupId the group ID 1302 * @param folderId the folder ID 1303 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1304 * @return the last matching bookmarks entry 1305 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1306 * @throws SystemException if a system exception occurred 1307 */ 1308 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 1309 long groupId, long folderId, 1310 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1311 throws com.liferay.portal.kernel.exception.SystemException, 1312 com.liferay.portlet.bookmarks.NoSuchEntryException { 1313 return getPersistence() 1314 .findByG_F_Last(groupId, folderId, orderByComparator); 1315 } 1316 1317 /** 1318 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1319 * 1320 * @param groupId the group ID 1321 * @param folderId the folder ID 1322 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1323 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1324 * @throws SystemException if a system exception occurred 1325 */ 1326 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 1327 long groupId, long folderId, 1328 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1329 throws com.liferay.portal.kernel.exception.SystemException { 1330 return getPersistence() 1331 .fetchByG_F_Last(groupId, folderId, orderByComparator); 1332 } 1333 1334 /** 1335 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1336 * 1337 * @param entryId the primary key of the current bookmarks entry 1338 * @param groupId the group ID 1339 * @param folderId the folder ID 1340 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1341 * @return the previous, current, and next bookmarks entry 1342 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1343 * @throws SystemException if a system exception occurred 1344 */ 1345 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 1346 long entryId, long groupId, long folderId, 1347 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1348 throws com.liferay.portal.kernel.exception.SystemException, 1349 com.liferay.portlet.bookmarks.NoSuchEntryException { 1350 return getPersistence() 1351 .findByG_F_PrevAndNext(entryId, groupId, folderId, 1352 orderByComparator); 1353 } 1354 1355 /** 1356 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1357 * 1358 * @param groupId the group ID 1359 * @param folderId the folder ID 1360 * @return the matching bookmarks entries that the user has permission to view 1361 * @throws SystemException if a system exception occurred 1362 */ 1363 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1364 long groupId, long folderId) 1365 throws com.liferay.portal.kernel.exception.SystemException { 1366 return getPersistence().filterFindByG_F(groupId, folderId); 1367 } 1368 1369 /** 1370 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1371 * 1372 * <p> 1373 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1374 * </p> 1375 * 1376 * @param groupId the group ID 1377 * @param folderId the folder ID 1378 * @param start the lower bound of the range of bookmarks entries 1379 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1380 * @return the range of matching bookmarks entries that the user has permission to view 1381 * @throws SystemException if a system exception occurred 1382 */ 1383 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1384 long groupId, long folderId, int start, int end) 1385 throws com.liferay.portal.kernel.exception.SystemException { 1386 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 1387 } 1388 1389 /** 1390 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 1391 * 1392 * <p> 1393 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1394 * </p> 1395 * 1396 * @param groupId the group ID 1397 * @param folderId the folder ID 1398 * @param start the lower bound of the range of bookmarks entries 1399 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1400 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1401 * @return the ordered range of matching bookmarks entries that the user has permission to view 1402 * @throws SystemException if a system exception occurred 1403 */ 1404 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1405 long groupId, long folderId, int start, int end, 1406 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1407 throws com.liferay.portal.kernel.exception.SystemException { 1408 return getPersistence() 1409 .filterFindByG_F(groupId, folderId, start, end, 1410 orderByComparator); 1411 } 1412 1413 /** 1414 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1415 * 1416 * @param entryId the primary key of the current bookmarks entry 1417 * @param groupId the group ID 1418 * @param folderId the folder ID 1419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1420 * @return the previous, current, and next bookmarks entry 1421 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1422 * @throws SystemException if a system exception occurred 1423 */ 1424 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 1425 long entryId, long groupId, long folderId, 1426 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1427 throws com.liferay.portal.kernel.exception.SystemException, 1428 com.liferay.portlet.bookmarks.NoSuchEntryException { 1429 return getPersistence() 1430 .filterFindByG_F_PrevAndNext(entryId, groupId, folderId, 1431 orderByComparator); 1432 } 1433 1434 /** 1435 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1436 * 1437 * @param groupId the group ID 1438 * @param folderIds the folder IDs 1439 * @return the matching bookmarks entries that the user has permission to view 1440 * @throws SystemException if a system exception occurred 1441 */ 1442 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1443 long groupId, long[] folderIds) 1444 throws com.liferay.portal.kernel.exception.SystemException { 1445 return getPersistence().filterFindByG_F(groupId, folderIds); 1446 } 1447 1448 /** 1449 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1450 * 1451 * <p> 1452 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1453 * </p> 1454 * 1455 * @param groupId the group ID 1456 * @param folderIds the folder IDs 1457 * @param start the lower bound of the range of bookmarks entries 1458 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1459 * @return the range of matching bookmarks entries that the user has permission to view 1460 * @throws SystemException if a system exception occurred 1461 */ 1462 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1463 long groupId, long[] folderIds, int start, int end) 1464 throws com.liferay.portal.kernel.exception.SystemException { 1465 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 1466 } 1467 1468 /** 1469 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1470 * 1471 * <p> 1472 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1473 * </p> 1474 * 1475 * @param groupId the group ID 1476 * @param folderIds the folder IDs 1477 * @param start the lower bound of the range of bookmarks entries 1478 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1479 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1480 * @return the ordered range of matching bookmarks entries that the user has permission to view 1481 * @throws SystemException if a system exception occurred 1482 */ 1483 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1484 long groupId, long[] folderIds, int start, int end, 1485 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1486 throws com.liferay.portal.kernel.exception.SystemException { 1487 return getPersistence() 1488 .filterFindByG_F(groupId, folderIds, start, end, 1489 orderByComparator); 1490 } 1491 1492 /** 1493 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 1494 * 1495 * <p> 1496 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1497 * </p> 1498 * 1499 * @param groupId the group ID 1500 * @param folderIds the folder IDs 1501 * @return the matching bookmarks entries 1502 * @throws SystemException if a system exception occurred 1503 */ 1504 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1505 long groupId, long[] folderIds) 1506 throws com.liferay.portal.kernel.exception.SystemException { 1507 return getPersistence().findByG_F(groupId, folderIds); 1508 } 1509 1510 /** 1511 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 1512 * 1513 * <p> 1514 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1515 * </p> 1516 * 1517 * @param groupId the group ID 1518 * @param folderIds the folder IDs 1519 * @param start the lower bound of the range of bookmarks entries 1520 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1521 * @return the range of matching bookmarks entries 1522 * @throws SystemException if a system exception occurred 1523 */ 1524 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1525 long groupId, long[] folderIds, int start, int end) 1526 throws com.liferay.portal.kernel.exception.SystemException { 1527 return getPersistence().findByG_F(groupId, folderIds, start, end); 1528 } 1529 1530 /** 1531 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 1532 * 1533 * <p> 1534 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1535 * </p> 1536 * 1537 * @param groupId the group ID 1538 * @param folderIds the folder IDs 1539 * @param start the lower bound of the range of bookmarks entries 1540 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1541 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1542 * @return the ordered range of matching bookmarks entries 1543 * @throws SystemException if a system exception occurred 1544 */ 1545 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1546 long groupId, long[] folderIds, int start, int end, 1547 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1548 throws com.liferay.portal.kernel.exception.SystemException { 1549 return getPersistence() 1550 .findByG_F(groupId, folderIds, start, end, orderByComparator); 1551 } 1552 1553 /** 1554 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 1555 * 1556 * @param groupId the group ID 1557 * @param folderId the folder ID 1558 * @throws SystemException if a system exception occurred 1559 */ 1560 public static void removeByG_F(long groupId, long folderId) 1561 throws com.liferay.portal.kernel.exception.SystemException { 1562 getPersistence().removeByG_F(groupId, folderId); 1563 } 1564 1565 /** 1566 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 1567 * 1568 * @param groupId the group ID 1569 * @param folderId the folder ID 1570 * @return the number of matching bookmarks entries 1571 * @throws SystemException if a system exception occurred 1572 */ 1573 public static int countByG_F(long groupId, long folderId) 1574 throws com.liferay.portal.kernel.exception.SystemException { 1575 return getPersistence().countByG_F(groupId, folderId); 1576 } 1577 1578 /** 1579 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 1580 * 1581 * @param groupId the group ID 1582 * @param folderIds the folder IDs 1583 * @return the number of matching bookmarks entries 1584 * @throws SystemException if a system exception occurred 1585 */ 1586 public static int countByG_F(long groupId, long[] folderIds) 1587 throws com.liferay.portal.kernel.exception.SystemException { 1588 return getPersistence().countByG_F(groupId, folderIds); 1589 } 1590 1591 /** 1592 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1593 * 1594 * @param groupId the group ID 1595 * @param folderId the folder ID 1596 * @return the number of matching bookmarks entries that the user has permission to view 1597 * @throws SystemException if a system exception occurred 1598 */ 1599 public static int filterCountByG_F(long groupId, long folderId) 1600 throws com.liferay.portal.kernel.exception.SystemException { 1601 return getPersistence().filterCountByG_F(groupId, folderId); 1602 } 1603 1604 /** 1605 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1606 * 1607 * @param groupId the group ID 1608 * @param folderIds the folder IDs 1609 * @return the number of matching bookmarks entries that the user has permission to view 1610 * @throws SystemException if a system exception occurred 1611 */ 1612 public static int filterCountByG_F(long groupId, long[] folderIds) 1613 throws com.liferay.portal.kernel.exception.SystemException { 1614 return getPersistence().filterCountByG_F(groupId, folderIds); 1615 } 1616 1617 /** 1618 * Caches the bookmarks entry in the entity cache if it is enabled. 1619 * 1620 * @param bookmarksEntry the bookmarks entry 1621 */ 1622 public static void cacheResult( 1623 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 1624 getPersistence().cacheResult(bookmarksEntry); 1625 } 1626 1627 /** 1628 * Caches the bookmarks entries in the entity cache if it is enabled. 1629 * 1630 * @param bookmarksEntries the bookmarks entries 1631 */ 1632 public static void cacheResult( 1633 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) { 1634 getPersistence().cacheResult(bookmarksEntries); 1635 } 1636 1637 /** 1638 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 1639 * 1640 * @param entryId the primary key for the new bookmarks entry 1641 * @return the new bookmarks entry 1642 */ 1643 public static com.liferay.portlet.bookmarks.model.BookmarksEntry create( 1644 long entryId) { 1645 return getPersistence().create(entryId); 1646 } 1647 1648 /** 1649 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 1650 * 1651 * @param entryId the primary key of the bookmarks entry 1652 * @return the bookmarks entry that was removed 1653 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1654 * @throws SystemException if a system exception occurred 1655 */ 1656 public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 1657 long entryId) 1658 throws com.liferay.portal.kernel.exception.SystemException, 1659 com.liferay.portlet.bookmarks.NoSuchEntryException { 1660 return getPersistence().remove(entryId); 1661 } 1662 1663 public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 1664 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 1665 throws com.liferay.portal.kernel.exception.SystemException { 1666 return getPersistence().updateImpl(bookmarksEntry); 1667 } 1668 1669 /** 1670 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 1671 * 1672 * @param entryId the primary key of the bookmarks entry 1673 * @return the bookmarks entry 1674 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1675 * @throws SystemException if a system exception occurred 1676 */ 1677 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 1678 long entryId) 1679 throws com.liferay.portal.kernel.exception.SystemException, 1680 com.liferay.portlet.bookmarks.NoSuchEntryException { 1681 return getPersistence().findByPrimaryKey(entryId); 1682 } 1683 1684 /** 1685 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 1686 * 1687 * @param entryId the primary key of the bookmarks entry 1688 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 1689 * @throws SystemException if a system exception occurred 1690 */ 1691 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 1692 long entryId) 1693 throws com.liferay.portal.kernel.exception.SystemException { 1694 return getPersistence().fetchByPrimaryKey(entryId); 1695 } 1696 1697 /** 1698 * Returns all the bookmarks entries. 1699 * 1700 * @return the bookmarks entries 1701 * @throws SystemException if a system exception occurred 1702 */ 1703 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 1704 throws com.liferay.portal.kernel.exception.SystemException { 1705 return getPersistence().findAll(); 1706 } 1707 1708 /** 1709 * Returns a range of all the bookmarks entries. 1710 * 1711 * <p> 1712 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1713 * </p> 1714 * 1715 * @param start the lower bound of the range of bookmarks entries 1716 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1717 * @return the range of bookmarks entries 1718 * @throws SystemException if a system exception occurred 1719 */ 1720 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1721 int start, int end) 1722 throws com.liferay.portal.kernel.exception.SystemException { 1723 return getPersistence().findAll(start, end); 1724 } 1725 1726 /** 1727 * Returns an ordered range of all the bookmarks entries. 1728 * 1729 * <p> 1730 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1731 * </p> 1732 * 1733 * @param start the lower bound of the range of bookmarks entries 1734 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1735 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1736 * @return the ordered range of bookmarks entries 1737 * @throws SystemException if a system exception occurred 1738 */ 1739 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1740 int start, int end, 1741 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1742 throws com.liferay.portal.kernel.exception.SystemException { 1743 return getPersistence().findAll(start, end, orderByComparator); 1744 } 1745 1746 /** 1747 * Removes all the bookmarks entries from the database. 1748 * 1749 * @throws SystemException if a system exception occurred 1750 */ 1751 public static void removeAll() 1752 throws com.liferay.portal.kernel.exception.SystemException { 1753 getPersistence().removeAll(); 1754 } 1755 1756 /** 1757 * Returns the number of bookmarks entries. 1758 * 1759 * @return the number of bookmarks entries 1760 * @throws SystemException if a system exception occurred 1761 */ 1762 public static int countAll() 1763 throws com.liferay.portal.kernel.exception.SystemException { 1764 return getPersistence().countAll(); 1765 } 1766 1767 public static BookmarksEntryPersistence getPersistence() { 1768 if (_persistence == null) { 1769 _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName()); 1770 1771 ReferenceRegistry.registerReference(BookmarksEntryUtil.class, 1772 "_persistence"); 1773 } 1774 1775 return _persistence; 1776 } 1777 1778 /** 1779 * @deprecated 1780 */ 1781 public void setPersistence(BookmarksEntryPersistence persistence) { 1782 } 1783 1784 private static BookmarksEntryPersistence _persistence; 1785 }