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 companyId = ?. 529 * 530 * @param companyId the company ID 531 * @return the matching bookmarks entries 532 * @throws SystemException if a system exception occurred 533 */ 534 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 535 long companyId) 536 throws com.liferay.portal.kernel.exception.SystemException; 537 538 /** 539 * Returns a range of all the bookmarks entries where companyId = ?. 540 * 541 * <p> 542 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 543 * </p> 544 * 545 * @param companyId the company ID 546 * @param start the lower bound of the range of bookmarks entries 547 * @param end the upper bound of the range of bookmarks entries (not inclusive) 548 * @return the range of matching bookmarks entries 549 * @throws SystemException if a system exception occurred 550 */ 551 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 552 long companyId, int start, int end) 553 throws com.liferay.portal.kernel.exception.SystemException; 554 555 /** 556 * Returns an ordered range of all the bookmarks entries where companyId = ?. 557 * 558 * <p> 559 * 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. 560 * </p> 561 * 562 * @param companyId the company ID 563 * @param start the lower bound of the range of bookmarks entries 564 * @param end the upper bound of the range of bookmarks entries (not inclusive) 565 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 566 * @return the ordered range of matching bookmarks entries 567 * @throws SystemException if a system exception occurred 568 */ 569 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId( 570 long companyId, int start, int end, 571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 572 throws com.liferay.portal.kernel.exception.SystemException; 573 574 /** 575 * Returns the first bookmarks entry in the ordered set where companyId = ?. 576 * 577 * @param companyId the company ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching bookmarks entry 580 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_First( 584 long companyId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.bookmarks.NoSuchEntryException; 588 589 /** 590 * Returns the first bookmarks entry in the ordered set where companyId = ?. 591 * 592 * @param companyId the company ID 593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 594 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 595 * @throws SystemException if a system exception occurred 596 */ 597 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_First( 598 long companyId, 599 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 600 throws com.liferay.portal.kernel.exception.SystemException; 601 602 /** 603 * Returns the last bookmarks entry in the ordered set where companyId = ?. 604 * 605 * @param companyId the company ID 606 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 607 * @return the last matching bookmarks entry 608 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 609 * @throws SystemException if a system exception occurred 610 */ 611 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_Last( 612 long companyId, 613 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 614 throws com.liferay.portal.kernel.exception.SystemException, 615 com.liferay.portlet.bookmarks.NoSuchEntryException; 616 617 /** 618 * Returns the last bookmarks entry in the ordered set where companyId = ?. 619 * 620 * @param companyId the company ID 621 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 622 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 623 * @throws SystemException if a system exception occurred 624 */ 625 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_Last( 626 long companyId, 627 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 628 throws com.liferay.portal.kernel.exception.SystemException; 629 630 /** 631 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = ?. 632 * 633 * @param entryId the primary key of the current bookmarks entry 634 * @param companyId the company ID 635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 636 * @return the previous, current, and next bookmarks entry 637 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 638 * @throws SystemException if a system exception occurred 639 */ 640 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByCompanyId_PrevAndNext( 641 long entryId, long companyId, 642 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 643 throws com.liferay.portal.kernel.exception.SystemException, 644 com.liferay.portlet.bookmarks.NoSuchEntryException; 645 646 /** 647 * Removes all the bookmarks entries where companyId = ? from the database. 648 * 649 * @param companyId the company ID 650 * @throws SystemException if a system exception occurred 651 */ 652 public void removeByCompanyId(long companyId) 653 throws com.liferay.portal.kernel.exception.SystemException; 654 655 /** 656 * Returns the number of bookmarks entries where companyId = ?. 657 * 658 * @param companyId the company ID 659 * @return the number of matching bookmarks entries 660 * @throws SystemException if a system exception occurred 661 */ 662 public int countByCompanyId(long companyId) 663 throws com.liferay.portal.kernel.exception.SystemException; 664 665 /** 666 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 667 * 668 * @param groupId the group ID 669 * @param folderId the folder ID 670 * @return the matching bookmarks entries 671 * @throws SystemException if a system exception occurred 672 */ 673 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 674 long groupId, long folderId) 675 throws com.liferay.portal.kernel.exception.SystemException; 676 677 /** 678 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 679 * 680 * <p> 681 * 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. 682 * </p> 683 * 684 * @param groupId the group ID 685 * @param folderId the folder ID 686 * @param start the lower bound of the range of bookmarks entries 687 * @param end the upper bound of the range of bookmarks entries (not inclusive) 688 * @return the range of matching bookmarks entries 689 * @throws SystemException if a system exception occurred 690 */ 691 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 692 long groupId, long folderId, int start, int end) 693 throws com.liferay.portal.kernel.exception.SystemException; 694 695 /** 696 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 697 * 698 * <p> 699 * 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. 700 * </p> 701 * 702 * @param groupId the group ID 703 * @param folderId the folder ID 704 * @param start the lower bound of the range of bookmarks entries 705 * @param end the upper bound of the range of bookmarks entries (not inclusive) 706 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 707 * @return the ordered range of matching bookmarks entries 708 * @throws SystemException if a system exception occurred 709 */ 710 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 711 long groupId, long folderId, int start, int end, 712 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 713 throws com.liferay.portal.kernel.exception.SystemException; 714 715 /** 716 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 717 * 718 * @param groupId the group ID 719 * @param folderId the folder ID 720 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 721 * @return the first matching bookmarks entry 722 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 723 * @throws SystemException if a system exception occurred 724 */ 725 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 726 long groupId, long folderId, 727 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 728 throws com.liferay.portal.kernel.exception.SystemException, 729 com.liferay.portlet.bookmarks.NoSuchEntryException; 730 731 /** 732 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 733 * 734 * @param groupId the group ID 735 * @param folderId the folder ID 736 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 737 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 738 * @throws SystemException if a system exception occurred 739 */ 740 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 741 long groupId, long folderId, 742 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 743 throws com.liferay.portal.kernel.exception.SystemException; 744 745 /** 746 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 747 * 748 * @param groupId the group ID 749 * @param folderId the folder ID 750 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 751 * @return the last matching bookmarks entry 752 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 753 * @throws SystemException if a system exception occurred 754 */ 755 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 756 long groupId, long folderId, 757 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 758 throws com.liferay.portal.kernel.exception.SystemException, 759 com.liferay.portlet.bookmarks.NoSuchEntryException; 760 761 /** 762 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 763 * 764 * @param groupId the group ID 765 * @param folderId the folder ID 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 768 * @throws SystemException if a system exception occurred 769 */ 770 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 771 long groupId, long folderId, 772 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 773 throws com.liferay.portal.kernel.exception.SystemException; 774 775 /** 776 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 777 * 778 * @param entryId the primary key of the current bookmarks entry 779 * @param groupId the group ID 780 * @param folderId the folder ID 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the previous, current, and next bookmarks entry 783 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 784 * @throws SystemException if a system exception occurred 785 */ 786 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 787 long entryId, long groupId, long folderId, 788 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 789 throws com.liferay.portal.kernel.exception.SystemException, 790 com.liferay.portlet.bookmarks.NoSuchEntryException; 791 792 /** 793 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 794 * 795 * @param groupId the group ID 796 * @param folderId the folder ID 797 * @return the matching bookmarks entries that the user has permission to view 798 * @throws SystemException if a system exception occurred 799 */ 800 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 801 long groupId, long folderId) 802 throws com.liferay.portal.kernel.exception.SystemException; 803 804 /** 805 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 806 * 807 * <p> 808 * 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. 809 * </p> 810 * 811 * @param groupId the group ID 812 * @param folderId the folder ID 813 * @param start the lower bound of the range of bookmarks entries 814 * @param end the upper bound of the range of bookmarks entries (not inclusive) 815 * @return the range of matching bookmarks entries that the user has permission to view 816 * @throws SystemException if a system exception occurred 817 */ 818 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 819 long groupId, long folderId, int start, int end) 820 throws com.liferay.portal.kernel.exception.SystemException; 821 822 /** 823 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 824 * 825 * <p> 826 * 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. 827 * </p> 828 * 829 * @param groupId the group ID 830 * @param folderId the folder ID 831 * @param start the lower bound of the range of bookmarks entries 832 * @param end the upper bound of the range of bookmarks entries (not inclusive) 833 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 834 * @return the ordered range of matching bookmarks entries that the user has permission to view 835 * @throws SystemException if a system exception occurred 836 */ 837 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 838 long groupId, long folderId, int start, int end, 839 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 840 throws com.liferay.portal.kernel.exception.SystemException; 841 842 /** 843 * 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 = ?. 844 * 845 * @param entryId the primary key of the current bookmarks entry 846 * @param groupId the group ID 847 * @param folderId the folder ID 848 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 849 * @return the previous, current, and next bookmarks entry 850 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 851 * @throws SystemException if a system exception occurred 852 */ 853 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 854 long entryId, long groupId, long folderId, 855 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 856 throws com.liferay.portal.kernel.exception.SystemException, 857 com.liferay.portlet.bookmarks.NoSuchEntryException; 858 859 /** 860 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 861 * 862 * @param groupId the group ID 863 * @param folderIds the folder IDs 864 * @return the matching bookmarks entries that the user has permission to view 865 * @throws SystemException if a system exception occurred 866 */ 867 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 868 long groupId, long[] folderIds) 869 throws com.liferay.portal.kernel.exception.SystemException; 870 871 /** 872 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 873 * 874 * <p> 875 * 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. 876 * </p> 877 * 878 * @param groupId the group ID 879 * @param folderIds the folder IDs 880 * @param start the lower bound of the range of bookmarks entries 881 * @param end the upper bound of the range of bookmarks entries (not inclusive) 882 * @return the range of matching bookmarks entries that the user has permission to view 883 * @throws SystemException if a system exception occurred 884 */ 885 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 886 long groupId, long[] folderIds, int start, int end) 887 throws com.liferay.portal.kernel.exception.SystemException; 888 889 /** 890 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 891 * 892 * <p> 893 * 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. 894 * </p> 895 * 896 * @param groupId the group ID 897 * @param folderIds the folder IDs 898 * @param start the lower bound of the range of bookmarks entries 899 * @param end the upper bound of the range of bookmarks entries (not inclusive) 900 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 901 * @return the ordered range of matching bookmarks entries that the user has permission to view 902 * @throws SystemException if a system exception occurred 903 */ 904 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 905 long groupId, long[] folderIds, int start, int end, 906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 907 throws com.liferay.portal.kernel.exception.SystemException; 908 909 /** 910 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 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 folderIds the folder IDs 918 * @return the matching bookmarks entries 919 * @throws SystemException if a system exception occurred 920 */ 921 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 922 long groupId, long[] folderIds) 923 throws com.liferay.portal.kernel.exception.SystemException; 924 925 /** 926 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 927 * 928 * <p> 929 * 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. 930 * </p> 931 * 932 * @param groupId the group ID 933 * @param folderIds the folder IDs 934 * @param start the lower bound of the range of bookmarks entries 935 * @param end the upper bound of the range of bookmarks entries (not inclusive) 936 * @return the range of matching bookmarks entries 937 * @throws SystemException if a system exception occurred 938 */ 939 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 940 long groupId, long[] folderIds, int start, int end) 941 throws com.liferay.portal.kernel.exception.SystemException; 942 943 /** 944 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 945 * 946 * <p> 947 * 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. 948 * </p> 949 * 950 * @param groupId the group ID 951 * @param folderIds the folder IDs 952 * @param start the lower bound of the range of bookmarks entries 953 * @param end the upper bound of the range of bookmarks entries (not inclusive) 954 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 955 * @return the ordered range of matching bookmarks entries 956 * @throws SystemException if a system exception occurred 957 */ 958 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 959 long groupId, long[] folderIds, int start, int end, 960 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 961 throws com.liferay.portal.kernel.exception.SystemException; 962 963 /** 964 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 965 * 966 * @param groupId the group ID 967 * @param folderId the folder ID 968 * @throws SystemException if a system exception occurred 969 */ 970 public void removeByG_F(long groupId, long folderId) 971 throws com.liferay.portal.kernel.exception.SystemException; 972 973 /** 974 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 975 * 976 * @param groupId the group ID 977 * @param folderId the folder ID 978 * @return the number of matching bookmarks entries 979 * @throws SystemException if a system exception occurred 980 */ 981 public int countByG_F(long groupId, long folderId) 982 throws com.liferay.portal.kernel.exception.SystemException; 983 984 /** 985 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 986 * 987 * @param groupId the group ID 988 * @param folderIds the folder IDs 989 * @return the number of matching bookmarks entries 990 * @throws SystemException if a system exception occurred 991 */ 992 public int countByG_F(long groupId, long[] folderIds) 993 throws com.liferay.portal.kernel.exception.SystemException; 994 995 /** 996 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 997 * 998 * @param groupId the group ID 999 * @param folderId the folder ID 1000 * @return the number of matching bookmarks entries that the user has permission to view 1001 * @throws SystemException if a system exception occurred 1002 */ 1003 public int filterCountByG_F(long groupId, long folderId) 1004 throws com.liferay.portal.kernel.exception.SystemException; 1005 1006 /** 1007 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1008 * 1009 * @param groupId the group ID 1010 * @param folderIds the folder IDs 1011 * @return the number of matching bookmarks entries that the user has permission to view 1012 * @throws SystemException if a system exception occurred 1013 */ 1014 public int filterCountByG_F(long groupId, long[] folderIds) 1015 throws com.liferay.portal.kernel.exception.SystemException; 1016 1017 /** 1018 * Returns all the bookmarks entries where groupId = ? and status = ?. 1019 * 1020 * @param groupId the group ID 1021 * @param status the status 1022 * @return the matching bookmarks entries 1023 * @throws SystemException if a system exception occurred 1024 */ 1025 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1026 long groupId, int status) 1027 throws com.liferay.portal.kernel.exception.SystemException; 1028 1029 /** 1030 * Returns a range of all the bookmarks entries where groupId = ? and status = ?. 1031 * 1032 * <p> 1033 * 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. 1034 * </p> 1035 * 1036 * @param groupId the group ID 1037 * @param status the status 1038 * @param start the lower bound of the range of bookmarks entries 1039 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1040 * @return the range of matching bookmarks entries 1041 * @throws SystemException if a system exception occurred 1042 */ 1043 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1044 long groupId, int status, int start, int end) 1045 throws com.liferay.portal.kernel.exception.SystemException; 1046 1047 /** 1048 * Returns an ordered range of all the bookmarks entries where groupId = ? and status = ?. 1049 * 1050 * <p> 1051 * 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. 1052 * </p> 1053 * 1054 * @param groupId the group ID 1055 * @param status the status 1056 * @param start the lower bound of the range of bookmarks entries 1057 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1058 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1059 * @return the ordered range of matching bookmarks entries 1060 * @throws SystemException if a system exception occurred 1061 */ 1062 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 1063 long groupId, int status, int start, int end, 1064 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1065 throws com.liferay.portal.kernel.exception.SystemException; 1066 1067 /** 1068 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1069 * 1070 * @param groupId the group ID 1071 * @param status the status 1072 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1073 * @return the first matching bookmarks entry 1074 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1075 * @throws SystemException if a system exception occurred 1076 */ 1077 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First( 1078 long groupId, int status, 1079 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1080 throws com.liferay.portal.kernel.exception.SystemException, 1081 com.liferay.portlet.bookmarks.NoSuchEntryException; 1082 1083 /** 1084 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 1085 * 1086 * @param groupId the group ID 1087 * @param status the status 1088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1089 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1090 * @throws SystemException if a system exception occurred 1091 */ 1092 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First( 1093 long groupId, int status, 1094 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1095 throws com.liferay.portal.kernel.exception.SystemException; 1096 1097 /** 1098 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1099 * 1100 * @param groupId the group ID 1101 * @param status the status 1102 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1103 * @return the last matching bookmarks entry 1104 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1105 * @throws SystemException if a system exception occurred 1106 */ 1107 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last( 1108 long groupId, int status, 1109 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1110 throws com.liferay.portal.kernel.exception.SystemException, 1111 com.liferay.portlet.bookmarks.NoSuchEntryException; 1112 1113 /** 1114 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 1115 * 1116 * @param groupId the group ID 1117 * @param status the status 1118 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1119 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1120 * @throws SystemException if a system exception occurred 1121 */ 1122 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last( 1123 long groupId, int status, 1124 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1125 throws com.liferay.portal.kernel.exception.SystemException; 1126 1127 /** 1128 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and status = ?. 1129 * 1130 * @param entryId the primary key of the current bookmarks entry 1131 * @param groupId the group ID 1132 * @param status the status 1133 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1134 * @return the previous, current, and next bookmarks entry 1135 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1136 * @throws SystemException if a system exception occurred 1137 */ 1138 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext( 1139 long entryId, long groupId, int status, 1140 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1141 throws com.liferay.portal.kernel.exception.SystemException, 1142 com.liferay.portlet.bookmarks.NoSuchEntryException; 1143 1144 /** 1145 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1146 * 1147 * @param groupId the group ID 1148 * @param status the status 1149 * @return the matching bookmarks entries that the user has permission to view 1150 * @throws SystemException if a system exception occurred 1151 */ 1152 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1153 long groupId, int status) 1154 throws com.liferay.portal.kernel.exception.SystemException; 1155 1156 /** 1157 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1158 * 1159 * <p> 1160 * 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. 1161 * </p> 1162 * 1163 * @param groupId the group ID 1164 * @param status the status 1165 * @param start the lower bound of the range of bookmarks entries 1166 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1167 * @return the range of matching bookmarks entries that the user has permission to view 1168 * @throws SystemException if a system exception occurred 1169 */ 1170 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1171 long groupId, int status, int start, int end) 1172 throws com.liferay.portal.kernel.exception.SystemException; 1173 1174 /** 1175 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and status = ?. 1176 * 1177 * <p> 1178 * 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. 1179 * </p> 1180 * 1181 * @param groupId the group ID 1182 * @param status the status 1183 * @param start the lower bound of the range of bookmarks entries 1184 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1185 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1186 * @return the ordered range of matching bookmarks entries that the user has permission to view 1187 * @throws SystemException if a system exception occurred 1188 */ 1189 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1190 long groupId, int status, int start, int end, 1191 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1192 throws com.liferay.portal.kernel.exception.SystemException; 1193 1194 /** 1195 * 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 = ?. 1196 * 1197 * @param entryId the primary key of the current bookmarks entry 1198 * @param groupId the group ID 1199 * @param status the status 1200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1201 * @return the previous, current, and next bookmarks entry 1202 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1203 * @throws SystemException if a system exception occurred 1204 */ 1205 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext( 1206 long entryId, long groupId, int status, 1207 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1208 throws com.liferay.portal.kernel.exception.SystemException, 1209 com.liferay.portlet.bookmarks.NoSuchEntryException; 1210 1211 /** 1212 * Removes all the bookmarks entries where groupId = ? and status = ? from the database. 1213 * 1214 * @param groupId the group ID 1215 * @param status the status 1216 * @throws SystemException if a system exception occurred 1217 */ 1218 public void removeByG_S(long groupId, int status) 1219 throws com.liferay.portal.kernel.exception.SystemException; 1220 1221 /** 1222 * Returns the number of bookmarks entries where groupId = ? and status = ?. 1223 * 1224 * @param groupId the group ID 1225 * @param status the status 1226 * @return the number of matching bookmarks entries 1227 * @throws SystemException if a system exception occurred 1228 */ 1229 public int countByG_S(long groupId, int status) 1230 throws com.liferay.portal.kernel.exception.SystemException; 1231 1232 /** 1233 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1234 * 1235 * @param groupId the group ID 1236 * @param status the status 1237 * @return the number of matching bookmarks entries that the user has permission to view 1238 * @throws SystemException if a system exception occurred 1239 */ 1240 public int filterCountByG_S(long groupId, int status) 1241 throws com.liferay.portal.kernel.exception.SystemException; 1242 1243 /** 1244 * Returns all the bookmarks entries where companyId = ? and status ≠ ?. 1245 * 1246 * @param companyId the company ID 1247 * @param status the status 1248 * @return the matching bookmarks entries 1249 * @throws SystemException if a system exception occurred 1250 */ 1251 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1252 long companyId, int status) 1253 throws com.liferay.portal.kernel.exception.SystemException; 1254 1255 /** 1256 * Returns a range of all the bookmarks entries where companyId = ? and status ≠ ?. 1257 * 1258 * <p> 1259 * 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. 1260 * </p> 1261 * 1262 * @param companyId the company ID 1263 * @param status the status 1264 * @param start the lower bound of the range of bookmarks entries 1265 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1266 * @return the range of matching bookmarks entries 1267 * @throws SystemException if a system exception occurred 1268 */ 1269 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1270 long companyId, int status, int start, int end) 1271 throws com.liferay.portal.kernel.exception.SystemException; 1272 1273 /** 1274 * Returns an ordered range of all the bookmarks entries where companyId = ? and status ≠ ?. 1275 * 1276 * <p> 1277 * 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. 1278 * </p> 1279 * 1280 * @param companyId the company 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 1286 * @throws SystemException if a system exception occurred 1287 */ 1288 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS( 1289 long companyId, 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 first bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1295 * 1296 * @param companyId the company ID 1297 * @param status the status 1298 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1299 * @return the first matching bookmarks entry 1300 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1301 * @throws SystemException if a system exception occurred 1302 */ 1303 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_First( 1304 long companyId, int status, 1305 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1306 throws com.liferay.portal.kernel.exception.SystemException, 1307 com.liferay.portlet.bookmarks.NoSuchEntryException; 1308 1309 /** 1310 * Returns the first bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1311 * 1312 * @param companyId the company ID 1313 * @param status the status 1314 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1315 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1316 * @throws SystemException if a system exception occurred 1317 */ 1318 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_First( 1319 long companyId, int status, 1320 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1321 throws com.liferay.portal.kernel.exception.SystemException; 1322 1323 /** 1324 * Returns the last bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1325 * 1326 * @param companyId the company ID 1327 * @param status the status 1328 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1329 * @return the last matching bookmarks entry 1330 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1331 * @throws SystemException if a system exception occurred 1332 */ 1333 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_Last( 1334 long companyId, int status, 1335 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1336 throws com.liferay.portal.kernel.exception.SystemException, 1337 com.liferay.portlet.bookmarks.NoSuchEntryException; 1338 1339 /** 1340 * Returns the last bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1341 * 1342 * @param companyId the company ID 1343 * @param status the status 1344 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1345 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1346 * @throws SystemException if a system exception occurred 1347 */ 1348 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_Last( 1349 long companyId, int status, 1350 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1351 throws com.liferay.portal.kernel.exception.SystemException; 1352 1353 /** 1354 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = ? and status ≠ ?. 1355 * 1356 * @param entryId the primary key of the current bookmarks entry 1357 * @param companyId the company ID 1358 * @param status the status 1359 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1360 * @return the previous, current, and next bookmarks entry 1361 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1362 * @throws SystemException if a system exception occurred 1363 */ 1364 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByC_NotS_PrevAndNext( 1365 long entryId, long companyId, int status, 1366 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1367 throws com.liferay.portal.kernel.exception.SystemException, 1368 com.liferay.portlet.bookmarks.NoSuchEntryException; 1369 1370 /** 1371 * Removes all the bookmarks entries where companyId = ? and status ≠ ? from the database. 1372 * 1373 * @param companyId the company ID 1374 * @param status the status 1375 * @throws SystemException if a system exception occurred 1376 */ 1377 public void removeByC_NotS(long companyId, int status) 1378 throws com.liferay.portal.kernel.exception.SystemException; 1379 1380 /** 1381 * Returns the number of bookmarks entries where companyId = ? and status ≠ ?. 1382 * 1383 * @param companyId the company ID 1384 * @param status the status 1385 * @return the number of matching bookmarks entries 1386 * @throws SystemException if a system exception occurred 1387 */ 1388 public int countByC_NotS(long companyId, int status) 1389 throws com.liferay.portal.kernel.exception.SystemException; 1390 1391 /** 1392 * Returns all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1393 * 1394 * @param groupId the group ID 1395 * @param userId the user ID 1396 * @param status the status 1397 * @return the matching bookmarks entries 1398 * @throws SystemException if a system exception occurred 1399 */ 1400 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1401 long groupId, long userId, int status) 1402 throws com.liferay.portal.kernel.exception.SystemException; 1403 1404 /** 1405 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1406 * 1407 * <p> 1408 * 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. 1409 * </p> 1410 * 1411 * @param groupId the group ID 1412 * @param userId the user ID 1413 * @param status the status 1414 * @param start the lower bound of the range of bookmarks entries 1415 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1416 * @return the range of matching bookmarks entries 1417 * @throws SystemException if a system exception occurred 1418 */ 1419 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1420 long groupId, long userId, int status, int start, int end) 1421 throws com.liferay.portal.kernel.exception.SystemException; 1422 1423 /** 1424 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1425 * 1426 * <p> 1427 * 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. 1428 * </p> 1429 * 1430 * @param groupId the group ID 1431 * @param userId the user ID 1432 * @param status the status 1433 * @param start the lower bound of the range of bookmarks entries 1434 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1435 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1436 * @return the ordered range of matching bookmarks entries 1437 * @throws SystemException if a system exception occurred 1438 */ 1439 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1440 long groupId, long userId, int status, int start, int end, 1441 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1442 throws com.liferay.portal.kernel.exception.SystemException; 1443 1444 /** 1445 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1446 * 1447 * @param groupId the group ID 1448 * @param userId the user ID 1449 * @param status the status 1450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1451 * @return the first matching bookmarks entry 1452 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1453 * @throws SystemException if a system exception occurred 1454 */ 1455 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First( 1456 long groupId, long userId, int status, 1457 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1458 throws com.liferay.portal.kernel.exception.SystemException, 1459 com.liferay.portlet.bookmarks.NoSuchEntryException; 1460 1461 /** 1462 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1463 * 1464 * @param groupId the group ID 1465 * @param userId the user ID 1466 * @param status the status 1467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1468 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1469 * @throws SystemException if a system exception occurred 1470 */ 1471 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First( 1472 long groupId, long userId, int status, 1473 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1474 throws com.liferay.portal.kernel.exception.SystemException; 1475 1476 /** 1477 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1478 * 1479 * @param groupId the group ID 1480 * @param userId the user ID 1481 * @param status the status 1482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1483 * @return the last matching bookmarks entry 1484 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1485 * @throws SystemException if a system exception occurred 1486 */ 1487 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last( 1488 long groupId, long userId, int status, 1489 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1490 throws com.liferay.portal.kernel.exception.SystemException, 1491 com.liferay.portlet.bookmarks.NoSuchEntryException; 1492 1493 /** 1494 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1495 * 1496 * @param groupId the group ID 1497 * @param userId the user ID 1498 * @param status the status 1499 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1500 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1501 * @throws SystemException if a system exception occurred 1502 */ 1503 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last( 1504 long groupId, long userId, int status, 1505 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1506 throws com.liferay.portal.kernel.exception.SystemException; 1507 1508 /** 1509 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1510 * 1511 * @param entryId the primary key of the current bookmarks entry 1512 * @param groupId the group ID 1513 * @param userId the user ID 1514 * @param status the status 1515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1516 * @return the previous, current, and next bookmarks entry 1517 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1518 * @throws SystemException if a system exception occurred 1519 */ 1520 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext( 1521 long entryId, long groupId, long userId, int status, 1522 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1523 throws com.liferay.portal.kernel.exception.SystemException, 1524 com.liferay.portlet.bookmarks.NoSuchEntryException; 1525 1526 /** 1527 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1528 * 1529 * @param groupId the group ID 1530 * @param userId the user ID 1531 * @param status the status 1532 * @return the matching bookmarks entries that the user has permission to view 1533 * @throws SystemException if a system exception occurred 1534 */ 1535 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1536 long groupId, long userId, int status) 1537 throws com.liferay.portal.kernel.exception.SystemException; 1538 1539 /** 1540 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1541 * 1542 * <p> 1543 * 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. 1544 * </p> 1545 * 1546 * @param groupId the group ID 1547 * @param userId the user ID 1548 * @param status the status 1549 * @param start the lower bound of the range of bookmarks entries 1550 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1551 * @return the range of matching bookmarks entries that the user has permission to view 1552 * @throws SystemException if a system exception occurred 1553 */ 1554 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1555 long groupId, long userId, int status, int start, int end) 1556 throws com.liferay.portal.kernel.exception.SystemException; 1557 1558 /** 1559 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and status = ?. 1560 * 1561 * <p> 1562 * 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. 1563 * </p> 1564 * 1565 * @param groupId the group ID 1566 * @param userId the user ID 1567 * @param status the status 1568 * @param start the lower bound of the range of bookmarks entries 1569 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1570 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1571 * @return the ordered range of matching bookmarks entries that the user has permission to view 1572 * @throws SystemException if a system exception occurred 1573 */ 1574 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1575 long groupId, long userId, int status, int start, int end, 1576 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1577 throws com.liferay.portal.kernel.exception.SystemException; 1578 1579 /** 1580 * 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 = ?. 1581 * 1582 * @param entryId the primary key of the current bookmarks entry 1583 * @param groupId the group ID 1584 * @param userId the user ID 1585 * @param status the status 1586 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1587 * @return the previous, current, and next bookmarks entry 1588 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1589 * @throws SystemException if a system exception occurred 1590 */ 1591 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext( 1592 long entryId, long groupId, long userId, int status, 1593 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1594 throws com.liferay.portal.kernel.exception.SystemException, 1595 com.liferay.portlet.bookmarks.NoSuchEntryException; 1596 1597 /** 1598 * Removes all the bookmarks entries where groupId = ? and userId = ? and status = ? from the database. 1599 * 1600 * @param groupId the group ID 1601 * @param userId the user ID 1602 * @param status the status 1603 * @throws SystemException if a system exception occurred 1604 */ 1605 public void removeByG_U_S(long groupId, long userId, int status) 1606 throws com.liferay.portal.kernel.exception.SystemException; 1607 1608 /** 1609 * Returns the number of bookmarks entries where groupId = ? and userId = ? and status = ?. 1610 * 1611 * @param groupId the group ID 1612 * @param userId the user ID 1613 * @param status the status 1614 * @return the number of matching bookmarks entries 1615 * @throws SystemException if a system exception occurred 1616 */ 1617 public int countByG_U_S(long groupId, long userId, int status) 1618 throws com.liferay.portal.kernel.exception.SystemException; 1619 1620 /** 1621 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1622 * 1623 * @param groupId the group ID 1624 * @param userId the user ID 1625 * @param status the status 1626 * @return the number of matching bookmarks entries that the user has permission to view 1627 * @throws SystemException if a system exception occurred 1628 */ 1629 public int filterCountByG_U_S(long groupId, long userId, int status) 1630 throws com.liferay.portal.kernel.exception.SystemException; 1631 1632 /** 1633 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1634 * 1635 * @param groupId the group ID 1636 * @param folderId the folder ID 1637 * @param status the status 1638 * @return the matching bookmarks entries 1639 * @throws SystemException if a system exception occurred 1640 */ 1641 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1642 long groupId, long folderId, int status) 1643 throws com.liferay.portal.kernel.exception.SystemException; 1644 1645 /** 1646 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1647 * 1648 * <p> 1649 * 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. 1650 * </p> 1651 * 1652 * @param groupId the group ID 1653 * @param folderId the folder ID 1654 * @param status the status 1655 * @param start the lower bound of the range of bookmarks entries 1656 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1657 * @return the range of matching bookmarks entries 1658 * @throws SystemException if a system exception occurred 1659 */ 1660 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1661 long groupId, long folderId, int status, int start, int end) 1662 throws com.liferay.portal.kernel.exception.SystemException; 1663 1664 /** 1665 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1666 * 1667 * <p> 1668 * 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. 1669 * </p> 1670 * 1671 * @param groupId the group ID 1672 * @param folderId the folder ID 1673 * @param status the status 1674 * @param start the lower bound of the range of bookmarks entries 1675 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1676 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1677 * @return the ordered range of matching bookmarks entries 1678 * @throws SystemException if a system exception occurred 1679 */ 1680 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1681 long groupId, long folderId, int status, int start, int end, 1682 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1683 throws com.liferay.portal.kernel.exception.SystemException; 1684 1685 /** 1686 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1687 * 1688 * @param groupId the group ID 1689 * @param folderId the folder ID 1690 * @param status the status 1691 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1692 * @return the first matching bookmarks entry 1693 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1694 * @throws SystemException if a system exception occurred 1695 */ 1696 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First( 1697 long groupId, long folderId, int status, 1698 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1699 throws com.liferay.portal.kernel.exception.SystemException, 1700 com.liferay.portlet.bookmarks.NoSuchEntryException; 1701 1702 /** 1703 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1704 * 1705 * @param groupId the group ID 1706 * @param folderId the folder ID 1707 * @param status the status 1708 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1709 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1710 * @throws SystemException if a system exception occurred 1711 */ 1712 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First( 1713 long groupId, long folderId, int status, 1714 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1715 throws com.liferay.portal.kernel.exception.SystemException; 1716 1717 /** 1718 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1719 * 1720 * @param groupId the group ID 1721 * @param folderId the folder ID 1722 * @param status the status 1723 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1724 * @return the last matching bookmarks entry 1725 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1726 * @throws SystemException if a system exception occurred 1727 */ 1728 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last( 1729 long groupId, long folderId, int status, 1730 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1731 throws com.liferay.portal.kernel.exception.SystemException, 1732 com.liferay.portlet.bookmarks.NoSuchEntryException; 1733 1734 /** 1735 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1736 * 1737 * @param groupId the group ID 1738 * @param folderId the folder ID 1739 * @param status the status 1740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1741 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1742 * @throws SystemException if a system exception occurred 1743 */ 1744 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last( 1745 long groupId, long folderId, int status, 1746 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1747 throws com.liferay.portal.kernel.exception.SystemException; 1748 1749 /** 1750 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1751 * 1752 * @param entryId the primary key of the current bookmarks entry 1753 * @param groupId the group ID 1754 * @param folderId the folder ID 1755 * @param status the status 1756 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1757 * @return the previous, current, and next bookmarks entry 1758 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1759 * @throws SystemException if a system exception occurred 1760 */ 1761 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext( 1762 long entryId, long groupId, long folderId, int status, 1763 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1764 throws com.liferay.portal.kernel.exception.SystemException, 1765 com.liferay.portlet.bookmarks.NoSuchEntryException; 1766 1767 /** 1768 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1769 * 1770 * @param groupId the group ID 1771 * @param folderId the folder ID 1772 * @param status the status 1773 * @return the matching bookmarks entries that the user has permission to view 1774 * @throws SystemException if a system exception occurred 1775 */ 1776 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1777 long groupId, long folderId, int status) 1778 throws com.liferay.portal.kernel.exception.SystemException; 1779 1780 /** 1781 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1782 * 1783 * <p> 1784 * 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. 1785 * </p> 1786 * 1787 * @param groupId the group ID 1788 * @param folderId the folder ID 1789 * @param status the status 1790 * @param start the lower bound of the range of bookmarks entries 1791 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1792 * @return the range of matching bookmarks entries that the user has permission to view 1793 * @throws SystemException if a system exception occurred 1794 */ 1795 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1796 long groupId, long folderId, int status, int start, int end) 1797 throws com.liferay.portal.kernel.exception.SystemException; 1798 1799 /** 1800 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 1801 * 1802 * <p> 1803 * 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. 1804 * </p> 1805 * 1806 * @param groupId the group ID 1807 * @param folderId the folder ID 1808 * @param status the status 1809 * @param start the lower bound of the range of bookmarks entries 1810 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1811 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1812 * @return the ordered range of matching bookmarks entries that the user has permission to view 1813 * @throws SystemException if a system exception occurred 1814 */ 1815 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1816 long groupId, long folderId, int status, int start, int end, 1817 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1818 throws com.liferay.portal.kernel.exception.SystemException; 1819 1820 /** 1821 * 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 = ?. 1822 * 1823 * @param entryId the primary key of the current bookmarks entry 1824 * @param groupId the group ID 1825 * @param folderId the folder ID 1826 * @param status the status 1827 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1828 * @return the previous, current, and next bookmarks entry 1829 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1830 * @throws SystemException if a system exception occurred 1831 */ 1832 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext( 1833 long entryId, long groupId, long folderId, int status, 1834 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1835 throws com.liferay.portal.kernel.exception.SystemException, 1836 com.liferay.portlet.bookmarks.NoSuchEntryException; 1837 1838 /** 1839 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1840 * 1841 * @param groupId the group ID 1842 * @param folderIds the folder IDs 1843 * @param status the status 1844 * @return the matching bookmarks entries that the user has permission to view 1845 * @throws SystemException if a system exception occurred 1846 */ 1847 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1848 long groupId, long[] folderIds, int status) 1849 throws com.liferay.portal.kernel.exception.SystemException; 1850 1851 /** 1852 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1853 * 1854 * <p> 1855 * 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. 1856 * </p> 1857 * 1858 * @param groupId the group ID 1859 * @param folderIds the folder IDs 1860 * @param status the status 1861 * @param start the lower bound of the range of bookmarks entries 1862 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1863 * @return the range of matching bookmarks entries that the user has permission to view 1864 * @throws SystemException if a system exception occurred 1865 */ 1866 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1867 long groupId, long[] folderIds, int status, int start, int end) 1868 throws com.liferay.portal.kernel.exception.SystemException; 1869 1870 /** 1871 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1872 * 1873 * <p> 1874 * 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. 1875 * </p> 1876 * 1877 * @param groupId the group ID 1878 * @param folderIds the folder IDs 1879 * @param status the status 1880 * @param start the lower bound of the range of bookmarks entries 1881 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1882 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1883 * @return the ordered range of matching bookmarks entries that the user has permission to view 1884 * @throws SystemException if a system exception occurred 1885 */ 1886 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1887 long groupId, long[] folderIds, int status, int start, int end, 1888 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1889 throws com.liferay.portal.kernel.exception.SystemException; 1890 1891 /** 1892 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1893 * 1894 * <p> 1895 * 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. 1896 * </p> 1897 * 1898 * @param groupId the group ID 1899 * @param folderIds the folder IDs 1900 * @param status the status 1901 * @return the matching bookmarks entries 1902 * @throws SystemException if a system exception occurred 1903 */ 1904 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1905 long groupId, long[] folderIds, int status) 1906 throws com.liferay.portal.kernel.exception.SystemException; 1907 1908 /** 1909 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1910 * 1911 * <p> 1912 * 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. 1913 * </p> 1914 * 1915 * @param groupId the group ID 1916 * @param folderIds the folder IDs 1917 * @param status the status 1918 * @param start the lower bound of the range of bookmarks entries 1919 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1920 * @return the range of matching bookmarks entries 1921 * @throws SystemException if a system exception occurred 1922 */ 1923 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1924 long groupId, long[] folderIds, int status, int start, int end) 1925 throws com.liferay.portal.kernel.exception.SystemException; 1926 1927 /** 1928 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1929 * 1930 * <p> 1931 * 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. 1932 * </p> 1933 * 1934 * @param groupId the group ID 1935 * @param folderIds the folder IDs 1936 * @param status the status 1937 * @param start the lower bound of the range of bookmarks entries 1938 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1939 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1940 * @return the ordered range of matching bookmarks entries 1941 * @throws SystemException if a system exception occurred 1942 */ 1943 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1944 long groupId, long[] folderIds, int status, int start, int end, 1945 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1946 throws com.liferay.portal.kernel.exception.SystemException; 1947 1948 /** 1949 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status = ? from the database. 1950 * 1951 * @param groupId the group ID 1952 * @param folderId the folder ID 1953 * @param status the status 1954 * @throws SystemException if a system exception occurred 1955 */ 1956 public void removeByG_F_S(long groupId, long folderId, int status) 1957 throws com.liferay.portal.kernel.exception.SystemException; 1958 1959 /** 1960 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status = ?. 1961 * 1962 * @param groupId the group ID 1963 * @param folderId the folder ID 1964 * @param status the status 1965 * @return the number of matching bookmarks entries 1966 * @throws SystemException if a system exception occurred 1967 */ 1968 public int countByG_F_S(long groupId, long folderId, int status) 1969 throws com.liferay.portal.kernel.exception.SystemException; 1970 1971 /** 1972 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1973 * 1974 * @param groupId the group ID 1975 * @param folderIds the folder IDs 1976 * @param status the status 1977 * @return the number of matching bookmarks entries 1978 * @throws SystemException if a system exception occurred 1979 */ 1980 public int countByG_F_S(long groupId, long[] folderIds, int status) 1981 throws com.liferay.portal.kernel.exception.SystemException; 1982 1983 /** 1984 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1985 * 1986 * @param groupId the group ID 1987 * @param folderId the folder ID 1988 * @param status the status 1989 * @return the number of matching bookmarks entries that the user has permission to view 1990 * @throws SystemException if a system exception occurred 1991 */ 1992 public int filterCountByG_F_S(long groupId, long folderId, int status) 1993 throws com.liferay.portal.kernel.exception.SystemException; 1994 1995 /** 1996 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1997 * 1998 * @param groupId the group ID 1999 * @param folderIds the folder IDs 2000 * @param status the status 2001 * @return the number of matching bookmarks entries that the user has permission to view 2002 * @throws SystemException if a system exception occurred 2003 */ 2004 public int filterCountByG_F_S(long groupId, long[] folderIds, int status) 2005 throws com.liferay.portal.kernel.exception.SystemException; 2006 2007 /** 2008 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2009 * 2010 * @param groupId the group ID 2011 * @param folderId the folder ID 2012 * @param status the status 2013 * @return the matching bookmarks entries 2014 * @throws SystemException if a system exception occurred 2015 */ 2016 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2017 long groupId, long folderId, int status) 2018 throws com.liferay.portal.kernel.exception.SystemException; 2019 2020 /** 2021 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2022 * 2023 * <p> 2024 * 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. 2025 * </p> 2026 * 2027 * @param groupId the group ID 2028 * @param folderId the folder ID 2029 * @param status the status 2030 * @param start the lower bound of the range of bookmarks entries 2031 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2032 * @return the range of matching bookmarks entries 2033 * @throws SystemException if a system exception occurred 2034 */ 2035 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2036 long groupId, long folderId, int status, int start, int end) 2037 throws com.liferay.portal.kernel.exception.SystemException; 2038 2039 /** 2040 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2041 * 2042 * <p> 2043 * 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. 2044 * </p> 2045 * 2046 * @param groupId the group ID 2047 * @param folderId the folder ID 2048 * @param status the status 2049 * @param start the lower bound of the range of bookmarks entries 2050 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2051 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2052 * @return the ordered range of matching bookmarks entries 2053 * @throws SystemException if a system exception occurred 2054 */ 2055 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2056 long groupId, long folderId, int status, int start, int end, 2057 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2058 throws com.liferay.portal.kernel.exception.SystemException; 2059 2060 /** 2061 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2062 * 2063 * @param groupId the group ID 2064 * @param folderId the folder ID 2065 * @param status the status 2066 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2067 * @return the first matching bookmarks entry 2068 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2069 * @throws SystemException if a system exception occurred 2070 */ 2071 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First( 2072 long groupId, long folderId, int status, 2073 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2074 throws com.liferay.portal.kernel.exception.SystemException, 2075 com.liferay.portlet.bookmarks.NoSuchEntryException; 2076 2077 /** 2078 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2079 * 2080 * @param groupId the group ID 2081 * @param folderId the folder ID 2082 * @param status the status 2083 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2084 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2085 * @throws SystemException if a system exception occurred 2086 */ 2087 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First( 2088 long groupId, long folderId, int status, 2089 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2090 throws com.liferay.portal.kernel.exception.SystemException; 2091 2092 /** 2093 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2094 * 2095 * @param groupId the group ID 2096 * @param folderId the folder ID 2097 * @param status the status 2098 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2099 * @return the last matching bookmarks entry 2100 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2101 * @throws SystemException if a system exception occurred 2102 */ 2103 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last( 2104 long groupId, long folderId, int status, 2105 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2106 throws com.liferay.portal.kernel.exception.SystemException, 2107 com.liferay.portlet.bookmarks.NoSuchEntryException; 2108 2109 /** 2110 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2111 * 2112 * @param groupId the group ID 2113 * @param folderId the folder ID 2114 * @param status the status 2115 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2116 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2117 * @throws SystemException if a system exception occurred 2118 */ 2119 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last( 2120 long groupId, long folderId, int status, 2121 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2122 throws com.liferay.portal.kernel.exception.SystemException; 2123 2124 /** 2125 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 2126 * 2127 * @param entryId the primary key of the current bookmarks entry 2128 * @param groupId the group ID 2129 * @param folderId the folder ID 2130 * @param status the status 2131 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2132 * @return the previous, current, and next bookmarks entry 2133 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2134 * @throws SystemException if a system exception occurred 2135 */ 2136 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext( 2137 long entryId, long groupId, long folderId, int status, 2138 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2139 throws com.liferay.portal.kernel.exception.SystemException, 2140 com.liferay.portlet.bookmarks.NoSuchEntryException; 2141 2142 /** 2143 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2144 * 2145 * @param groupId the group ID 2146 * @param folderId the folder ID 2147 * @param status the status 2148 * @return the matching bookmarks entries that the user has permission to view 2149 * @throws SystemException if a system exception occurred 2150 */ 2151 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2152 long groupId, long folderId, int status) 2153 throws com.liferay.portal.kernel.exception.SystemException; 2154 2155 /** 2156 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2157 * 2158 * <p> 2159 * 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. 2160 * </p> 2161 * 2162 * @param groupId the group ID 2163 * @param folderId the folder ID 2164 * @param status the status 2165 * @param start the lower bound of the range of bookmarks entries 2166 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2167 * @return the range of matching bookmarks entries that the user has permission to view 2168 * @throws SystemException if a system exception occurred 2169 */ 2170 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2171 long groupId, long folderId, int status, int start, int end) 2172 throws com.liferay.portal.kernel.exception.SystemException; 2173 2174 /** 2175 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status ≠ ?. 2176 * 2177 * <p> 2178 * 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. 2179 * </p> 2180 * 2181 * @param groupId the group ID 2182 * @param folderId the folder ID 2183 * @param status the status 2184 * @param start the lower bound of the range of bookmarks entries 2185 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2186 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2187 * @return the ordered range of matching bookmarks entries that the user has permission to view 2188 * @throws SystemException if a system exception occurred 2189 */ 2190 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2191 long groupId, long folderId, int status, int start, int end, 2192 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2193 throws com.liferay.portal.kernel.exception.SystemException; 2194 2195 /** 2196 * 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 ≠ ?. 2197 * 2198 * @param entryId the primary key of the current bookmarks entry 2199 * @param groupId the group ID 2200 * @param folderId the folder ID 2201 * @param status the status 2202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2203 * @return the previous, current, and next bookmarks entry 2204 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2205 * @throws SystemException if a system exception occurred 2206 */ 2207 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext( 2208 long entryId, long groupId, long folderId, int status, 2209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2210 throws com.liferay.portal.kernel.exception.SystemException, 2211 com.liferay.portlet.bookmarks.NoSuchEntryException; 2212 2213 /** 2214 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2215 * 2216 * @param groupId the group ID 2217 * @param folderIds the folder IDs 2218 * @param status the status 2219 * @return the matching bookmarks entries that the user has permission to view 2220 * @throws SystemException if a system exception occurred 2221 */ 2222 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2223 long groupId, long[] folderIds, int status) 2224 throws com.liferay.portal.kernel.exception.SystemException; 2225 2226 /** 2227 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2228 * 2229 * <p> 2230 * 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. 2231 * </p> 2232 * 2233 * @param groupId the group ID 2234 * @param folderIds the folder IDs 2235 * @param status the status 2236 * @param start the lower bound of the range of bookmarks entries 2237 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2238 * @return the range of matching bookmarks entries that the user has permission to view 2239 * @throws SystemException if a system exception occurred 2240 */ 2241 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2242 long groupId, long[] folderIds, int status, int start, int end) 2243 throws com.liferay.portal.kernel.exception.SystemException; 2244 2245 /** 2246 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2247 * 2248 * <p> 2249 * 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. 2250 * </p> 2251 * 2252 * @param groupId the group ID 2253 * @param folderIds the folder IDs 2254 * @param status the status 2255 * @param start the lower bound of the range of bookmarks entries 2256 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2257 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2258 * @return the ordered range of matching bookmarks entries that the user has permission to view 2259 * @throws SystemException if a system exception occurred 2260 */ 2261 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS( 2262 long groupId, long[] folderIds, int status, int start, int end, 2263 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2264 throws com.liferay.portal.kernel.exception.SystemException; 2265 2266 /** 2267 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2268 * 2269 * <p> 2270 * 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. 2271 * </p> 2272 * 2273 * @param groupId the group ID 2274 * @param folderIds the folder IDs 2275 * @param status the status 2276 * @return the matching bookmarks entries 2277 * @throws SystemException if a system exception occurred 2278 */ 2279 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2280 long groupId, long[] folderIds, int status) 2281 throws com.liferay.portal.kernel.exception.SystemException; 2282 2283 /** 2284 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2285 * 2286 * <p> 2287 * 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. 2288 * </p> 2289 * 2290 * @param groupId the group ID 2291 * @param folderIds the folder IDs 2292 * @param status the status 2293 * @param start the lower bound of the range of bookmarks entries 2294 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2295 * @return the range of matching bookmarks entries 2296 * @throws SystemException if a system exception occurred 2297 */ 2298 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2299 long groupId, long[] folderIds, int status, int start, int end) 2300 throws com.liferay.portal.kernel.exception.SystemException; 2301 2302 /** 2303 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2304 * 2305 * <p> 2306 * 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. 2307 * </p> 2308 * 2309 * @param groupId the group ID 2310 * @param folderIds the folder IDs 2311 * @param status the status 2312 * @param start the lower bound of the range of bookmarks entries 2313 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2314 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2315 * @return the ordered range of matching bookmarks entries 2316 * @throws SystemException if a system exception occurred 2317 */ 2318 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS( 2319 long groupId, long[] folderIds, int status, int start, int end, 2320 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2321 throws com.liferay.portal.kernel.exception.SystemException; 2322 2323 /** 2324 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status ≠ ? from the database. 2325 * 2326 * @param groupId the group ID 2327 * @param folderId the folder ID 2328 * @param status the status 2329 * @throws SystemException if a system exception occurred 2330 */ 2331 public void removeByG_F_NotS(long groupId, long folderId, int status) 2332 throws com.liferay.portal.kernel.exception.SystemException; 2333 2334 /** 2335 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status ≠ ?. 2336 * 2337 * @param groupId the group ID 2338 * @param folderId the folder ID 2339 * @param status the status 2340 * @return the number of matching bookmarks entries 2341 * @throws SystemException if a system exception occurred 2342 */ 2343 public int countByG_F_NotS(long groupId, long folderId, int status) 2344 throws com.liferay.portal.kernel.exception.SystemException; 2345 2346 /** 2347 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status ≠ ?. 2348 * 2349 * @param groupId the group ID 2350 * @param folderIds the folder IDs 2351 * @param status the status 2352 * @return the number of matching bookmarks entries 2353 * @throws SystemException if a system exception occurred 2354 */ 2355 public int countByG_F_NotS(long groupId, long[] folderIds, int status) 2356 throws com.liferay.portal.kernel.exception.SystemException; 2357 2358 /** 2359 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 2360 * 2361 * @param groupId the group ID 2362 * @param folderId the folder ID 2363 * @param status the status 2364 * @return the number of matching bookmarks entries that the user has permission to view 2365 * @throws SystemException if a system exception occurred 2366 */ 2367 public int filterCountByG_F_NotS(long groupId, long folderId, int status) 2368 throws com.liferay.portal.kernel.exception.SystemException; 2369 2370 /** 2371 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status ≠ ?. 2372 * 2373 * @param groupId the group ID 2374 * @param folderIds the folder IDs 2375 * @param status the status 2376 * @return the number of matching bookmarks entries that the user has permission to view 2377 * @throws SystemException if a system exception occurred 2378 */ 2379 public int filterCountByG_F_NotS(long groupId, long[] folderIds, int status) 2380 throws com.liferay.portal.kernel.exception.SystemException; 2381 2382 /** 2383 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2384 * 2385 * @param groupId the group ID 2386 * @param userId the user ID 2387 * @param folderId the folder ID 2388 * @param status the status 2389 * @return the matching bookmarks entries 2390 * @throws SystemException if a system exception occurred 2391 */ 2392 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2393 long groupId, long userId, long folderId, int status) 2394 throws com.liferay.portal.kernel.exception.SystemException; 2395 2396 /** 2397 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2398 * 2399 * <p> 2400 * 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. 2401 * </p> 2402 * 2403 * @param groupId the group ID 2404 * @param userId the user ID 2405 * @param folderId the folder ID 2406 * @param status the status 2407 * @param start the lower bound of the range of bookmarks entries 2408 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2409 * @return the range of matching bookmarks entries 2410 * @throws SystemException if a system exception occurred 2411 */ 2412 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2413 long groupId, long userId, long folderId, int status, int start, int end) 2414 throws com.liferay.portal.kernel.exception.SystemException; 2415 2416 /** 2417 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2418 * 2419 * <p> 2420 * 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. 2421 * </p> 2422 * 2423 * @param groupId the group ID 2424 * @param userId the user ID 2425 * @param folderId the folder ID 2426 * @param status the status 2427 * @param start the lower bound of the range of bookmarks entries 2428 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2429 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2430 * @return the ordered range of matching bookmarks entries 2431 * @throws SystemException if a system exception occurred 2432 */ 2433 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2434 long groupId, long userId, long folderId, int status, int start, 2435 int end, 2436 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2437 throws com.liferay.portal.kernel.exception.SystemException; 2438 2439 /** 2440 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2441 * 2442 * @param groupId the group ID 2443 * @param userId the user ID 2444 * @param folderId the folder ID 2445 * @param status the status 2446 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2447 * @return the first matching bookmarks entry 2448 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2449 * @throws SystemException if a system exception occurred 2450 */ 2451 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First( 2452 long groupId, long userId, long folderId, int status, 2453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2454 throws com.liferay.portal.kernel.exception.SystemException, 2455 com.liferay.portlet.bookmarks.NoSuchEntryException; 2456 2457 /** 2458 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2459 * 2460 * @param groupId the group ID 2461 * @param userId the user ID 2462 * @param folderId the folder ID 2463 * @param status the status 2464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2465 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2466 * @throws SystemException if a system exception occurred 2467 */ 2468 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First( 2469 long groupId, long userId, long folderId, int status, 2470 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2471 throws com.liferay.portal.kernel.exception.SystemException; 2472 2473 /** 2474 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2475 * 2476 * @param groupId the group ID 2477 * @param userId the user ID 2478 * @param folderId the folder ID 2479 * @param status the status 2480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2481 * @return the last matching bookmarks entry 2482 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 2483 * @throws SystemException if a system exception occurred 2484 */ 2485 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last( 2486 long groupId, long userId, long folderId, int status, 2487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2488 throws com.liferay.portal.kernel.exception.SystemException, 2489 com.liferay.portlet.bookmarks.NoSuchEntryException; 2490 2491 /** 2492 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2493 * 2494 * @param groupId the group ID 2495 * @param userId the user ID 2496 * @param folderId the folder ID 2497 * @param status the status 2498 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2499 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 2500 * @throws SystemException if a system exception occurred 2501 */ 2502 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last( 2503 long groupId, long userId, long folderId, int status, 2504 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2505 throws com.liferay.portal.kernel.exception.SystemException; 2506 2507 /** 2508 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 2509 * 2510 * @param entryId the primary key of the current bookmarks entry 2511 * @param groupId the group ID 2512 * @param userId the user ID 2513 * @param folderId the folder ID 2514 * @param status the status 2515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2516 * @return the previous, current, and next bookmarks entry 2517 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2518 * @throws SystemException if a system exception occurred 2519 */ 2520 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext( 2521 long entryId, long groupId, long userId, long folderId, int status, 2522 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2523 throws com.liferay.portal.kernel.exception.SystemException, 2524 com.liferay.portlet.bookmarks.NoSuchEntryException; 2525 2526 /** 2527 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2528 * 2529 * @param groupId the group ID 2530 * @param userId the user ID 2531 * @param folderId the folder ID 2532 * @param status the status 2533 * @return the matching bookmarks entries that the user has permission to view 2534 * @throws SystemException if a system exception occurred 2535 */ 2536 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2537 long groupId, long userId, long folderId, int status) 2538 throws com.liferay.portal.kernel.exception.SystemException; 2539 2540 /** 2541 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2542 * 2543 * <p> 2544 * 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. 2545 * </p> 2546 * 2547 * @param groupId the group ID 2548 * @param userId the user ID 2549 * @param folderId the folder ID 2550 * @param status the status 2551 * @param start the lower bound of the range of bookmarks entries 2552 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2553 * @return the range of matching bookmarks entries that the user has permission to view 2554 * @throws SystemException if a system exception occurred 2555 */ 2556 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2557 long groupId, long userId, long folderId, int status, int start, int end) 2558 throws com.liferay.portal.kernel.exception.SystemException; 2559 2560 /** 2561 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2562 * 2563 * <p> 2564 * 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. 2565 * </p> 2566 * 2567 * @param groupId the group ID 2568 * @param userId the user ID 2569 * @param folderId the folder ID 2570 * @param status the status 2571 * @param start the lower bound of the range of bookmarks entries 2572 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2573 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2574 * @return the ordered range of matching bookmarks entries that the user has permission to view 2575 * @throws SystemException if a system exception occurred 2576 */ 2577 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2578 long groupId, long userId, long folderId, int status, int start, 2579 int end, 2580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2581 throws com.liferay.portal.kernel.exception.SystemException; 2582 2583 /** 2584 * 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 = ?. 2585 * 2586 * @param entryId the primary key of the current bookmarks entry 2587 * @param groupId the group ID 2588 * @param userId the user ID 2589 * @param folderId the folder ID 2590 * @param status the status 2591 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2592 * @return the previous, current, and next bookmarks entry 2593 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2594 * @throws SystemException if a system exception occurred 2595 */ 2596 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext( 2597 long entryId, long groupId, long userId, long folderId, int status, 2598 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2599 throws com.liferay.portal.kernel.exception.SystemException, 2600 com.liferay.portlet.bookmarks.NoSuchEntryException; 2601 2602 /** 2603 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2604 * 2605 * @param groupId the group ID 2606 * @param userId the user ID 2607 * @param folderIds the folder IDs 2608 * @param status the status 2609 * @return the matching bookmarks entries that the user has permission to view 2610 * @throws SystemException if a system exception occurred 2611 */ 2612 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2613 long groupId, long userId, long[] folderIds, int status) 2614 throws com.liferay.portal.kernel.exception.SystemException; 2615 2616 /** 2617 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2618 * 2619 * <p> 2620 * 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. 2621 * </p> 2622 * 2623 * @param groupId the group ID 2624 * @param userId the user ID 2625 * @param folderIds the folder IDs 2626 * @param status the status 2627 * @param start the lower bound of the range of bookmarks entries 2628 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2629 * @return the range of matching bookmarks entries that the user has permission to view 2630 * @throws SystemException if a system exception occurred 2631 */ 2632 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2633 long groupId, long userId, long[] folderIds, int status, int start, 2634 int end) throws com.liferay.portal.kernel.exception.SystemException; 2635 2636 /** 2637 * 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 = ?. 2638 * 2639 * <p> 2640 * 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. 2641 * </p> 2642 * 2643 * @param groupId the group ID 2644 * @param userId the user ID 2645 * @param folderIds the folder IDs 2646 * @param status the status 2647 * @param start the lower bound of the range of bookmarks entries 2648 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2649 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2650 * @return the ordered range of matching bookmarks entries that the user has permission to view 2651 * @throws SystemException if a system exception occurred 2652 */ 2653 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 2654 long groupId, long userId, long[] folderIds, int status, int start, 2655 int end, 2656 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2657 throws com.liferay.portal.kernel.exception.SystemException; 2658 2659 /** 2660 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2661 * 2662 * <p> 2663 * 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. 2664 * </p> 2665 * 2666 * @param groupId the group ID 2667 * @param userId the user ID 2668 * @param folderIds the folder IDs 2669 * @param status the status 2670 * @return the matching bookmarks entries 2671 * @throws SystemException if a system exception occurred 2672 */ 2673 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2674 long groupId, long userId, long[] folderIds, int status) 2675 throws com.liferay.portal.kernel.exception.SystemException; 2676 2677 /** 2678 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2679 * 2680 * <p> 2681 * 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. 2682 * </p> 2683 * 2684 * @param groupId the group ID 2685 * @param userId the user ID 2686 * @param folderIds the folder IDs 2687 * @param status the status 2688 * @param start the lower bound of the range of bookmarks entries 2689 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2690 * @return the range of matching bookmarks entries 2691 * @throws SystemException if a system exception occurred 2692 */ 2693 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2694 long groupId, long userId, long[] folderIds, int status, int start, 2695 int end) throws com.liferay.portal.kernel.exception.SystemException; 2696 2697 /** 2698 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2699 * 2700 * <p> 2701 * 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. 2702 * </p> 2703 * 2704 * @param groupId the group ID 2705 * @param userId the user ID 2706 * @param folderIds the folder IDs 2707 * @param status the status 2708 * @param start the lower bound of the range of bookmarks entries 2709 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2710 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2711 * @return the ordered range of matching bookmarks entries 2712 * @throws SystemException if a system exception occurred 2713 */ 2714 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2715 long groupId, long userId, long[] folderIds, int status, int start, 2716 int end, 2717 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2718 throws com.liferay.portal.kernel.exception.SystemException; 2719 2720 /** 2721 * Removes all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ? from the database. 2722 * 2723 * @param groupId the group ID 2724 * @param userId the user ID 2725 * @param folderId the folder ID 2726 * @param status the status 2727 * @throws SystemException if a system exception occurred 2728 */ 2729 public void removeByG_U_F_S(long groupId, long userId, long folderId, 2730 int status) throws com.liferay.portal.kernel.exception.SystemException; 2731 2732 /** 2733 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2734 * 2735 * @param groupId the group ID 2736 * @param userId the user ID 2737 * @param folderId the folder ID 2738 * @param status the status 2739 * @return the number of matching bookmarks entries 2740 * @throws SystemException if a system exception occurred 2741 */ 2742 public int countByG_U_F_S(long groupId, long userId, long folderId, 2743 int status) throws com.liferay.portal.kernel.exception.SystemException; 2744 2745 /** 2746 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2747 * 2748 * @param groupId the group ID 2749 * @param userId the user ID 2750 * @param folderIds the folder IDs 2751 * @param status the status 2752 * @return the number of matching bookmarks entries 2753 * @throws SystemException if a system exception occurred 2754 */ 2755 public int countByG_U_F_S(long groupId, long userId, long[] folderIds, 2756 int status) throws com.liferay.portal.kernel.exception.SystemException; 2757 2758 /** 2759 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2760 * 2761 * @param groupId the group ID 2762 * @param userId the user ID 2763 * @param folderId the folder ID 2764 * @param status the status 2765 * @return the number of matching bookmarks entries that the user has permission to view 2766 * @throws SystemException if a system exception occurred 2767 */ 2768 public int filterCountByG_U_F_S(long groupId, long userId, long folderId, 2769 int status) throws com.liferay.portal.kernel.exception.SystemException; 2770 2771 /** 2772 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2773 * 2774 * @param groupId the group ID 2775 * @param userId the user ID 2776 * @param folderIds the folder IDs 2777 * @param status the status 2778 * @return the number of matching bookmarks entries that the user has permission to view 2779 * @throws SystemException if a system exception occurred 2780 */ 2781 public int filterCountByG_U_F_S(long groupId, long userId, 2782 long[] folderIds, int status) 2783 throws com.liferay.portal.kernel.exception.SystemException; 2784 2785 /** 2786 * Caches the bookmarks entry in the entity cache if it is enabled. 2787 * 2788 * @param bookmarksEntry the bookmarks entry 2789 */ 2790 public void cacheResult( 2791 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry); 2792 2793 /** 2794 * Caches the bookmarks entries in the entity cache if it is enabled. 2795 * 2796 * @param bookmarksEntries the bookmarks entries 2797 */ 2798 public void cacheResult( 2799 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries); 2800 2801 /** 2802 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 2803 * 2804 * @param entryId the primary key for the new bookmarks entry 2805 * @return the new bookmarks entry 2806 */ 2807 public com.liferay.portlet.bookmarks.model.BookmarksEntry create( 2808 long entryId); 2809 2810 /** 2811 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 2812 * 2813 * @param entryId the primary key of the bookmarks entry 2814 * @return the bookmarks entry that was removed 2815 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2816 * @throws SystemException if a system exception occurred 2817 */ 2818 public com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 2819 long entryId) 2820 throws com.liferay.portal.kernel.exception.SystemException, 2821 com.liferay.portlet.bookmarks.NoSuchEntryException; 2822 2823 public com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 2824 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 2825 throws com.liferay.portal.kernel.exception.SystemException; 2826 2827 /** 2828 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 2829 * 2830 * @param entryId the primary key of the bookmarks entry 2831 * @return the bookmarks entry 2832 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2833 * @throws SystemException if a system exception occurred 2834 */ 2835 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 2836 long entryId) 2837 throws com.liferay.portal.kernel.exception.SystemException, 2838 com.liferay.portlet.bookmarks.NoSuchEntryException; 2839 2840 /** 2841 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 2842 * 2843 * @param entryId the primary key of the bookmarks entry 2844 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 2845 * @throws SystemException if a system exception occurred 2846 */ 2847 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 2848 long entryId) 2849 throws com.liferay.portal.kernel.exception.SystemException; 2850 2851 /** 2852 * Returns all the bookmarks entries. 2853 * 2854 * @return the bookmarks entries 2855 * @throws SystemException if a system exception occurred 2856 */ 2857 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 2858 throws com.liferay.portal.kernel.exception.SystemException; 2859 2860 /** 2861 * Returns a range of all the bookmarks entries. 2862 * 2863 * <p> 2864 * 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. 2865 * </p> 2866 * 2867 * @param start the lower bound of the range of bookmarks entries 2868 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2869 * @return the range of bookmarks entries 2870 * @throws SystemException if a system exception occurred 2871 */ 2872 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2873 int start, int end) 2874 throws com.liferay.portal.kernel.exception.SystemException; 2875 2876 /** 2877 * Returns an ordered range of all the bookmarks entries. 2878 * 2879 * <p> 2880 * 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. 2881 * </p> 2882 * 2883 * @param start the lower bound of the range of bookmarks entries 2884 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2885 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2886 * @return the ordered range of bookmarks entries 2887 * @throws SystemException if a system exception occurred 2888 */ 2889 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2890 int start, int end, 2891 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2892 throws com.liferay.portal.kernel.exception.SystemException; 2893 2894 /** 2895 * Removes all the bookmarks entries from the database. 2896 * 2897 * @throws SystemException if a system exception occurred 2898 */ 2899 public void removeAll() 2900 throws com.liferay.portal.kernel.exception.SystemException; 2901 2902 /** 2903 * Returns the number of bookmarks entries. 2904 * 2905 * @return the number of bookmarks entries 2906 * @throws SystemException if a system exception occurred 2907 */ 2908 public int countAll() 2909 throws com.liferay.portal.kernel.exception.SystemException; 2910 }