001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.bookmarks.service.persistence; 016 017 import com.liferay.portal.service.persistence.BasePersistence; 018 019 import com.liferay.portlet.bookmarks.model.BookmarksEntry; 020 021 /** 022 * The persistence interface for the bookmarks entry service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see BookmarksEntryPersistenceImpl 030 * @see BookmarksEntryUtil 031 * @generated 032 */ 033 public interface BookmarksEntryPersistence extends BasePersistence<BookmarksEntry> { 034 /* 035 * NOTE FOR DEVELOPERS: 036 * 037 * Never modify or reference this interface directly. Always use {@link BookmarksEntryUtil} to access the bookmarks entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 038 */ 039 040 /** 041 * Returns all the bookmarks entries where resourceBlockId = ?. 042 * 043 * @param resourceBlockId the resource block ID 044 * @return the matching bookmarks entries 045 * @throws SystemException if a system exception occurred 046 */ 047 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 048 long resourceBlockId) 049 throws com.liferay.portal.kernel.exception.SystemException; 050 051 /** 052 * Returns a range of all the bookmarks entries where resourceBlockId = ?. 053 * 054 * <p> 055 * 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. 056 * </p> 057 * 058 * @param resourceBlockId the resource block ID 059 * @param start the lower bound of the range of bookmarks entries 060 * @param end the upper bound of the range of bookmarks entries (not inclusive) 061 * @return the range of matching bookmarks entries 062 * @throws SystemException if a system exception occurred 063 */ 064 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 065 long resourceBlockId, int start, int end) 066 throws com.liferay.portal.kernel.exception.SystemException; 067 068 /** 069 * Returns an ordered range of all the bookmarks entries where resourceBlockId = ?. 070 * 071 * <p> 072 * 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. 073 * </p> 074 * 075 * @param resourceBlockId the resource block ID 076 * @param start the lower bound of the range of bookmarks entries 077 * @param end the upper bound of the range of bookmarks entries (not inclusive) 078 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 079 * @return the ordered range of matching bookmarks entries 080 * @throws SystemException if a system exception occurred 081 */ 082 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 083 long resourceBlockId, int start, int end, 084 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 085 throws com.liferay.portal.kernel.exception.SystemException; 086 087 /** 088 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 089 * 090 * @param resourceBlockId the resource block ID 091 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 092 * @return the first matching bookmarks entry 093 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 094 * @throws SystemException if a system exception occurred 095 */ 096 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First( 097 long resourceBlockId, 098 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 099 throws com.liferay.portal.kernel.exception.SystemException, 100 com.liferay.portlet.bookmarks.NoSuchEntryException; 101 102 /** 103 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 104 * 105 * @param resourceBlockId the resource block ID 106 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 107 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 108 * @throws SystemException if a system exception occurred 109 */ 110 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First( 111 long resourceBlockId, 112 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 113 throws com.liferay.portal.kernel.exception.SystemException; 114 115 /** 116 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 117 * 118 * @param resourceBlockId the resource block ID 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the last matching bookmarks entry 121 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 122 * @throws SystemException if a system exception occurred 123 */ 124 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last( 125 long resourceBlockId, 126 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 127 throws com.liferay.portal.kernel.exception.SystemException, 128 com.liferay.portlet.bookmarks.NoSuchEntryException; 129 130 /** 131 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 132 * 133 * @param resourceBlockId the resource block ID 134 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 135 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 136 * @throws SystemException if a system exception occurred 137 */ 138 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last( 139 long resourceBlockId, 140 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 141 throws com.liferay.portal.kernel.exception.SystemException; 142 143 /** 144 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = ?. 145 * 146 * @param entryId the primary key of the current bookmarks entry 147 * @param resourceBlockId the resource block ID 148 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 149 * @return the previous, current, and next bookmarks entry 150 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 151 * @throws SystemException if a system exception occurred 152 */ 153 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext( 154 long entryId, long resourceBlockId, 155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 156 throws com.liferay.portal.kernel.exception.SystemException, 157 com.liferay.portlet.bookmarks.NoSuchEntryException; 158 159 /** 160 * Removes all the bookmarks entries where resourceBlockId = ? from the database. 161 * 162 * @param resourceBlockId the resource block ID 163 * @throws SystemException if a system exception occurred 164 */ 165 public void removeByResourceBlockId(long resourceBlockId) 166 throws com.liferay.portal.kernel.exception.SystemException; 167 168 /** 169 * Returns the number of bookmarks entries where resourceBlockId = ?. 170 * 171 * @param resourceBlockId the resource block ID 172 * @return the number of matching bookmarks entries 173 * @throws SystemException if a system exception occurred 174 */ 175 public int countByResourceBlockId(long resourceBlockId) 176 throws com.liferay.portal.kernel.exception.SystemException; 177 178 /** 179 * Returns all the bookmarks entries where uuid = ?. 180 * 181 * @param uuid the uuid 182 * @return the matching bookmarks entries 183 * @throws SystemException if a system exception occurred 184 */ 185 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 186 java.lang.String uuid) 187 throws com.liferay.portal.kernel.exception.SystemException; 188 189 /** 190 * Returns a range of all the bookmarks entries where uuid = ?. 191 * 192 * <p> 193 * 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. 194 * </p> 195 * 196 * @param uuid the uuid 197 * @param start the lower bound of the range of bookmarks entries 198 * @param end the upper bound of the range of bookmarks entries (not inclusive) 199 * @return the range of matching bookmarks entries 200 * @throws SystemException if a system exception occurred 201 */ 202 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 203 java.lang.String uuid, int start, int end) 204 throws com.liferay.portal.kernel.exception.SystemException; 205 206 /** 207 * Returns an ordered range of all the bookmarks entries where uuid = ?. 208 * 209 * <p> 210 * 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. 211 * </p> 212 * 213 * @param uuid the uuid 214 * @param start the lower bound of the range of bookmarks entries 215 * @param end the upper bound of the range of bookmarks entries (not inclusive) 216 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 217 * @return the ordered range of matching bookmarks entries 218 * @throws SystemException if a system exception occurred 219 */ 220 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 221 java.lang.String uuid, int start, int end, 222 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 223 throws com.liferay.portal.kernel.exception.SystemException; 224 225 /** 226 * Returns the first bookmarks entry in the ordered set where uuid = ?. 227 * 228 * @param uuid the uuid 229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 230 * @return the first matching bookmarks entry 231 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 232 * @throws SystemException if a system exception occurred 233 */ 234 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First( 235 java.lang.String uuid, 236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 237 throws com.liferay.portal.kernel.exception.SystemException, 238 com.liferay.portlet.bookmarks.NoSuchEntryException; 239 240 /** 241 * Returns the first bookmarks entry in the ordered set where uuid = ?. 242 * 243 * @param uuid the uuid 244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 245 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 246 * @throws SystemException if a system exception occurred 247 */ 248 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First( 249 java.lang.String uuid, 250 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 251 throws com.liferay.portal.kernel.exception.SystemException; 252 253 /** 254 * Returns the last bookmarks entry in the ordered set where uuid = ?. 255 * 256 * @param uuid the uuid 257 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 258 * @return the last matching bookmarks entry 259 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 260 * @throws SystemException if a system exception occurred 261 */ 262 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last( 263 java.lang.String uuid, 264 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 265 throws com.liferay.portal.kernel.exception.SystemException, 266 com.liferay.portlet.bookmarks.NoSuchEntryException; 267 268 /** 269 * Returns the last bookmarks entry in the ordered set where uuid = ?. 270 * 271 * @param uuid the uuid 272 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 273 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 274 * @throws SystemException if a system exception occurred 275 */ 276 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last( 277 java.lang.String uuid, 278 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 279 throws com.liferay.portal.kernel.exception.SystemException; 280 281 /** 282 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ?. 283 * 284 * @param entryId the primary key of the current bookmarks entry 285 * @param uuid the uuid 286 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 287 * @return the previous, current, and next bookmarks entry 288 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 289 * @throws SystemException if a system exception occurred 290 */ 291 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext( 292 long entryId, java.lang.String uuid, 293 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 294 throws com.liferay.portal.kernel.exception.SystemException, 295 com.liferay.portlet.bookmarks.NoSuchEntryException; 296 297 /** 298 * Removes all the bookmarks entries where uuid = ? from the database. 299 * 300 * @param uuid the uuid 301 * @throws SystemException if a system exception occurred 302 */ 303 public void removeByUuid(java.lang.String uuid) 304 throws com.liferay.portal.kernel.exception.SystemException; 305 306 /** 307 * Returns the number of bookmarks entries where uuid = ?. 308 * 309 * @param uuid the uuid 310 * @return the number of matching bookmarks entries 311 * @throws SystemException if a system exception occurred 312 */ 313 public int countByUuid(java.lang.String uuid) 314 throws com.liferay.portal.kernel.exception.SystemException; 315 316 /** 317 * Returns the bookmarks entry where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 318 * 319 * @param uuid the uuid 320 * @param groupId the group ID 321 * @return the matching bookmarks entry 322 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 323 * @throws SystemException if a system exception occurred 324 */ 325 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.bookmarks.NoSuchEntryException; 329 330 /** 331 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 332 * 333 * @param uuid the uuid 334 * @param groupId the group ID 335 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 336 * @throws SystemException if a system exception occurred 337 */ 338 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 339 java.lang.String uuid, long groupId) 340 throws com.liferay.portal.kernel.exception.SystemException; 341 342 /** 343 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 344 * 345 * @param uuid the uuid 346 * @param groupId the group ID 347 * @param retrieveFromCache whether to use the finder cache 348 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 349 * @throws SystemException if a system exception occurred 350 */ 351 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 352 java.lang.String uuid, long groupId, boolean retrieveFromCache) 353 throws com.liferay.portal.kernel.exception.SystemException; 354 355 /** 356 * Removes the bookmarks entry where uuid = ? and groupId = ? from the database. 357 * 358 * @param uuid the uuid 359 * @param groupId the group ID 360 * @return the bookmarks entry that was removed 361 * @throws SystemException if a system exception occurred 362 */ 363 public com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G( 364 java.lang.String uuid, long groupId) 365 throws com.liferay.portal.kernel.exception.SystemException, 366 com.liferay.portlet.bookmarks.NoSuchEntryException; 367 368 /** 369 * Returns the number of bookmarks entries where uuid = ? and groupId = ?. 370 * 371 * @param uuid the uuid 372 * @param groupId the group ID 373 * @return the number of matching bookmarks entries 374 * @throws SystemException if a system exception occurred 375 */ 376 public int countByUUID_G(java.lang.String uuid, long groupId) 377 throws com.liferay.portal.kernel.exception.SystemException; 378 379 /** 380 * Returns all the bookmarks entries where uuid = ? and companyId = ?. 381 * 382 * @param uuid the uuid 383 * @param companyId the company ID 384 * @return the matching bookmarks entries 385 * @throws SystemException if a system exception occurred 386 */ 387 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 388 java.lang.String uuid, long companyId) 389 throws com.liferay.portal.kernel.exception.SystemException; 390 391 /** 392 * Returns a range of all the bookmarks entries where uuid = ? and companyId = ?. 393 * 394 * <p> 395 * 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. 396 * </p> 397 * 398 * @param uuid the uuid 399 * @param companyId the company ID 400 * @param start the lower bound of the range of bookmarks entries 401 * @param end the upper bound of the range of bookmarks entries (not inclusive) 402 * @return the range of matching bookmarks entries 403 * @throws SystemException if a system exception occurred 404 */ 405 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 406 java.lang.String uuid, long companyId, int start, int end) 407 throws com.liferay.portal.kernel.exception.SystemException; 408 409 /** 410 * Returns an ordered range of all the bookmarks entries where uuid = ? and companyId = ?. 411 * 412 * <p> 413 * 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. 414 * </p> 415 * 416 * @param uuid the uuid 417 * @param companyId the company ID 418 * @param start the lower bound of the range of bookmarks entries 419 * @param end the upper bound of the range of bookmarks entries (not inclusive) 420 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 421 * @return the ordered range of matching bookmarks entries 422 * @throws SystemException if a system exception occurred 423 */ 424 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 425 java.lang.String uuid, long companyId, int start, int end, 426 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 427 throws com.liferay.portal.kernel.exception.SystemException; 428 429 /** 430 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 431 * 432 * @param uuid the uuid 433 * @param companyId the company ID 434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 435 * @return the first matching bookmarks entry 436 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 437 * @throws SystemException if a system exception occurred 438 */ 439 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First( 440 java.lang.String uuid, long companyId, 441 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 442 throws com.liferay.portal.kernel.exception.SystemException, 443 com.liferay.portlet.bookmarks.NoSuchEntryException; 444 445 /** 446 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 447 * 448 * @param uuid the uuid 449 * @param companyId the company ID 450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 451 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 452 * @throws SystemException if a system exception occurred 453 */ 454 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First( 455 java.lang.String uuid, long companyId, 456 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 457 throws com.liferay.portal.kernel.exception.SystemException; 458 459 /** 460 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 461 * 462 * @param uuid the uuid 463 * @param companyId the company ID 464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 465 * @return the last matching bookmarks entry 466 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 467 * @throws SystemException if a system exception occurred 468 */ 469 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last( 470 java.lang.String uuid, long companyId, 471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 472 throws com.liferay.portal.kernel.exception.SystemException, 473 com.liferay.portlet.bookmarks.NoSuchEntryException; 474 475 /** 476 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 477 * 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 482 * @throws SystemException if a system exception occurred 483 */ 484 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last( 485 java.lang.String uuid, long companyId, 486 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 487 throws com.liferay.portal.kernel.exception.SystemException; 488 489 /** 490 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ? and companyId = ?. 491 * 492 * @param entryId the primary key of the current bookmarks entry 493 * @param uuid the uuid 494 * @param companyId the company ID 495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 496 * @return the previous, current, and next bookmarks entry 497 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 498 * @throws SystemException if a system exception occurred 499 */ 500 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext( 501 long entryId, java.lang.String uuid, long companyId, 502 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 503 throws com.liferay.portal.kernel.exception.SystemException, 504 com.liferay.portlet.bookmarks.NoSuchEntryException; 505 506 /** 507 * Removes all the bookmarks entries where uuid = ? and companyId = ? from the database. 508 * 509 * @param uuid the uuid 510 * @param companyId the company ID 511 * @throws SystemException if a system exception occurred 512 */ 513 public void removeByUuid_C(java.lang.String uuid, long companyId) 514 throws com.liferay.portal.kernel.exception.SystemException; 515 516 /** 517 * Returns the number of bookmarks entries where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @return the number of matching bookmarks entries 522 * @throws SystemException if a system exception occurred 523 */ 524 public int countByUuid_C(java.lang.String uuid, long companyId) 525 throws com.liferay.portal.kernel.exception.SystemException; 526 527 /** 528 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 529 * 530 * @param groupId the group ID 531 * @param folderId the folder ID 532 * @return the matching bookmarks entries 533 * @throws SystemException if a system exception occurred 534 */ 535 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 536 long groupId, long folderId) 537 throws com.liferay.portal.kernel.exception.SystemException; 538 539 /** 540 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 541 * 542 * <p> 543 * 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. 544 * </p> 545 * 546 * @param groupId the group ID 547 * @param folderId the folder ID 548 * @param start the lower bound of the range of bookmarks entries 549 * @param end the upper bound of the range of bookmarks entries (not inclusive) 550 * @return the range of matching bookmarks entries 551 * @throws SystemException if a system exception occurred 552 */ 553 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 554 long groupId, long folderId, int start, int end) 555 throws com.liferay.portal.kernel.exception.SystemException; 556 557 /** 558 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 559 * 560 * <p> 561 * 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. 562 * </p> 563 * 564 * @param groupId the group ID 565 * @param folderId the folder ID 566 * @param start the lower bound of the range of bookmarks entries 567 * @param end the upper bound of the range of bookmarks entries (not inclusive) 568 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 569 * @return the ordered range of matching bookmarks entries 570 * @throws SystemException if a system exception occurred 571 */ 572 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 573 long groupId, long folderId, int start, int end, 574 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 575 throws com.liferay.portal.kernel.exception.SystemException; 576 577 /** 578 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 579 * 580 * @param groupId the group ID 581 * @param folderId the folder ID 582 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 583 * @return the first matching bookmarks entry 584 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 585 * @throws SystemException if a system exception occurred 586 */ 587 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 588 long groupId, long folderId, 589 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 590 throws com.liferay.portal.kernel.exception.SystemException, 591 com.liferay.portlet.bookmarks.NoSuchEntryException; 592 593 /** 594 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 595 * 596 * @param groupId the group ID 597 * @param folderId the folder ID 598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 599 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 600 * @throws SystemException if a system exception occurred 601 */ 602 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 603 long groupId, long folderId, 604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 605 throws com.liferay.portal.kernel.exception.SystemException; 606 607 /** 608 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 609 * 610 * @param groupId the group ID 611 * @param folderId the folder ID 612 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 613 * @return the last matching bookmarks entry 614 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 615 * @throws SystemException if a system exception occurred 616 */ 617 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 618 long groupId, long folderId, 619 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 620 throws com.liferay.portal.kernel.exception.SystemException, 621 com.liferay.portlet.bookmarks.NoSuchEntryException; 622 623 /** 624 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 625 * 626 * @param groupId the group ID 627 * @param folderId the folder ID 628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 629 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 630 * @throws SystemException if a system exception occurred 631 */ 632 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 633 long groupId, long folderId, 634 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 635 throws com.liferay.portal.kernel.exception.SystemException; 636 637 /** 638 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 639 * 640 * @param entryId the primary key of the current bookmarks entry 641 * @param groupId the group ID 642 * @param folderId the folder ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next bookmarks entry 645 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 649 long entryId, long groupId, long folderId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.bookmarks.NoSuchEntryException; 653 654 /** 655 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 656 * 657 * @param groupId the group ID 658 * @param folderId the folder ID 659 * @return the matching bookmarks entries that the user has permission to view 660 * @throws SystemException if a system exception occurred 661 */ 662 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 663 long groupId, long folderId) 664 throws com.liferay.portal.kernel.exception.SystemException; 665 666 /** 667 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 668 * 669 * <p> 670 * 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. 671 * </p> 672 * 673 * @param groupId the group ID 674 * @param folderId the folder ID 675 * @param start the lower bound of the range of bookmarks entries 676 * @param end the upper bound of the range of bookmarks entries (not inclusive) 677 * @return the range of matching bookmarks entries that the user has permission to view 678 * @throws SystemException if a system exception occurred 679 */ 680 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 681 long groupId, long folderId, int start, int end) 682 throws com.liferay.portal.kernel.exception.SystemException; 683 684 /** 685 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 686 * 687 * <p> 688 * 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. 689 * </p> 690 * 691 * @param groupId the group ID 692 * @param folderId the folder ID 693 * @param start the lower bound of the range of bookmarks entries 694 * @param end the upper bound of the range of bookmarks entries (not inclusive) 695 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 696 * @return the ordered range of matching bookmarks entries that the user has permission to view 697 * @throws SystemException if a system exception occurred 698 */ 699 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 700 long groupId, long folderId, int start, int end, 701 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 702 throws com.liferay.portal.kernel.exception.SystemException; 703 704 /** 705 * 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 = ?. 706 * 707 * @param entryId the primary key of the current bookmarks entry 708 * @param groupId the group ID 709 * @param folderId the folder ID 710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 711 * @return the previous, current, and next bookmarks entry 712 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 713 * @throws SystemException if a system exception occurred 714 */ 715 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 716 long entryId, long groupId, long folderId, 717 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 718 throws com.liferay.portal.kernel.exception.SystemException, 719 com.liferay.portlet.bookmarks.NoSuchEntryException; 720 721 /** 722 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 723 * 724 * @param groupId the group ID 725 * @param folderIds the folder IDs 726 * @return the matching bookmarks entries that the user has permission to view 727 * @throws SystemException if a system exception occurred 728 */ 729 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 730 long groupId, long[] folderIds) 731 throws com.liferay.portal.kernel.exception.SystemException; 732 733 /** 734 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 735 * 736 * <p> 737 * 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. 738 * </p> 739 * 740 * @param groupId the group ID 741 * @param folderIds the folder IDs 742 * @param start the lower bound of the range of bookmarks entries 743 * @param end the upper bound of the range of bookmarks entries (not inclusive) 744 * @return the range of matching bookmarks entries that the user has permission to view 745 * @throws SystemException if a system exception occurred 746 */ 747 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 748 long groupId, long[] folderIds, int start, int end) 749 throws com.liferay.portal.kernel.exception.SystemException; 750 751 /** 752 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 753 * 754 * <p> 755 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 756 * </p> 757 * 758 * @param groupId the group ID 759 * @param folderIds the folder IDs 760 * @param start the lower bound of the range of bookmarks entries 761 * @param end the upper bound of the range of bookmarks entries (not inclusive) 762 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 763 * @return the ordered range of matching bookmarks entries that the user has permission to view 764 * @throws SystemException if a system exception occurred 765 */ 766 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 767 long groupId, long[] folderIds, int start, int end, 768 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 769 throws com.liferay.portal.kernel.exception.SystemException; 770 771 /** 772 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 773 * 774 * <p> 775 * 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. 776 * </p> 777 * 778 * @param groupId the group ID 779 * @param folderIds the folder IDs 780 * @return the matching bookmarks entries 781 * @throws SystemException if a system exception occurred 782 */ 783 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 784 long groupId, long[] folderIds) 785 throws com.liferay.portal.kernel.exception.SystemException; 786 787 /** 788 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 789 * 790 * <p> 791 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 792 * </p> 793 * 794 * @param groupId the group ID 795 * @param folderIds the folder IDs 796 * @param start the lower bound of the range of bookmarks entries 797 * @param end the upper bound of the range of bookmarks entries (not inclusive) 798 * @return the range of matching bookmarks entries 799 * @throws SystemException if a system exception occurred 800 */ 801 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 802 long groupId, long[] folderIds, int start, int end) 803 throws com.liferay.portal.kernel.exception.SystemException; 804 805 /** 806 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 807 * 808 * <p> 809 * 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. 810 * </p> 811 * 812 * @param groupId the group ID 813 * @param folderIds the folder IDs 814 * @param start the lower bound of the range of bookmarks entries 815 * @param end the upper bound of the range of bookmarks entries (not inclusive) 816 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 817 * @return the ordered range of matching bookmarks entries 818 * @throws SystemException if a system exception occurred 819 */ 820 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 821 long groupId, long[] folderIds, int start, int end, 822 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 823 throws com.liferay.portal.kernel.exception.SystemException; 824 825 /** 826 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 827 * 828 * @param groupId the group ID 829 * @param folderId the folder ID 830 * @throws SystemException if a system exception occurred 831 */ 832 public void removeByG_F(long groupId, long folderId) 833 throws com.liferay.portal.kernel.exception.SystemException; 834 835 /** 836 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 837 * 838 * @param groupId the group ID 839 * @param folderId the folder ID 840 * @return the number of matching bookmarks entries 841 * @throws SystemException if a system exception occurred 842 */ 843 public int countByG_F(long groupId, long folderId) 844 throws com.liferay.portal.kernel.exception.SystemException; 845 846 /** 847 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 848 * 849 * @param groupId the group ID 850 * @param folderIds the folder IDs 851 * @return the number of matching bookmarks entries 852 * @throws SystemException if a system exception occurred 853 */ 854 public int countByG_F(long groupId, long[] folderIds) 855 throws com.liferay.portal.kernel.exception.SystemException; 856 857 /** 858 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 859 * 860 * @param groupId the group ID 861 * @param folderId the folder ID 862 * @return the number of matching bookmarks entries that the user has permission to view 863 * @throws SystemException if a system exception occurred 864 */ 865 public int filterCountByG_F(long groupId, long folderId) 866 throws com.liferay.portal.kernel.exception.SystemException; 867 868 /** 869 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 870 * 871 * @param groupId the group ID 872 * @param folderIds the folder IDs 873 * @return the number of matching bookmarks entries that the user has permission to view 874 * @throws SystemException if a system exception occurred 875 */ 876 public int filterCountByG_F(long groupId, long[] folderIds) 877 throws com.liferay.portal.kernel.exception.SystemException; 878 879 /** 880 * Returns all the bookmarks entries where groupId = ? and status = ?. 881 * 882 * @param groupId the group ID 883 * @param status the status 884 * @return the matching bookmarks entries 885 * @throws SystemException if a system exception occurred 886 */ 887 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 888 long groupId, int status) 889 throws com.liferay.portal.kernel.exception.SystemException; 890 891 /** 892 * Returns a range of all the bookmarks entries where groupId = ? and status = ?. 893 * 894 * <p> 895 * 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. 896 * </p> 897 * 898 * @param groupId the group ID 899 * @param status the status 900 * @param start the lower bound of the range of bookmarks entries 901 * @param end the upper bound of the range of bookmarks entries (not inclusive) 902 * @return the range of matching bookmarks entries 903 * @throws SystemException if a system exception occurred 904 */ 905 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 906 long groupId, int status, int start, int end) 907 throws com.liferay.portal.kernel.exception.SystemException; 908 909 /** 910 * Returns an ordered range of all the bookmarks entries where groupId = ? and status = ?. 911 * 912 * <p> 913 * 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. 914 * </p> 915 * 916 * @param groupId the group ID 917 * @param status the status 918 * @param start the lower bound of the range of bookmarks entries 919 * @param end the upper bound of the range of bookmarks entries (not inclusive) 920 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 921 * @return the ordered range of matching bookmarks entries 922 * @throws SystemException if a system exception occurred 923 */ 924 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 925 long groupId, int status, int start, int end, 926 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 927 throws com.liferay.portal.kernel.exception.SystemException; 928 929 /** 930 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 931 * 932 * @param groupId the group ID 933 * @param status the status 934 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 935 * @return the first matching bookmarks entry 936 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 937 * @throws SystemException if a system exception occurred 938 */ 939 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First( 940 long groupId, int status, 941 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 942 throws com.liferay.portal.kernel.exception.SystemException, 943 com.liferay.portlet.bookmarks.NoSuchEntryException; 944 945 /** 946 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 947 * 948 * @param groupId the group ID 949 * @param status the status 950 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 951 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 952 * @throws SystemException if a system exception occurred 953 */ 954 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First( 955 long groupId, int status, 956 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 957 throws com.liferay.portal.kernel.exception.SystemException; 958 959 /** 960 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 961 * 962 * @param groupId the group ID 963 * @param status the status 964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 965 * @return the last matching bookmarks entry 966 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 967 * @throws SystemException if a system exception occurred 968 */ 969 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last( 970 long groupId, int status, 971 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 972 throws com.liferay.portal.kernel.exception.SystemException, 973 com.liferay.portlet.bookmarks.NoSuchEntryException; 974 975 /** 976 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 977 * 978 * @param groupId the group ID 979 * @param status the status 980 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 981 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 982 * @throws SystemException if a system exception occurred 983 */ 984 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last( 985 long groupId, int status, 986 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 987 throws com.liferay.portal.kernel.exception.SystemException; 988 989 /** 990 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and status = ?. 991 * 992 * @param entryId the primary key of the current bookmarks entry 993 * @param groupId the group ID 994 * @param status the status 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the previous, current, and next bookmarks entry 997 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 998 * @throws SystemException if a system exception occurred 999 */ 1000 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext( 1001 long entryId, long groupId, int status, 1002 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.bookmarks.NoSuchEntryException; 1005 1006 /** 1007 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1008 * 1009 * @param groupId the group ID 1010 * @param status the status 1011 * @return the matching bookmarks entries that the user has permission to view 1012 * @throws SystemException if a system exception occurred 1013 */ 1014 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1015 long groupId, int status) 1016 throws com.liferay.portal.kernel.exception.SystemException; 1017 1018 /** 1019 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1020 * 1021 * <p> 1022 * 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. 1023 * </p> 1024 * 1025 * @param groupId the group ID 1026 * @param status the status 1027 * @param start the lower bound of the range of bookmarks entries 1028 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1029 * @return the range of matching bookmarks entries that the user has permission to view 1030 * @throws SystemException if a system exception occurred 1031 */ 1032 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1033 long groupId, int status, int start, int end) 1034 throws com.liferay.portal.kernel.exception.SystemException; 1035 1036 /** 1037 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and status = ?. 1038 * 1039 * <p> 1040 * 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. 1041 * </p> 1042 * 1043 * @param groupId the group ID 1044 * @param status the status 1045 * @param start the lower bound of the range of bookmarks entries 1046 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1047 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1048 * @return the ordered range of matching bookmarks entries that the user has permission to view 1049 * @throws SystemException if a system exception occurred 1050 */ 1051 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1052 long groupId, int status, int start, int end, 1053 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1054 throws com.liferay.portal.kernel.exception.SystemException; 1055 1056 /** 1057 * 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 = ?. 1058 * 1059 * @param entryId the primary key of the current bookmarks entry 1060 * @param groupId the group ID 1061 * @param status the status 1062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1063 * @return the previous, current, and next bookmarks entry 1064 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1065 * @throws SystemException if a system exception occurred 1066 */ 1067 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext( 1068 long entryId, long groupId, int status, 1069 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1070 throws com.liferay.portal.kernel.exception.SystemException, 1071 com.liferay.portlet.bookmarks.NoSuchEntryException; 1072 1073 /** 1074 * Removes all the bookmarks entries where groupId = ? and status = ? from the database. 1075 * 1076 * @param groupId the group ID 1077 * @param status the status 1078 * @throws SystemException if a system exception occurred 1079 */ 1080 public void removeByG_S(long groupId, int status) 1081 throws com.liferay.portal.kernel.exception.SystemException; 1082 1083 /** 1084 * Returns the number of bookmarks entries where groupId = ? and status = ?. 1085 * 1086 * @param groupId the group ID 1087 * @param status the status 1088 * @return the number of matching bookmarks entries 1089 * @throws SystemException if a system exception occurred 1090 */ 1091 public int countByG_S(long groupId, int status) 1092 throws com.liferay.portal.kernel.exception.SystemException; 1093 1094 /** 1095 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1096 * 1097 * @param groupId the group ID 1098 * @param status the status 1099 * @return the number of matching bookmarks entries that the user has permission to view 1100 * @throws SystemException if a system exception occurred 1101 */ 1102 public int filterCountByG_S(long groupId, int status) 1103 throws com.liferay.portal.kernel.exception.SystemException; 1104 1105 /** 1106 * Returns all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1107 * 1108 * @param groupId the group ID 1109 * @param userId the user ID 1110 * @param status the status 1111 * @return the matching bookmarks entries 1112 * @throws SystemException if a system exception occurred 1113 */ 1114 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1115 long groupId, long userId, int status) 1116 throws com.liferay.portal.kernel.exception.SystemException; 1117 1118 /** 1119 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1120 * 1121 * <p> 1122 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 1123 * </p> 1124 * 1125 * @param groupId the group ID 1126 * @param userId the user ID 1127 * @param status the status 1128 * @param start the lower bound of the range of bookmarks entries 1129 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1130 * @return the range of matching bookmarks entries 1131 * @throws SystemException if a system exception occurred 1132 */ 1133 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1134 long groupId, long userId, int status, int start, int end) 1135 throws com.liferay.portal.kernel.exception.SystemException; 1136 1137 /** 1138 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1139 * 1140 * <p> 1141 * 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. 1142 * </p> 1143 * 1144 * @param groupId the group ID 1145 * @param userId the user ID 1146 * @param status the status 1147 * @param start the lower bound of the range of bookmarks entries 1148 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1150 * @return the ordered range of matching bookmarks entries 1151 * @throws SystemException if a system exception occurred 1152 */ 1153 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1154 long groupId, long userId, int status, int start, int end, 1155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1156 throws com.liferay.portal.kernel.exception.SystemException; 1157 1158 /** 1159 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1160 * 1161 * @param groupId the group ID 1162 * @param userId the user ID 1163 * @param status the status 1164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1165 * @return the first matching bookmarks entry 1166 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1167 * @throws SystemException if a system exception occurred 1168 */ 1169 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First( 1170 long groupId, long userId, int status, 1171 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1172 throws com.liferay.portal.kernel.exception.SystemException, 1173 com.liferay.portlet.bookmarks.NoSuchEntryException; 1174 1175 /** 1176 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1177 * 1178 * @param groupId the group ID 1179 * @param userId the user ID 1180 * @param status the status 1181 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1182 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1183 * @throws SystemException if a system exception occurred 1184 */ 1185 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First( 1186 long groupId, long userId, int status, 1187 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1188 throws com.liferay.portal.kernel.exception.SystemException; 1189 1190 /** 1191 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1192 * 1193 * @param groupId the group ID 1194 * @param userId the user ID 1195 * @param status the status 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the last matching bookmarks entry 1198 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1199 * @throws SystemException if a system exception occurred 1200 */ 1201 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last( 1202 long groupId, long userId, int status, 1203 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1204 throws com.liferay.portal.kernel.exception.SystemException, 1205 com.liferay.portlet.bookmarks.NoSuchEntryException; 1206 1207 /** 1208 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1209 * 1210 * @param groupId the group ID 1211 * @param userId the user ID 1212 * @param status the status 1213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1214 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1215 * @throws SystemException if a system exception occurred 1216 */ 1217 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last( 1218 long groupId, long userId, int status, 1219 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1220 throws com.liferay.portal.kernel.exception.SystemException; 1221 1222 /** 1223 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1224 * 1225 * @param entryId the primary key of the current bookmarks entry 1226 * @param groupId the group ID 1227 * @param userId the user ID 1228 * @param status the status 1229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1230 * @return the previous, current, and next bookmarks entry 1231 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1232 * @throws SystemException if a system exception occurred 1233 */ 1234 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext( 1235 long entryId, long groupId, long userId, int status, 1236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1237 throws com.liferay.portal.kernel.exception.SystemException, 1238 com.liferay.portlet.bookmarks.NoSuchEntryException; 1239 1240 /** 1241 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1242 * 1243 * @param groupId the group ID 1244 * @param userId the user ID 1245 * @param status the status 1246 * @return the matching bookmarks entries that the user has permission to view 1247 * @throws SystemException if a system exception occurred 1248 */ 1249 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1250 long groupId, long userId, int status) 1251 throws com.liferay.portal.kernel.exception.SystemException; 1252 1253 /** 1254 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1255 * 1256 * <p> 1257 * 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. 1258 * </p> 1259 * 1260 * @param groupId the group ID 1261 * @param userId the user ID 1262 * @param status the status 1263 * @param start the lower bound of the range of bookmarks entries 1264 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1265 * @return the range of matching bookmarks entries that the user has permission to view 1266 * @throws SystemException if a system exception occurred 1267 */ 1268 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1269 long groupId, long userId, int status, int start, int end) 1270 throws com.liferay.portal.kernel.exception.SystemException; 1271 1272 /** 1273 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and status = ?. 1274 * 1275 * <p> 1276 * 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. 1277 * </p> 1278 * 1279 * @param groupId the group ID 1280 * @param userId the user ID 1281 * @param status the status 1282 * @param start the lower bound of the range of bookmarks entries 1283 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1284 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1285 * @return the ordered range of matching bookmarks entries that the user has permission to view 1286 * @throws SystemException if a system exception occurred 1287 */ 1288 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1289 long groupId, long userId, int status, int start, int end, 1290 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1291 throws com.liferay.portal.kernel.exception.SystemException; 1292 1293 /** 1294 * 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 = ?. 1295 * 1296 * @param entryId the primary key of the current bookmarks entry 1297 * @param groupId the group ID 1298 * @param userId the user ID 1299 * @param status the status 1300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1301 * @return the previous, current, and next bookmarks entry 1302 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1303 * @throws SystemException if a system exception occurred 1304 */ 1305 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext( 1306 long entryId, long groupId, long userId, int status, 1307 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1308 throws com.liferay.portal.kernel.exception.SystemException, 1309 com.liferay.portlet.bookmarks.NoSuchEntryException; 1310 1311 /** 1312 * Removes all the bookmarks entries where groupId = ? and userId = ? and status = ? from the database. 1313 * 1314 * @param groupId the group ID 1315 * @param userId the user ID 1316 * @param status the status 1317 * @throws SystemException if a system exception occurred 1318 */ 1319 public void removeByG_U_S(long groupId, long userId, int status) 1320 throws com.liferay.portal.kernel.exception.SystemException; 1321 1322 /** 1323 * Returns the number of bookmarks entries where groupId = ? and userId = ? and status = ?. 1324 * 1325 * @param groupId the group ID 1326 * @param userId the user ID 1327 * @param status the status 1328 * @return the number of matching bookmarks entries 1329 * @throws SystemException if a system exception occurred 1330 */ 1331 public int countByG_U_S(long groupId, long userId, int status) 1332 throws com.liferay.portal.kernel.exception.SystemException; 1333 1334 /** 1335 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1336 * 1337 * @param groupId the group ID 1338 * @param userId the user ID 1339 * @param status the status 1340 * @return the number of matching bookmarks entries that the user has permission to view 1341 * @throws SystemException if a system exception occurred 1342 */ 1343 public int filterCountByG_U_S(long groupId, long userId, int status) 1344 throws com.liferay.portal.kernel.exception.SystemException; 1345 1346 /** 1347 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1348 * 1349 * @param groupId the group ID 1350 * @param folderId the folder ID 1351 * @param status the status 1352 * @return the matching bookmarks entries 1353 * @throws SystemException if a system exception occurred 1354 */ 1355 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1356 long groupId, long folderId, int status) 1357 throws com.liferay.portal.kernel.exception.SystemException; 1358 1359 /** 1360 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1361 * 1362 * <p> 1363 * 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. 1364 * </p> 1365 * 1366 * @param groupId the group ID 1367 * @param folderId the folder ID 1368 * @param status the status 1369 * @param start the lower bound of the range of bookmarks entries 1370 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1371 * @return the range of matching bookmarks entries 1372 * @throws SystemException if a system exception occurred 1373 */ 1374 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1375 long groupId, long folderId, int status, int start, int end) 1376 throws com.liferay.portal.kernel.exception.SystemException; 1377 1378 /** 1379 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1380 * 1381 * <p> 1382 * 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. 1383 * </p> 1384 * 1385 * @param groupId the group ID 1386 * @param folderId the folder ID 1387 * @param status the status 1388 * @param start the lower bound of the range of bookmarks entries 1389 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1391 * @return the ordered range of matching bookmarks entries 1392 * @throws SystemException if a system exception occurred 1393 */ 1394 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1395 long groupId, long folderId, int status, int start, int end, 1396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1397 throws com.liferay.portal.kernel.exception.SystemException; 1398 1399 /** 1400 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1401 * 1402 * @param groupId the group ID 1403 * @param folderId the folder ID 1404 * @param status the status 1405 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1406 * @return the first matching bookmarks entry 1407 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1408 * @throws SystemException if a system exception occurred 1409 */ 1410 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First( 1411 long groupId, long folderId, int status, 1412 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1413 throws com.liferay.portal.kernel.exception.SystemException, 1414 com.liferay.portlet.bookmarks.NoSuchEntryException; 1415 1416 /** 1417 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1418 * 1419 * @param groupId the group ID 1420 * @param folderId the folder ID 1421 * @param status the status 1422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1423 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1424 * @throws SystemException if a system exception occurred 1425 */ 1426 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First( 1427 long groupId, long folderId, int status, 1428 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1429 throws com.liferay.portal.kernel.exception.SystemException; 1430 1431 /** 1432 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1433 * 1434 * @param groupId the group ID 1435 * @param folderId the folder ID 1436 * @param status the status 1437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1438 * @return the last matching bookmarks entry 1439 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1440 * @throws SystemException if a system exception occurred 1441 */ 1442 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last( 1443 long groupId, long folderId, int status, 1444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1445 throws com.liferay.portal.kernel.exception.SystemException, 1446 com.liferay.portlet.bookmarks.NoSuchEntryException; 1447 1448 /** 1449 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1450 * 1451 * @param groupId the group ID 1452 * @param folderId the folder ID 1453 * @param status the status 1454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1455 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1456 * @throws SystemException if a system exception occurred 1457 */ 1458 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last( 1459 long groupId, long folderId, int status, 1460 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1461 throws com.liferay.portal.kernel.exception.SystemException; 1462 1463 /** 1464 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1465 * 1466 * @param entryId the primary key of the current bookmarks entry 1467 * @param groupId the group ID 1468 * @param folderId the folder ID 1469 * @param status the status 1470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1471 * @return the previous, current, and next bookmarks entry 1472 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1473 * @throws SystemException if a system exception occurred 1474 */ 1475 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext( 1476 long entryId, long groupId, long folderId, int status, 1477 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1478 throws com.liferay.portal.kernel.exception.SystemException, 1479 com.liferay.portlet.bookmarks.NoSuchEntryException; 1480 1481 /** 1482 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1483 * 1484 * @param groupId the group ID 1485 * @param folderId the folder ID 1486 * @param status the status 1487 * @return the matching bookmarks entries that the user has permission to view 1488 * @throws SystemException if a system exception occurred 1489 */ 1490 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1491 long groupId, long folderId, int status) 1492 throws com.liferay.portal.kernel.exception.SystemException; 1493 1494 /** 1495 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1496 * 1497 * <p> 1498 * 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. 1499 * </p> 1500 * 1501 * @param groupId the group ID 1502 * @param folderId the folder ID 1503 * @param status the status 1504 * @param start the lower bound of the range of bookmarks entries 1505 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1506 * @return the range of matching bookmarks entries that the user has permission to view 1507 * @throws SystemException if a system exception occurred 1508 */ 1509 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1510 long groupId, long folderId, int status, int start, int end) 1511 throws com.liferay.portal.kernel.exception.SystemException; 1512 1513 /** 1514 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 1515 * 1516 * <p> 1517 * 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. 1518 * </p> 1519 * 1520 * @param groupId the group ID 1521 * @param folderId the folder 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 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1526 * @return the ordered range of matching bookmarks entries that the user has permission to view 1527 * @throws SystemException if a system exception occurred 1528 */ 1529 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1530 long groupId, long folderId, int status, int start, int end, 1531 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1532 throws com.liferay.portal.kernel.exception.SystemException; 1533 1534 /** 1535 * 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 = ?. 1536 * 1537 * @param entryId the primary key of the current bookmarks entry 1538 * @param groupId the group ID 1539 * @param folderId the folder ID 1540 * @param status the status 1541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1542 * @return the previous, current, and next bookmarks entry 1543 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1544 * @throws SystemException if a system exception occurred 1545 */ 1546 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext( 1547 long entryId, long groupId, long folderId, int status, 1548 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1549 throws com.liferay.portal.kernel.exception.SystemException, 1550 com.liferay.portlet.bookmarks.NoSuchEntryException; 1551 1552 /** 1553 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1554 * 1555 * @param groupId the group ID 1556 * @param folderIds the folder IDs 1557 * @param status the status 1558 * @return the matching bookmarks entries that the user has permission to view 1559 * @throws SystemException if a system exception occurred 1560 */ 1561 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1562 long groupId, long[] folderIds, int status) 1563 throws com.liferay.portal.kernel.exception.SystemException; 1564 1565 /** 1566 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1567 * 1568 * <p> 1569 * 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. 1570 * </p> 1571 * 1572 * @param groupId the group ID 1573 * @param folderIds the folder IDs 1574 * @param status the status 1575 * @param start the lower bound of the range of bookmarks entries 1576 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1577 * @return the range of matching bookmarks entries that the user has permission to view 1578 * @throws SystemException if a system exception occurred 1579 */ 1580 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1581 long groupId, long[] folderIds, int status, int start, int end) 1582 throws com.liferay.portal.kernel.exception.SystemException; 1583 1584 /** 1585 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1586 * 1587 * <p> 1588 * 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. 1589 * </p> 1590 * 1591 * @param groupId the group ID 1592 * @param folderIds the folder IDs 1593 * @param status the status 1594 * @param start the lower bound of the range of bookmarks entries 1595 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1596 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1597 * @return the ordered range of matching bookmarks entries that the user has permission to view 1598 * @throws SystemException if a system exception occurred 1599 */ 1600 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1601 long groupId, long[] folderIds, int status, int start, int end, 1602 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1603 throws com.liferay.portal.kernel.exception.SystemException; 1604 1605 /** 1606 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1607 * 1608 * <p> 1609 * 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. 1610 * </p> 1611 * 1612 * @param groupId the group ID 1613 * @param folderIds the folder IDs 1614 * @param status the status 1615 * @return the matching bookmarks entries 1616 * @throws SystemException if a system exception occurred 1617 */ 1618 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1619 long groupId, long[] folderIds, int status) 1620 throws com.liferay.portal.kernel.exception.SystemException; 1621 1622 /** 1623 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1624 * 1625 * <p> 1626 * 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. 1627 * </p> 1628 * 1629 * @param groupId the group ID 1630 * @param folderIds the folder IDs 1631 * @param status the status 1632 * @param start the lower bound of the range of bookmarks entries 1633 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1634 * @return the range of matching bookmarks entries 1635 * @throws SystemException if a system exception occurred 1636 */ 1637 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1638 long groupId, long[] folderIds, int status, int start, int end) 1639 throws com.liferay.portal.kernel.exception.SystemException; 1640 1641 /** 1642 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1643 * 1644 * <p> 1645 * 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. 1646 * </p> 1647 * 1648 * @param groupId the group ID 1649 * @param folderIds the folder IDs 1650 * @param status the status 1651 * @param start the lower bound of the range of bookmarks entries 1652 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1653 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1654 * @return the ordered range of matching bookmarks entries 1655 * @throws SystemException if a system exception occurred 1656 */ 1657 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1658 long groupId, long[] folderIds, int status, int start, int end, 1659 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1660 throws com.liferay.portal.kernel.exception.SystemException; 1661 1662 /** 1663 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status = ? from the database. 1664 * 1665 * @param groupId the group ID 1666 * @param folderId the folder ID 1667 * @param status the status 1668 * @throws SystemException if a system exception occurred 1669 */ 1670 public void removeByG_F_S(long groupId, long folderId, int status) 1671 throws com.liferay.portal.kernel.exception.SystemException; 1672 1673 /** 1674 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status = ?. 1675 * 1676 * @param groupId the group ID 1677 * @param folderId the folder ID 1678 * @param status the status 1679 * @return the number of matching bookmarks entries 1680 * @throws SystemException if a system exception occurred 1681 */ 1682 public int countByG_F_S(long groupId, long folderId, int status) 1683 throws com.liferay.portal.kernel.exception.SystemException; 1684 1685 /** 1686 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1687 * 1688 * @param groupId the group ID 1689 * @param folderIds the folder IDs 1690 * @param status the status 1691 * @return the number of matching bookmarks entries 1692 * @throws SystemException if a system exception occurred 1693 */ 1694 public int countByG_F_S(long groupId, long[] folderIds, int status) 1695 throws com.liferay.portal.kernel.exception.SystemException; 1696 1697 /** 1698 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1699 * 1700 * @param groupId the group ID 1701 * @param folderId the folder ID 1702 * @param status the status 1703 * @return the number of matching bookmarks entries that the user has permission to view 1704 * @throws SystemException if a system exception occurred 1705 */ 1706 public int filterCountByG_F_S(long groupId, long folderId, int status) 1707 throws com.liferay.portal.kernel.exception.SystemException; 1708 1709 /** 1710 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1711 * 1712 * @param groupId the group ID 1713 * @param folderIds the folder IDs 1714 * @param status the status 1715 * @return the number of matching bookmarks entries that the user has permission to view 1716 * @throws SystemException if a system exception occurred 1717 */ 1718 public int filterCountByG_F_S(long groupId, long[] folderIds, int status) 1719 throws com.liferay.portal.kernel.exception.SystemException; 1720 1721 /** 1722 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 1723 * 1724 * @param groupId the group ID 1725 * @param folderId the folder ID 1726 * @param status the status 1727 * @return the matching bookmarks entries 1728 * @throws SystemException if a system exception occurred 1729 */ 1730 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 1731 long groupId, long folderId, int status) 1732 throws com.liferay.portal.kernel.exception.SystemException; 1733 1734 /** 1735 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 1736 * 1737 * <p> 1738 * 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. 1739 * </p> 1740 * 1741 * @param groupId the group ID 1742 * @param folderId the folder ID 1743 * @param status the status 1744 * @param start the lower bound of the range of bookmarks entries 1745 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1746 * @return the range of matching bookmarks entries 1747 * @throws SystemException if a system exception occurred 1748 */ 1749 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 1750 long groupId, long folderId, int status, int start, int end) 1751 throws com.liferay.portal.kernel.exception.SystemException; 1752 1753 /** 1754 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 1755 * 1756 * <p> 1757 * 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. 1758 * </p> 1759 * 1760 * @param groupId the group ID 1761 * @param folderId the folder ID 1762 * @param status the status 1763 * @param start the lower bound of the range of bookmarks entries 1764 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1765 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1766 * @return the ordered range of matching bookmarks entries 1767 * @throws SystemException if a system exception occurred 1768 */ 1769 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 1770 long groupId, long folderId, int status, int start, int end, 1771 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1772 throws com.liferay.portal.kernel.exception.SystemException; 1773 1774 /** 1775 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 1776 * 1777 * @param groupId the group ID 1778 * @param folderId the folder ID 1779 * @param status the status 1780 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1781 * @return the first matching bookmarks entry 1782 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1783 * @throws SystemException if a system exception occurred 1784 */ 1785 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First( 1786 long groupId, long folderId, int status, 1787 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1788 throws com.liferay.portal.kernel.exception.SystemException, 1789 com.liferay.portlet.bookmarks.NoSuchEntryException; 1790 1791 /** 1792 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 1793 * 1794 * @param groupId the group ID 1795 * @param folderId the folder ID 1796 * @param status the status 1797 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1798 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1799 * @throws SystemException if a system exception occurred 1800 */ 1801 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First( 1802 long groupId, long folderId, int status, 1803 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1804 throws com.liferay.portal.kernel.exception.SystemException; 1805 1806 /** 1807 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 1808 * 1809 * @param groupId the group ID 1810 * @param folderId the folder ID 1811 * @param status the status 1812 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1813 * @return the last matching bookmarks entry 1814 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1815 * @throws SystemException if a system exception occurred 1816 */ 1817 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last( 1818 long groupId, long folderId, int status, 1819 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1820 throws com.liferay.portal.kernel.exception.SystemException, 1821 com.liferay.portlet.bookmarks.NoSuchEntryException; 1822 1823 /** 1824 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 1825 * 1826 * @param groupId the group ID 1827 * @param folderId the folder ID 1828 * @param status the status 1829 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1830 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1831 * @throws SystemException if a system exception occurred 1832 */ 1833 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last( 1834 long groupId, long folderId, int status, 1835 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1836 throws com.liferay.portal.kernel.exception.SystemException; 1837 1838 /** 1839 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 1840 * 1841 * @param entryId the primary key of the current bookmarks entry 1842 * @param groupId the group ID 1843 * @param folderId the folder ID 1844 * @param status the status 1845 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1846 * @return the previous, current, and next bookmarks entry 1847 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1848 * @throws SystemException if a system exception occurred 1849 */ 1850 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext( 1851 long entryId, long groupId, long folderId, int status, 1852 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1853 throws com.liferay.portal.kernel.exception.SystemException, 1854 com.liferay.portlet.bookmarks.NoSuchEntryException; 1855 1856 /** 1857 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 1858 * 1859 * @param groupId the group ID 1860 * @param folderId the folder ID 1861 * @param status the status 1862 * @return the matching bookmarks entries that the user has permission to view 1863 * @throws SystemException if a system exception occurred 1864 */ 1865 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 1866 long groupId, long folderId, int status) 1867 throws com.liferay.portal.kernel.exception.SystemException; 1868 1869 /** 1870 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 1871 * 1872 * <p> 1873 * 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. 1874 * </p> 1875 * 1876 * @param groupId the group ID 1877 * @param folderId the folder ID 1878 * @param status the status 1879 * @param start the lower bound of the range of bookmarks entries 1880 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1881 * @return the range of matching bookmarks entries that the user has permission to view 1882 * @throws SystemException if a system exception occurred 1883 */ 1884 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 1885 long groupId, long folderId, int status, int start, int end) 1886 throws com.liferay.portal.kernel.exception.SystemException; 1887 1888 /** 1889 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status ≠ ?. 1890 * 1891 * <p> 1892 * 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. 1893 * </p> 1894 * 1895 * @param groupId the group ID 1896 * @param folderId the folder ID 1897 * @param status the status 1898 * @param start the lower bound of the range of bookmarks entries 1899 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1900 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1901 * @return the ordered range of matching bookmarks entries that the user has permission to view 1902 * @throws SystemException if a system exception occurred 1903 */ 1904 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 1905 long groupId, long folderId, int status, int start, int end, 1906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1907 throws com.liferay.portal.kernel.exception.SystemException; 1908 1909 /** 1910 * 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 ≠ ?. 1911 * 1912 * @param entryId the primary key of the current bookmarks entry 1913 * @param groupId the group ID 1914 * @param folderId the folder ID 1915 * @param status the status 1916 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1917 * @return the previous, current, and next bookmarks entry 1918 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1919 * @throws SystemException if a system exception occurred 1920 */ 1921 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext( 1922 long entryId, long groupId, long folderId, int status, 1923 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1924 throws com.liferay.portal.kernel.exception.SystemException, 1925 com.liferay.portlet.bookmarks.NoSuchEntryException; 1926 1927 /** 1928 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 1929 * 1930 * @param groupId the group ID 1931 * @param folderIds the folder IDs 1932 * @param status the status 1933 * @return the matching bookmarks entries that the user has permission to view 1934 * @throws SystemException if a system exception occurred 1935 */ 1936 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 1937 long groupId, long[] folderIds, int status) 1938 throws com.liferay.portal.kernel.exception.SystemException; 1939 1940 /** 1941 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 1942 * 1943 * <p> 1944 * 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. 1945 * </p> 1946 * 1947 * @param groupId the group ID 1948 * @param folderIds the folder IDs 1949 * @param status the status 1950 * @param start the lower bound of the range of bookmarks entries 1951 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1952 * @return the range of matching bookmarks entries that the user has permission to view 1953 * @throws SystemException if a system exception occurred 1954 */ 1955 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 1956 long groupId, long[] folderIds, int status, int start, int end) 1957 throws com.liferay.portal.kernel.exception.SystemException; 1958 1959 /** 1960 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 1961 * 1962 * <p> 1963 * 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. 1964 * </p> 1965 * 1966 * @param groupId the group ID 1967 * @param folderIds the folder IDs 1968 * @param status the status 1969 * @param start the lower bound of the range of bookmarks entries 1970 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1971 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1972 * @return the ordered range of matching bookmarks entries that the user has permission to view 1973 * @throws SystemException if a system exception occurred 1974 */ 1975 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 1976 long groupId, long[] folderIds, int status, int start, int end, 1977 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1978 throws com.liferay.portal.kernel.exception.SystemException; 1979 1980 /** 1981 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 1982 * 1983 * <p> 1984 * 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. 1985 * </p> 1986 * 1987 * @param groupId the group ID 1988 * @param folderIds the folder IDs 1989 * @param status the status 1990 * @return the matching bookmarks entries 1991 * @throws SystemException if a system exception occurred 1992 */ 1993 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 1994 long groupId, long[] folderIds, int status) 1995 throws com.liferay.portal.kernel.exception.SystemException; 1996 1997 /** 1998 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 1999 * 2000 * <p> 2001 * 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. 2002 * </p> 2003 * 2004 * @param groupId the group ID 2005 * @param folderIds the folder IDs 2006 * @param status the status 2007 * @param start the lower bound of the range of bookmarks entries 2008 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2009 * @return the range of matching bookmarks entries 2010 * @throws SystemException if a system exception occurred 2011 */ 2012 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2013 long groupId, long[] folderIds, int status, int start, int end) 2014 throws com.liferay.portal.kernel.exception.SystemException; 2015 2016 /** 2017 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2018 * 2019 * <p> 2020 * 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. 2021 * </p> 2022 * 2023 * @param groupId the group ID 2024 * @param folderIds the folder IDs 2025 * @param status the status 2026 * @param start the lower bound of the range of bookmarks entries 2027 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2028 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2029 * @return the ordered range of matching bookmarks entries 2030 * @throws SystemException if a system exception occurred 2031 */ 2032 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2033 long groupId, long[] folderIds, int status, int start, int end, 2034 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2035 throws com.liferay.portal.kernel.exception.SystemException; 2036 2037 /** 2038 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ? from the database. 2039 * 2040 * @param groupId the group ID 2041 * @param folderId the folder ID 2042 * @param status the status 2043 * @throws SystemException if a system exception occurred 2044 */ 2045 public void removeByG_F_NotS(long groupId, long folderId, int status) 2046 throws com.liferay.portal.kernel.exception.SystemException; 2047 2048 /** 2049 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2050 * 2051 * @param groupId the group ID 2052 * @param folderId the folder ID 2053 * @param status the status 2054 * @return the number of matching bookmarks entries 2055 * @throws SystemException if a system exception occurred 2056 */ 2057 public int countByG_F_NotS(long groupId, long folderId, int status) 2058 throws com.liferay.portal.kernel.exception.SystemException; 2059 2060 /** 2061 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2062 * 2063 * @param groupId the group ID 2064 * @param folderIds the folder IDs 2065 * @param status the status 2066 * @return the number of matching bookmarks entries 2067 * @throws SystemException if a system exception occurred 2068 */ 2069 public int countByG_F_NotS(long groupId, long[] folderIds, int status) 2070 throws com.liferay.portal.kernel.exception.SystemException; 2071 2072 /** 2073 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2074 * 2075 * @param groupId the group ID 2076 * @param folderId the folder ID 2077 * @param status the status 2078 * @return the number of matching bookmarks entries that the user has permission to view 2079 * @throws SystemException if a system exception occurred 2080 */ 2081 public int filterCountByG_F_NotS(long groupId, long folderId, int status) 2082 throws com.liferay.portal.kernel.exception.SystemException; 2083 2084 /** 2085 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2086 * 2087 * @param groupId the group ID 2088 * @param folderIds the folder IDs 2089 * @param status the status 2090 * @return the number of matching bookmarks entries that the user has permission to view 2091 * @throws SystemException if a system exception occurred 2092 */ 2093 public int filterCountByG_F_NotS(long groupId, long[] folderIds, int status) 2094 throws com.liferay.portal.kernel.exception.SystemException; 2095 2096 /** 2097 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2098 * 2099 * @param groupId the group ID 2100 * @param userId the user ID 2101 * @param folderId the folder ID 2102 * @param status the status 2103 * @return the matching bookmarks entries 2104 * @throws SystemException if a system exception occurred 2105 */ 2106 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2107 long groupId, long userId, long folderId, int status) 2108 throws com.liferay.portal.kernel.exception.SystemException; 2109 2110 /** 2111 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2112 * 2113 * <p> 2114 * 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. 2115 * </p> 2116 * 2117 * @param groupId the group ID 2118 * @param userId the user ID 2119 * @param folderId the folder ID 2120 * @param status the status 2121 * @param start the lower bound of the range of bookmarks entries 2122 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2123 * @return the range of matching bookmarks entries 2124 * @throws SystemException if a system exception occurred 2125 */ 2126 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2127 long groupId, long userId, long folderId, int status, int start, int end) 2128 throws com.liferay.portal.kernel.exception.SystemException; 2129 2130 /** 2131 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2132 * 2133 * <p> 2134 * 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. 2135 * </p> 2136 * 2137 * @param groupId the group ID 2138 * @param userId the user ID 2139 * @param folderId the folder ID 2140 * @param status the status 2141 * @param start the lower bound of the range of bookmarks entries 2142 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2143 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2144 * @return the ordered range of matching bookmarks entries 2145 * @throws SystemException if a system exception occurred 2146 */ 2147 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2148 long groupId, long userId, long folderId, int status, int start, 2149 int end, 2150 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2151 throws com.liferay.portal.kernel.exception.SystemException; 2152 2153 /** 2154 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2155 * 2156 * @param groupId the group ID 2157 * @param userId the user ID 2158 * @param folderId the folder ID 2159 * @param status the status 2160 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2161 * @return the first matching bookmarks entry 2162 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2163 * @throws SystemException if a system exception occurred 2164 */ 2165 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First( 2166 long groupId, long userId, long folderId, int status, 2167 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2168 throws com.liferay.portal.kernel.exception.SystemException, 2169 com.liferay.portlet.bookmarks.NoSuchEntryException; 2170 2171 /** 2172 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2173 * 2174 * @param groupId the group ID 2175 * @param userId the user ID 2176 * @param folderId the folder ID 2177 * @param status the status 2178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2179 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2180 * @throws SystemException if a system exception occurred 2181 */ 2182 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First( 2183 long groupId, long userId, long folderId, int status, 2184 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2185 throws com.liferay.portal.kernel.exception.SystemException; 2186 2187 /** 2188 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2189 * 2190 * @param groupId the group ID 2191 * @param userId the user ID 2192 * @param folderId the folder ID 2193 * @param status the status 2194 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2195 * @return the last matching bookmarks entry 2196 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2197 * @throws SystemException if a system exception occurred 2198 */ 2199 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last( 2200 long groupId, long userId, long folderId, int status, 2201 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2202 throws com.liferay.portal.kernel.exception.SystemException, 2203 com.liferay.portlet.bookmarks.NoSuchEntryException; 2204 2205 /** 2206 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2207 * 2208 * @param groupId the group ID 2209 * @param userId the user ID 2210 * @param folderId the folder ID 2211 * @param status the status 2212 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2213 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2214 * @throws SystemException if a system exception occurred 2215 */ 2216 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last( 2217 long groupId, long userId, long folderId, int status, 2218 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2219 throws com.liferay.portal.kernel.exception.SystemException; 2220 2221 /** 2222 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2223 * 2224 * @param entryId the primary key of the current bookmarks entry 2225 * @param groupId the group ID 2226 * @param userId the user ID 2227 * @param folderId the folder ID 2228 * @param status the status 2229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2230 * @return the previous, current, and next bookmarks entry 2231 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2232 * @throws SystemException if a system exception occurred 2233 */ 2234 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext( 2235 long entryId, long groupId, long userId, long folderId, int status, 2236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2237 throws com.liferay.portal.kernel.exception.SystemException, 2238 com.liferay.portlet.bookmarks.NoSuchEntryException; 2239 2240 /** 2241 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2242 * 2243 * @param groupId the group ID 2244 * @param userId the user ID 2245 * @param folderId the folder ID 2246 * @param status the status 2247 * @return the matching bookmarks entries that the user has permission to view 2248 * @throws SystemException if a system exception occurred 2249 */ 2250 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2251 long groupId, long userId, long folderId, int status) 2252 throws com.liferay.portal.kernel.exception.SystemException; 2253 2254 /** 2255 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2256 * 2257 * <p> 2258 * 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. 2259 * </p> 2260 * 2261 * @param groupId the group ID 2262 * @param userId the user ID 2263 * @param folderId the folder ID 2264 * @param status the status 2265 * @param start the lower bound of the range of bookmarks entries 2266 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2267 * @return the range of matching bookmarks entries that the user has permission to view 2268 * @throws SystemException if a system exception occurred 2269 */ 2270 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2271 long groupId, long userId, long folderId, int status, int start, int end) 2272 throws com.liferay.portal.kernel.exception.SystemException; 2273 2274 /** 2275 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2276 * 2277 * <p> 2278 * 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. 2279 * </p> 2280 * 2281 * @param groupId the group ID 2282 * @param userId the user ID 2283 * @param folderId the folder ID 2284 * @param status the status 2285 * @param start the lower bound of the range of bookmarks entries 2286 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2287 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2288 * @return the ordered range of matching bookmarks entries that the user has permission to view 2289 * @throws SystemException if a system exception occurred 2290 */ 2291 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2292 long groupId, long userId, long folderId, int status, int start, 2293 int end, 2294 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2295 throws com.liferay.portal.kernel.exception.SystemException; 2296 2297 /** 2298 * 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 = ?. 2299 * 2300 * @param entryId the primary key of the current bookmarks entry 2301 * @param groupId the group ID 2302 * @param userId the user ID 2303 * @param folderId the folder ID 2304 * @param status the status 2305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2306 * @return the previous, current, and next bookmarks entry 2307 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2308 * @throws SystemException if a system exception occurred 2309 */ 2310 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext( 2311 long entryId, long groupId, long userId, long folderId, int status, 2312 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2313 throws com.liferay.portal.kernel.exception.SystemException, 2314 com.liferay.portlet.bookmarks.NoSuchEntryException; 2315 2316 /** 2317 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2318 * 2319 * @param groupId the group ID 2320 * @param userId the user ID 2321 * @param folderIds the folder IDs 2322 * @param status the status 2323 * @return the matching bookmarks entries that the user has permission to view 2324 * @throws SystemException if a system exception occurred 2325 */ 2326 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2327 long groupId, long userId, long[] folderIds, int status) 2328 throws com.liferay.portal.kernel.exception.SystemException; 2329 2330 /** 2331 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2332 * 2333 * <p> 2334 * 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. 2335 * </p> 2336 * 2337 * @param groupId the group ID 2338 * @param userId the user ID 2339 * @param folderIds the folder IDs 2340 * @param status the status 2341 * @param start the lower bound of the range of bookmarks entries 2342 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2343 * @return the range of matching bookmarks entries that the user has permission to view 2344 * @throws SystemException if a system exception occurred 2345 */ 2346 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2347 long groupId, long userId, long[] folderIds, int status, int start, 2348 int end) throws com.liferay.portal.kernel.exception.SystemException; 2349 2350 /** 2351 * 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 = ?. 2352 * 2353 * <p> 2354 * 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. 2355 * </p> 2356 * 2357 * @param groupId the group ID 2358 * @param userId the user ID 2359 * @param folderIds the folder IDs 2360 * @param status the status 2361 * @param start the lower bound of the range of bookmarks entries 2362 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2363 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2364 * @return the ordered range of matching bookmarks entries that the user has permission to view 2365 * @throws SystemException if a system exception occurred 2366 */ 2367 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2368 long groupId, long userId, long[] folderIds, int status, int start, 2369 int end, 2370 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2371 throws com.liferay.portal.kernel.exception.SystemException; 2372 2373 /** 2374 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2375 * 2376 * <p> 2377 * 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. 2378 * </p> 2379 * 2380 * @param groupId the group ID 2381 * @param userId the user ID 2382 * @param folderIds the folder IDs 2383 * @param status the status 2384 * @return the matching bookmarks entries 2385 * @throws SystemException if a system exception occurred 2386 */ 2387 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2388 long groupId, long userId, long[] folderIds, int status) 2389 throws com.liferay.portal.kernel.exception.SystemException; 2390 2391 /** 2392 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2393 * 2394 * <p> 2395 * 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. 2396 * </p> 2397 * 2398 * @param groupId the group ID 2399 * @param userId the user ID 2400 * @param folderIds the folder IDs 2401 * @param status the status 2402 * @param start the lower bound of the range of bookmarks entries 2403 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2404 * @return the range of matching bookmarks entries 2405 * @throws SystemException if a system exception occurred 2406 */ 2407 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2408 long groupId, long userId, long[] folderIds, int status, int start, 2409 int end) throws com.liferay.portal.kernel.exception.SystemException; 2410 2411 /** 2412 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2413 * 2414 * <p> 2415 * 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. 2416 * </p> 2417 * 2418 * @param groupId the group ID 2419 * @param userId the user ID 2420 * @param folderIds the folder IDs 2421 * @param status the status 2422 * @param start the lower bound of the range of bookmarks entries 2423 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2424 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2425 * @return the ordered range of matching bookmarks entries 2426 * @throws SystemException if a system exception occurred 2427 */ 2428 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2429 long groupId, long userId, long[] folderIds, int status, int start, 2430 int end, 2431 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2432 throws com.liferay.portal.kernel.exception.SystemException; 2433 2434 /** 2435 * Removes all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ? from the database. 2436 * 2437 * @param groupId the group ID 2438 * @param userId the user ID 2439 * @param folderId the folder ID 2440 * @param status the status 2441 * @throws SystemException if a system exception occurred 2442 */ 2443 public void removeByG_U_F_S(long groupId, long userId, long folderId, 2444 int status) throws com.liferay.portal.kernel.exception.SystemException; 2445 2446 /** 2447 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2448 * 2449 * @param groupId the group ID 2450 * @param userId the user ID 2451 * @param folderId the folder ID 2452 * @param status the status 2453 * @return the number of matching bookmarks entries 2454 * @throws SystemException if a system exception occurred 2455 */ 2456 public int countByG_U_F_S(long groupId, long userId, long folderId, 2457 int status) throws com.liferay.portal.kernel.exception.SystemException; 2458 2459 /** 2460 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2461 * 2462 * @param groupId the group ID 2463 * @param userId the user ID 2464 * @param folderIds the folder IDs 2465 * @param status the status 2466 * @return the number of matching bookmarks entries 2467 * @throws SystemException if a system exception occurred 2468 */ 2469 public int countByG_U_F_S(long groupId, long userId, long[] folderIds, 2470 int status) throws com.liferay.portal.kernel.exception.SystemException; 2471 2472 /** 2473 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2474 * 2475 * @param groupId the group ID 2476 * @param userId the user ID 2477 * @param folderId the folder ID 2478 * @param status the status 2479 * @return the number of matching bookmarks entries that the user has permission to view 2480 * @throws SystemException if a system exception occurred 2481 */ 2482 public int filterCountByG_U_F_S(long groupId, long userId, long folderId, 2483 int status) throws com.liferay.portal.kernel.exception.SystemException; 2484 2485 /** 2486 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2487 * 2488 * @param groupId the group ID 2489 * @param userId the user ID 2490 * @param folderIds the folder IDs 2491 * @param status the status 2492 * @return the number of matching bookmarks entries that the user has permission to view 2493 * @throws SystemException if a system exception occurred 2494 */ 2495 public int filterCountByG_U_F_S(long groupId, long userId, 2496 long[] folderIds, int status) 2497 throws com.liferay.portal.kernel.exception.SystemException; 2498 2499 /** 2500 * Caches the bookmarks entry in the entity cache if it is enabled. 2501 * 2502 * @param bookmarksEntry the bookmarks entry 2503 */ 2504 public void cacheResult( 2505 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry); 2506 2507 /** 2508 * Caches the bookmarks entries in the entity cache if it is enabled. 2509 * 2510 * @param bookmarksEntries the bookmarks entries 2511 */ 2512 public void cacheResult( 2513 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries); 2514 2515 /** 2516 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 2517 * 2518 * @param entryId the primary key for the new bookmarks entry 2519 * @return the new bookmarks entry 2520 */ 2521 public com.liferay.portlet.bookmarks.model.BookmarksEntry create( 2522 long entryId); 2523 2524 /** 2525 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 2526 * 2527 * @param entryId the primary key of the bookmarks entry 2528 * @return the bookmarks entry that was removed 2529 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2530 * @throws SystemException if a system exception occurred 2531 */ 2532 public com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 2533 long entryId) 2534 throws com.liferay.portal.kernel.exception.SystemException, 2535 com.liferay.portlet.bookmarks.NoSuchEntryException; 2536 2537 public com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 2538 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 2539 throws com.liferay.portal.kernel.exception.SystemException; 2540 2541 /** 2542 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 2543 * 2544 * @param entryId the primary key of the bookmarks entry 2545 * @return the bookmarks entry 2546 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2547 * @throws SystemException if a system exception occurred 2548 */ 2549 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 2550 long entryId) 2551 throws com.liferay.portal.kernel.exception.SystemException, 2552 com.liferay.portlet.bookmarks.NoSuchEntryException; 2553 2554 /** 2555 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 2556 * 2557 * @param entryId the primary key of the bookmarks entry 2558 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 2559 * @throws SystemException if a system exception occurred 2560 */ 2561 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 2562 long entryId) 2563 throws com.liferay.portal.kernel.exception.SystemException; 2564 2565 /** 2566 * Returns all the bookmarks entries. 2567 * 2568 * @return the bookmarks entries 2569 * @throws SystemException if a system exception occurred 2570 */ 2571 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 2572 throws com.liferay.portal.kernel.exception.SystemException; 2573 2574 /** 2575 * Returns a range of all the bookmarks entries. 2576 * 2577 * <p> 2578 * 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. 2579 * </p> 2580 * 2581 * @param start the lower bound of the range of bookmarks entries 2582 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2583 * @return the range of bookmarks entries 2584 * @throws SystemException if a system exception occurred 2585 */ 2586 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2587 int start, int end) 2588 throws com.liferay.portal.kernel.exception.SystemException; 2589 2590 /** 2591 * Returns an ordered range of all the bookmarks entries. 2592 * 2593 * <p> 2594 * 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. 2595 * </p> 2596 * 2597 * @param start the lower bound of the range of bookmarks entries 2598 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2599 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2600 * @return the ordered range of bookmarks entries 2601 * @throws SystemException if a system exception occurred 2602 */ 2603 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2604 int start, int end, 2605 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2606 throws com.liferay.portal.kernel.exception.SystemException; 2607 2608 /** 2609 * Removes all the bookmarks entries from the database. 2610 * 2611 * @throws SystemException if a system exception occurred 2612 */ 2613 public void removeAll() 2614 throws com.liferay.portal.kernel.exception.SystemException; 2615 2616 /** 2617 * Returns the number of bookmarks entries. 2618 * 2619 * @return the number of bookmarks entries 2620 * @throws SystemException if a system exception occurred 2621 */ 2622 public int countAll() 2623 throws com.liferay.portal.kernel.exception.SystemException; 2624 }