001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 013 */ 014 015 package com.liferay.portlet.bookmarks.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.bookmarks.model.BookmarksFolder; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the bookmarks folder service. This utility wraps {@link BookmarksFolderPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see BookmarksFolderPersistence 037 * @see BookmarksFolderPersistenceImpl 038 * @generated 039 */ 040 public class BookmarksFolderUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(BookmarksFolder bookmarksFolder) { 058 getPersistence().clearCache(bookmarksFolder); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<BookmarksFolder> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<BookmarksFolder> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<BookmarksFolder> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 099 */ 100 public static BookmarksFolder remove(BookmarksFolder bookmarksFolder) 101 throws SystemException { 102 return getPersistence().remove(bookmarksFolder); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 107 */ 108 public static BookmarksFolder update(BookmarksFolder bookmarksFolder, 109 boolean merge) throws SystemException { 110 return getPersistence().update(bookmarksFolder, merge); 111 } 112 113 /** 114 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 115 */ 116 public static BookmarksFolder update(BookmarksFolder bookmarksFolder, 117 boolean merge, ServiceContext serviceContext) throws SystemException { 118 return getPersistence().update(bookmarksFolder, merge, serviceContext); 119 } 120 121 /** 122 * Caches the bookmarks folder in the entity cache if it is enabled. 123 * 124 * @param bookmarksFolder the bookmarks folder to cache 125 */ 126 public static void cacheResult( 127 com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) { 128 getPersistence().cacheResult(bookmarksFolder); 129 } 130 131 /** 132 * Caches the bookmarks folders in the entity cache if it is enabled. 133 * 134 * @param bookmarksFolders the bookmarks folders to cache 135 */ 136 public static void cacheResult( 137 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> bookmarksFolders) { 138 getPersistence().cacheResult(bookmarksFolders); 139 } 140 141 /** 142 * Creates a new bookmarks folder with the primary key. Does not add the bookmarks folder to the database. 143 * 144 * @param folderId the primary key for the new bookmarks folder 145 * @return the new bookmarks folder 146 */ 147 public static com.liferay.portlet.bookmarks.model.BookmarksFolder create( 148 long folderId) { 149 return getPersistence().create(folderId); 150 } 151 152 /** 153 * Removes the bookmarks folder with the primary key from the database. Also notifies the appropriate model listeners. 154 * 155 * @param folderId the primary key of the bookmarks folder to remove 156 * @return the bookmarks folder that was removed 157 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 158 * @throws SystemException if a system exception occurred 159 */ 160 public static com.liferay.portlet.bookmarks.model.BookmarksFolder remove( 161 long folderId) 162 throws com.liferay.portal.kernel.exception.SystemException, 163 com.liferay.portlet.bookmarks.NoSuchFolderException { 164 return getPersistence().remove(folderId); 165 } 166 167 public static com.liferay.portlet.bookmarks.model.BookmarksFolder updateImpl( 168 com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder, 169 boolean merge) 170 throws com.liferay.portal.kernel.exception.SystemException { 171 return getPersistence().updateImpl(bookmarksFolder, merge); 172 } 173 174 /** 175 * Finds the bookmarks folder with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 176 * 177 * @param folderId the primary key of the bookmarks folder to find 178 * @return the bookmarks folder 179 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 180 * @throws SystemException if a system exception occurred 181 */ 182 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByPrimaryKey( 183 long folderId) 184 throws com.liferay.portal.kernel.exception.SystemException, 185 com.liferay.portlet.bookmarks.NoSuchFolderException { 186 return getPersistence().findByPrimaryKey(folderId); 187 } 188 189 /** 190 * Finds the bookmarks folder with the primary key or returns <code>null</code> if it could not be found. 191 * 192 * @param folderId the primary key of the bookmarks folder to find 193 * @return the bookmarks folder, or <code>null</code> if a bookmarks folder with the primary key could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByPrimaryKey( 197 long folderId) 198 throws com.liferay.portal.kernel.exception.SystemException { 199 return getPersistence().fetchByPrimaryKey(folderId); 200 } 201 202 /** 203 * Finds all the bookmarks folders where uuid = ?. 204 * 205 * @param uuid the uuid to search with 206 * @return the matching bookmarks folders 207 * @throws SystemException if a system exception occurred 208 */ 209 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 210 java.lang.String uuid) 211 throws com.liferay.portal.kernel.exception.SystemException { 212 return getPersistence().findByUuid(uuid); 213 } 214 215 /** 216 * Finds a range of all the bookmarks folders where uuid = ?. 217 * 218 * <p> 219 * 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. 220 * </p> 221 * 222 * @param uuid the uuid to search with 223 * @param start the lower bound of the range of bookmarks folders to return 224 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 225 * @return the range of matching bookmarks folders 226 * @throws SystemException if a system exception occurred 227 */ 228 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 229 java.lang.String uuid, int start, int end) 230 throws com.liferay.portal.kernel.exception.SystemException { 231 return getPersistence().findByUuid(uuid, start, end); 232 } 233 234 /** 235 * Finds an ordered range of all the bookmarks folders where uuid = ?. 236 * 237 * <p> 238 * 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. 239 * </p> 240 * 241 * @param uuid the uuid to search with 242 * @param start the lower bound of the range of bookmarks folders to return 243 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 244 * @param orderByComparator the comparator to order the results by 245 * @return the ordered range of matching bookmarks folders 246 * @throws SystemException if a system exception occurred 247 */ 248 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 249 java.lang.String uuid, int start, int end, 250 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 251 throws com.liferay.portal.kernel.exception.SystemException { 252 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 253 } 254 255 /** 256 * Finds the first bookmarks folder in the ordered set where uuid = ?. 257 * 258 * <p> 259 * 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. 260 * </p> 261 * 262 * @param uuid the uuid to search with 263 * @param orderByComparator the comparator to order the set by 264 * @return the first matching bookmarks folder 265 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 266 * @throws SystemException if a system exception occurred 267 */ 268 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_First( 269 java.lang.String uuid, 270 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 271 throws com.liferay.portal.kernel.exception.SystemException, 272 com.liferay.portlet.bookmarks.NoSuchFolderException { 273 return getPersistence().findByUuid_First(uuid, orderByComparator); 274 } 275 276 /** 277 * Finds the last bookmarks folder in the ordered set where uuid = ?. 278 * 279 * <p> 280 * 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. 281 * </p> 282 * 283 * @param uuid the uuid to search with 284 * @param orderByComparator the comparator to order the set by 285 * @return the last matching bookmarks folder 286 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 287 * @throws SystemException if a system exception occurred 288 */ 289 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_Last( 290 java.lang.String uuid, 291 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 292 throws com.liferay.portal.kernel.exception.SystemException, 293 com.liferay.portlet.bookmarks.NoSuchFolderException { 294 return getPersistence().findByUuid_Last(uuid, orderByComparator); 295 } 296 297 /** 298 * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = ?. 299 * 300 * <p> 301 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 302 * </p> 303 * 304 * @param folderId the primary key of the current bookmarks folder 305 * @param uuid the uuid to search with 306 * @param orderByComparator the comparator to order the set by 307 * @return the previous, current, and next bookmarks folder 308 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_PrevAndNext( 312 long folderId, java.lang.String uuid, 313 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 314 throws com.liferay.portal.kernel.exception.SystemException, 315 com.liferay.portlet.bookmarks.NoSuchFolderException { 316 return getPersistence() 317 .findByUuid_PrevAndNext(folderId, uuid, orderByComparator); 318 } 319 320 /** 321 * Finds the bookmarks folder where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 322 * 323 * @param uuid the uuid to search with 324 * @param groupId the group ID to search with 325 * @return the matching bookmarks folder 326 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 327 * @throws SystemException if a system exception occurred 328 */ 329 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUUID_G( 330 java.lang.String uuid, long groupId) 331 throws com.liferay.portal.kernel.exception.SystemException, 332 com.liferay.portlet.bookmarks.NoSuchFolderException { 333 return getPersistence().findByUUID_G(uuid, groupId); 334 } 335 336 /** 337 * Finds the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 338 * 339 * @param uuid the uuid to search with 340 * @param groupId the group ID to search with 341 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 342 * @throws SystemException if a system exception occurred 343 */ 344 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 345 java.lang.String uuid, long groupId) 346 throws com.liferay.portal.kernel.exception.SystemException { 347 return getPersistence().fetchByUUID_G(uuid, groupId); 348 } 349 350 /** 351 * Finds the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 352 * 353 * @param uuid the uuid to search with 354 * @param groupId the group ID to search with 355 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 356 * @throws SystemException if a system exception occurred 357 */ 358 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 359 java.lang.String uuid, long groupId, boolean retrieveFromCache) 360 throws com.liferay.portal.kernel.exception.SystemException { 361 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 362 } 363 364 /** 365 * Finds all the bookmarks folders where groupId = ?. 366 * 367 * @param groupId the group ID to search with 368 * @return the matching bookmarks folders 369 * @throws SystemException if a system exception occurred 370 */ 371 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 372 long groupId) 373 throws com.liferay.portal.kernel.exception.SystemException { 374 return getPersistence().findByGroupId(groupId); 375 } 376 377 /** 378 * Finds a range of all the bookmarks folders where groupId = ?. 379 * 380 * <p> 381 * 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. 382 * </p> 383 * 384 * @param groupId the group ID to search with 385 * @param start the lower bound of the range of bookmarks folders to return 386 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 387 * @return the range of matching bookmarks folders 388 * @throws SystemException if a system exception occurred 389 */ 390 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 391 long groupId, int start, int end) 392 throws com.liferay.portal.kernel.exception.SystemException { 393 return getPersistence().findByGroupId(groupId, start, end); 394 } 395 396 /** 397 * Finds an ordered range of all the bookmarks folders where groupId = ?. 398 * 399 * <p> 400 * 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. 401 * </p> 402 * 403 * @param groupId the group ID to search with 404 * @param start the lower bound of the range of bookmarks folders to return 405 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 406 * @param orderByComparator the comparator to order the results by 407 * @return the ordered range of matching bookmarks folders 408 * @throws SystemException if a system exception occurred 409 */ 410 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 411 long groupId, int start, int end, 412 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 413 throws com.liferay.portal.kernel.exception.SystemException { 414 return getPersistence() 415 .findByGroupId(groupId, start, end, orderByComparator); 416 } 417 418 /** 419 * Finds the first bookmarks folder in the ordered set where groupId = ?. 420 * 421 * <p> 422 * 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. 423 * </p> 424 * 425 * @param groupId the group ID to search with 426 * @param orderByComparator the comparator to order the set by 427 * @return the first matching bookmarks folder 428 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 429 * @throws SystemException if a system exception occurred 430 */ 431 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_First( 432 long groupId, 433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 434 throws com.liferay.portal.kernel.exception.SystemException, 435 com.liferay.portlet.bookmarks.NoSuchFolderException { 436 return getPersistence().findByGroupId_First(groupId, orderByComparator); 437 } 438 439 /** 440 * Finds the last bookmarks folder in the ordered set where groupId = ?. 441 * 442 * <p> 443 * 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. 444 * </p> 445 * 446 * @param groupId the group ID to search with 447 * @param orderByComparator the comparator to order the set by 448 * @return the last matching bookmarks folder 449 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 450 * @throws SystemException if a system exception occurred 451 */ 452 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_Last( 453 long groupId, 454 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 455 throws com.liferay.portal.kernel.exception.SystemException, 456 com.liferay.portlet.bookmarks.NoSuchFolderException { 457 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 458 } 459 460 /** 461 * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ?. 462 * 463 * <p> 464 * 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. 465 * </p> 466 * 467 * @param folderId the primary key of the current bookmarks folder 468 * @param groupId the group ID to search with 469 * @param orderByComparator the comparator to order the set by 470 * @return the previous, current, and next bookmarks folder 471 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 472 * @throws SystemException if a system exception occurred 473 */ 474 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByGroupId_PrevAndNext( 475 long folderId, long groupId, 476 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 477 throws com.liferay.portal.kernel.exception.SystemException, 478 com.liferay.portlet.bookmarks.NoSuchFolderException { 479 return getPersistence() 480 .findByGroupId_PrevAndNext(folderId, groupId, 481 orderByComparator); 482 } 483 484 /** 485 * Filters by the user's permissions and finds all the bookmarks folders where groupId = ?. 486 * 487 * @param groupId the group ID to search with 488 * @return the matching bookmarks folders that the user has permission to view 489 * @throws SystemException if a system exception occurred 490 */ 491 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 492 long groupId) 493 throws com.liferay.portal.kernel.exception.SystemException { 494 return getPersistence().filterFindByGroupId(groupId); 495 } 496 497 /** 498 * Filters by the user's permissions and finds a range of all the bookmarks folders where groupId = ?. 499 * 500 * <p> 501 * 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. 502 * </p> 503 * 504 * @param groupId the group ID to search with 505 * @param start the lower bound of the range of bookmarks folders to return 506 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 507 * @return the range of matching bookmarks folders that the user has permission to view 508 * @throws SystemException if a system exception occurred 509 */ 510 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 511 long groupId, int start, int end) 512 throws com.liferay.portal.kernel.exception.SystemException { 513 return getPersistence().filterFindByGroupId(groupId, start, end); 514 } 515 516 /** 517 * Filters by the user's permissions and finds an ordered range of all the bookmarks folders where groupId = ?. 518 * 519 * <p> 520 * 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. 521 * </p> 522 * 523 * @param groupId the group ID to search with 524 * @param start the lower bound of the range of bookmarks folders to return 525 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 526 * @param orderByComparator the comparator to order the results by 527 * @return the ordered range of matching bookmarks folders that the user has permission to view 528 * @throws SystemException if a system exception occurred 529 */ 530 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 531 long groupId, int start, int end, 532 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 533 throws com.liferay.portal.kernel.exception.SystemException { 534 return getPersistence() 535 .filterFindByGroupId(groupId, start, end, orderByComparator); 536 } 537 538 /** 539 * Filters the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ?. 540 * 541 * <p> 542 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 543 * </p> 544 * 545 * @param folderId the primary key of the current bookmarks folder 546 * @param groupId the group ID to search with 547 * @param orderByComparator the comparator to order the set by 548 * @return the previous, current, and next bookmarks folder 549 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 550 * @throws SystemException if a system exception occurred 551 */ 552 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByGroupId_PrevAndNext( 553 long folderId, long groupId, 554 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 555 throws com.liferay.portal.kernel.exception.SystemException, 556 com.liferay.portlet.bookmarks.NoSuchFolderException { 557 return getPersistence() 558 .filterFindByGroupId_PrevAndNext(folderId, groupId, 559 orderByComparator); 560 } 561 562 /** 563 * Finds all the bookmarks folders where companyId = ?. 564 * 565 * @param companyId the company ID to search with 566 * @return the matching bookmarks folders 567 * @throws SystemException if a system exception occurred 568 */ 569 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 570 long companyId) 571 throws com.liferay.portal.kernel.exception.SystemException { 572 return getPersistence().findByCompanyId(companyId); 573 } 574 575 /** 576 * Finds a range of all the bookmarks folders where companyId = ?. 577 * 578 * <p> 579 * 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. 580 * </p> 581 * 582 * @param companyId the company ID to search with 583 * @param start the lower bound of the range of bookmarks folders to return 584 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 585 * @return the range of matching bookmarks folders 586 * @throws SystemException if a system exception occurred 587 */ 588 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 589 long companyId, int start, int end) 590 throws com.liferay.portal.kernel.exception.SystemException { 591 return getPersistence().findByCompanyId(companyId, start, end); 592 } 593 594 /** 595 * Finds an ordered range of all the bookmarks folders where companyId = ?. 596 * 597 * <p> 598 * 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. 599 * </p> 600 * 601 * @param companyId the company ID to search with 602 * @param start the lower bound of the range of bookmarks folders to return 603 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 604 * @param orderByComparator the comparator to order the results by 605 * @return the ordered range of matching bookmarks folders 606 * @throws SystemException if a system exception occurred 607 */ 608 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 609 long companyId, int start, int end, 610 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 611 throws com.liferay.portal.kernel.exception.SystemException { 612 return getPersistence() 613 .findByCompanyId(companyId, start, end, orderByComparator); 614 } 615 616 /** 617 * Finds the first bookmarks folder in the ordered set where companyId = ?. 618 * 619 * <p> 620 * 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. 621 * </p> 622 * 623 * @param companyId the company ID to search with 624 * @param orderByComparator the comparator to order the set by 625 * @return the first matching bookmarks folder 626 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 627 * @throws SystemException if a system exception occurred 628 */ 629 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_First( 630 long companyId, 631 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 632 throws com.liferay.portal.kernel.exception.SystemException, 633 com.liferay.portlet.bookmarks.NoSuchFolderException { 634 return getPersistence() 635 .findByCompanyId_First(companyId, orderByComparator); 636 } 637 638 /** 639 * Finds the last bookmarks folder in the ordered set where companyId = ?. 640 * 641 * <p> 642 * 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. 643 * </p> 644 * 645 * @param companyId the company ID to search with 646 * @param orderByComparator the comparator to order the set by 647 * @return the last matching bookmarks folder 648 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 649 * @throws SystemException if a system exception occurred 650 */ 651 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_Last( 652 long companyId, 653 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 654 throws com.liferay.portal.kernel.exception.SystemException, 655 com.liferay.portlet.bookmarks.NoSuchFolderException { 656 return getPersistence() 657 .findByCompanyId_Last(companyId, orderByComparator); 658 } 659 660 /** 661 * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = ?. 662 * 663 * <p> 664 * 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. 665 * </p> 666 * 667 * @param folderId the primary key of the current bookmarks folder 668 * @param companyId the company ID to search with 669 * @param orderByComparator the comparator to order the set by 670 * @return the previous, current, and next bookmarks folder 671 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 672 * @throws SystemException if a system exception occurred 673 */ 674 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByCompanyId_PrevAndNext( 675 long folderId, long companyId, 676 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 677 throws com.liferay.portal.kernel.exception.SystemException, 678 com.liferay.portlet.bookmarks.NoSuchFolderException { 679 return getPersistence() 680 .findByCompanyId_PrevAndNext(folderId, companyId, 681 orderByComparator); 682 } 683 684 /** 685 * Finds all the bookmarks folders where groupId = ? and parentFolderId = ?. 686 * 687 * @param groupId the group ID to search with 688 * @param parentFolderId the parent folder ID to search with 689 * @return the matching bookmarks folders 690 * @throws SystemException if a system exception occurred 691 */ 692 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 693 long groupId, long parentFolderId) 694 throws com.liferay.portal.kernel.exception.SystemException { 695 return getPersistence().findByG_P(groupId, parentFolderId); 696 } 697 698 /** 699 * Finds a range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 700 * 701 * <p> 702 * 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. 703 * </p> 704 * 705 * @param groupId the group ID to search with 706 * @param parentFolderId the parent folder ID to search with 707 * @param start the lower bound of the range of bookmarks folders to return 708 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 709 * @return the range of matching bookmarks folders 710 * @throws SystemException if a system exception occurred 711 */ 712 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 713 long groupId, long parentFolderId, int start, int end) 714 throws com.liferay.portal.kernel.exception.SystemException { 715 return getPersistence().findByG_P(groupId, parentFolderId, start, end); 716 } 717 718 /** 719 * Finds an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 720 * 721 * <p> 722 * 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. 723 * </p> 724 * 725 * @param groupId the group ID to search with 726 * @param parentFolderId the parent folder ID to search with 727 * @param start the lower bound of the range of bookmarks folders to return 728 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 729 * @param orderByComparator the comparator to order the results by 730 * @return the ordered range of matching bookmarks folders 731 * @throws SystemException if a system exception occurred 732 */ 733 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 734 long groupId, long parentFolderId, int start, int end, 735 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 736 throws com.liferay.portal.kernel.exception.SystemException { 737 return getPersistence() 738 .findByG_P(groupId, parentFolderId, start, end, 739 orderByComparator); 740 } 741 742 /** 743 * Finds the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 744 * 745 * <p> 746 * 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. 747 * </p> 748 * 749 * @param groupId the group ID to search with 750 * @param parentFolderId the parent folder ID to search with 751 * @param orderByComparator the comparator to order the set by 752 * @return the first matching bookmarks folder 753 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 754 * @throws SystemException if a system exception occurred 755 */ 756 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_First( 757 long groupId, long parentFolderId, 758 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 759 throws com.liferay.portal.kernel.exception.SystemException, 760 com.liferay.portlet.bookmarks.NoSuchFolderException { 761 return getPersistence() 762 .findByG_P_First(groupId, parentFolderId, orderByComparator); 763 } 764 765 /** 766 * Finds the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 767 * 768 * <p> 769 * 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. 770 * </p> 771 * 772 * @param groupId the group ID to search with 773 * @param parentFolderId the parent folder ID to search with 774 * @param orderByComparator the comparator to order the set by 775 * @return the last matching bookmarks folder 776 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 777 * @throws SystemException if a system exception occurred 778 */ 779 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_Last( 780 long groupId, long parentFolderId, 781 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 782 throws com.liferay.portal.kernel.exception.SystemException, 783 com.liferay.portlet.bookmarks.NoSuchFolderException { 784 return getPersistence() 785 .findByG_P_Last(groupId, parentFolderId, orderByComparator); 786 } 787 788 /** 789 * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 790 * 791 * <p> 792 * 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. 793 * </p> 794 * 795 * @param folderId the primary key of the current bookmarks folder 796 * @param groupId the group ID to search with 797 * @param parentFolderId the parent folder ID to search with 798 * @param orderByComparator the comparator to order the set by 799 * @return the previous, current, and next bookmarks folder 800 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 801 * @throws SystemException if a system exception occurred 802 */ 803 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_PrevAndNext( 804 long folderId, long groupId, long parentFolderId, 805 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 806 throws com.liferay.portal.kernel.exception.SystemException, 807 com.liferay.portlet.bookmarks.NoSuchFolderException { 808 return getPersistence() 809 .findByG_P_PrevAndNext(folderId, groupId, parentFolderId, 810 orderByComparator); 811 } 812 813 /** 814 * Filters by the user's permissions and finds all the bookmarks folders where groupId = ? and parentFolderId = ?. 815 * 816 * @param groupId the group ID to search with 817 * @param parentFolderId the parent folder ID to search with 818 * @return the matching bookmarks folders that the user has permission to view 819 * @throws SystemException if a system exception occurred 820 */ 821 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 822 long groupId, long parentFolderId) 823 throws com.liferay.portal.kernel.exception.SystemException { 824 return getPersistence().filterFindByG_P(groupId, parentFolderId); 825 } 826 827 /** 828 * Filters by the user's permissions and finds a range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 829 * 830 * <p> 831 * 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. 832 * </p> 833 * 834 * @param groupId the group ID to search with 835 * @param parentFolderId the parent folder ID to search with 836 * @param start the lower bound of the range of bookmarks folders to return 837 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 838 * @return the range of matching bookmarks folders that the user has permission to view 839 * @throws SystemException if a system exception occurred 840 */ 841 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 842 long groupId, long parentFolderId, int start, int end) 843 throws com.liferay.portal.kernel.exception.SystemException { 844 return getPersistence() 845 .filterFindByG_P(groupId, parentFolderId, start, end); 846 } 847 848 /** 849 * Filters by the user's permissions and finds an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 850 * 851 * <p> 852 * 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. 853 * </p> 854 * 855 * @param groupId the group ID to search with 856 * @param parentFolderId the parent folder ID to search with 857 * @param start the lower bound of the range of bookmarks folders to return 858 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 859 * @param orderByComparator the comparator to order the results by 860 * @return the ordered range of matching bookmarks folders that the user has permission to view 861 * @throws SystemException if a system exception occurred 862 */ 863 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 864 long groupId, long parentFolderId, int start, int end, 865 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 866 throws com.liferay.portal.kernel.exception.SystemException { 867 return getPersistence() 868 .filterFindByG_P(groupId, parentFolderId, start, end, 869 orderByComparator); 870 } 871 872 /** 873 * Filters the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 874 * 875 * <p> 876 * 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. 877 * </p> 878 * 879 * @param folderId the primary key of the current bookmarks folder 880 * @param groupId the group ID to search with 881 * @param parentFolderId the parent folder ID to search with 882 * @param orderByComparator the comparator to order the set by 883 * @return the previous, current, and next bookmarks folder 884 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 885 * @throws SystemException if a system exception occurred 886 */ 887 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_PrevAndNext( 888 long folderId, long groupId, long parentFolderId, 889 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 890 throws com.liferay.portal.kernel.exception.SystemException, 891 com.liferay.portlet.bookmarks.NoSuchFolderException { 892 return getPersistence() 893 .filterFindByG_P_PrevAndNext(folderId, groupId, 894 parentFolderId, orderByComparator); 895 } 896 897 /** 898 * Finds all the bookmarks folders. 899 * 900 * @return the bookmarks folders 901 * @throws SystemException if a system exception occurred 902 */ 903 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll() 904 throws com.liferay.portal.kernel.exception.SystemException { 905 return getPersistence().findAll(); 906 } 907 908 /** 909 * Finds a range of all the bookmarks folders. 910 * 911 * <p> 912 * 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. 913 * </p> 914 * 915 * @param start the lower bound of the range of bookmarks folders to return 916 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 917 * @return the range of bookmarks folders 918 * @throws SystemException if a system exception occurred 919 */ 920 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 921 int start, int end) 922 throws com.liferay.portal.kernel.exception.SystemException { 923 return getPersistence().findAll(start, end); 924 } 925 926 /** 927 * Finds an ordered range of all the bookmarks folders. 928 * 929 * <p> 930 * 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. 931 * </p> 932 * 933 * @param start the lower bound of the range of bookmarks folders to return 934 * @param end the upper bound of the range of bookmarks folders to return (not inclusive) 935 * @param orderByComparator the comparator to order the results by 936 * @return the ordered range of bookmarks folders 937 * @throws SystemException if a system exception occurred 938 */ 939 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 940 int start, int end, 941 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 942 throws com.liferay.portal.kernel.exception.SystemException { 943 return getPersistence().findAll(start, end, orderByComparator); 944 } 945 946 /** 947 * Removes all the bookmarks folders where uuid = ? from the database. 948 * 949 * @param uuid the uuid to search with 950 * @throws SystemException if a system exception occurred 951 */ 952 public static void removeByUuid(java.lang.String uuid) 953 throws com.liferay.portal.kernel.exception.SystemException { 954 getPersistence().removeByUuid(uuid); 955 } 956 957 /** 958 * Removes the bookmarks folder where uuid = ? and groupId = ? from the database. 959 * 960 * @param uuid the uuid to search with 961 * @param groupId the group ID to search with 962 * @throws SystemException if a system exception occurred 963 */ 964 public static void removeByUUID_G(java.lang.String uuid, long groupId) 965 throws com.liferay.portal.kernel.exception.SystemException, 966 com.liferay.portlet.bookmarks.NoSuchFolderException { 967 getPersistence().removeByUUID_G(uuid, groupId); 968 } 969 970 /** 971 * Removes all the bookmarks folders where groupId = ? from the database. 972 * 973 * @param groupId the group ID to search with 974 * @throws SystemException if a system exception occurred 975 */ 976 public static void removeByGroupId(long groupId) 977 throws com.liferay.portal.kernel.exception.SystemException { 978 getPersistence().removeByGroupId(groupId); 979 } 980 981 /** 982 * Removes all the bookmarks folders where companyId = ? from the database. 983 * 984 * @param companyId the company ID to search with 985 * @throws SystemException if a system exception occurred 986 */ 987 public static void removeByCompanyId(long companyId) 988 throws com.liferay.portal.kernel.exception.SystemException { 989 getPersistence().removeByCompanyId(companyId); 990 } 991 992 /** 993 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? from the database. 994 * 995 * @param groupId the group ID to search with 996 * @param parentFolderId the parent folder ID to search with 997 * @throws SystemException if a system exception occurred 998 */ 999 public static void removeByG_P(long groupId, long parentFolderId) 1000 throws com.liferay.portal.kernel.exception.SystemException { 1001 getPersistence().removeByG_P(groupId, parentFolderId); 1002 } 1003 1004 /** 1005 * Removes all the bookmarks folders from the database. 1006 * 1007 * @throws SystemException if a system exception occurred 1008 */ 1009 public static void removeAll() 1010 throws com.liferay.portal.kernel.exception.SystemException { 1011 getPersistence().removeAll(); 1012 } 1013 1014 /** 1015 * Counts all the bookmarks folders where uuid = ?. 1016 * 1017 * @param uuid the uuid to search with 1018 * @return the number of matching bookmarks folders 1019 * @throws SystemException if a system exception occurred 1020 */ 1021 public static int countByUuid(java.lang.String uuid) 1022 throws com.liferay.portal.kernel.exception.SystemException { 1023 return getPersistence().countByUuid(uuid); 1024 } 1025 1026 /** 1027 * Counts all the bookmarks folders where uuid = ? and groupId = ?. 1028 * 1029 * @param uuid the uuid to search with 1030 * @param groupId the group ID to search with 1031 * @return the number of matching bookmarks folders 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static int countByUUID_G(java.lang.String uuid, long groupId) 1035 throws com.liferay.portal.kernel.exception.SystemException { 1036 return getPersistence().countByUUID_G(uuid, groupId); 1037 } 1038 1039 /** 1040 * Counts all the bookmarks folders where groupId = ?. 1041 * 1042 * @param groupId the group ID to search with 1043 * @return the number of matching bookmarks folders 1044 * @throws SystemException if a system exception occurred 1045 */ 1046 public static int countByGroupId(long groupId) 1047 throws com.liferay.portal.kernel.exception.SystemException { 1048 return getPersistence().countByGroupId(groupId); 1049 } 1050 1051 /** 1052 * Filters by the user's permissions and counts all the bookmarks folders where groupId = ?. 1053 * 1054 * @param groupId the group ID to search with 1055 * @return the number of matching bookmarks folders that the user has permission to view 1056 * @throws SystemException if a system exception occurred 1057 */ 1058 public static int filterCountByGroupId(long groupId) 1059 throws com.liferay.portal.kernel.exception.SystemException { 1060 return getPersistence().filterCountByGroupId(groupId); 1061 } 1062 1063 /** 1064 * Counts all the bookmarks folders where companyId = ?. 1065 * 1066 * @param companyId the company ID to search with 1067 * @return the number of matching bookmarks folders 1068 * @throws SystemException if a system exception occurred 1069 */ 1070 public static int countByCompanyId(long companyId) 1071 throws com.liferay.portal.kernel.exception.SystemException { 1072 return getPersistence().countByCompanyId(companyId); 1073 } 1074 1075 /** 1076 * Counts all the bookmarks folders where groupId = ? and parentFolderId = ?. 1077 * 1078 * @param groupId the group ID to search with 1079 * @param parentFolderId the parent folder ID to search with 1080 * @return the number of matching bookmarks folders 1081 * @throws SystemException if a system exception occurred 1082 */ 1083 public static int countByG_P(long groupId, long parentFolderId) 1084 throws com.liferay.portal.kernel.exception.SystemException { 1085 return getPersistence().countByG_P(groupId, parentFolderId); 1086 } 1087 1088 /** 1089 * Filters by the user's permissions and counts all the bookmarks folders where groupId = ? and parentFolderId = ?. 1090 * 1091 * @param groupId the group ID to search with 1092 * @param parentFolderId the parent folder ID to search with 1093 * @return the number of matching bookmarks folders that the user has permission to view 1094 * @throws SystemException if a system exception occurred 1095 */ 1096 public static int filterCountByG_P(long groupId, long parentFolderId) 1097 throws com.liferay.portal.kernel.exception.SystemException { 1098 return getPersistence().filterCountByG_P(groupId, parentFolderId); 1099 } 1100 1101 /** 1102 * Counts all the bookmarks folders. 1103 * 1104 * @return the number of bookmarks folders 1105 * @throws SystemException if a system exception occurred 1106 */ 1107 public static int countAll() 1108 throws com.liferay.portal.kernel.exception.SystemException { 1109 return getPersistence().countAll(); 1110 } 1111 1112 public static BookmarksFolderPersistence getPersistence() { 1113 if (_persistence == null) { 1114 _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName()); 1115 1116 ReferenceRegistry.registerReference(BookmarksFolderUtil.class, 1117 "_persistence"); 1118 } 1119 1120 return _persistence; 1121 } 1122 1123 public void setPersistence(BookmarksFolderPersistence persistence) { 1124 _persistence = persistence; 1125 1126 ReferenceRegistry.registerReference(BookmarksFolderUtil.class, 1127 "_persistence"); 1128 } 1129 1130 private static BookmarksFolderPersistence _persistence; 1131 }