001 /** 002 * Copyright (c) 2000-2012 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.journal.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.journal.model.JournalFeed; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the journal feed service. This utility wraps {@link JournalFeedPersistenceImpl} 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 JournalFeedPersistence 037 * @see JournalFeedPersistenceImpl 038 * @generated 039 */ 040 public class JournalFeedUtil { 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(JournalFeed journalFeed) { 058 getPersistence().clearCache(journalFeed); 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<JournalFeed> 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<JournalFeed> 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<JournalFeed> 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#update(com.liferay.portal.model.BaseModel, boolean) 099 */ 100 public static JournalFeed update(JournalFeed journalFeed, boolean merge) 101 throws SystemException { 102 return getPersistence().update(journalFeed, merge); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 107 */ 108 public static JournalFeed update(JournalFeed journalFeed, boolean merge, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(journalFeed, merge, serviceContext); 111 } 112 113 /** 114 * Caches the journal feed in the entity cache if it is enabled. 115 * 116 * @param journalFeed the journal feed 117 */ 118 public static void cacheResult( 119 com.liferay.portlet.journal.model.JournalFeed journalFeed) { 120 getPersistence().cacheResult(journalFeed); 121 } 122 123 /** 124 * Caches the journal feeds in the entity cache if it is enabled. 125 * 126 * @param journalFeeds the journal feeds 127 */ 128 public static void cacheResult( 129 java.util.List<com.liferay.portlet.journal.model.JournalFeed> journalFeeds) { 130 getPersistence().cacheResult(journalFeeds); 131 } 132 133 /** 134 * Creates a new journal feed with the primary key. Does not add the journal feed to the database. 135 * 136 * @param id the primary key for the new journal feed 137 * @return the new journal feed 138 */ 139 public static com.liferay.portlet.journal.model.JournalFeed create(long id) { 140 return getPersistence().create(id); 141 } 142 143 /** 144 * Removes the journal feed with the primary key from the database. Also notifies the appropriate model listeners. 145 * 146 * @param id the primary key of the journal feed 147 * @return the journal feed that was removed 148 * @throws com.liferay.portlet.journal.NoSuchFeedException if a journal feed with the primary key could not be found 149 * @throws SystemException if a system exception occurred 150 */ 151 public static com.liferay.portlet.journal.model.JournalFeed remove(long id) 152 throws com.liferay.portal.kernel.exception.SystemException, 153 com.liferay.portlet.journal.NoSuchFeedException { 154 return getPersistence().remove(id); 155 } 156 157 public static com.liferay.portlet.journal.model.JournalFeed updateImpl( 158 com.liferay.portlet.journal.model.JournalFeed journalFeed, boolean merge) 159 throws com.liferay.portal.kernel.exception.SystemException { 160 return getPersistence().updateImpl(journalFeed, merge); 161 } 162 163 /** 164 * Returns the journal feed with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchFeedException} if it could not be found. 165 * 166 * @param id the primary key of the journal feed 167 * @return the journal feed 168 * @throws com.liferay.portlet.journal.NoSuchFeedException if a journal feed with the primary key could not be found 169 * @throws SystemException if a system exception occurred 170 */ 171 public static com.liferay.portlet.journal.model.JournalFeed findByPrimaryKey( 172 long id) 173 throws com.liferay.portal.kernel.exception.SystemException, 174 com.liferay.portlet.journal.NoSuchFeedException { 175 return getPersistence().findByPrimaryKey(id); 176 } 177 178 /** 179 * Returns the journal feed with the primary key or returns <code>null</code> if it could not be found. 180 * 181 * @param id the primary key of the journal feed 182 * @return the journal feed, or <code>null</code> if a journal feed with the primary key could not be found 183 * @throws SystemException if a system exception occurred 184 */ 185 public static com.liferay.portlet.journal.model.JournalFeed fetchByPrimaryKey( 186 long id) throws com.liferay.portal.kernel.exception.SystemException { 187 return getPersistence().fetchByPrimaryKey(id); 188 } 189 190 /** 191 * Returns all the journal feeds where uuid = ?. 192 * 193 * @param uuid the uuid 194 * @return the matching journal feeds 195 * @throws SystemException if a system exception occurred 196 */ 197 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findByUuid( 198 java.lang.String uuid) 199 throws com.liferay.portal.kernel.exception.SystemException { 200 return getPersistence().findByUuid(uuid); 201 } 202 203 /** 204 * Returns a range of all the journal feeds where uuid = ?. 205 * 206 * <p> 207 * 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. 208 * </p> 209 * 210 * @param uuid the uuid 211 * @param start the lower bound of the range of journal feeds 212 * @param end the upper bound of the range of journal feeds (not inclusive) 213 * @return the range of matching journal feeds 214 * @throws SystemException if a system exception occurred 215 */ 216 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findByUuid( 217 java.lang.String uuid, int start, int end) 218 throws com.liferay.portal.kernel.exception.SystemException { 219 return getPersistence().findByUuid(uuid, start, end); 220 } 221 222 /** 223 * Returns an ordered range of all the journal feeds where uuid = ?. 224 * 225 * <p> 226 * 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. 227 * </p> 228 * 229 * @param uuid the uuid 230 * @param start the lower bound of the range of journal feeds 231 * @param end the upper bound of the range of journal feeds (not inclusive) 232 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 233 * @return the ordered range of matching journal feeds 234 * @throws SystemException if a system exception occurred 235 */ 236 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findByUuid( 237 java.lang.String uuid, int start, int end, 238 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 239 throws com.liferay.portal.kernel.exception.SystemException { 240 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 241 } 242 243 /** 244 * Returns the first journal feed in the ordered set where uuid = ?. 245 * 246 * <p> 247 * 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. 248 * </p> 249 * 250 * @param uuid the uuid 251 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 252 * @return the first matching journal feed 253 * @throws com.liferay.portlet.journal.NoSuchFeedException if a matching journal feed could not be found 254 * @throws SystemException if a system exception occurred 255 */ 256 public static com.liferay.portlet.journal.model.JournalFeed findByUuid_First( 257 java.lang.String uuid, 258 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 259 throws com.liferay.portal.kernel.exception.SystemException, 260 com.liferay.portlet.journal.NoSuchFeedException { 261 return getPersistence().findByUuid_First(uuid, orderByComparator); 262 } 263 264 /** 265 * Returns the last journal feed in the ordered set where uuid = ?. 266 * 267 * <p> 268 * 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. 269 * </p> 270 * 271 * @param uuid the uuid 272 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 273 * @return the last matching journal feed 274 * @throws com.liferay.portlet.journal.NoSuchFeedException if a matching journal feed could not be found 275 * @throws SystemException if a system exception occurred 276 */ 277 public static com.liferay.portlet.journal.model.JournalFeed findByUuid_Last( 278 java.lang.String uuid, 279 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 280 throws com.liferay.portal.kernel.exception.SystemException, 281 com.liferay.portlet.journal.NoSuchFeedException { 282 return getPersistence().findByUuid_Last(uuid, orderByComparator); 283 } 284 285 /** 286 * Returns the journal feeds before and after the current journal feed in the ordered set where uuid = ?. 287 * 288 * <p> 289 * 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. 290 * </p> 291 * 292 * @param id the primary key of the current journal feed 293 * @param uuid the uuid 294 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 295 * @return the previous, current, and next journal feed 296 * @throws com.liferay.portlet.journal.NoSuchFeedException if a journal feed with the primary key could not be found 297 * @throws SystemException if a system exception occurred 298 */ 299 public static com.liferay.portlet.journal.model.JournalFeed[] findByUuid_PrevAndNext( 300 long id, java.lang.String uuid, 301 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 302 throws com.liferay.portal.kernel.exception.SystemException, 303 com.liferay.portlet.journal.NoSuchFeedException { 304 return getPersistence() 305 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 306 } 307 308 /** 309 * Returns the journal feed where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchFeedException} if it could not be found. 310 * 311 * @param uuid the uuid 312 * @param groupId the group ID 313 * @return the matching journal feed 314 * @throws com.liferay.portlet.journal.NoSuchFeedException if a matching journal feed could not be found 315 * @throws SystemException if a system exception occurred 316 */ 317 public static com.liferay.portlet.journal.model.JournalFeed findByUUID_G( 318 java.lang.String uuid, long groupId) 319 throws com.liferay.portal.kernel.exception.SystemException, 320 com.liferay.portlet.journal.NoSuchFeedException { 321 return getPersistence().findByUUID_G(uuid, groupId); 322 } 323 324 /** 325 * Returns the journal feed where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 326 * 327 * @param uuid the uuid 328 * @param groupId the group ID 329 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 330 * @throws SystemException if a system exception occurred 331 */ 332 public static com.liferay.portlet.journal.model.JournalFeed fetchByUUID_G( 333 java.lang.String uuid, long groupId) 334 throws com.liferay.portal.kernel.exception.SystemException { 335 return getPersistence().fetchByUUID_G(uuid, groupId); 336 } 337 338 /** 339 * Returns the journal feed where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 340 * 341 * @param uuid the uuid 342 * @param groupId the group ID 343 * @param retrieveFromCache whether to use the finder cache 344 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 345 * @throws SystemException if a system exception occurred 346 */ 347 public static com.liferay.portlet.journal.model.JournalFeed fetchByUUID_G( 348 java.lang.String uuid, long groupId, boolean retrieveFromCache) 349 throws com.liferay.portal.kernel.exception.SystemException { 350 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 351 } 352 353 /** 354 * Returns all the journal feeds where groupId = ?. 355 * 356 * @param groupId the group ID 357 * @return the matching journal feeds 358 * @throws SystemException if a system exception occurred 359 */ 360 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findByGroupId( 361 long groupId) 362 throws com.liferay.portal.kernel.exception.SystemException { 363 return getPersistence().findByGroupId(groupId); 364 } 365 366 /** 367 * Returns a range of all the journal feeds where groupId = ?. 368 * 369 * <p> 370 * 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. 371 * </p> 372 * 373 * @param groupId the group ID 374 * @param start the lower bound of the range of journal feeds 375 * @param end the upper bound of the range of journal feeds (not inclusive) 376 * @return the range of matching journal feeds 377 * @throws SystemException if a system exception occurred 378 */ 379 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findByGroupId( 380 long groupId, int start, int end) 381 throws com.liferay.portal.kernel.exception.SystemException { 382 return getPersistence().findByGroupId(groupId, start, end); 383 } 384 385 /** 386 * Returns an ordered range of all the journal feeds where groupId = ?. 387 * 388 * <p> 389 * 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. 390 * </p> 391 * 392 * @param groupId the group ID 393 * @param start the lower bound of the range of journal feeds 394 * @param end the upper bound of the range of journal feeds (not inclusive) 395 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 396 * @return the ordered range of matching journal feeds 397 * @throws SystemException if a system exception occurred 398 */ 399 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findByGroupId( 400 long groupId, int start, int end, 401 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 402 throws com.liferay.portal.kernel.exception.SystemException { 403 return getPersistence() 404 .findByGroupId(groupId, start, end, orderByComparator); 405 } 406 407 /** 408 * Returns the first journal feed in the ordered set where groupId = ?. 409 * 410 * <p> 411 * 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. 412 * </p> 413 * 414 * @param groupId the group ID 415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 416 * @return the first matching journal feed 417 * @throws com.liferay.portlet.journal.NoSuchFeedException if a matching journal feed could not be found 418 * @throws SystemException if a system exception occurred 419 */ 420 public static com.liferay.portlet.journal.model.JournalFeed findByGroupId_First( 421 long groupId, 422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 423 throws com.liferay.portal.kernel.exception.SystemException, 424 com.liferay.portlet.journal.NoSuchFeedException { 425 return getPersistence().findByGroupId_First(groupId, orderByComparator); 426 } 427 428 /** 429 * Returns the last journal feed in the ordered set where groupId = ?. 430 * 431 * <p> 432 * 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. 433 * </p> 434 * 435 * @param groupId the group ID 436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 437 * @return the last matching journal feed 438 * @throws com.liferay.portlet.journal.NoSuchFeedException if a matching journal feed could not be found 439 * @throws SystemException if a system exception occurred 440 */ 441 public static com.liferay.portlet.journal.model.JournalFeed findByGroupId_Last( 442 long groupId, 443 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 444 throws com.liferay.portal.kernel.exception.SystemException, 445 com.liferay.portlet.journal.NoSuchFeedException { 446 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 447 } 448 449 /** 450 * Returns the journal feeds before and after the current journal feed in the ordered set where groupId = ?. 451 * 452 * <p> 453 * 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. 454 * </p> 455 * 456 * @param id the primary key of the current journal feed 457 * @param groupId the group ID 458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 459 * @return the previous, current, and next journal feed 460 * @throws com.liferay.portlet.journal.NoSuchFeedException if a journal feed with the primary key could not be found 461 * @throws SystemException if a system exception occurred 462 */ 463 public static com.liferay.portlet.journal.model.JournalFeed[] findByGroupId_PrevAndNext( 464 long id, long groupId, 465 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 466 throws com.liferay.portal.kernel.exception.SystemException, 467 com.liferay.portlet.journal.NoSuchFeedException { 468 return getPersistence() 469 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 470 } 471 472 /** 473 * Returns all the journal feeds that the user has permission to view where groupId = ?. 474 * 475 * @param groupId the group ID 476 * @return the matching journal feeds that the user has permission to view 477 * @throws SystemException if a system exception occurred 478 */ 479 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> filterFindByGroupId( 480 long groupId) 481 throws com.liferay.portal.kernel.exception.SystemException { 482 return getPersistence().filterFindByGroupId(groupId); 483 } 484 485 /** 486 * Returns a range of all the journal feeds that the user has permission to view where groupId = ?. 487 * 488 * <p> 489 * 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. 490 * </p> 491 * 492 * @param groupId the group ID 493 * @param start the lower bound of the range of journal feeds 494 * @param end the upper bound of the range of journal feeds (not inclusive) 495 * @return the range of matching journal feeds that the user has permission to view 496 * @throws SystemException if a system exception occurred 497 */ 498 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> filterFindByGroupId( 499 long groupId, int start, int end) 500 throws com.liferay.portal.kernel.exception.SystemException { 501 return getPersistence().filterFindByGroupId(groupId, start, end); 502 } 503 504 /** 505 * Returns an ordered range of all the journal feeds that the user has permissions to view where groupId = ?. 506 * 507 * <p> 508 * 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. 509 * </p> 510 * 511 * @param groupId the group ID 512 * @param start the lower bound of the range of journal feeds 513 * @param end the upper bound of the range of journal feeds (not inclusive) 514 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 515 * @return the ordered range of matching journal feeds that the user has permission to view 516 * @throws SystemException if a system exception occurred 517 */ 518 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> filterFindByGroupId( 519 long groupId, int start, int end, 520 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 521 throws com.liferay.portal.kernel.exception.SystemException { 522 return getPersistence() 523 .filterFindByGroupId(groupId, start, end, orderByComparator); 524 } 525 526 /** 527 * Returns the journal feeds before and after the current journal feed in the ordered set of journal feeds that the user has permission to view where groupId = ?. 528 * 529 * @param id the primary key of the current journal feed 530 * @param groupId the group ID 531 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 532 * @return the previous, current, and next journal feed 533 * @throws com.liferay.portlet.journal.NoSuchFeedException if a journal feed with the primary key could not be found 534 * @throws SystemException if a system exception occurred 535 */ 536 public static com.liferay.portlet.journal.model.JournalFeed[] filterFindByGroupId_PrevAndNext( 537 long id, long groupId, 538 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 539 throws com.liferay.portal.kernel.exception.SystemException, 540 com.liferay.portlet.journal.NoSuchFeedException { 541 return getPersistence() 542 .filterFindByGroupId_PrevAndNext(id, groupId, 543 orderByComparator); 544 } 545 546 /** 547 * Returns the journal feed where groupId = ? and feedId = ? or throws a {@link com.liferay.portlet.journal.NoSuchFeedException} if it could not be found. 548 * 549 * @param groupId the group ID 550 * @param feedId the feed ID 551 * @return the matching journal feed 552 * @throws com.liferay.portlet.journal.NoSuchFeedException if a matching journal feed could not be found 553 * @throws SystemException if a system exception occurred 554 */ 555 public static com.liferay.portlet.journal.model.JournalFeed findByG_F( 556 long groupId, java.lang.String feedId) 557 throws com.liferay.portal.kernel.exception.SystemException, 558 com.liferay.portlet.journal.NoSuchFeedException { 559 return getPersistence().findByG_F(groupId, feedId); 560 } 561 562 /** 563 * Returns the journal feed where groupId = ? and feedId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 564 * 565 * @param groupId the group ID 566 * @param feedId the feed ID 567 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 568 * @throws SystemException if a system exception occurred 569 */ 570 public static com.liferay.portlet.journal.model.JournalFeed fetchByG_F( 571 long groupId, java.lang.String feedId) 572 throws com.liferay.portal.kernel.exception.SystemException { 573 return getPersistence().fetchByG_F(groupId, feedId); 574 } 575 576 /** 577 * Returns the journal feed where groupId = ? and feedId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 578 * 579 * @param groupId the group ID 580 * @param feedId the feed ID 581 * @param retrieveFromCache whether to use the finder cache 582 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 583 * @throws SystemException if a system exception occurred 584 */ 585 public static com.liferay.portlet.journal.model.JournalFeed fetchByG_F( 586 long groupId, java.lang.String feedId, boolean retrieveFromCache) 587 throws com.liferay.portal.kernel.exception.SystemException { 588 return getPersistence().fetchByG_F(groupId, feedId, retrieveFromCache); 589 } 590 591 /** 592 * Returns all the journal feeds. 593 * 594 * @return the journal feeds 595 * @throws SystemException if a system exception occurred 596 */ 597 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findAll() 598 throws com.liferay.portal.kernel.exception.SystemException { 599 return getPersistence().findAll(); 600 } 601 602 /** 603 * Returns a range of all the journal feeds. 604 * 605 * <p> 606 * 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. 607 * </p> 608 * 609 * @param start the lower bound of the range of journal feeds 610 * @param end the upper bound of the range of journal feeds (not inclusive) 611 * @return the range of journal feeds 612 * @throws SystemException if a system exception occurred 613 */ 614 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findAll( 615 int start, int end) 616 throws com.liferay.portal.kernel.exception.SystemException { 617 return getPersistence().findAll(start, end); 618 } 619 620 /** 621 * Returns an ordered range of all the journal feeds. 622 * 623 * <p> 624 * 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. 625 * </p> 626 * 627 * @param start the lower bound of the range of journal feeds 628 * @param end the upper bound of the range of journal feeds (not inclusive) 629 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 630 * @return the ordered range of journal feeds 631 * @throws SystemException if a system exception occurred 632 */ 633 public static java.util.List<com.liferay.portlet.journal.model.JournalFeed> findAll( 634 int start, int end, 635 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 636 throws com.liferay.portal.kernel.exception.SystemException { 637 return getPersistence().findAll(start, end, orderByComparator); 638 } 639 640 /** 641 * Removes all the journal feeds where uuid = ? from the database. 642 * 643 * @param uuid the uuid 644 * @throws SystemException if a system exception occurred 645 */ 646 public static void removeByUuid(java.lang.String uuid) 647 throws com.liferay.portal.kernel.exception.SystemException { 648 getPersistence().removeByUuid(uuid); 649 } 650 651 /** 652 * Removes the journal feed where uuid = ? and groupId = ? from the database. 653 * 654 * @param uuid the uuid 655 * @param groupId the group ID 656 * @throws SystemException if a system exception occurred 657 */ 658 public static void removeByUUID_G(java.lang.String uuid, long groupId) 659 throws com.liferay.portal.kernel.exception.SystemException, 660 com.liferay.portlet.journal.NoSuchFeedException { 661 getPersistence().removeByUUID_G(uuid, groupId); 662 } 663 664 /** 665 * Removes all the journal feeds where groupId = ? from the database. 666 * 667 * @param groupId the group ID 668 * @throws SystemException if a system exception occurred 669 */ 670 public static void removeByGroupId(long groupId) 671 throws com.liferay.portal.kernel.exception.SystemException { 672 getPersistence().removeByGroupId(groupId); 673 } 674 675 /** 676 * Removes the journal feed where groupId = ? and feedId = ? from the database. 677 * 678 * @param groupId the group ID 679 * @param feedId the feed ID 680 * @throws SystemException if a system exception occurred 681 */ 682 public static void removeByG_F(long groupId, java.lang.String feedId) 683 throws com.liferay.portal.kernel.exception.SystemException, 684 com.liferay.portlet.journal.NoSuchFeedException { 685 getPersistence().removeByG_F(groupId, feedId); 686 } 687 688 /** 689 * Removes all the journal feeds from the database. 690 * 691 * @throws SystemException if a system exception occurred 692 */ 693 public static void removeAll() 694 throws com.liferay.portal.kernel.exception.SystemException { 695 getPersistence().removeAll(); 696 } 697 698 /** 699 * Returns the number of journal feeds where uuid = ?. 700 * 701 * @param uuid the uuid 702 * @return the number of matching journal feeds 703 * @throws SystemException if a system exception occurred 704 */ 705 public static int countByUuid(java.lang.String uuid) 706 throws com.liferay.portal.kernel.exception.SystemException { 707 return getPersistence().countByUuid(uuid); 708 } 709 710 /** 711 * Returns the number of journal feeds where uuid = ? and groupId = ?. 712 * 713 * @param uuid the uuid 714 * @param groupId the group ID 715 * @return the number of matching journal feeds 716 * @throws SystemException if a system exception occurred 717 */ 718 public static int countByUUID_G(java.lang.String uuid, long groupId) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().countByUUID_G(uuid, groupId); 721 } 722 723 /** 724 * Returns the number of journal feeds where groupId = ?. 725 * 726 * @param groupId the group ID 727 * @return the number of matching journal feeds 728 * @throws SystemException if a system exception occurred 729 */ 730 public static int countByGroupId(long groupId) 731 throws com.liferay.portal.kernel.exception.SystemException { 732 return getPersistence().countByGroupId(groupId); 733 } 734 735 /** 736 * Returns the number of journal feeds that the user has permission to view where groupId = ?. 737 * 738 * @param groupId the group ID 739 * @return the number of matching journal feeds that the user has permission to view 740 * @throws SystemException if a system exception occurred 741 */ 742 public static int filterCountByGroupId(long groupId) 743 throws com.liferay.portal.kernel.exception.SystemException { 744 return getPersistence().filterCountByGroupId(groupId); 745 } 746 747 /** 748 * Returns the number of journal feeds where groupId = ? and feedId = ?. 749 * 750 * @param groupId the group ID 751 * @param feedId the feed ID 752 * @return the number of matching journal feeds 753 * @throws SystemException if a system exception occurred 754 */ 755 public static int countByG_F(long groupId, java.lang.String feedId) 756 throws com.liferay.portal.kernel.exception.SystemException { 757 return getPersistence().countByG_F(groupId, feedId); 758 } 759 760 /** 761 * Returns the number of journal feeds. 762 * 763 * @return the number of journal feeds 764 * @throws SystemException if a system exception occurred 765 */ 766 public static int countAll() 767 throws com.liferay.portal.kernel.exception.SystemException { 768 return getPersistence().countAll(); 769 } 770 771 public static JournalFeedPersistence getPersistence() { 772 if (_persistence == null) { 773 _persistence = (JournalFeedPersistence)PortalBeanLocatorUtil.locate(JournalFeedPersistence.class.getName()); 774 775 ReferenceRegistry.registerReference(JournalFeedUtil.class, 776 "_persistence"); 777 } 778 779 return _persistence; 780 } 781 782 public void setPersistence(JournalFeedPersistence persistence) { 783 _persistence = persistence; 784 785 ReferenceRegistry.registerReference(JournalFeedUtil.class, 786 "_persistence"); 787 } 788 789 private static JournalFeedPersistence _persistence; 790 }