001 /** 002 * Copyright (c) 2000-present 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 aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.bookmarks.model.BookmarksEntry; 026 027 import java.util.List; 028 029 /** 030 * 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see BookmarksEntryPersistence 038 * @see BookmarksEntryPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class BookmarksEntryUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(BookmarksEntry bookmarksEntry) { 060 getPersistence().clearCache(bookmarksEntry); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<BookmarksEntry> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<BookmarksEntry> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 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<BookmarksEntry> orderByComparator) { 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 return getPersistence().update(bookmarksEntry); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static BookmarksEntry update(BookmarksEntry bookmarksEntry, 108 ServiceContext serviceContext) { 109 return getPersistence().update(bookmarksEntry, serviceContext); 110 } 111 112 /** 113 * Returns all the bookmarks entries where resourceBlockId = ?. 114 * 115 * @param resourceBlockId the resource block ID 116 * @return the matching bookmarks entries 117 */ 118 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 119 long resourceBlockId) { 120 return getPersistence().findByResourceBlockId(resourceBlockId); 121 } 122 123 /** 124 * Returns a range of all the bookmarks entries where resourceBlockId = ?. 125 * 126 * <p> 127 * 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. 128 * </p> 129 * 130 * @param resourceBlockId the resource block ID 131 * @param start the lower bound of the range of bookmarks entries 132 * @param end the upper bound of the range of bookmarks entries (not inclusive) 133 * @return the range of matching bookmarks entries 134 */ 135 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 136 long resourceBlockId, int start, int end) { 137 return getPersistence() 138 .findByResourceBlockId(resourceBlockId, start, end); 139 } 140 141 /** 142 * Returns an ordered range of all the bookmarks entries where resourceBlockId = ?. 143 * 144 * <p> 145 * 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. 146 * </p> 147 * 148 * @param resourceBlockId the resource block ID 149 * @param start the lower bound of the range of bookmarks entries 150 * @param end the upper bound of the range of bookmarks entries (not inclusive) 151 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 152 * @return the ordered range of matching bookmarks entries 153 */ 154 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 155 long resourceBlockId, int start, int end, 156 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 157 return getPersistence() 158 .findByResourceBlockId(resourceBlockId, start, end, 159 orderByComparator); 160 } 161 162 /** 163 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 164 * 165 * @param resourceBlockId the resource block ID 166 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 167 * @return the first matching bookmarks entry 168 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 169 */ 170 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First( 171 long resourceBlockId, 172 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 173 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 174 return getPersistence() 175 .findByResourceBlockId_First(resourceBlockId, 176 orderByComparator); 177 } 178 179 /** 180 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 181 * 182 * @param resourceBlockId the resource block ID 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 185 */ 186 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First( 187 long resourceBlockId, 188 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 189 return getPersistence() 190 .fetchByResourceBlockId_First(resourceBlockId, 191 orderByComparator); 192 } 193 194 /** 195 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 196 * 197 * @param resourceBlockId the resource block ID 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the last matching bookmarks entry 200 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 201 */ 202 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last( 203 long resourceBlockId, 204 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 205 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 206 return getPersistence() 207 .findByResourceBlockId_Last(resourceBlockId, 208 orderByComparator); 209 } 210 211 /** 212 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 213 * 214 * @param resourceBlockId the resource block ID 215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 216 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 217 */ 218 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last( 219 long resourceBlockId, 220 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 221 return getPersistence() 222 .fetchByResourceBlockId_Last(resourceBlockId, 223 orderByComparator); 224 } 225 226 /** 227 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = ?. 228 * 229 * @param entryId the primary key of the current bookmarks entry 230 * @param resourceBlockId the resource block ID 231 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 232 * @return the previous, current, and next bookmarks entry 233 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 234 */ 235 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext( 236 long entryId, long resourceBlockId, 237 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 238 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 239 return getPersistence() 240 .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId, 241 orderByComparator); 242 } 243 244 /** 245 * Removes all the bookmarks entries where resourceBlockId = ? from the database. 246 * 247 * @param resourceBlockId the resource block ID 248 */ 249 public static void removeByResourceBlockId(long resourceBlockId) { 250 getPersistence().removeByResourceBlockId(resourceBlockId); 251 } 252 253 /** 254 * Returns the number of bookmarks entries where resourceBlockId = ?. 255 * 256 * @param resourceBlockId the resource block ID 257 * @return the number of matching bookmarks entries 258 */ 259 public static int countByResourceBlockId(long resourceBlockId) { 260 return getPersistence().countByResourceBlockId(resourceBlockId); 261 } 262 263 /** 264 * Returns all the bookmarks entries where uuid = ?. 265 * 266 * @param uuid the uuid 267 * @return the matching bookmarks entries 268 */ 269 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 270 java.lang.String uuid) { 271 return getPersistence().findByUuid(uuid); 272 } 273 274 /** 275 * Returns a range of all the bookmarks entries where uuid = ?. 276 * 277 * <p> 278 * 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. 279 * </p> 280 * 281 * @param uuid the uuid 282 * @param start the lower bound of the range of bookmarks entries 283 * @param end the upper bound of the range of bookmarks entries (not inclusive) 284 * @return the range of matching bookmarks entries 285 */ 286 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 287 java.lang.String uuid, int start, int end) { 288 return getPersistence().findByUuid(uuid, start, end); 289 } 290 291 /** 292 * Returns an ordered range of all the bookmarks entries where uuid = ?. 293 * 294 * <p> 295 * 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. 296 * </p> 297 * 298 * @param uuid the uuid 299 * @param start the lower bound of the range of bookmarks entries 300 * @param end the upper bound of the range of bookmarks entries (not inclusive) 301 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 302 * @return the ordered range of matching bookmarks entries 303 */ 304 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 305 java.lang.String uuid, int start, int end, 306 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 307 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 308 } 309 310 /** 311 * Returns the first bookmarks entry in the ordered set where uuid = ?. 312 * 313 * @param uuid the uuid 314 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 315 * @return the first matching bookmarks entry 316 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 317 */ 318 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First( 319 java.lang.String uuid, 320 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 321 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 322 return getPersistence().findByUuid_First(uuid, orderByComparator); 323 } 324 325 /** 326 * Returns the first bookmarks entry in the ordered set where uuid = ?. 327 * 328 * @param uuid the uuid 329 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 330 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 331 */ 332 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First( 333 java.lang.String uuid, 334 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 335 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 336 } 337 338 /** 339 * Returns the last bookmarks entry in the ordered set where uuid = ?. 340 * 341 * @param uuid the uuid 342 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 343 * @return the last matching bookmarks entry 344 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 345 */ 346 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last( 347 java.lang.String uuid, 348 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 349 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 350 return getPersistence().findByUuid_Last(uuid, orderByComparator); 351 } 352 353 /** 354 * Returns the last bookmarks entry in the ordered set where uuid = ?. 355 * 356 * @param uuid the uuid 357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 358 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 359 */ 360 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last( 361 java.lang.String uuid, 362 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 363 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 364 } 365 366 /** 367 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ?. 368 * 369 * @param entryId the primary key of the current bookmarks entry 370 * @param uuid the uuid 371 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 372 * @return the previous, current, and next bookmarks entry 373 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 374 */ 375 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext( 376 long entryId, java.lang.String uuid, 377 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 378 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 379 return getPersistence() 380 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 381 } 382 383 /** 384 * Removes all the bookmarks entries where uuid = ? from the database. 385 * 386 * @param uuid the uuid 387 */ 388 public static void removeByUuid(java.lang.String uuid) { 389 getPersistence().removeByUuid(uuid); 390 } 391 392 /** 393 * Returns the number of bookmarks entries where uuid = ?. 394 * 395 * @param uuid the uuid 396 * @return the number of matching bookmarks entries 397 */ 398 public static int countByUuid(java.lang.String uuid) { 399 return getPersistence().countByUuid(uuid); 400 } 401 402 /** 403 * Returns the bookmarks entry where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 404 * 405 * @param uuid the uuid 406 * @param groupId the group ID 407 * @return the matching bookmarks entry 408 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 409 */ 410 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G( 411 java.lang.String uuid, long groupId) 412 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 413 return getPersistence().findByUUID_G(uuid, groupId); 414 } 415 416 /** 417 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 418 * 419 * @param uuid the uuid 420 * @param groupId the group ID 421 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 422 */ 423 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 424 java.lang.String uuid, long groupId) { 425 return getPersistence().fetchByUUID_G(uuid, groupId); 426 } 427 428 /** 429 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 430 * 431 * @param uuid the uuid 432 * @param groupId the group ID 433 * @param retrieveFromCache whether to use the finder cache 434 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 435 */ 436 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 437 java.lang.String uuid, long groupId, boolean retrieveFromCache) { 438 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 439 } 440 441 /** 442 * Removes the bookmarks entry where uuid = ? and groupId = ? from the database. 443 * 444 * @param uuid the uuid 445 * @param groupId the group ID 446 * @return the bookmarks entry that was removed 447 */ 448 public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G( 449 java.lang.String uuid, long groupId) 450 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 451 return getPersistence().removeByUUID_G(uuid, groupId); 452 } 453 454 /** 455 * Returns the number of bookmarks entries where uuid = ? and groupId = ?. 456 * 457 * @param uuid the uuid 458 * @param groupId the group ID 459 * @return the number of matching bookmarks entries 460 */ 461 public static int countByUUID_G(java.lang.String uuid, long groupId) { 462 return getPersistence().countByUUID_G(uuid, groupId); 463 } 464 465 /** 466 * Returns all the bookmarks entries where uuid = ? and companyId = ?. 467 * 468 * @param uuid the uuid 469 * @param companyId the company ID 470 * @return the matching bookmarks entries 471 */ 472 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 473 java.lang.String uuid, long companyId) { 474 return getPersistence().findByUuid_C(uuid, companyId); 475 } 476 477 /** 478 * Returns a range of all the bookmarks entries where uuid = ? and companyId = ?. 479 * 480 * <p> 481 * 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. 482 * </p> 483 * 484 * @param uuid the uuid 485 * @param companyId the company ID 486 * @param start the lower bound of the range of bookmarks entries 487 * @param end the upper bound of the range of bookmarks entries (not inclusive) 488 * @return the range of matching bookmarks entries 489 */ 490 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 491 java.lang.String uuid, long companyId, int start, int end) { 492 return getPersistence().findByUuid_C(uuid, companyId, start, end); 493 } 494 495 /** 496 * Returns an ordered range of all the bookmarks entries where uuid = ? and companyId = ?. 497 * 498 * <p> 499 * 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. 500 * </p> 501 * 502 * @param uuid the uuid 503 * @param companyId the company ID 504 * @param start the lower bound of the range of bookmarks entries 505 * @param end the upper bound of the range of bookmarks entries (not inclusive) 506 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 507 * @return the ordered range of matching bookmarks entries 508 */ 509 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 510 java.lang.String uuid, long companyId, int start, int end, 511 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 512 return getPersistence() 513 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 514 } 515 516 /** 517 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 522 * @return the first matching bookmarks entry 523 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 524 */ 525 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First( 526 java.lang.String uuid, long companyId, 527 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 528 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 529 return getPersistence() 530 .findByUuid_C_First(uuid, companyId, orderByComparator); 531 } 532 533 /** 534 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 535 * 536 * @param uuid the uuid 537 * @param companyId the company ID 538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 539 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 540 */ 541 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First( 542 java.lang.String uuid, long companyId, 543 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 544 return getPersistence() 545 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 546 } 547 548 /** 549 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 550 * 551 * @param uuid the uuid 552 * @param companyId the company ID 553 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 554 * @return the last matching bookmarks entry 555 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 556 */ 557 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last( 558 java.lang.String uuid, long companyId, 559 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 560 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 561 return getPersistence() 562 .findByUuid_C_Last(uuid, companyId, orderByComparator); 563 } 564 565 /** 566 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 567 * 568 * @param uuid the uuid 569 * @param companyId the company ID 570 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 571 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 572 */ 573 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last( 574 java.lang.String uuid, long companyId, 575 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 576 return getPersistence() 577 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 578 } 579 580 /** 581 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ? and companyId = ?. 582 * 583 * @param entryId the primary key of the current bookmarks entry 584 * @param uuid the uuid 585 * @param companyId the company ID 586 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 587 * @return the previous, current, and next bookmarks entry 588 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 589 */ 590 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext( 591 long entryId, java.lang.String uuid, long companyId, 592 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 593 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 594 return getPersistence() 595 .findByUuid_C_PrevAndNext(entryId, uuid, companyId, 596 orderByComparator); 597 } 598 599 /** 600 * Removes all the bookmarks entries where uuid = ? and companyId = ? from the database. 601 * 602 * @param uuid the uuid 603 * @param companyId the company ID 604 */ 605 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 606 getPersistence().removeByUuid_C(uuid, companyId); 607 } 608 609 /** 610 * Returns the number of bookmarks entries where uuid = ? and companyId = ?. 611 * 612 * @param uuid the uuid 613 * @param companyId the company ID 614 * @return the number of matching bookmarks entries 615 */ 616 public static int countByUuid_C(java.lang.String uuid, long companyId) { 617 return getPersistence().countByUuid_C(uuid, companyId); 618 } 619 620 /** 621 * Returns all the bookmarks entries where companyId = ?. 622 * 623 * @param companyId the company ID 624 * @return the matching bookmarks entries 625 */ 626 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 627 long companyId) { 628 return getPersistence().findByCompanyId(companyId); 629 } 630 631 /** 632 * Returns a range of all the bookmarks entries where companyId = ?. 633 * 634 * <p> 635 * 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. 636 * </p> 637 * 638 * @param companyId the company ID 639 * @param start the lower bound of the range of bookmarks entries 640 * @param end the upper bound of the range of bookmarks entries (not inclusive) 641 * @return the range of matching bookmarks entries 642 */ 643 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 644 long companyId, int start, int end) { 645 return getPersistence().findByCompanyId(companyId, start, end); 646 } 647 648 /** 649 * Returns an ordered range of all the bookmarks entries where companyId = ?. 650 * 651 * <p> 652 * 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. 653 * </p> 654 * 655 * @param companyId the company ID 656 * @param start the lower bound of the range of bookmarks entries 657 * @param end the upper bound of the range of bookmarks entries (not inclusive) 658 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 659 * @return the ordered range of matching bookmarks entries 660 */ 661 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 662 long companyId, int start, int end, 663 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 664 return getPersistence() 665 .findByCompanyId(companyId, start, end, orderByComparator); 666 } 667 668 /** 669 * Returns the first bookmarks entry in the ordered set where companyId = ?. 670 * 671 * @param companyId the company ID 672 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 673 * @return the first matching bookmarks entry 674 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 675 */ 676 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_First( 677 long companyId, 678 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 679 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 680 return getPersistence() 681 .findByCompanyId_First(companyId, orderByComparator); 682 } 683 684 /** 685 * Returns the first bookmarks entry in the ordered set where companyId = ?. 686 * 687 * @param companyId the company ID 688 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 689 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 690 */ 691 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_First( 692 long companyId, 693 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 694 return getPersistence() 695 .fetchByCompanyId_First(companyId, orderByComparator); 696 } 697 698 /** 699 * Returns the last bookmarks entry in the ordered set where companyId = ?. 700 * 701 * @param companyId the company ID 702 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 703 * @return the last matching bookmarks entry 704 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 705 */ 706 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_Last( 707 long companyId, 708 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 709 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 710 return getPersistence() 711 .findByCompanyId_Last(companyId, orderByComparator); 712 } 713 714 /** 715 * Returns the last bookmarks entry in the ordered set where companyId = ?. 716 * 717 * @param companyId the company ID 718 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 719 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 720 */ 721 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_Last( 722 long companyId, 723 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 724 return getPersistence() 725 .fetchByCompanyId_Last(companyId, orderByComparator); 726 } 727 728 /** 729 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = ?. 730 * 731 * @param entryId the primary key of the current bookmarks entry 732 * @param companyId the company ID 733 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 734 * @return the previous, current, and next bookmarks entry 735 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 736 */ 737 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByCompanyId_PrevAndNext( 738 long entryId, long companyId, 739 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 740 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 741 return getPersistence() 742 .findByCompanyId_PrevAndNext(entryId, companyId, 743 orderByComparator); 744 } 745 746 /** 747 * Removes all the bookmarks entries where companyId = ? from the database. 748 * 749 * @param companyId the company ID 750 */ 751 public static void removeByCompanyId(long companyId) { 752 getPersistence().removeByCompanyId(companyId); 753 } 754 755 /** 756 * Returns the number of bookmarks entries where companyId = ?. 757 * 758 * @param companyId the company ID 759 * @return the number of matching bookmarks entries 760 */ 761 public static int countByCompanyId(long companyId) { 762 return getPersistence().countByCompanyId(companyId); 763 } 764 765 /** 766 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 767 * 768 * @param groupId the group ID 769 * @param folderId the folder ID 770 * @return the matching bookmarks entries 771 */ 772 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 773 long groupId, long folderId) { 774 return getPersistence().findByG_F(groupId, folderId); 775 } 776 777 /** 778 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 779 * 780 * <p> 781 * 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. 782 * </p> 783 * 784 * @param groupId the group ID 785 * @param folderId the folder ID 786 * @param start the lower bound of the range of bookmarks entries 787 * @param end the upper bound of the range of bookmarks entries (not inclusive) 788 * @return the range of matching bookmarks entries 789 */ 790 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 791 long groupId, long folderId, int start, int end) { 792 return getPersistence().findByG_F(groupId, folderId, start, end); 793 } 794 795 /** 796 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 797 * 798 * <p> 799 * 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. 800 * </p> 801 * 802 * @param groupId the group ID 803 * @param folderId the folder ID 804 * @param start the lower bound of the range of bookmarks entries 805 * @param end the upper bound of the range of bookmarks entries (not inclusive) 806 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 807 * @return the ordered range of matching bookmarks entries 808 */ 809 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 810 long groupId, long folderId, int start, int end, 811 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 812 return getPersistence() 813 .findByG_F(groupId, folderId, start, end, orderByComparator); 814 } 815 816 /** 817 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 818 * 819 * @param groupId the group ID 820 * @param folderId the folder ID 821 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 822 * @return the first matching bookmarks entry 823 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 824 */ 825 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 826 long groupId, long folderId, 827 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 828 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 829 return getPersistence() 830 .findByG_F_First(groupId, folderId, orderByComparator); 831 } 832 833 /** 834 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 835 * 836 * @param groupId the group ID 837 * @param folderId the folder ID 838 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 839 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 840 */ 841 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 842 long groupId, long folderId, 843 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 844 return getPersistence() 845 .fetchByG_F_First(groupId, folderId, orderByComparator); 846 } 847 848 /** 849 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 850 * 851 * @param groupId the group ID 852 * @param folderId the folder ID 853 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 854 * @return the last matching bookmarks entry 855 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 856 */ 857 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 858 long groupId, long folderId, 859 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 860 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 861 return getPersistence() 862 .findByG_F_Last(groupId, folderId, orderByComparator); 863 } 864 865 /** 866 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 867 * 868 * @param groupId the group ID 869 * @param folderId the folder ID 870 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 871 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 872 */ 873 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 874 long groupId, long folderId, 875 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 876 return getPersistence() 877 .fetchByG_F_Last(groupId, folderId, orderByComparator); 878 } 879 880 /** 881 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 882 * 883 * @param entryId the primary key of the current bookmarks entry 884 * @param groupId the group ID 885 * @param folderId the folder ID 886 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 887 * @return the previous, current, and next bookmarks entry 888 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 889 */ 890 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 891 long entryId, long groupId, long folderId, 892 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 893 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 894 return getPersistence() 895 .findByG_F_PrevAndNext(entryId, groupId, folderId, 896 orderByComparator); 897 } 898 899 /** 900 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 901 * 902 * @param groupId the group ID 903 * @param folderId the folder ID 904 * @return the matching bookmarks entries that the user has permission to view 905 */ 906 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 907 long groupId, long folderId) { 908 return getPersistence().filterFindByG_F(groupId, folderId); 909 } 910 911 /** 912 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 913 * 914 * <p> 915 * 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. 916 * </p> 917 * 918 * @param groupId the group ID 919 * @param folderId the folder ID 920 * @param start the lower bound of the range of bookmarks entries 921 * @param end the upper bound of the range of bookmarks entries (not inclusive) 922 * @return the range of matching bookmarks entries that the user has permission to view 923 */ 924 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 925 long groupId, long folderId, int start, int end) { 926 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 927 } 928 929 /** 930 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 931 * 932 * <p> 933 * 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. 934 * </p> 935 * 936 * @param groupId the group ID 937 * @param folderId the folder ID 938 * @param start the lower bound of the range of bookmarks entries 939 * @param end the upper bound of the range of bookmarks entries (not inclusive) 940 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 941 * @return the ordered range of matching bookmarks entries that the user has permission to view 942 */ 943 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 944 long groupId, long folderId, int start, int end, 945 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 946 return getPersistence() 947 .filterFindByG_F(groupId, folderId, start, end, 948 orderByComparator); 949 } 950 951 /** 952 * 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 = ?. 953 * 954 * @param entryId the primary key of the current bookmarks entry 955 * @param groupId the group ID 956 * @param folderId the folder ID 957 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 958 * @return the previous, current, and next bookmarks entry 959 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 960 */ 961 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 962 long entryId, long groupId, long folderId, 963 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 964 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 965 return getPersistence() 966 .filterFindByG_F_PrevAndNext(entryId, groupId, folderId, 967 orderByComparator); 968 } 969 970 /** 971 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 972 * 973 * @param groupId the group ID 974 * @param folderIds the folder IDs 975 * @return the matching bookmarks entries that the user has permission to view 976 */ 977 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 978 long groupId, long[] folderIds) { 979 return getPersistence().filterFindByG_F(groupId, folderIds); 980 } 981 982 /** 983 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 984 * 985 * <p> 986 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 987 * </p> 988 * 989 * @param groupId the group ID 990 * @param folderIds the folder IDs 991 * @param start the lower bound of the range of bookmarks entries 992 * @param end the upper bound of the range of bookmarks entries (not inclusive) 993 * @return the range of matching bookmarks entries that the user has permission to view 994 */ 995 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 996 long groupId, long[] folderIds, int start, int end) { 997 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 998 } 999 1000 /** 1001 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1002 * 1003 * <p> 1004 * 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. 1005 * </p> 1006 * 1007 * @param groupId the group ID 1008 * @param folderIds the folder IDs 1009 * @param start the lower bound of the range of bookmarks entries 1010 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1011 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1012 * @return the ordered range of matching bookmarks entries that the user has permission to view 1013 */ 1014 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1015 long groupId, long[] folderIds, int start, int end, 1016 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1017 return getPersistence() 1018 .filterFindByG_F(groupId, folderIds, start, end, 1019 orderByComparator); 1020 } 1021 1022 /** 1023 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 1024 * 1025 * <p> 1026 * 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. 1027 * </p> 1028 * 1029 * @param groupId the group ID 1030 * @param folderIds the folder IDs 1031 * @return the matching bookmarks entries 1032 */ 1033 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1034 long groupId, long[] folderIds) { 1035 return getPersistence().findByG_F(groupId, folderIds); 1036 } 1037 1038 /** 1039 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 1040 * 1041 * <p> 1042 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 1043 * </p> 1044 * 1045 * @param groupId the group ID 1046 * @param folderIds the folder IDs 1047 * @param start the lower bound of the range of bookmarks entries 1048 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1049 * @return the range of matching bookmarks entries 1050 */ 1051 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1052 long groupId, long[] folderIds, int start, int end) { 1053 return getPersistence().findByG_F(groupId, folderIds, start, end); 1054 } 1055 1056 /** 1057 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 1058 * 1059 * <p> 1060 * 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. 1061 * </p> 1062 * 1063 * @param groupId the group ID 1064 * @param folderIds the folder IDs 1065 * @param start the lower bound of the range of bookmarks entries 1066 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1067 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1068 * @return the ordered range of matching bookmarks entries 1069 */ 1070 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1071 long groupId, long[] folderIds, int start, int end, 1072 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1073 return getPersistence() 1074 .findByG_F(groupId, folderIds, start, end, orderByComparator); 1075 } 1076 1077 /** 1078 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 1079 * 1080 * @param groupId the group ID 1081 * @param folderId the folder ID 1082 */ 1083 public static void removeByG_F(long groupId, long folderId) { 1084 getPersistence().removeByG_F(groupId, folderId); 1085 } 1086 1087 /** 1088 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 1089 * 1090 * @param groupId the group ID 1091 * @param folderId the folder ID 1092 * @return the number of matching bookmarks entries 1093 */ 1094 public static int countByG_F(long groupId, long folderId) { 1095 return getPersistence().countByG_F(groupId, folderId); 1096 } 1097 1098 /** 1099 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 1100 * 1101 * @param groupId the group ID 1102 * @param folderIds the folder IDs 1103 * @return the number of matching bookmarks entries 1104 */ 1105 public static int countByG_F(long groupId, long[] folderIds) { 1106 return getPersistence().countByG_F(groupId, folderIds); 1107 } 1108 1109 /** 1110 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1111 * 1112 * @param groupId the group ID 1113 * @param folderId the folder ID 1114 * @return the number of matching bookmarks entries that the user has permission to view 1115 */ 1116 public static int filterCountByG_F(long groupId, long folderId) { 1117 return getPersistence().filterCountByG_F(groupId, folderId); 1118 } 1119 1120 /** 1121 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1122 * 1123 * @param groupId the group ID 1124 * @param folderIds the folder IDs 1125 * @return the number of matching bookmarks entries that the user has permission to view 1126 */ 1127 public static int filterCountByG_F(long groupId, long[] folderIds) { 1128 return getPersistence().filterCountByG_F(groupId, folderIds); 1129 } 1130 1131 /** 1132 * Returns all the bookmarks entries where groupId = ? and status = ?. 1133 * 1134 * @param groupId the group ID 1135 * @param status the status 1136 * @return the matching bookmarks entries 1137 */ 1138 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1139 long groupId, int status) { 1140 return getPersistence().findByG_S(groupId, status); 1141 } 1142 1143 /** 1144 * Returns a range of all the bookmarks entries where groupId = ? and status = ?. 1145 * 1146 * <p> 1147 * 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. 1148 * </p> 1149 * 1150 * @param groupId the group ID 1151 * @param status the status 1152 * @param start the lower bound of the range of bookmarks entries 1153 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1154 * @return the range of matching bookmarks entries 1155 */ 1156 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1157 long groupId, int status, int start, int end) { 1158 return getPersistence().findByG_S(groupId, status, start, end); 1159 } 1160 1161 /** 1162 * Returns an ordered range of all the bookmarks entries where groupId = ? and status = ?. 1163 * 1164 * <p> 1165 * 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. 1166 * </p> 1167 * 1168 * @param groupId the group ID 1169 * @param status the status 1170 * @param start the lower bound of the range of bookmarks entries 1171 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1172 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1173 * @return the ordered range of matching bookmarks entries 1174 */ 1175 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1176 long groupId, int status, int start, int end, 1177 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1178 return getPersistence() 1179 .findByG_S(groupId, status, start, end, orderByComparator); 1180 } 1181 1182 /** 1183 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1184 * 1185 * @param groupId the group ID 1186 * @param status the status 1187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1188 * @return the first matching bookmarks entry 1189 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1190 */ 1191 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First( 1192 long groupId, int status, 1193 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1194 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1195 return getPersistence() 1196 .findByG_S_First(groupId, status, orderByComparator); 1197 } 1198 1199 /** 1200 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1201 * 1202 * @param groupId the group ID 1203 * @param status the status 1204 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1205 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1206 */ 1207 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First( 1208 long groupId, int status, 1209 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1210 return getPersistence() 1211 .fetchByG_S_First(groupId, status, orderByComparator); 1212 } 1213 1214 /** 1215 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1216 * 1217 * @param groupId the group ID 1218 * @param status the status 1219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1220 * @return the last matching bookmarks entry 1221 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1222 */ 1223 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last( 1224 long groupId, int status, 1225 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1226 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1227 return getPersistence() 1228 .findByG_S_Last(groupId, status, orderByComparator); 1229 } 1230 1231 /** 1232 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1233 * 1234 * @param groupId the group ID 1235 * @param status the status 1236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1237 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1238 */ 1239 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last( 1240 long groupId, int status, 1241 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1242 return getPersistence() 1243 .fetchByG_S_Last(groupId, status, orderByComparator); 1244 } 1245 1246 /** 1247 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and status = ?. 1248 * 1249 * @param entryId the primary key of the current bookmarks entry 1250 * @param groupId the group ID 1251 * @param status the status 1252 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1253 * @return the previous, current, and next bookmarks entry 1254 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1255 */ 1256 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext( 1257 long entryId, long groupId, int status, 1258 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1259 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1260 return getPersistence() 1261 .findByG_S_PrevAndNext(entryId, groupId, status, 1262 orderByComparator); 1263 } 1264 1265 /** 1266 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1267 * 1268 * @param groupId the group ID 1269 * @param status the status 1270 * @return the matching bookmarks entries that the user has permission to view 1271 */ 1272 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1273 long groupId, int status) { 1274 return getPersistence().filterFindByG_S(groupId, status); 1275 } 1276 1277 /** 1278 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1279 * 1280 * <p> 1281 * 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. 1282 * </p> 1283 * 1284 * @param groupId the group ID 1285 * @param status the status 1286 * @param start the lower bound of the range of bookmarks entries 1287 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1288 * @return the range of matching bookmarks entries that the user has permission to view 1289 */ 1290 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1291 long groupId, int status, int start, int end) { 1292 return getPersistence().filterFindByG_S(groupId, status, start, end); 1293 } 1294 1295 /** 1296 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and status = ?. 1297 * 1298 * <p> 1299 * 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. 1300 * </p> 1301 * 1302 * @param groupId the group ID 1303 * @param status the status 1304 * @param start the lower bound of the range of bookmarks entries 1305 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1306 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1307 * @return the ordered range of matching bookmarks entries that the user has permission to view 1308 */ 1309 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1310 long groupId, int status, int start, int end, 1311 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1312 return getPersistence() 1313 .filterFindByG_S(groupId, status, start, end, 1314 orderByComparator); 1315 } 1316 1317 /** 1318 * 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 status = ?. 1319 * 1320 * @param entryId the primary key of the current bookmarks entry 1321 * @param groupId the group ID 1322 * @param status the status 1323 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1324 * @return the previous, current, and next bookmarks entry 1325 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1326 */ 1327 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext( 1328 long entryId, long groupId, int status, 1329 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1330 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1331 return getPersistence() 1332 .filterFindByG_S_PrevAndNext(entryId, groupId, status, 1333 orderByComparator); 1334 } 1335 1336 /** 1337 * Removes all the bookmarks entries where groupId = ? and status = ? from the database. 1338 * 1339 * @param groupId the group ID 1340 * @param status the status 1341 */ 1342 public static void removeByG_S(long groupId, int status) { 1343 getPersistence().removeByG_S(groupId, status); 1344 } 1345 1346 /** 1347 * Returns the number of bookmarks entries where groupId = ? and status = ?. 1348 * 1349 * @param groupId the group ID 1350 * @param status the status 1351 * @return the number of matching bookmarks entries 1352 */ 1353 public static int countByG_S(long groupId, int status) { 1354 return getPersistence().countByG_S(groupId, status); 1355 } 1356 1357 /** 1358 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1359 * 1360 * @param groupId the group ID 1361 * @param status the status 1362 * @return the number of matching bookmarks entries that the user has permission to view 1363 */ 1364 public static int filterCountByG_S(long groupId, int status) { 1365 return getPersistence().filterCountByG_S(groupId, status); 1366 } 1367 1368 /** 1369 * Returns all the bookmarks entries where groupId = ? and status ≠ ?. 1370 * 1371 * @param groupId the group ID 1372 * @param status the status 1373 * @return the matching bookmarks entries 1374 */ 1375 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_NotS( 1376 long groupId, int status) { 1377 return getPersistence().findByG_NotS(groupId, status); 1378 } 1379 1380 /** 1381 * Returns a range of all the bookmarks entries where groupId = ? and status ≠ ?. 1382 * 1383 * <p> 1384 * 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. 1385 * </p> 1386 * 1387 * @param groupId the group ID 1388 * @param status the status 1389 * @param start the lower bound of the range of bookmarks entries 1390 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1391 * @return the range of matching bookmarks entries 1392 */ 1393 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_NotS( 1394 long groupId, int status, int start, int end) { 1395 return getPersistence().findByG_NotS(groupId, status, start, end); 1396 } 1397 1398 /** 1399 * Returns an ordered range of all the bookmarks entries where groupId = ? and status ≠ ?. 1400 * 1401 * <p> 1402 * 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. 1403 * </p> 1404 * 1405 * @param groupId the group ID 1406 * @param status the status 1407 * @param start the lower bound of the range of bookmarks entries 1408 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1409 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1410 * @return the ordered range of matching bookmarks entries 1411 */ 1412 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_NotS( 1413 long groupId, int status, int start, int end, 1414 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1415 return getPersistence() 1416 .findByG_NotS(groupId, status, start, end, orderByComparator); 1417 } 1418 1419 /** 1420 * Returns the first bookmarks entry in the ordered set where groupId = ? and status ≠ ?. 1421 * 1422 * @param groupId the group ID 1423 * @param status the status 1424 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1425 * @return the first matching bookmarks entry 1426 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1427 */ 1428 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_NotS_First( 1429 long groupId, int status, 1430 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1431 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1432 return getPersistence() 1433 .findByG_NotS_First(groupId, status, orderByComparator); 1434 } 1435 1436 /** 1437 * Returns the first bookmarks entry in the ordered set where groupId = ? and status ≠ ?. 1438 * 1439 * @param groupId the group ID 1440 * @param status the status 1441 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1442 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1443 */ 1444 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_NotS_First( 1445 long groupId, int status, 1446 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1447 return getPersistence() 1448 .fetchByG_NotS_First(groupId, status, orderByComparator); 1449 } 1450 1451 /** 1452 * Returns the last bookmarks entry in the ordered set where groupId = ? and status ≠ ?. 1453 * 1454 * @param groupId the group ID 1455 * @param status the status 1456 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1457 * @return the last matching bookmarks entry 1458 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1459 */ 1460 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_NotS_Last( 1461 long groupId, int status, 1462 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1463 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1464 return getPersistence() 1465 .findByG_NotS_Last(groupId, status, orderByComparator); 1466 } 1467 1468 /** 1469 * Returns the last bookmarks entry in the ordered set where groupId = ? and status ≠ ?. 1470 * 1471 * @param groupId the group ID 1472 * @param status the status 1473 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1474 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1475 */ 1476 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_NotS_Last( 1477 long groupId, int status, 1478 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1479 return getPersistence() 1480 .fetchByG_NotS_Last(groupId, status, orderByComparator); 1481 } 1482 1483 /** 1484 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and status ≠ ?. 1485 * 1486 * @param entryId the primary key of the current bookmarks entry 1487 * @param groupId the group ID 1488 * @param status the status 1489 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1490 * @return the previous, current, and next bookmarks entry 1491 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1492 */ 1493 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_NotS_PrevAndNext( 1494 long entryId, long groupId, int status, 1495 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1496 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1497 return getPersistence() 1498 .findByG_NotS_PrevAndNext(entryId, groupId, status, 1499 orderByComparator); 1500 } 1501 1502 /** 1503 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and status ≠ ?. 1504 * 1505 * @param groupId the group ID 1506 * @param status the status 1507 * @return the matching bookmarks entries that the user has permission to view 1508 */ 1509 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS( 1510 long groupId, int status) { 1511 return getPersistence().filterFindByG_NotS(groupId, status); 1512 } 1513 1514 /** 1515 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and status ≠ ?. 1516 * 1517 * <p> 1518 * 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. 1519 * </p> 1520 * 1521 * @param groupId the group ID 1522 * @param status the status 1523 * @param start the lower bound of the range of bookmarks entries 1524 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1525 * @return the range of matching bookmarks entries that the user has permission to view 1526 */ 1527 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS( 1528 long groupId, int status, int start, int end) { 1529 return getPersistence().filterFindByG_NotS(groupId, status, start, end); 1530 } 1531 1532 /** 1533 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and status ≠ ?. 1534 * 1535 * <p> 1536 * 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. 1537 * </p> 1538 * 1539 * @param groupId the group ID 1540 * @param status the status 1541 * @param start the lower bound of the range of bookmarks entries 1542 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1543 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1544 * @return the ordered range of matching bookmarks entries that the user has permission to view 1545 */ 1546 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS( 1547 long groupId, int status, int start, int end, 1548 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1549 return getPersistence() 1550 .filterFindByG_NotS(groupId, status, start, end, 1551 orderByComparator); 1552 } 1553 1554 /** 1555 * 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 status ≠ ?. 1556 * 1557 * @param entryId the primary key of the current bookmarks entry 1558 * @param groupId the group ID 1559 * @param status the status 1560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1561 * @return the previous, current, and next bookmarks entry 1562 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1563 */ 1564 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_NotS_PrevAndNext( 1565 long entryId, long groupId, int status, 1566 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1567 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1568 return getPersistence() 1569 .filterFindByG_NotS_PrevAndNext(entryId, groupId, status, 1570 orderByComparator); 1571 } 1572 1573 /** 1574 * Removes all the bookmarks entries where groupId = ? and status ≠ ? from the database. 1575 * 1576 * @param groupId the group ID 1577 * @param status the status 1578 */ 1579 public static void removeByG_NotS(long groupId, int status) { 1580 getPersistence().removeByG_NotS(groupId, status); 1581 } 1582 1583 /** 1584 * Returns the number of bookmarks entries where groupId = ? and status ≠ ?. 1585 * 1586 * @param groupId the group ID 1587 * @param status the status 1588 * @return the number of matching bookmarks entries 1589 */ 1590 public static int countByG_NotS(long groupId, int status) { 1591 return getPersistence().countByG_NotS(groupId, status); 1592 } 1593 1594 /** 1595 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and status ≠ ?. 1596 * 1597 * @param groupId the group ID 1598 * @param status the status 1599 * @return the number of matching bookmarks entries that the user has permission to view 1600 */ 1601 public static int filterCountByG_NotS(long groupId, int status) { 1602 return getPersistence().filterCountByG_NotS(groupId, status); 1603 } 1604 1605 /** 1606 * Returns all the bookmarks entries where companyId = ? and status ≠ ?. 1607 * 1608 * @param companyId the company ID 1609 * @param status the status 1610 * @return the matching bookmarks entries 1611 */ 1612 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1613 long companyId, int status) { 1614 return getPersistence().findByC_NotS(companyId, status); 1615 } 1616 1617 /** 1618 * Returns a range of all the bookmarks entries where companyId = ? and status ≠ ?. 1619 * 1620 * <p> 1621 * 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. 1622 * </p> 1623 * 1624 * @param companyId the company ID 1625 * @param status the status 1626 * @param start the lower bound of the range of bookmarks entries 1627 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1628 * @return the range of matching bookmarks entries 1629 */ 1630 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1631 long companyId, int status, int start, int end) { 1632 return getPersistence().findByC_NotS(companyId, status, start, end); 1633 } 1634 1635 /** 1636 * Returns an ordered range of all the bookmarks entries where companyId = ? and status ≠ ?. 1637 * 1638 * <p> 1639 * 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. 1640 * </p> 1641 * 1642 * @param companyId the company ID 1643 * @param status the status 1644 * @param start the lower bound of the range of bookmarks entries 1645 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1646 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1647 * @return the ordered range of matching bookmarks entries 1648 */ 1649 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1650 long companyId, int status, int start, int end, 1651 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1652 return getPersistence() 1653 .findByC_NotS(companyId, status, start, end, 1654 orderByComparator); 1655 } 1656 1657 /** 1658 * Returns the first bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1659 * 1660 * @param companyId the company ID 1661 * @param status the status 1662 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1663 * @return the first matching bookmarks entry 1664 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1665 */ 1666 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_First( 1667 long companyId, int status, 1668 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1669 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1670 return getPersistence() 1671 .findByC_NotS_First(companyId, status, orderByComparator); 1672 } 1673 1674 /** 1675 * Returns the first bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1676 * 1677 * @param companyId the company ID 1678 * @param status the status 1679 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1680 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1681 */ 1682 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_First( 1683 long companyId, int status, 1684 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1685 return getPersistence() 1686 .fetchByC_NotS_First(companyId, status, orderByComparator); 1687 } 1688 1689 /** 1690 * Returns the last bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1691 * 1692 * @param companyId the company ID 1693 * @param status the status 1694 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1695 * @return the last matching bookmarks entry 1696 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1697 */ 1698 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_Last( 1699 long companyId, int status, 1700 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1701 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1702 return getPersistence() 1703 .findByC_NotS_Last(companyId, status, orderByComparator); 1704 } 1705 1706 /** 1707 * Returns the last bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1708 * 1709 * @param companyId the company ID 1710 * @param status the status 1711 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1712 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1713 */ 1714 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_Last( 1715 long companyId, int status, 1716 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1717 return getPersistence() 1718 .fetchByC_NotS_Last(companyId, status, orderByComparator); 1719 } 1720 1721 /** 1722 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1723 * 1724 * @param entryId the primary key of the current bookmarks entry 1725 * @param companyId the company ID 1726 * @param status the status 1727 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1728 * @return the previous, current, and next bookmarks entry 1729 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1730 */ 1731 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByC_NotS_PrevAndNext( 1732 long entryId, long companyId, int status, 1733 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1734 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1735 return getPersistence() 1736 .findByC_NotS_PrevAndNext(entryId, companyId, status, 1737 orderByComparator); 1738 } 1739 1740 /** 1741 * Removes all the bookmarks entries where companyId = ? and status ≠ ? from the database. 1742 * 1743 * @param companyId the company ID 1744 * @param status the status 1745 */ 1746 public static void removeByC_NotS(long companyId, int status) { 1747 getPersistence().removeByC_NotS(companyId, status); 1748 } 1749 1750 /** 1751 * Returns the number of bookmarks entries where companyId = ? and status ≠ ?. 1752 * 1753 * @param companyId the company ID 1754 * @param status the status 1755 * @return the number of matching bookmarks entries 1756 */ 1757 public static int countByC_NotS(long companyId, int status) { 1758 return getPersistence().countByC_NotS(companyId, status); 1759 } 1760 1761 /** 1762 * Returns all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1763 * 1764 * @param groupId the group ID 1765 * @param userId the user ID 1766 * @param status the status 1767 * @return the matching bookmarks entries 1768 */ 1769 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1770 long groupId, long userId, int status) { 1771 return getPersistence().findByG_U_S(groupId, userId, status); 1772 } 1773 1774 /** 1775 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1776 * 1777 * <p> 1778 * 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. 1779 * </p> 1780 * 1781 * @param groupId the group ID 1782 * @param userId the user ID 1783 * @param status the status 1784 * @param start the lower bound of the range of bookmarks entries 1785 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1786 * @return the range of matching bookmarks entries 1787 */ 1788 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1789 long groupId, long userId, int status, int start, int end) { 1790 return getPersistence().findByG_U_S(groupId, userId, status, start, end); 1791 } 1792 1793 /** 1794 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1795 * 1796 * <p> 1797 * 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. 1798 * </p> 1799 * 1800 * @param groupId the group ID 1801 * @param userId the user ID 1802 * @param status the status 1803 * @param start the lower bound of the range of bookmarks entries 1804 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1805 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1806 * @return the ordered range of matching bookmarks entries 1807 */ 1808 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1809 long groupId, long userId, int status, int start, int end, 1810 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1811 return getPersistence() 1812 .findByG_U_S(groupId, userId, status, start, end, 1813 orderByComparator); 1814 } 1815 1816 /** 1817 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1818 * 1819 * @param groupId the group ID 1820 * @param userId the user ID 1821 * @param status the status 1822 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1823 * @return the first matching bookmarks entry 1824 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1825 */ 1826 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First( 1827 long groupId, long userId, int status, 1828 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1829 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1830 return getPersistence() 1831 .findByG_U_S_First(groupId, userId, status, orderByComparator); 1832 } 1833 1834 /** 1835 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1836 * 1837 * @param groupId the group ID 1838 * @param userId the user ID 1839 * @param status the status 1840 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1841 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1842 */ 1843 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First( 1844 long groupId, long userId, int status, 1845 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1846 return getPersistence() 1847 .fetchByG_U_S_First(groupId, userId, status, 1848 orderByComparator); 1849 } 1850 1851 /** 1852 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1853 * 1854 * @param groupId the group ID 1855 * @param userId the user ID 1856 * @param status the status 1857 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1858 * @return the last matching bookmarks entry 1859 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1860 */ 1861 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last( 1862 long groupId, long userId, int status, 1863 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1864 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1865 return getPersistence() 1866 .findByG_U_S_Last(groupId, userId, status, orderByComparator); 1867 } 1868 1869 /** 1870 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1871 * 1872 * @param groupId the group ID 1873 * @param userId the user ID 1874 * @param status the status 1875 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1876 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1877 */ 1878 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last( 1879 long groupId, long userId, int status, 1880 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1881 return getPersistence() 1882 .fetchByG_U_S_Last(groupId, userId, status, orderByComparator); 1883 } 1884 1885 /** 1886 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1887 * 1888 * @param entryId the primary key of the current bookmarks entry 1889 * @param groupId the group ID 1890 * @param userId the user ID 1891 * @param status the status 1892 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1893 * @return the previous, current, and next bookmarks entry 1894 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1895 */ 1896 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext( 1897 long entryId, long groupId, long userId, int status, 1898 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1899 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1900 return getPersistence() 1901 .findByG_U_S_PrevAndNext(entryId, groupId, userId, status, 1902 orderByComparator); 1903 } 1904 1905 /** 1906 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1907 * 1908 * @param groupId the group ID 1909 * @param userId the user ID 1910 * @param status the status 1911 * @return the matching bookmarks entries that the user has permission to view 1912 */ 1913 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1914 long groupId, long userId, int status) { 1915 return getPersistence().filterFindByG_U_S(groupId, userId, status); 1916 } 1917 1918 /** 1919 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1920 * 1921 * <p> 1922 * 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. 1923 * </p> 1924 * 1925 * @param groupId the group ID 1926 * @param userId the user ID 1927 * @param status the status 1928 * @param start the lower bound of the range of bookmarks entries 1929 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1930 * @return the range of matching bookmarks entries that the user has permission to view 1931 */ 1932 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1933 long groupId, long userId, int status, int start, int end) { 1934 return getPersistence() 1935 .filterFindByG_U_S(groupId, userId, status, start, end); 1936 } 1937 1938 /** 1939 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and status = ?. 1940 * 1941 * <p> 1942 * 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. 1943 * </p> 1944 * 1945 * @param groupId the group ID 1946 * @param userId the user ID 1947 * @param status the status 1948 * @param start the lower bound of the range of bookmarks entries 1949 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1950 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1951 * @return the ordered range of matching bookmarks entries that the user has permission to view 1952 */ 1953 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1954 long groupId, long userId, int status, int start, int end, 1955 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 1956 return getPersistence() 1957 .filterFindByG_U_S(groupId, userId, status, start, end, 1958 orderByComparator); 1959 } 1960 1961 /** 1962 * 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 = ? and status = ?. 1963 * 1964 * @param entryId the primary key of the current bookmarks entry 1965 * @param groupId the group ID 1966 * @param userId the user ID 1967 * @param status the status 1968 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1969 * @return the previous, current, and next bookmarks entry 1970 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1971 */ 1972 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext( 1973 long entryId, long groupId, long userId, int status, 1974 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 1975 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 1976 return getPersistence() 1977 .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId, 1978 status, orderByComparator); 1979 } 1980 1981 /** 1982 * Removes all the bookmarks entries where groupId = ? and userId = ? and status = ? from the database. 1983 * 1984 * @param groupId the group ID 1985 * @param userId the user ID 1986 * @param status the status 1987 */ 1988 public static void removeByG_U_S(long groupId, long userId, int status) { 1989 getPersistence().removeByG_U_S(groupId, userId, status); 1990 } 1991 1992 /** 1993 * Returns the number of bookmarks entries where groupId = ? and userId = ? and status = ?. 1994 * 1995 * @param groupId the group ID 1996 * @param userId the user ID 1997 * @param status the status 1998 * @return the number of matching bookmarks entries 1999 */ 2000 public static int countByG_U_S(long groupId, long userId, int status) { 2001 return getPersistence().countByG_U_S(groupId, userId, status); 2002 } 2003 2004 /** 2005 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 2006 * 2007 * @param groupId the group ID 2008 * @param userId the user ID 2009 * @param status the status 2010 * @return the number of matching bookmarks entries that the user has permission to view 2011 */ 2012 public static int filterCountByG_U_S(long groupId, long userId, int status) { 2013 return getPersistence().filterCountByG_U_S(groupId, userId, status); 2014 } 2015 2016 /** 2017 * Returns all the bookmarks entries where groupId = ? and userId = ? and status ≠ ?. 2018 * 2019 * @param groupId the group ID 2020 * @param userId the user ID 2021 * @param status the status 2022 * @return the matching bookmarks entries 2023 */ 2024 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS( 2025 long groupId, long userId, int status) { 2026 return getPersistence().findByG_U_NotS(groupId, userId, status); 2027 } 2028 2029 /** 2030 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and status ≠ ?. 2031 * 2032 * <p> 2033 * 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. 2034 * </p> 2035 * 2036 * @param groupId the group ID 2037 * @param userId the user ID 2038 * @param status the status 2039 * @param start the lower bound of the range of bookmarks entries 2040 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2041 * @return the range of matching bookmarks entries 2042 */ 2043 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS( 2044 long groupId, long userId, int status, int start, int end) { 2045 return getPersistence() 2046 .findByG_U_NotS(groupId, userId, status, start, end); 2047 } 2048 2049 /** 2050 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and status ≠ ?. 2051 * 2052 * <p> 2053 * 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. 2054 * </p> 2055 * 2056 * @param groupId the group ID 2057 * @param userId the user ID 2058 * @param status the status 2059 * @param start the lower bound of the range of bookmarks entries 2060 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2061 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2062 * @return the ordered range of matching bookmarks entries 2063 */ 2064 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS( 2065 long groupId, long userId, int status, int start, int end, 2066 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2067 return getPersistence() 2068 .findByG_U_NotS(groupId, userId, status, start, end, 2069 orderByComparator); 2070 } 2071 2072 /** 2073 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 2074 * 2075 * @param groupId the group ID 2076 * @param userId the user ID 2077 * @param status the status 2078 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2079 * @return the first matching bookmarks entry 2080 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2081 */ 2082 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_NotS_First( 2083 long groupId, long userId, int status, 2084 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2085 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2086 return getPersistence() 2087 .findByG_U_NotS_First(groupId, userId, status, 2088 orderByComparator); 2089 } 2090 2091 /** 2092 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 2093 * 2094 * @param groupId the group ID 2095 * @param userId the user ID 2096 * @param status the status 2097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2098 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2099 */ 2100 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_NotS_First( 2101 long groupId, long userId, int status, 2102 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2103 return getPersistence() 2104 .fetchByG_U_NotS_First(groupId, userId, status, 2105 orderByComparator); 2106 } 2107 2108 /** 2109 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 2110 * 2111 * @param groupId the group ID 2112 * @param userId the user ID 2113 * @param status the status 2114 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2115 * @return the last matching bookmarks entry 2116 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2117 */ 2118 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_NotS_Last( 2119 long groupId, long userId, int status, 2120 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2121 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2122 return getPersistence() 2123 .findByG_U_NotS_Last(groupId, userId, status, 2124 orderByComparator); 2125 } 2126 2127 /** 2128 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 2129 * 2130 * @param groupId the group ID 2131 * @param userId the user ID 2132 * @param status the status 2133 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2134 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2135 */ 2136 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_NotS_Last( 2137 long groupId, long userId, int status, 2138 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2139 return getPersistence() 2140 .fetchByG_U_NotS_Last(groupId, userId, status, 2141 orderByComparator); 2142 } 2143 2144 /** 2145 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 2146 * 2147 * @param entryId the primary key of the current bookmarks entry 2148 * @param groupId the group ID 2149 * @param userId the user ID 2150 * @param status the status 2151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2152 * @return the previous, current, and next bookmarks entry 2153 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2154 */ 2155 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_NotS_PrevAndNext( 2156 long entryId, long groupId, long userId, int status, 2157 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2158 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2159 return getPersistence() 2160 .findByG_U_NotS_PrevAndNext(entryId, groupId, userId, 2161 status, orderByComparator); 2162 } 2163 2164 /** 2165 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status ≠ ?. 2166 * 2167 * @param groupId the group ID 2168 * @param userId the user ID 2169 * @param status the status 2170 * @return the matching bookmarks entries that the user has permission to view 2171 */ 2172 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS( 2173 long groupId, long userId, int status) { 2174 return getPersistence().filterFindByG_U_NotS(groupId, userId, status); 2175 } 2176 2177 /** 2178 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status ≠ ?. 2179 * 2180 * <p> 2181 * 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. 2182 * </p> 2183 * 2184 * @param groupId the group ID 2185 * @param userId the user ID 2186 * @param status the status 2187 * @param start the lower bound of the range of bookmarks entries 2188 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2189 * @return the range of matching bookmarks entries that the user has permission to view 2190 */ 2191 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS( 2192 long groupId, long userId, int status, int start, int end) { 2193 return getPersistence() 2194 .filterFindByG_U_NotS(groupId, userId, status, start, end); 2195 } 2196 2197 /** 2198 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and status ≠ ?. 2199 * 2200 * <p> 2201 * 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. 2202 * </p> 2203 * 2204 * @param groupId the group ID 2205 * @param userId the user ID 2206 * @param status the status 2207 * @param start the lower bound of the range of bookmarks entries 2208 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2209 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2210 * @return the ordered range of matching bookmarks entries that the user has permission to view 2211 */ 2212 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS( 2213 long groupId, long userId, int status, int start, int end, 2214 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2215 return getPersistence() 2216 .filterFindByG_U_NotS(groupId, userId, status, start, end, 2217 orderByComparator); 2218 } 2219 2220 /** 2221 * 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 = ? and status ≠ ?. 2222 * 2223 * @param entryId the primary key of the current bookmarks entry 2224 * @param groupId the group ID 2225 * @param userId the user ID 2226 * @param status the status 2227 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2228 * @return the previous, current, and next bookmarks entry 2229 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2230 */ 2231 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_NotS_PrevAndNext( 2232 long entryId, long groupId, long userId, int status, 2233 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2234 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2235 return getPersistence() 2236 .filterFindByG_U_NotS_PrevAndNext(entryId, groupId, userId, 2237 status, orderByComparator); 2238 } 2239 2240 /** 2241 * Removes all the bookmarks entries where groupId = ? and userId = ? and status ≠ ? from the database. 2242 * 2243 * @param groupId the group ID 2244 * @param userId the user ID 2245 * @param status the status 2246 */ 2247 public static void removeByG_U_NotS(long groupId, long userId, int status) { 2248 getPersistence().removeByG_U_NotS(groupId, userId, status); 2249 } 2250 2251 /** 2252 * Returns the number of bookmarks entries where groupId = ? and userId = ? and status ≠ ?. 2253 * 2254 * @param groupId the group ID 2255 * @param userId the user ID 2256 * @param status the status 2257 * @return the number of matching bookmarks entries 2258 */ 2259 public static int countByG_U_NotS(long groupId, long userId, int status) { 2260 return getPersistence().countByG_U_NotS(groupId, userId, status); 2261 } 2262 2263 /** 2264 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status ≠ ?. 2265 * 2266 * @param groupId the group ID 2267 * @param userId the user ID 2268 * @param status the status 2269 * @return the number of matching bookmarks entries that the user has permission to view 2270 */ 2271 public static int filterCountByG_U_NotS(long groupId, long userId, 2272 int status) { 2273 return getPersistence().filterCountByG_U_NotS(groupId, userId, status); 2274 } 2275 2276 /** 2277 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 2278 * 2279 * @param groupId the group ID 2280 * @param folderId the folder ID 2281 * @param status the status 2282 * @return the matching bookmarks entries 2283 */ 2284 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2285 long groupId, long folderId, int status) { 2286 return getPersistence().findByG_F_S(groupId, folderId, status); 2287 } 2288 2289 /** 2290 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 2291 * 2292 * <p> 2293 * 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. 2294 * </p> 2295 * 2296 * @param groupId the group ID 2297 * @param folderId the folder ID 2298 * @param status the status 2299 * @param start the lower bound of the range of bookmarks entries 2300 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2301 * @return the range of matching bookmarks entries 2302 */ 2303 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2304 long groupId, long folderId, int status, int start, int end) { 2305 return getPersistence() 2306 .findByG_F_S(groupId, folderId, status, start, end); 2307 } 2308 2309 /** 2310 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 2311 * 2312 * <p> 2313 * 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. 2314 * </p> 2315 * 2316 * @param groupId the group ID 2317 * @param folderId the folder ID 2318 * @param status the status 2319 * @param start the lower bound of the range of bookmarks entries 2320 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2321 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2322 * @return the ordered range of matching bookmarks entries 2323 */ 2324 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2325 long groupId, long folderId, int status, int start, int end, 2326 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2327 return getPersistence() 2328 .findByG_F_S(groupId, folderId, status, start, end, 2329 orderByComparator); 2330 } 2331 2332 /** 2333 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2334 * 2335 * @param groupId the group ID 2336 * @param folderId the folder ID 2337 * @param status the status 2338 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2339 * @return the first matching bookmarks entry 2340 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2341 */ 2342 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First( 2343 long groupId, long folderId, int status, 2344 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2345 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2346 return getPersistence() 2347 .findByG_F_S_First(groupId, folderId, status, 2348 orderByComparator); 2349 } 2350 2351 /** 2352 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2353 * 2354 * @param groupId the group ID 2355 * @param folderId the folder ID 2356 * @param status the status 2357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2358 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2359 */ 2360 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First( 2361 long groupId, long folderId, int status, 2362 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2363 return getPersistence() 2364 .fetchByG_F_S_First(groupId, folderId, status, 2365 orderByComparator); 2366 } 2367 2368 /** 2369 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2370 * 2371 * @param groupId the group ID 2372 * @param folderId the folder ID 2373 * @param status the status 2374 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2375 * @return the last matching bookmarks entry 2376 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2377 */ 2378 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last( 2379 long groupId, long folderId, int status, 2380 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2381 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2382 return getPersistence() 2383 .findByG_F_S_Last(groupId, folderId, status, 2384 orderByComparator); 2385 } 2386 2387 /** 2388 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2389 * 2390 * @param groupId the group ID 2391 * @param folderId the folder ID 2392 * @param status the status 2393 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2394 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2395 */ 2396 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last( 2397 long groupId, long folderId, int status, 2398 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2399 return getPersistence() 2400 .fetchByG_F_S_Last(groupId, folderId, status, 2401 orderByComparator); 2402 } 2403 2404 /** 2405 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 2406 * 2407 * @param entryId the primary key of the current bookmarks entry 2408 * @param groupId the group ID 2409 * @param folderId the folder ID 2410 * @param status the status 2411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2412 * @return the previous, current, and next bookmarks entry 2413 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2414 */ 2415 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext( 2416 long entryId, long groupId, long folderId, int status, 2417 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2418 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2419 return getPersistence() 2420 .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status, 2421 orderByComparator); 2422 } 2423 2424 /** 2425 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2426 * 2427 * @param groupId the group ID 2428 * @param folderId the folder ID 2429 * @param status the status 2430 * @return the matching bookmarks entries that the user has permission to view 2431 */ 2432 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2433 long groupId, long folderId, int status) { 2434 return getPersistence().filterFindByG_F_S(groupId, folderId, status); 2435 } 2436 2437 /** 2438 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2439 * 2440 * <p> 2441 * 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. 2442 * </p> 2443 * 2444 * @param groupId the group ID 2445 * @param folderId the folder ID 2446 * @param status the status 2447 * @param start the lower bound of the range of bookmarks entries 2448 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2449 * @return the range of matching bookmarks entries that the user has permission to view 2450 */ 2451 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2452 long groupId, long folderId, int status, int start, int end) { 2453 return getPersistence() 2454 .filterFindByG_F_S(groupId, folderId, status, start, end); 2455 } 2456 2457 /** 2458 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 2459 * 2460 * <p> 2461 * 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. 2462 * </p> 2463 * 2464 * @param groupId the group ID 2465 * @param folderId the folder ID 2466 * @param status the status 2467 * @param start the lower bound of the range of bookmarks entries 2468 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2469 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2470 * @return the ordered range of matching bookmarks entries that the user has permission to view 2471 */ 2472 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2473 long groupId, long folderId, int status, int start, int end, 2474 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2475 return getPersistence() 2476 .filterFindByG_F_S(groupId, folderId, status, start, end, 2477 orderByComparator); 2478 } 2479 2480 /** 2481 * 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 = ? and status = ?. 2482 * 2483 * @param entryId the primary key of the current bookmarks entry 2484 * @param groupId the group ID 2485 * @param folderId the folder ID 2486 * @param status the status 2487 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2488 * @return the previous, current, and next bookmarks entry 2489 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2490 */ 2491 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext( 2492 long entryId, long groupId, long folderId, int status, 2493 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2494 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2495 return getPersistence() 2496 .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId, 2497 status, orderByComparator); 2498 } 2499 2500 /** 2501 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2502 * 2503 * @param groupId the group ID 2504 * @param folderIds the folder IDs 2505 * @param status the status 2506 * @return the matching bookmarks entries that the user has permission to view 2507 */ 2508 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2509 long groupId, long[] folderIds, int status) { 2510 return getPersistence().filterFindByG_F_S(groupId, folderIds, status); 2511 } 2512 2513 /** 2514 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2515 * 2516 * <p> 2517 * 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. 2518 * </p> 2519 * 2520 * @param groupId the group ID 2521 * @param folderIds the folder IDs 2522 * @param status the status 2523 * @param start the lower bound of the range of bookmarks entries 2524 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2525 * @return the range of matching bookmarks entries that the user has permission to view 2526 */ 2527 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2528 long groupId, long[] folderIds, int status, int start, int end) { 2529 return getPersistence() 2530 .filterFindByG_F_S(groupId, folderIds, status, start, end); 2531 } 2532 2533 /** 2534 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2535 * 2536 * <p> 2537 * 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. 2538 * </p> 2539 * 2540 * @param groupId the group ID 2541 * @param folderIds the folder IDs 2542 * @param status the status 2543 * @param start the lower bound of the range of bookmarks entries 2544 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2545 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2546 * @return the ordered range of matching bookmarks entries that the user has permission to view 2547 */ 2548 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 2549 long groupId, long[] folderIds, int status, int start, int end, 2550 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2551 return getPersistence() 2552 .filterFindByG_F_S(groupId, folderIds, status, start, end, 2553 orderByComparator); 2554 } 2555 2556 /** 2557 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2558 * 2559 * <p> 2560 * 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. 2561 * </p> 2562 * 2563 * @param groupId the group ID 2564 * @param folderIds the folder IDs 2565 * @param status the status 2566 * @return the matching bookmarks entries 2567 */ 2568 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2569 long groupId, long[] folderIds, int status) { 2570 return getPersistence().findByG_F_S(groupId, folderIds, status); 2571 } 2572 2573 /** 2574 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2575 * 2576 * <p> 2577 * 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. 2578 * </p> 2579 * 2580 * @param groupId the group ID 2581 * @param folderIds the folder IDs 2582 * @param status the status 2583 * @param start the lower bound of the range of bookmarks entries 2584 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2585 * @return the range of matching bookmarks entries 2586 */ 2587 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2588 long groupId, long[] folderIds, int status, int start, int end) { 2589 return getPersistence() 2590 .findByG_F_S(groupId, folderIds, status, start, end); 2591 } 2592 2593 /** 2594 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2595 * 2596 * <p> 2597 * 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. 2598 * </p> 2599 * 2600 * @param groupId the group ID 2601 * @param folderIds the folder IDs 2602 * @param status the status 2603 * @param start the lower bound of the range of bookmarks entries 2604 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2605 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2606 * @return the ordered range of matching bookmarks entries 2607 */ 2608 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 2609 long groupId, long[] folderIds, int status, int start, int end, 2610 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2611 return getPersistence() 2612 .findByG_F_S(groupId, folderIds, status, start, end, 2613 orderByComparator); 2614 } 2615 2616 /** 2617 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status = ? from the database. 2618 * 2619 * @param groupId the group ID 2620 * @param folderId the folder ID 2621 * @param status the status 2622 */ 2623 public static void removeByG_F_S(long groupId, long folderId, int status) { 2624 getPersistence().removeByG_F_S(groupId, folderId, status); 2625 } 2626 2627 /** 2628 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status = ?. 2629 * 2630 * @param groupId the group ID 2631 * @param folderId the folder ID 2632 * @param status the status 2633 * @return the number of matching bookmarks entries 2634 */ 2635 public static int countByG_F_S(long groupId, long folderId, int status) { 2636 return getPersistence().countByG_F_S(groupId, folderId, status); 2637 } 2638 2639 /** 2640 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status = ?. 2641 * 2642 * @param groupId the group ID 2643 * @param folderIds the folder IDs 2644 * @param status the status 2645 * @return the number of matching bookmarks entries 2646 */ 2647 public static int countByG_F_S(long groupId, long[] folderIds, int status) { 2648 return getPersistence().countByG_F_S(groupId, folderIds, status); 2649 } 2650 2651 /** 2652 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 2653 * 2654 * @param groupId the group ID 2655 * @param folderId the folder ID 2656 * @param status the status 2657 * @return the number of matching bookmarks entries that the user has permission to view 2658 */ 2659 public static int filterCountByG_F_S(long groupId, long folderId, int status) { 2660 return getPersistence().filterCountByG_F_S(groupId, folderId, status); 2661 } 2662 2663 /** 2664 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 2665 * 2666 * @param groupId the group ID 2667 * @param folderIds the folder IDs 2668 * @param status the status 2669 * @return the number of matching bookmarks entries that the user has permission to view 2670 */ 2671 public static int filterCountByG_F_S(long groupId, long[] folderIds, 2672 int status) { 2673 return getPersistence().filterCountByG_F_S(groupId, folderIds, status); 2674 } 2675 2676 /** 2677 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2678 * 2679 * @param groupId the group ID 2680 * @param folderId the folder ID 2681 * @param status the status 2682 * @return the matching bookmarks entries 2683 */ 2684 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2685 long groupId, long folderId, int status) { 2686 return getPersistence().findByG_F_NotS(groupId, folderId, status); 2687 } 2688 2689 /** 2690 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2691 * 2692 * <p> 2693 * 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. 2694 * </p> 2695 * 2696 * @param groupId the group ID 2697 * @param folderId the folder ID 2698 * @param status the status 2699 * @param start the lower bound of the range of bookmarks entries 2700 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2701 * @return the range of matching bookmarks entries 2702 */ 2703 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2704 long groupId, long folderId, int status, int start, int end) { 2705 return getPersistence() 2706 .findByG_F_NotS(groupId, folderId, status, start, end); 2707 } 2708 2709 /** 2710 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2711 * 2712 * <p> 2713 * 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. 2714 * </p> 2715 * 2716 * @param groupId the group ID 2717 * @param folderId the folder ID 2718 * @param status the status 2719 * @param start the lower bound of the range of bookmarks entries 2720 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2721 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2722 * @return the ordered range of matching bookmarks entries 2723 */ 2724 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2725 long groupId, long folderId, int status, int start, int end, 2726 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2727 return getPersistence() 2728 .findByG_F_NotS(groupId, folderId, status, start, end, 2729 orderByComparator); 2730 } 2731 2732 /** 2733 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2734 * 2735 * @param groupId the group ID 2736 * @param folderId the folder ID 2737 * @param status the status 2738 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2739 * @return the first matching bookmarks entry 2740 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2741 */ 2742 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First( 2743 long groupId, long folderId, int status, 2744 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2745 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2746 return getPersistence() 2747 .findByG_F_NotS_First(groupId, folderId, status, 2748 orderByComparator); 2749 } 2750 2751 /** 2752 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2753 * 2754 * @param groupId the group ID 2755 * @param folderId the folder ID 2756 * @param status the status 2757 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2758 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2759 */ 2760 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First( 2761 long groupId, long folderId, int status, 2762 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2763 return getPersistence() 2764 .fetchByG_F_NotS_First(groupId, folderId, status, 2765 orderByComparator); 2766 } 2767 2768 /** 2769 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2770 * 2771 * @param groupId the group ID 2772 * @param folderId the folder ID 2773 * @param status the status 2774 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2775 * @return the last matching bookmarks entry 2776 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2777 */ 2778 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last( 2779 long groupId, long folderId, int status, 2780 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2781 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2782 return getPersistence() 2783 .findByG_F_NotS_Last(groupId, folderId, status, 2784 orderByComparator); 2785 } 2786 2787 /** 2788 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2789 * 2790 * @param groupId the group ID 2791 * @param folderId the folder ID 2792 * @param status the status 2793 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2794 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2795 */ 2796 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last( 2797 long groupId, long folderId, int status, 2798 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2799 return getPersistence() 2800 .fetchByG_F_NotS_Last(groupId, folderId, status, 2801 orderByComparator); 2802 } 2803 2804 /** 2805 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2806 * 2807 * @param entryId the primary key of the current bookmarks entry 2808 * @param groupId the group ID 2809 * @param folderId the folder ID 2810 * @param status the status 2811 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2812 * @return the previous, current, and next bookmarks entry 2813 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2814 */ 2815 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext( 2816 long entryId, long groupId, long folderId, int status, 2817 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2818 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2819 return getPersistence() 2820 .findByG_F_NotS_PrevAndNext(entryId, groupId, folderId, 2821 status, orderByComparator); 2822 } 2823 2824 /** 2825 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2826 * 2827 * @param groupId the group ID 2828 * @param folderId the folder ID 2829 * @param status the status 2830 * @return the matching bookmarks entries that the user has permission to view 2831 */ 2832 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2833 long groupId, long folderId, int status) { 2834 return getPersistence().filterFindByG_F_NotS(groupId, folderId, status); 2835 } 2836 2837 /** 2838 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2839 * 2840 * <p> 2841 * 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. 2842 * </p> 2843 * 2844 * @param groupId the group ID 2845 * @param folderId the folder ID 2846 * @param status the status 2847 * @param start the lower bound of the range of bookmarks entries 2848 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2849 * @return the range of matching bookmarks entries that the user has permission to view 2850 */ 2851 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2852 long groupId, long folderId, int status, int start, int end) { 2853 return getPersistence() 2854 .filterFindByG_F_NotS(groupId, folderId, status, start, end); 2855 } 2856 2857 /** 2858 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status ≠ ?. 2859 * 2860 * <p> 2861 * 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. 2862 * </p> 2863 * 2864 * @param groupId the group ID 2865 * @param folderId the folder ID 2866 * @param status the status 2867 * @param start the lower bound of the range of bookmarks entries 2868 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2869 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2870 * @return the ordered range of matching bookmarks entries that the user has permission to view 2871 */ 2872 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2873 long groupId, long folderId, int status, int start, int end, 2874 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2875 return getPersistence() 2876 .filterFindByG_F_NotS(groupId, folderId, status, start, end, 2877 orderByComparator); 2878 } 2879 2880 /** 2881 * 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 = ? and status ≠ ?. 2882 * 2883 * @param entryId the primary key of the current bookmarks entry 2884 * @param groupId the group ID 2885 * @param folderId the folder ID 2886 * @param status the status 2887 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2888 * @return the previous, current, and next bookmarks entry 2889 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2890 */ 2891 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext( 2892 long entryId, long groupId, long folderId, int status, 2893 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 2894 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 2895 return getPersistence() 2896 .filterFindByG_F_NotS_PrevAndNext(entryId, groupId, 2897 folderId, status, orderByComparator); 2898 } 2899 2900 /** 2901 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2902 * 2903 * @param groupId the group ID 2904 * @param folderIds the folder IDs 2905 * @param status the status 2906 * @return the matching bookmarks entries that the user has permission to view 2907 */ 2908 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2909 long groupId, long[] folderIds, int status) { 2910 return getPersistence().filterFindByG_F_NotS(groupId, folderIds, status); 2911 } 2912 2913 /** 2914 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2915 * 2916 * <p> 2917 * 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. 2918 * </p> 2919 * 2920 * @param groupId the group ID 2921 * @param folderIds the folder IDs 2922 * @param status the status 2923 * @param start the lower bound of the range of bookmarks entries 2924 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2925 * @return the range of matching bookmarks entries that the user has permission to view 2926 */ 2927 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2928 long groupId, long[] folderIds, int status, int start, int end) { 2929 return getPersistence() 2930 .filterFindByG_F_NotS(groupId, folderIds, status, start, end); 2931 } 2932 2933 /** 2934 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2935 * 2936 * <p> 2937 * 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. 2938 * </p> 2939 * 2940 * @param groupId the group ID 2941 * @param folderIds the folder IDs 2942 * @param status the status 2943 * @param start the lower bound of the range of bookmarks entries 2944 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2945 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2946 * @return the ordered range of matching bookmarks entries that the user has permission to view 2947 */ 2948 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2949 long groupId, long[] folderIds, int status, int start, int end, 2950 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 2951 return getPersistence() 2952 .filterFindByG_F_NotS(groupId, folderIds, status, start, 2953 end, orderByComparator); 2954 } 2955 2956 /** 2957 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2958 * 2959 * <p> 2960 * 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. 2961 * </p> 2962 * 2963 * @param groupId the group ID 2964 * @param folderIds the folder IDs 2965 * @param status the status 2966 * @return the matching bookmarks entries 2967 */ 2968 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2969 long groupId, long[] folderIds, int status) { 2970 return getPersistence().findByG_F_NotS(groupId, folderIds, status); 2971 } 2972 2973 /** 2974 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2975 * 2976 * <p> 2977 * 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. 2978 * </p> 2979 * 2980 * @param groupId the group ID 2981 * @param folderIds the folder IDs 2982 * @param status the status 2983 * @param start the lower bound of the range of bookmarks entries 2984 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2985 * @return the range of matching bookmarks entries 2986 */ 2987 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2988 long groupId, long[] folderIds, int status, int start, int end) { 2989 return getPersistence() 2990 .findByG_F_NotS(groupId, folderIds, status, start, end); 2991 } 2992 2993 /** 2994 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2995 * 2996 * <p> 2997 * 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. 2998 * </p> 2999 * 3000 * @param groupId the group ID 3001 * @param folderIds the folder IDs 3002 * @param status the status 3003 * @param start the lower bound of the range of bookmarks entries 3004 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3005 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3006 * @return the ordered range of matching bookmarks entries 3007 */ 3008 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 3009 long groupId, long[] folderIds, int status, int start, int end, 3010 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3011 return getPersistence() 3012 .findByG_F_NotS(groupId, folderIds, status, start, end, 3013 orderByComparator); 3014 } 3015 3016 /** 3017 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ? from the database. 3018 * 3019 * @param groupId the group ID 3020 * @param folderId the folder ID 3021 * @param status the status 3022 */ 3023 public static void removeByG_F_NotS(long groupId, long folderId, int status) { 3024 getPersistence().removeByG_F_NotS(groupId, folderId, status); 3025 } 3026 3027 /** 3028 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 3029 * 3030 * @param groupId the group ID 3031 * @param folderId the folder ID 3032 * @param status the status 3033 * @return the number of matching bookmarks entries 3034 */ 3035 public static int countByG_F_NotS(long groupId, long folderId, int status) { 3036 return getPersistence().countByG_F_NotS(groupId, folderId, status); 3037 } 3038 3039 /** 3040 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 3041 * 3042 * @param groupId the group ID 3043 * @param folderIds the folder IDs 3044 * @param status the status 3045 * @return the number of matching bookmarks entries 3046 */ 3047 public static int countByG_F_NotS(long groupId, long[] folderIds, int status) { 3048 return getPersistence().countByG_F_NotS(groupId, folderIds, status); 3049 } 3050 3051 /** 3052 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 3053 * 3054 * @param groupId the group ID 3055 * @param folderId the folder ID 3056 * @param status the status 3057 * @return the number of matching bookmarks entries that the user has permission to view 3058 */ 3059 public static int filterCountByG_F_NotS(long groupId, long folderId, 3060 int status) { 3061 return getPersistence().filterCountByG_F_NotS(groupId, folderId, status); 3062 } 3063 3064 /** 3065 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 3066 * 3067 * @param groupId the group ID 3068 * @param folderIds the folder IDs 3069 * @param status the status 3070 * @return the number of matching bookmarks entries that the user has permission to view 3071 */ 3072 public static int filterCountByG_F_NotS(long groupId, long[] folderIds, 3073 int status) { 3074 return getPersistence().filterCountByG_F_NotS(groupId, folderIds, status); 3075 } 3076 3077 /** 3078 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 3079 * 3080 * @param groupId the group ID 3081 * @param userId the user ID 3082 * @param folderId the folder ID 3083 * @param status the status 3084 * @return the matching bookmarks entries 3085 */ 3086 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3087 long groupId, long userId, long folderId, int status) { 3088 return getPersistence().findByG_U_F_S(groupId, userId, folderId, status); 3089 } 3090 3091 /** 3092 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 3093 * 3094 * <p> 3095 * 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. 3096 * </p> 3097 * 3098 * @param groupId the group ID 3099 * @param userId the user ID 3100 * @param folderId the folder ID 3101 * @param status the status 3102 * @param start the lower bound of the range of bookmarks entries 3103 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3104 * @return the range of matching bookmarks entries 3105 */ 3106 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3107 long groupId, long userId, long folderId, int status, int start, int end) { 3108 return getPersistence() 3109 .findByG_U_F_S(groupId, userId, folderId, status, start, end); 3110 } 3111 3112 /** 3113 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 3114 * 3115 * <p> 3116 * 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. 3117 * </p> 3118 * 3119 * @param groupId the group ID 3120 * @param userId the user ID 3121 * @param folderId the folder ID 3122 * @param status the status 3123 * @param start the lower bound of the range of bookmarks entries 3124 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3125 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3126 * @return the ordered range of matching bookmarks entries 3127 */ 3128 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3129 long groupId, long userId, long folderId, int status, int start, 3130 int end, 3131 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3132 return getPersistence() 3133 .findByG_U_F_S(groupId, userId, folderId, status, start, 3134 end, orderByComparator); 3135 } 3136 3137 /** 3138 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 3139 * 3140 * @param groupId the group ID 3141 * @param userId the user ID 3142 * @param folderId the folder ID 3143 * @param status the status 3144 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3145 * @return the first matching bookmarks entry 3146 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 3147 */ 3148 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First( 3149 long groupId, long userId, long folderId, int status, 3150 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 3151 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 3152 return getPersistence() 3153 .findByG_U_F_S_First(groupId, userId, folderId, status, 3154 orderByComparator); 3155 } 3156 3157 /** 3158 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 3159 * 3160 * @param groupId the group ID 3161 * @param userId the user ID 3162 * @param folderId the folder ID 3163 * @param status the status 3164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3165 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 3166 */ 3167 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First( 3168 long groupId, long userId, long folderId, int status, 3169 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3170 return getPersistence() 3171 .fetchByG_U_F_S_First(groupId, userId, folderId, status, 3172 orderByComparator); 3173 } 3174 3175 /** 3176 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 3177 * 3178 * @param groupId the group ID 3179 * @param userId the user ID 3180 * @param folderId the folder ID 3181 * @param status the status 3182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3183 * @return the last matching bookmarks entry 3184 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 3185 */ 3186 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last( 3187 long groupId, long userId, long folderId, int status, 3188 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 3189 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 3190 return getPersistence() 3191 .findByG_U_F_S_Last(groupId, userId, folderId, status, 3192 orderByComparator); 3193 } 3194 3195 /** 3196 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 3197 * 3198 * @param groupId the group ID 3199 * @param userId the user ID 3200 * @param folderId the folder ID 3201 * @param status the status 3202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3203 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 3204 */ 3205 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last( 3206 long groupId, long userId, long folderId, int status, 3207 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3208 return getPersistence() 3209 .fetchByG_U_F_S_Last(groupId, userId, folderId, status, 3210 orderByComparator); 3211 } 3212 3213 /** 3214 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 3215 * 3216 * @param entryId the primary key of the current bookmarks entry 3217 * @param groupId the group ID 3218 * @param userId the user ID 3219 * @param folderId the folder ID 3220 * @param status the status 3221 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3222 * @return the previous, current, and next bookmarks entry 3223 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3224 */ 3225 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext( 3226 long entryId, long groupId, long userId, long folderId, int status, 3227 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 3228 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 3229 return getPersistence() 3230 .findByG_U_F_S_PrevAndNext(entryId, groupId, userId, 3231 folderId, status, orderByComparator); 3232 } 3233 3234 /** 3235 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3236 * 3237 * @param groupId the group ID 3238 * @param userId the user ID 3239 * @param folderId the folder ID 3240 * @param status the status 3241 * @return the matching bookmarks entries that the user has permission to view 3242 */ 3243 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3244 long groupId, long userId, long folderId, int status) { 3245 return getPersistence() 3246 .filterFindByG_U_F_S(groupId, userId, folderId, status); 3247 } 3248 3249 /** 3250 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3251 * 3252 * <p> 3253 * 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. 3254 * </p> 3255 * 3256 * @param groupId the group ID 3257 * @param userId the user ID 3258 * @param folderId the folder ID 3259 * @param status the status 3260 * @param start the lower bound of the range of bookmarks entries 3261 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3262 * @return the range of matching bookmarks entries that the user has permission to view 3263 */ 3264 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3265 long groupId, long userId, long folderId, int status, int start, int end) { 3266 return getPersistence() 3267 .filterFindByG_U_F_S(groupId, userId, folderId, status, 3268 start, end); 3269 } 3270 3271 /** 3272 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3273 * 3274 * <p> 3275 * 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. 3276 * </p> 3277 * 3278 * @param groupId the group ID 3279 * @param userId the user ID 3280 * @param folderId the folder ID 3281 * @param status the status 3282 * @param start the lower bound of the range of bookmarks entries 3283 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3284 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3285 * @return the ordered range of matching bookmarks entries that the user has permission to view 3286 */ 3287 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3288 long groupId, long userId, long folderId, int status, int start, 3289 int end, 3290 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3291 return getPersistence() 3292 .filterFindByG_U_F_S(groupId, userId, folderId, status, 3293 start, end, orderByComparator); 3294 } 3295 3296 /** 3297 * 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 = ? and folderId = ? and status = ?. 3298 * 3299 * @param entryId the primary key of the current bookmarks entry 3300 * @param groupId the group ID 3301 * @param userId the user ID 3302 * @param folderId the folder ID 3303 * @param status the status 3304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3305 * @return the previous, current, and next bookmarks entry 3306 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3307 */ 3308 public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext( 3309 long entryId, long groupId, long userId, long folderId, int status, 3310 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) 3311 throws com.liferay.portlet.bookmarks.NoSuchEntryException { 3312 return getPersistence() 3313 .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId, 3314 folderId, status, orderByComparator); 3315 } 3316 3317 /** 3318 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3319 * 3320 * @param groupId the group ID 3321 * @param userId the user ID 3322 * @param folderIds the folder IDs 3323 * @param status the status 3324 * @return the matching bookmarks entries that the user has permission to view 3325 */ 3326 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3327 long groupId, long userId, long[] folderIds, int status) { 3328 return getPersistence() 3329 .filterFindByG_U_F_S(groupId, userId, folderIds, status); 3330 } 3331 3332 /** 3333 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3334 * 3335 * <p> 3336 * 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. 3337 * </p> 3338 * 3339 * @param groupId the group ID 3340 * @param userId the user ID 3341 * @param folderIds the folder IDs 3342 * @param status the status 3343 * @param start the lower bound of the range of bookmarks entries 3344 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3345 * @return the range of matching bookmarks entries that the user has permission to view 3346 */ 3347 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3348 long groupId, long userId, long[] folderIds, int status, int start, 3349 int end) { 3350 return getPersistence() 3351 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 3352 start, end); 3353 } 3354 3355 /** 3356 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3357 * 3358 * <p> 3359 * 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. 3360 * </p> 3361 * 3362 * @param groupId the group ID 3363 * @param userId the user ID 3364 * @param folderIds the folder IDs 3365 * @param status the status 3366 * @param start the lower bound of the range of bookmarks entries 3367 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3368 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3369 * @return the ordered range of matching bookmarks entries that the user has permission to view 3370 */ 3371 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 3372 long groupId, long userId, long[] folderIds, int status, int start, 3373 int end, 3374 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3375 return getPersistence() 3376 .filterFindByG_U_F_S(groupId, userId, folderIds, status, 3377 start, end, orderByComparator); 3378 } 3379 3380 /** 3381 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3382 * 3383 * <p> 3384 * 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. 3385 * </p> 3386 * 3387 * @param groupId the group ID 3388 * @param userId the user ID 3389 * @param folderIds the folder IDs 3390 * @param status the status 3391 * @return the matching bookmarks entries 3392 */ 3393 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3394 long groupId, long userId, long[] folderIds, int status) { 3395 return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status); 3396 } 3397 3398 /** 3399 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3400 * 3401 * <p> 3402 * 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. 3403 * </p> 3404 * 3405 * @param groupId the group ID 3406 * @param userId the user ID 3407 * @param folderIds the folder IDs 3408 * @param status the status 3409 * @param start the lower bound of the range of bookmarks entries 3410 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3411 * @return the range of matching bookmarks entries 3412 */ 3413 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3414 long groupId, long userId, long[] folderIds, int status, int start, 3415 int end) { 3416 return getPersistence() 3417 .findByG_U_F_S(groupId, userId, folderIds, status, start, end); 3418 } 3419 3420 /** 3421 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3422 * 3423 * <p> 3424 * 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. 3425 * </p> 3426 * 3427 * @param groupId the group ID 3428 * @param userId the user ID 3429 * @param folderIds the folder IDs 3430 * @param status the status 3431 * @param start the lower bound of the range of bookmarks entries 3432 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3433 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3434 * @return the ordered range of matching bookmarks entries 3435 */ 3436 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 3437 long groupId, long userId, long[] folderIds, int status, int start, 3438 int end, 3439 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3440 return getPersistence() 3441 .findByG_U_F_S(groupId, userId, folderIds, status, start, 3442 end, orderByComparator); 3443 } 3444 3445 /** 3446 * Removes all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ? from the database. 3447 * 3448 * @param groupId the group ID 3449 * @param userId the user ID 3450 * @param folderId the folder ID 3451 * @param status the status 3452 */ 3453 public static void removeByG_U_F_S(long groupId, long userId, 3454 long folderId, int status) { 3455 getPersistence().removeByG_U_F_S(groupId, userId, folderId, status); 3456 } 3457 3458 /** 3459 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 3460 * 3461 * @param groupId the group ID 3462 * @param userId the user ID 3463 * @param folderId the folder ID 3464 * @param status the status 3465 * @return the number of matching bookmarks entries 3466 */ 3467 public static int countByG_U_F_S(long groupId, long userId, long folderId, 3468 int status) { 3469 return getPersistence().countByG_U_F_S(groupId, userId, folderId, status); 3470 } 3471 3472 /** 3473 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 3474 * 3475 * @param groupId the group ID 3476 * @param userId the user ID 3477 * @param folderIds the folder IDs 3478 * @param status the status 3479 * @return the number of matching bookmarks entries 3480 */ 3481 public static int countByG_U_F_S(long groupId, long userId, 3482 long[] folderIds, int status) { 3483 return getPersistence() 3484 .countByG_U_F_S(groupId, userId, folderIds, status); 3485 } 3486 3487 /** 3488 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 3489 * 3490 * @param groupId the group ID 3491 * @param userId the user ID 3492 * @param folderId the folder ID 3493 * @param status the status 3494 * @return the number of matching bookmarks entries that the user has permission to view 3495 */ 3496 public static int filterCountByG_U_F_S(long groupId, long userId, 3497 long folderId, int status) { 3498 return getPersistence() 3499 .filterCountByG_U_F_S(groupId, userId, folderId, status); 3500 } 3501 3502 /** 3503 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 3504 * 3505 * @param groupId the group ID 3506 * @param userId the user ID 3507 * @param folderIds the folder IDs 3508 * @param status the status 3509 * @return the number of matching bookmarks entries that the user has permission to view 3510 */ 3511 public static int filterCountByG_U_F_S(long groupId, long userId, 3512 long[] folderIds, int status) { 3513 return getPersistence() 3514 .filterCountByG_U_F_S(groupId, userId, folderIds, status); 3515 } 3516 3517 /** 3518 * Caches the bookmarks entry in the entity cache if it is enabled. 3519 * 3520 * @param bookmarksEntry the bookmarks entry 3521 */ 3522 public static void cacheResult( 3523 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 3524 getPersistence().cacheResult(bookmarksEntry); 3525 } 3526 3527 /** 3528 * Caches the bookmarks entries in the entity cache if it is enabled. 3529 * 3530 * @param bookmarksEntries the bookmarks entries 3531 */ 3532 public static void cacheResult( 3533 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) { 3534 getPersistence().cacheResult(bookmarksEntries); 3535 } 3536 3537 /** 3538 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 3539 * 3540 * @param entryId the primary key for the new bookmarks entry 3541 * @return the new bookmarks entry 3542 */ 3543 public static com.liferay.portlet.bookmarks.model.BookmarksEntry create( 3544 long entryId) { 3545 return getPersistence().create(entryId); 3546 } 3547 3548 /** 3549 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 3550 * 3551 * @param entryId the primary key of the bookmarks entry 3552 * @return the bookmarks entry that was removed 3553 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3554 */ 3555 public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 3556 long entryId) throws com.liferay.portlet.bookmarks.NoSuchEntryException { 3557 return getPersistence().remove(entryId); 3558 } 3559 3560 public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 3561 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) { 3562 return getPersistence().updateImpl(bookmarksEntry); 3563 } 3564 3565 /** 3566 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 3567 * 3568 * @param entryId the primary key of the bookmarks entry 3569 * @return the bookmarks entry 3570 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 3571 */ 3572 public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 3573 long entryId) throws com.liferay.portlet.bookmarks.NoSuchEntryException { 3574 return getPersistence().findByPrimaryKey(entryId); 3575 } 3576 3577 /** 3578 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 3579 * 3580 * @param entryId the primary key of the bookmarks entry 3581 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 3582 */ 3583 public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 3584 long entryId) { 3585 return getPersistence().fetchByPrimaryKey(entryId); 3586 } 3587 3588 public static java.util.Map<java.io.Serializable, com.liferay.portlet.bookmarks.model.BookmarksEntry> fetchByPrimaryKeys( 3589 java.util.Set<java.io.Serializable> primaryKeys) { 3590 return getPersistence().fetchByPrimaryKeys(primaryKeys); 3591 } 3592 3593 /** 3594 * Returns all the bookmarks entries. 3595 * 3596 * @return the bookmarks entries 3597 */ 3598 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() { 3599 return getPersistence().findAll(); 3600 } 3601 3602 /** 3603 * Returns a range of all the bookmarks entries. 3604 * 3605 * <p> 3606 * 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. 3607 * </p> 3608 * 3609 * @param start the lower bound of the range of bookmarks entries 3610 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3611 * @return the range of bookmarks entries 3612 */ 3613 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 3614 int start, int end) { 3615 return getPersistence().findAll(start, end); 3616 } 3617 3618 /** 3619 * Returns an ordered range of all the bookmarks entries. 3620 * 3621 * <p> 3622 * 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. 3623 * </p> 3624 * 3625 * @param start the lower bound of the range of bookmarks entries 3626 * @param end the upper bound of the range of bookmarks entries (not inclusive) 3627 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3628 * @return the ordered range of bookmarks entries 3629 */ 3630 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 3631 int start, int end, 3632 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) { 3633 return getPersistence().findAll(start, end, orderByComparator); 3634 } 3635 3636 /** 3637 * Removes all the bookmarks entries from the database. 3638 */ 3639 public static void removeAll() { 3640 getPersistence().removeAll(); 3641 } 3642 3643 /** 3644 * Returns the number of bookmarks entries. 3645 * 3646 * @return the number of bookmarks entries 3647 */ 3648 public static int countAll() { 3649 return getPersistence().countAll(); 3650 } 3651 3652 public static BookmarksEntryPersistence getPersistence() { 3653 if (_persistence == null) { 3654 _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName()); 3655 3656 ReferenceRegistry.registerReference(BookmarksEntryUtil.class, 3657 "_persistence"); 3658 } 3659 3660 return _persistence; 3661 } 3662 3663 /** 3664 * @deprecated As of 6.2.0 3665 */ 3666 @Deprecated 3667 public void setPersistence(BookmarksEntryPersistence persistence) { 3668 } 3669 3670 private static BookmarksEntryPersistence _persistence; 3671 }