001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.journal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.journal.model.JournalFeed; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the journal feed service. This utility wraps {@link com.liferay.portlet.journal.service.persistence.impl.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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see JournalFeedPersistence 038 * @see com.liferay.portlet.journal.service.persistence.impl.JournalFeedPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class JournalFeedUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(JournalFeed journalFeed) { 060 getPersistence().clearCache(journalFeed); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<JournalFeed> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<JournalFeed> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 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<JournalFeed> orderByComparator) { 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) 099 */ 100 public static JournalFeed update(JournalFeed journalFeed) { 101 return getPersistence().update(journalFeed); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static JournalFeed update(JournalFeed journalFeed, 108 ServiceContext serviceContext) { 109 return getPersistence().update(journalFeed, serviceContext); 110 } 111 112 /** 113 * Returns all the journal feeds where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching journal feeds 117 */ 118 public static List<JournalFeed> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the journal feeds where uuid = ?. 124 * 125 * <p> 126 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of journal feeds 131 * @param end the upper bound of the range of journal feeds (not inclusive) 132 * @return the range of matching journal feeds 133 */ 134 public static List<JournalFeed> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the journal feeds where uuid = ?. 141 * 142 * <p> 143 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of journal feeds 148 * @param end the upper bound of the range of journal feeds (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching journal feeds 151 */ 152 public static List<JournalFeed> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<JournalFeed> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first journal feed in the ordered set where uuid = ?. 159 * 160 * @param uuid the uuid 161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 162 * @return the first matching journal feed 163 * @throws NoSuchFeedException if a matching journal feed could not be found 164 */ 165 public static JournalFeed findByUuid_First(java.lang.String uuid, 166 OrderByComparator<JournalFeed> orderByComparator) 167 throws com.liferay.portlet.journal.NoSuchFeedException { 168 return getPersistence().findByUuid_First(uuid, orderByComparator); 169 } 170 171 /** 172 * Returns the first journal feed in the ordered set where uuid = ?. 173 * 174 * @param uuid the uuid 175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 176 * @return the first matching journal feed, or <code>null</code> if a matching journal feed could not be found 177 */ 178 public static JournalFeed fetchByUuid_First(java.lang.String uuid, 179 OrderByComparator<JournalFeed> orderByComparator) { 180 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the last journal feed in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the last matching journal feed 189 * @throws NoSuchFeedException if a matching journal feed could not be found 190 */ 191 public static JournalFeed findByUuid_Last(java.lang.String uuid, 192 OrderByComparator<JournalFeed> orderByComparator) 193 throws com.liferay.portlet.journal.NoSuchFeedException { 194 return getPersistence().findByUuid_Last(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last journal feed in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching journal feed, or <code>null</code> if a matching journal feed could not be found 203 */ 204 public static JournalFeed fetchByUuid_Last(java.lang.String uuid, 205 OrderByComparator<JournalFeed> orderByComparator) { 206 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 207 } 208 209 /** 210 * Returns the journal feeds before and after the current journal feed in the ordered set where uuid = ?. 211 * 212 * @param id the primary key of the current journal feed 213 * @param uuid the uuid 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next journal feed 216 * @throws NoSuchFeedException if a journal feed with the primary key could not be found 217 */ 218 public static JournalFeed[] findByUuid_PrevAndNext(long id, 219 java.lang.String uuid, OrderByComparator<JournalFeed> orderByComparator) 220 throws com.liferay.portlet.journal.NoSuchFeedException { 221 return getPersistence() 222 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 223 } 224 225 /** 226 * Removes all the journal feeds where uuid = ? from the database. 227 * 228 * @param uuid the uuid 229 */ 230 public static void removeByUuid(java.lang.String uuid) { 231 getPersistence().removeByUuid(uuid); 232 } 233 234 /** 235 * Returns the number of journal feeds where uuid = ?. 236 * 237 * @param uuid the uuid 238 * @return the number of matching journal feeds 239 */ 240 public static int countByUuid(java.lang.String uuid) { 241 return getPersistence().countByUuid(uuid); 242 } 243 244 /** 245 * Returns the journal feed where uuid = ? and groupId = ? or throws a {@link NoSuchFeedException} if it could not be found. 246 * 247 * @param uuid the uuid 248 * @param groupId the group ID 249 * @return the matching journal feed 250 * @throws NoSuchFeedException if a matching journal feed could not be found 251 */ 252 public static JournalFeed findByUUID_G(java.lang.String uuid, long groupId) 253 throws com.liferay.portlet.journal.NoSuchFeedException { 254 return getPersistence().findByUUID_G(uuid, groupId); 255 } 256 257 /** 258 * Returns the journal feed where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 259 * 260 * @param uuid the uuid 261 * @param groupId the group ID 262 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 263 */ 264 public static JournalFeed fetchByUUID_G(java.lang.String uuid, long groupId) { 265 return getPersistence().fetchByUUID_G(uuid, groupId); 266 } 267 268 /** 269 * Returns the journal feed where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 270 * 271 * @param uuid the uuid 272 * @param groupId the group ID 273 * @param retrieveFromCache whether to use the finder cache 274 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 275 */ 276 public static JournalFeed fetchByUUID_G(java.lang.String uuid, 277 long groupId, boolean retrieveFromCache) { 278 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 279 } 280 281 /** 282 * Removes the journal feed where uuid = ? and groupId = ? from the database. 283 * 284 * @param uuid the uuid 285 * @param groupId the group ID 286 * @return the journal feed that was removed 287 */ 288 public static JournalFeed removeByUUID_G(java.lang.String uuid, long groupId) 289 throws com.liferay.portlet.journal.NoSuchFeedException { 290 return getPersistence().removeByUUID_G(uuid, groupId); 291 } 292 293 /** 294 * Returns the number of journal feeds where uuid = ? and groupId = ?. 295 * 296 * @param uuid the uuid 297 * @param groupId the group ID 298 * @return the number of matching journal feeds 299 */ 300 public static int countByUUID_G(java.lang.String uuid, long groupId) { 301 return getPersistence().countByUUID_G(uuid, groupId); 302 } 303 304 /** 305 * Returns all the journal feeds where uuid = ? and companyId = ?. 306 * 307 * @param uuid the uuid 308 * @param companyId the company ID 309 * @return the matching journal feeds 310 */ 311 public static List<JournalFeed> findByUuid_C(java.lang.String uuid, 312 long companyId) { 313 return getPersistence().findByUuid_C(uuid, companyId); 314 } 315 316 /** 317 * Returns a range of all the journal feeds where uuid = ? and companyId = ?. 318 * 319 * <p> 320 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 321 * </p> 322 * 323 * @param uuid the uuid 324 * @param companyId the company ID 325 * @param start the lower bound of the range of journal feeds 326 * @param end the upper bound of the range of journal feeds (not inclusive) 327 * @return the range of matching journal feeds 328 */ 329 public static List<JournalFeed> findByUuid_C(java.lang.String uuid, 330 long companyId, int start, int end) { 331 return getPersistence().findByUuid_C(uuid, companyId, start, end); 332 } 333 334 /** 335 * Returns an ordered range of all the journal feeds where uuid = ? and companyId = ?. 336 * 337 * <p> 338 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 339 * </p> 340 * 341 * @param uuid the uuid 342 * @param companyId the company ID 343 * @param start the lower bound of the range of journal feeds 344 * @param end the upper bound of the range of journal feeds (not inclusive) 345 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 346 * @return the ordered range of matching journal feeds 347 */ 348 public static List<JournalFeed> findByUuid_C(java.lang.String uuid, 349 long companyId, int start, int end, 350 OrderByComparator<JournalFeed> orderByComparator) { 351 return getPersistence() 352 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 353 } 354 355 /** 356 * Returns the first journal feed in the ordered set where uuid = ? and companyId = ?. 357 * 358 * @param uuid the uuid 359 * @param companyId the company ID 360 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 361 * @return the first matching journal feed 362 * @throws NoSuchFeedException if a matching journal feed could not be found 363 */ 364 public static JournalFeed findByUuid_C_First(java.lang.String uuid, 365 long companyId, OrderByComparator<JournalFeed> orderByComparator) 366 throws com.liferay.portlet.journal.NoSuchFeedException { 367 return getPersistence() 368 .findByUuid_C_First(uuid, companyId, orderByComparator); 369 } 370 371 /** 372 * Returns the first journal feed in the ordered set where uuid = ? and companyId = ?. 373 * 374 * @param uuid the uuid 375 * @param companyId the company ID 376 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 377 * @return the first matching journal feed, or <code>null</code> if a matching journal feed could not be found 378 */ 379 public static JournalFeed fetchByUuid_C_First(java.lang.String uuid, 380 long companyId, OrderByComparator<JournalFeed> orderByComparator) { 381 return getPersistence() 382 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 383 } 384 385 /** 386 * Returns the last journal feed in the ordered set where uuid = ? and companyId = ?. 387 * 388 * @param uuid the uuid 389 * @param companyId the company ID 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the last matching journal feed 392 * @throws NoSuchFeedException if a matching journal feed could not be found 393 */ 394 public static JournalFeed findByUuid_C_Last(java.lang.String uuid, 395 long companyId, OrderByComparator<JournalFeed> orderByComparator) 396 throws com.liferay.portlet.journal.NoSuchFeedException { 397 return getPersistence() 398 .findByUuid_C_Last(uuid, companyId, orderByComparator); 399 } 400 401 /** 402 * Returns the last journal feed in the ordered set where uuid = ? and companyId = ?. 403 * 404 * @param uuid the uuid 405 * @param companyId the company ID 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the last matching journal feed, or <code>null</code> if a matching journal feed could not be found 408 */ 409 public static JournalFeed fetchByUuid_C_Last(java.lang.String uuid, 410 long companyId, OrderByComparator<JournalFeed> orderByComparator) { 411 return getPersistence() 412 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 413 } 414 415 /** 416 * Returns the journal feeds before and after the current journal feed in the ordered set where uuid = ? and companyId = ?. 417 * 418 * @param id the primary key of the current journal feed 419 * @param uuid the uuid 420 * @param companyId the company ID 421 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 422 * @return the previous, current, and next journal feed 423 * @throws NoSuchFeedException if a journal feed with the primary key could not be found 424 */ 425 public static JournalFeed[] findByUuid_C_PrevAndNext(long id, 426 java.lang.String uuid, long companyId, 427 OrderByComparator<JournalFeed> orderByComparator) 428 throws com.liferay.portlet.journal.NoSuchFeedException { 429 return getPersistence() 430 .findByUuid_C_PrevAndNext(id, uuid, companyId, 431 orderByComparator); 432 } 433 434 /** 435 * Removes all the journal feeds where uuid = ? and companyId = ? from the database. 436 * 437 * @param uuid the uuid 438 * @param companyId the company ID 439 */ 440 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 441 getPersistence().removeByUuid_C(uuid, companyId); 442 } 443 444 /** 445 * Returns the number of journal feeds where uuid = ? and companyId = ?. 446 * 447 * @param uuid the uuid 448 * @param companyId the company ID 449 * @return the number of matching journal feeds 450 */ 451 public static int countByUuid_C(java.lang.String uuid, long companyId) { 452 return getPersistence().countByUuid_C(uuid, companyId); 453 } 454 455 /** 456 * Returns all the journal feeds where groupId = ?. 457 * 458 * @param groupId the group ID 459 * @return the matching journal feeds 460 */ 461 public static List<JournalFeed> findByGroupId(long groupId) { 462 return getPersistence().findByGroupId(groupId); 463 } 464 465 /** 466 * Returns a range of all the journal feeds where groupId = ?. 467 * 468 * <p> 469 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 470 * </p> 471 * 472 * @param groupId the group ID 473 * @param start the lower bound of the range of journal feeds 474 * @param end the upper bound of the range of journal feeds (not inclusive) 475 * @return the range of matching journal feeds 476 */ 477 public static List<JournalFeed> findByGroupId(long groupId, int start, 478 int end) { 479 return getPersistence().findByGroupId(groupId, start, end); 480 } 481 482 /** 483 * Returns an ordered range of all the journal feeds where groupId = ?. 484 * 485 * <p> 486 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 487 * </p> 488 * 489 * @param groupId the group ID 490 * @param start the lower bound of the range of journal feeds 491 * @param end the upper bound of the range of journal feeds (not inclusive) 492 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 493 * @return the ordered range of matching journal feeds 494 */ 495 public static List<JournalFeed> findByGroupId(long groupId, int start, 496 int end, OrderByComparator<JournalFeed> orderByComparator) { 497 return getPersistence() 498 .findByGroupId(groupId, start, end, orderByComparator); 499 } 500 501 /** 502 * Returns the first journal feed in the ordered set where groupId = ?. 503 * 504 * @param groupId the group ID 505 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 506 * @return the first matching journal feed 507 * @throws NoSuchFeedException if a matching journal feed could not be found 508 */ 509 public static JournalFeed findByGroupId_First(long groupId, 510 OrderByComparator<JournalFeed> orderByComparator) 511 throws com.liferay.portlet.journal.NoSuchFeedException { 512 return getPersistence().findByGroupId_First(groupId, orderByComparator); 513 } 514 515 /** 516 * Returns the first journal feed in the ordered set where groupId = ?. 517 * 518 * @param groupId the group ID 519 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 520 * @return the first matching journal feed, or <code>null</code> if a matching journal feed could not be found 521 */ 522 public static JournalFeed fetchByGroupId_First(long groupId, 523 OrderByComparator<JournalFeed> orderByComparator) { 524 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 525 } 526 527 /** 528 * Returns the last journal feed in the ordered set where groupId = ?. 529 * 530 * @param groupId the group ID 531 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 532 * @return the last matching journal feed 533 * @throws NoSuchFeedException if a matching journal feed could not be found 534 */ 535 public static JournalFeed findByGroupId_Last(long groupId, 536 OrderByComparator<JournalFeed> orderByComparator) 537 throws com.liferay.portlet.journal.NoSuchFeedException { 538 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 539 } 540 541 /** 542 * Returns the last journal feed in the ordered set where groupId = ?. 543 * 544 * @param groupId the group ID 545 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 546 * @return the last matching journal feed, or <code>null</code> if a matching journal feed could not be found 547 */ 548 public static JournalFeed fetchByGroupId_Last(long groupId, 549 OrderByComparator<JournalFeed> orderByComparator) { 550 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 551 } 552 553 /** 554 * Returns the journal feeds before and after the current journal feed in the ordered set where groupId = ?. 555 * 556 * @param id the primary key of the current journal feed 557 * @param groupId the group ID 558 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 559 * @return the previous, current, and next journal feed 560 * @throws NoSuchFeedException if a journal feed with the primary key could not be found 561 */ 562 public static JournalFeed[] findByGroupId_PrevAndNext(long id, 563 long groupId, OrderByComparator<JournalFeed> orderByComparator) 564 throws com.liferay.portlet.journal.NoSuchFeedException { 565 return getPersistence() 566 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 567 } 568 569 /** 570 * Returns all the journal feeds that the user has permission to view where groupId = ?. 571 * 572 * @param groupId the group ID 573 * @return the matching journal feeds that the user has permission to view 574 */ 575 public static List<JournalFeed> filterFindByGroupId(long groupId) { 576 return getPersistence().filterFindByGroupId(groupId); 577 } 578 579 /** 580 * Returns a range of all the journal feeds that the user has permission to view where groupId = ?. 581 * 582 * <p> 583 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 584 * </p> 585 * 586 * @param groupId the group ID 587 * @param start the lower bound of the range of journal feeds 588 * @param end the upper bound of the range of journal feeds (not inclusive) 589 * @return the range of matching journal feeds that the user has permission to view 590 */ 591 public static List<JournalFeed> filterFindByGroupId(long groupId, 592 int start, int end) { 593 return getPersistence().filterFindByGroupId(groupId, start, end); 594 } 595 596 /** 597 * Returns an ordered range of all the journal feeds that the user has permissions to view where groupId = ?. 598 * 599 * <p> 600 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 601 * </p> 602 * 603 * @param groupId the group ID 604 * @param start the lower bound of the range of journal feeds 605 * @param end the upper bound of the range of journal feeds (not inclusive) 606 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 607 * @return the ordered range of matching journal feeds that the user has permission to view 608 */ 609 public static List<JournalFeed> filterFindByGroupId(long groupId, 610 int start, int end, OrderByComparator<JournalFeed> orderByComparator) { 611 return getPersistence() 612 .filterFindByGroupId(groupId, start, end, orderByComparator); 613 } 614 615 /** 616 * 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 = ?. 617 * 618 * @param id the primary key of the current journal feed 619 * @param groupId the group ID 620 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 621 * @return the previous, current, and next journal feed 622 * @throws NoSuchFeedException if a journal feed with the primary key could not be found 623 */ 624 public static JournalFeed[] filterFindByGroupId_PrevAndNext(long id, 625 long groupId, OrderByComparator<JournalFeed> orderByComparator) 626 throws com.liferay.portlet.journal.NoSuchFeedException { 627 return getPersistence() 628 .filterFindByGroupId_PrevAndNext(id, groupId, 629 orderByComparator); 630 } 631 632 /** 633 * Removes all the journal feeds where groupId = ? from the database. 634 * 635 * @param groupId the group ID 636 */ 637 public static void removeByGroupId(long groupId) { 638 getPersistence().removeByGroupId(groupId); 639 } 640 641 /** 642 * Returns the number of journal feeds where groupId = ?. 643 * 644 * @param groupId the group ID 645 * @return the number of matching journal feeds 646 */ 647 public static int countByGroupId(long groupId) { 648 return getPersistence().countByGroupId(groupId); 649 } 650 651 /** 652 * Returns the number of journal feeds that the user has permission to view where groupId = ?. 653 * 654 * @param groupId the group ID 655 * @return the number of matching journal feeds that the user has permission to view 656 */ 657 public static int filterCountByGroupId(long groupId) { 658 return getPersistence().filterCountByGroupId(groupId); 659 } 660 661 /** 662 * Returns the journal feed where groupId = ? and feedId = ? or throws a {@link NoSuchFeedException} if it could not be found. 663 * 664 * @param groupId the group ID 665 * @param feedId the feed ID 666 * @return the matching journal feed 667 * @throws NoSuchFeedException if a matching journal feed could not be found 668 */ 669 public static JournalFeed findByG_F(long groupId, java.lang.String feedId) 670 throws com.liferay.portlet.journal.NoSuchFeedException { 671 return getPersistence().findByG_F(groupId, feedId); 672 } 673 674 /** 675 * Returns the journal feed where groupId = ? and feedId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 676 * 677 * @param groupId the group ID 678 * @param feedId the feed ID 679 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 680 */ 681 public static JournalFeed fetchByG_F(long groupId, java.lang.String feedId) { 682 return getPersistence().fetchByG_F(groupId, feedId); 683 } 684 685 /** 686 * Returns the journal feed where groupId = ? and feedId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 687 * 688 * @param groupId the group ID 689 * @param feedId the feed ID 690 * @param retrieveFromCache whether to use the finder cache 691 * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found 692 */ 693 public static JournalFeed fetchByG_F(long groupId, java.lang.String feedId, 694 boolean retrieveFromCache) { 695 return getPersistence().fetchByG_F(groupId, feedId, retrieveFromCache); 696 } 697 698 /** 699 * Removes the journal feed where groupId = ? and feedId = ? from the database. 700 * 701 * @param groupId the group ID 702 * @param feedId the feed ID 703 * @return the journal feed that was removed 704 */ 705 public static JournalFeed removeByG_F(long groupId, java.lang.String feedId) 706 throws com.liferay.portlet.journal.NoSuchFeedException { 707 return getPersistence().removeByG_F(groupId, feedId); 708 } 709 710 /** 711 * Returns the number of journal feeds where groupId = ? and feedId = ?. 712 * 713 * @param groupId the group ID 714 * @param feedId the feed ID 715 * @return the number of matching journal feeds 716 */ 717 public static int countByG_F(long groupId, java.lang.String feedId) { 718 return getPersistence().countByG_F(groupId, feedId); 719 } 720 721 /** 722 * Caches the journal feed in the entity cache if it is enabled. 723 * 724 * @param journalFeed the journal feed 725 */ 726 public static void cacheResult(JournalFeed journalFeed) { 727 getPersistence().cacheResult(journalFeed); 728 } 729 730 /** 731 * Caches the journal feeds in the entity cache if it is enabled. 732 * 733 * @param journalFeeds the journal feeds 734 */ 735 public static void cacheResult(List<JournalFeed> journalFeeds) { 736 getPersistence().cacheResult(journalFeeds); 737 } 738 739 /** 740 * Creates a new journal feed with the primary key. Does not add the journal feed to the database. 741 * 742 * @param id the primary key for the new journal feed 743 * @return the new journal feed 744 */ 745 public static JournalFeed create(long id) { 746 return getPersistence().create(id); 747 } 748 749 /** 750 * Removes the journal feed with the primary key from the database. Also notifies the appropriate model listeners. 751 * 752 * @param id the primary key of the journal feed 753 * @return the journal feed that was removed 754 * @throws NoSuchFeedException if a journal feed with the primary key could not be found 755 */ 756 public static JournalFeed remove(long id) 757 throws com.liferay.portlet.journal.NoSuchFeedException { 758 return getPersistence().remove(id); 759 } 760 761 public static JournalFeed updateImpl(JournalFeed journalFeed) { 762 return getPersistence().updateImpl(journalFeed); 763 } 764 765 /** 766 * Returns the journal feed with the primary key or throws a {@link NoSuchFeedException} if it could not be found. 767 * 768 * @param id the primary key of the journal feed 769 * @return the journal feed 770 * @throws NoSuchFeedException if a journal feed with the primary key could not be found 771 */ 772 public static JournalFeed findByPrimaryKey(long id) 773 throws com.liferay.portlet.journal.NoSuchFeedException { 774 return getPersistence().findByPrimaryKey(id); 775 } 776 777 /** 778 * Returns the journal feed with the primary key or returns <code>null</code> if it could not be found. 779 * 780 * @param id the primary key of the journal feed 781 * @return the journal feed, or <code>null</code> if a journal feed with the primary key could not be found 782 */ 783 public static JournalFeed fetchByPrimaryKey(long id) { 784 return getPersistence().fetchByPrimaryKey(id); 785 } 786 787 public static java.util.Map<java.io.Serializable, JournalFeed> fetchByPrimaryKeys( 788 java.util.Set<java.io.Serializable> primaryKeys) { 789 return getPersistence().fetchByPrimaryKeys(primaryKeys); 790 } 791 792 /** 793 * Returns all the journal feeds. 794 * 795 * @return the journal feeds 796 */ 797 public static List<JournalFeed> findAll() { 798 return getPersistence().findAll(); 799 } 800 801 /** 802 * Returns a range of all the journal feeds. 803 * 804 * <p> 805 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 806 * </p> 807 * 808 * @param start the lower bound of the range of journal feeds 809 * @param end the upper bound of the range of journal feeds (not inclusive) 810 * @return the range of journal feeds 811 */ 812 public static List<JournalFeed> findAll(int start, int end) { 813 return getPersistence().findAll(start, end); 814 } 815 816 /** 817 * Returns an ordered range of all the journal feeds. 818 * 819 * <p> 820 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 821 * </p> 822 * 823 * @param start the lower bound of the range of journal feeds 824 * @param end the upper bound of the range of journal feeds (not inclusive) 825 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 826 * @return the ordered range of journal feeds 827 */ 828 public static List<JournalFeed> findAll(int start, int end, 829 OrderByComparator<JournalFeed> orderByComparator) { 830 return getPersistence().findAll(start, end, orderByComparator); 831 } 832 833 /** 834 * Removes all the journal feeds from the database. 835 */ 836 public static void removeAll() { 837 getPersistence().removeAll(); 838 } 839 840 /** 841 * Returns the number of journal feeds. 842 * 843 * @return the number of journal feeds 844 */ 845 public static int countAll() { 846 return getPersistence().countAll(); 847 } 848 849 public static JournalFeedPersistence getPersistence() { 850 if (_persistence == null) { 851 _persistence = (JournalFeedPersistence)PortalBeanLocatorUtil.locate(JournalFeedPersistence.class.getName()); 852 853 ReferenceRegistry.registerReference(JournalFeedUtil.class, 854 "_persistence"); 855 } 856 857 return _persistence; 858 } 859 860 /** 861 * @deprecated As of 6.2.0 862 */ 863 @Deprecated 864 public void setPersistence(JournalFeedPersistence persistence) { 865 } 866 867 private static JournalFeedPersistence _persistence; 868 }