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