001 /** 002 * Copyright (c) 2000-2011 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.JournalContentSearch; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the journal content search service. This utility wraps {@link JournalContentSearchPersistenceImpl} 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 JournalContentSearchPersistence 037 * @see JournalContentSearchPersistenceImpl 038 * @generated 039 */ 040 public class JournalContentSearchUtil { 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(JournalContentSearch journalContentSearch) { 058 getPersistence().clearCache(journalContentSearch); 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<JournalContentSearch> 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<JournalContentSearch> 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<JournalContentSearch> 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 JournalContentSearch remove( 101 JournalContentSearch journalContentSearch) throws SystemException { 102 return getPersistence().remove(journalContentSearch); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 107 */ 108 public static JournalContentSearch update( 109 JournalContentSearch journalContentSearch, boolean merge) 110 throws SystemException { 111 return getPersistence().update(journalContentSearch, merge); 112 } 113 114 /** 115 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 116 */ 117 public static JournalContentSearch update( 118 JournalContentSearch journalContentSearch, boolean merge, 119 ServiceContext serviceContext) throws SystemException { 120 return getPersistence() 121 .update(journalContentSearch, merge, serviceContext); 122 } 123 124 /** 125 * Caches the journal content search in the entity cache if it is enabled. 126 * 127 * @param journalContentSearch the journal content search 128 */ 129 public static void cacheResult( 130 com.liferay.portlet.journal.model.JournalContentSearch journalContentSearch) { 131 getPersistence().cacheResult(journalContentSearch); 132 } 133 134 /** 135 * Caches the journal content searchs in the entity cache if it is enabled. 136 * 137 * @param journalContentSearchs the journal content searchs 138 */ 139 public static void cacheResult( 140 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> journalContentSearchs) { 141 getPersistence().cacheResult(journalContentSearchs); 142 } 143 144 /** 145 * Creates a new journal content search with the primary key. Does not add the journal content search to the database. 146 * 147 * @param contentSearchId the primary key for the new journal content search 148 * @return the new journal content search 149 */ 150 public static com.liferay.portlet.journal.model.JournalContentSearch create( 151 long contentSearchId) { 152 return getPersistence().create(contentSearchId); 153 } 154 155 /** 156 * Removes the journal content search with the primary key from the database. Also notifies the appropriate model listeners. 157 * 158 * @param contentSearchId the primary key of the journal content search 159 * @return the journal content search that was removed 160 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 161 * @throws SystemException if a system exception occurred 162 */ 163 public static com.liferay.portlet.journal.model.JournalContentSearch remove( 164 long contentSearchId) 165 throws com.liferay.portal.kernel.exception.SystemException, 166 com.liferay.portlet.journal.NoSuchContentSearchException { 167 return getPersistence().remove(contentSearchId); 168 } 169 170 public static com.liferay.portlet.journal.model.JournalContentSearch updateImpl( 171 com.liferay.portlet.journal.model.JournalContentSearch journalContentSearch, 172 boolean merge) 173 throws com.liferay.portal.kernel.exception.SystemException { 174 return getPersistence().updateImpl(journalContentSearch, merge); 175 } 176 177 /** 178 * Returns the journal content search with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchContentSearchException} if it could not be found. 179 * 180 * @param contentSearchId the primary key of the journal content search 181 * @return the journal content search 182 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search 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.JournalContentSearch findByPrimaryKey( 186 long contentSearchId) 187 throws com.liferay.portal.kernel.exception.SystemException, 188 com.liferay.portlet.journal.NoSuchContentSearchException { 189 return getPersistence().findByPrimaryKey(contentSearchId); 190 } 191 192 /** 193 * Returns the journal content search with the primary key or returns <code>null</code> if it could not be found. 194 * 195 * @param contentSearchId the primary key of the journal content search 196 * @return the journal content search, or <code>null</code> if a journal content search with the primary key could not be found 197 * @throws SystemException if a system exception occurred 198 */ 199 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByPrimaryKey( 200 long contentSearchId) 201 throws com.liferay.portal.kernel.exception.SystemException { 202 return getPersistence().fetchByPrimaryKey(contentSearchId); 203 } 204 205 /** 206 * Returns all the journal content searchs where articleId = ?. 207 * 208 * @param articleId the article ID 209 * @return the matching journal content searchs 210 * @throws SystemException if a system exception occurred 211 */ 212 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByArticleId( 213 java.lang.String articleId) 214 throws com.liferay.portal.kernel.exception.SystemException { 215 return getPersistence().findByArticleId(articleId); 216 } 217 218 /** 219 * Returns a range of all the journal content searchs where articleId = ?. 220 * 221 * <p> 222 * 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. 223 * </p> 224 * 225 * @param articleId the article ID 226 * @param start the lower bound of the range of journal content searchs 227 * @param end the upper bound of the range of journal content searchs (not inclusive) 228 * @return the range of matching journal content searchs 229 * @throws SystemException if a system exception occurred 230 */ 231 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByArticleId( 232 java.lang.String articleId, int start, int end) 233 throws com.liferay.portal.kernel.exception.SystemException { 234 return getPersistence().findByArticleId(articleId, start, end); 235 } 236 237 /** 238 * Returns an ordered range of all the journal content searchs where articleId = ?. 239 * 240 * <p> 241 * 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. 242 * </p> 243 * 244 * @param articleId the article ID 245 * @param start the lower bound of the range of journal content searchs 246 * @param end the upper bound of the range of journal content searchs (not inclusive) 247 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 248 * @return the ordered range of matching journal content searchs 249 * @throws SystemException if a system exception occurred 250 */ 251 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByArticleId( 252 java.lang.String articleId, int start, int end, 253 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 254 throws com.liferay.portal.kernel.exception.SystemException { 255 return getPersistence() 256 .findByArticleId(articleId, start, end, orderByComparator); 257 } 258 259 /** 260 * Returns the first journal content search in the ordered set where articleId = ?. 261 * 262 * <p> 263 * 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. 264 * </p> 265 * 266 * @param articleId the article ID 267 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 268 * @return the first matching journal content search 269 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 270 * @throws SystemException if a system exception occurred 271 */ 272 public static com.liferay.portlet.journal.model.JournalContentSearch findByArticleId_First( 273 java.lang.String articleId, 274 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 275 throws com.liferay.portal.kernel.exception.SystemException, 276 com.liferay.portlet.journal.NoSuchContentSearchException { 277 return getPersistence() 278 .findByArticleId_First(articleId, orderByComparator); 279 } 280 281 /** 282 * Returns the last journal content search in the ordered set where articleId = ?. 283 * 284 * <p> 285 * 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. 286 * </p> 287 * 288 * @param articleId the article ID 289 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 290 * @return the last matching journal content search 291 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 292 * @throws SystemException if a system exception occurred 293 */ 294 public static com.liferay.portlet.journal.model.JournalContentSearch findByArticleId_Last( 295 java.lang.String articleId, 296 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 297 throws com.liferay.portal.kernel.exception.SystemException, 298 com.liferay.portlet.journal.NoSuchContentSearchException { 299 return getPersistence() 300 .findByArticleId_Last(articleId, orderByComparator); 301 } 302 303 /** 304 * Returns the journal content searchs before and after the current journal content search in the ordered set where articleId = ?. 305 * 306 * <p> 307 * 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. 308 * </p> 309 * 310 * @param contentSearchId the primary key of the current journal content search 311 * @param articleId the article ID 312 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 313 * @return the previous, current, and next journal content search 314 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 315 * @throws SystemException if a system exception occurred 316 */ 317 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByArticleId_PrevAndNext( 318 long contentSearchId, java.lang.String articleId, 319 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 320 throws com.liferay.portal.kernel.exception.SystemException, 321 com.liferay.portlet.journal.NoSuchContentSearchException { 322 return getPersistence() 323 .findByArticleId_PrevAndNext(contentSearchId, articleId, 324 orderByComparator); 325 } 326 327 /** 328 * Returns all the journal content searchs where groupId = ? and privateLayout = ?. 329 * 330 * @param groupId the group ID 331 * @param privateLayout the private layout 332 * @return the matching journal content searchs 333 * @throws SystemException if a system exception occurred 334 */ 335 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P( 336 long groupId, boolean privateLayout) 337 throws com.liferay.portal.kernel.exception.SystemException { 338 return getPersistence().findByG_P(groupId, privateLayout); 339 } 340 341 /** 342 * Returns a range of all the journal content searchs where groupId = ? and privateLayout = ?. 343 * 344 * <p> 345 * 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. 346 * </p> 347 * 348 * @param groupId the group ID 349 * @param privateLayout the private layout 350 * @param start the lower bound of the range of journal content searchs 351 * @param end the upper bound of the range of journal content searchs (not inclusive) 352 * @return the range of matching journal content searchs 353 * @throws SystemException if a system exception occurred 354 */ 355 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P( 356 long groupId, boolean privateLayout, int start, int end) 357 throws com.liferay.portal.kernel.exception.SystemException { 358 return getPersistence().findByG_P(groupId, privateLayout, start, end); 359 } 360 361 /** 362 * Returns an ordered range of all the journal content searchs where groupId = ? and privateLayout = ?. 363 * 364 * <p> 365 * 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. 366 * </p> 367 * 368 * @param groupId the group ID 369 * @param privateLayout the private layout 370 * @param start the lower bound of the range of journal content searchs 371 * @param end the upper bound of the range of journal content searchs (not inclusive) 372 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 373 * @return the ordered range of matching journal content searchs 374 * @throws SystemException if a system exception occurred 375 */ 376 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P( 377 long groupId, boolean privateLayout, int start, int end, 378 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 379 throws com.liferay.portal.kernel.exception.SystemException { 380 return getPersistence() 381 .findByG_P(groupId, privateLayout, start, end, 382 orderByComparator); 383 } 384 385 /** 386 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ?. 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 privateLayout the private layout 394 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 395 * @return the first matching journal content search 396 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 397 * @throws SystemException if a system exception occurred 398 */ 399 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_First( 400 long groupId, boolean privateLayout, 401 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 402 throws com.liferay.portal.kernel.exception.SystemException, 403 com.liferay.portlet.journal.NoSuchContentSearchException { 404 return getPersistence() 405 .findByG_P_First(groupId, privateLayout, orderByComparator); 406 } 407 408 /** 409 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ?. 410 * 411 * <p> 412 * 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. 413 * </p> 414 * 415 * @param groupId the group ID 416 * @param privateLayout the private layout 417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 418 * @return the last matching journal content search 419 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 420 * @throws SystemException if a system exception occurred 421 */ 422 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_Last( 423 long groupId, boolean privateLayout, 424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 425 throws com.liferay.portal.kernel.exception.SystemException, 426 com.liferay.portlet.journal.NoSuchContentSearchException { 427 return getPersistence() 428 .findByG_P_Last(groupId, privateLayout, orderByComparator); 429 } 430 431 /** 432 * Returns the journal content searchs before and after the current journal content search in the ordered set where groupId = ? and privateLayout = ?. 433 * 434 * <p> 435 * 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. 436 * </p> 437 * 438 * @param contentSearchId the primary key of the current journal content search 439 * @param groupId the group ID 440 * @param privateLayout the private layout 441 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 442 * @return the previous, current, and next journal content search 443 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 444 * @throws SystemException if a system exception occurred 445 */ 446 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_PrevAndNext( 447 long contentSearchId, long groupId, boolean privateLayout, 448 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 449 throws com.liferay.portal.kernel.exception.SystemException, 450 com.liferay.portlet.journal.NoSuchContentSearchException { 451 return getPersistence() 452 .findByG_P_PrevAndNext(contentSearchId, groupId, 453 privateLayout, orderByComparator); 454 } 455 456 /** 457 * Returns all the journal content searchs where groupId = ? and articleId = ?. 458 * 459 * @param groupId the group ID 460 * @param articleId the article ID 461 * @return the matching journal content searchs 462 * @throws SystemException if a system exception occurred 463 */ 464 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A( 465 long groupId, java.lang.String articleId) 466 throws com.liferay.portal.kernel.exception.SystemException { 467 return getPersistence().findByG_A(groupId, articleId); 468 } 469 470 /** 471 * Returns a range of all the journal content searchs where groupId = ? and articleId = ?. 472 * 473 * <p> 474 * 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. 475 * </p> 476 * 477 * @param groupId the group ID 478 * @param articleId the article ID 479 * @param start the lower bound of the range of journal content searchs 480 * @param end the upper bound of the range of journal content searchs (not inclusive) 481 * @return the range of matching journal content searchs 482 * @throws SystemException if a system exception occurred 483 */ 484 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A( 485 long groupId, java.lang.String articleId, int start, int end) 486 throws com.liferay.portal.kernel.exception.SystemException { 487 return getPersistence().findByG_A(groupId, articleId, start, end); 488 } 489 490 /** 491 * Returns an ordered range of all the journal content searchs where groupId = ? and articleId = ?. 492 * 493 * <p> 494 * 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. 495 * </p> 496 * 497 * @param groupId the group ID 498 * @param articleId the article ID 499 * @param start the lower bound of the range of journal content searchs 500 * @param end the upper bound of the range of journal content searchs (not inclusive) 501 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 502 * @return the ordered range of matching journal content searchs 503 * @throws SystemException if a system exception occurred 504 */ 505 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A( 506 long groupId, java.lang.String articleId, int start, int end, 507 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 508 throws com.liferay.portal.kernel.exception.SystemException { 509 return getPersistence() 510 .findByG_A(groupId, articleId, start, end, orderByComparator); 511 } 512 513 /** 514 * Returns the first journal content search in the ordered set where groupId = ? and articleId = ?. 515 * 516 * <p> 517 * 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. 518 * </p> 519 * 520 * @param groupId the group ID 521 * @param articleId the article ID 522 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 523 * @return the first matching journal content search 524 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 525 * @throws SystemException if a system exception occurred 526 */ 527 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_A_First( 528 long groupId, java.lang.String articleId, 529 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 530 throws com.liferay.portal.kernel.exception.SystemException, 531 com.liferay.portlet.journal.NoSuchContentSearchException { 532 return getPersistence() 533 .findByG_A_First(groupId, articleId, orderByComparator); 534 } 535 536 /** 537 * Returns the last journal content search in the ordered set where groupId = ? and articleId = ?. 538 * 539 * <p> 540 * 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. 541 * </p> 542 * 543 * @param groupId the group ID 544 * @param articleId the article ID 545 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 546 * @return the last matching journal content search 547 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 548 * @throws SystemException if a system exception occurred 549 */ 550 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_A_Last( 551 long groupId, java.lang.String articleId, 552 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 553 throws com.liferay.portal.kernel.exception.SystemException, 554 com.liferay.portlet.journal.NoSuchContentSearchException { 555 return getPersistence() 556 .findByG_A_Last(groupId, articleId, orderByComparator); 557 } 558 559 /** 560 * Returns the journal content searchs before and after the current journal content search in the ordered set where groupId = ? and articleId = ?. 561 * 562 * <p> 563 * 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. 564 * </p> 565 * 566 * @param contentSearchId the primary key of the current journal content search 567 * @param groupId the group ID 568 * @param articleId the article ID 569 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 570 * @return the previous, current, and next journal content search 571 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 572 * @throws SystemException if a system exception occurred 573 */ 574 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_A_PrevAndNext( 575 long contentSearchId, long groupId, java.lang.String articleId, 576 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 577 throws com.liferay.portal.kernel.exception.SystemException, 578 com.liferay.portlet.journal.NoSuchContentSearchException { 579 return getPersistence() 580 .findByG_A_PrevAndNext(contentSearchId, groupId, articleId, 581 orderByComparator); 582 } 583 584 /** 585 * Returns all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ?. 586 * 587 * @param groupId the group ID 588 * @param privateLayout the private layout 589 * @param layoutId the layout ID 590 * @return the matching journal content searchs 591 * @throws SystemException if a system exception occurred 592 */ 593 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L( 594 long groupId, boolean privateLayout, long layoutId) 595 throws com.liferay.portal.kernel.exception.SystemException { 596 return getPersistence().findByG_P_L(groupId, privateLayout, layoutId); 597 } 598 599 /** 600 * Returns a range of all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ?. 601 * 602 * <p> 603 * 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. 604 * </p> 605 * 606 * @param groupId the group ID 607 * @param privateLayout the private layout 608 * @param layoutId the layout ID 609 * @param start the lower bound of the range of journal content searchs 610 * @param end the upper bound of the range of journal content searchs (not inclusive) 611 * @return the range of matching journal content searchs 612 * @throws SystemException if a system exception occurred 613 */ 614 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L( 615 long groupId, boolean privateLayout, long layoutId, int start, int end) 616 throws com.liferay.portal.kernel.exception.SystemException { 617 return getPersistence() 618 .findByG_P_L(groupId, privateLayout, layoutId, start, end); 619 } 620 621 /** 622 * Returns an ordered range of all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ?. 623 * 624 * <p> 625 * 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. 626 * </p> 627 * 628 * @param groupId the group ID 629 * @param privateLayout the private layout 630 * @param layoutId the layout ID 631 * @param start the lower bound of the range of journal content searchs 632 * @param end the upper bound of the range of journal content searchs (not inclusive) 633 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 634 * @return the ordered range of matching journal content searchs 635 * @throws SystemException if a system exception occurred 636 */ 637 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L( 638 long groupId, boolean privateLayout, long layoutId, int start, int end, 639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 640 throws com.liferay.portal.kernel.exception.SystemException { 641 return getPersistence() 642 .findByG_P_L(groupId, privateLayout, layoutId, start, end, 643 orderByComparator); 644 } 645 646 /** 647 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ?. 648 * 649 * <p> 650 * 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. 651 * </p> 652 * 653 * @param groupId the group ID 654 * @param privateLayout the private layout 655 * @param layoutId the layout ID 656 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 657 * @return the first matching journal content search 658 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 659 * @throws SystemException if a system exception occurred 660 */ 661 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_First( 662 long groupId, boolean privateLayout, long layoutId, 663 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 664 throws com.liferay.portal.kernel.exception.SystemException, 665 com.liferay.portlet.journal.NoSuchContentSearchException { 666 return getPersistence() 667 .findByG_P_L_First(groupId, privateLayout, layoutId, 668 orderByComparator); 669 } 670 671 /** 672 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ?. 673 * 674 * <p> 675 * 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. 676 * </p> 677 * 678 * @param groupId the group ID 679 * @param privateLayout the private layout 680 * @param layoutId the layout ID 681 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 682 * @return the last matching journal content search 683 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 684 * @throws SystemException if a system exception occurred 685 */ 686 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_Last( 687 long groupId, boolean privateLayout, long layoutId, 688 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 689 throws com.liferay.portal.kernel.exception.SystemException, 690 com.liferay.portlet.journal.NoSuchContentSearchException { 691 return getPersistence() 692 .findByG_P_L_Last(groupId, privateLayout, layoutId, 693 orderByComparator); 694 } 695 696 /** 697 * Returns the journal content searchs before and after the current journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ?. 698 * 699 * <p> 700 * 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. 701 * </p> 702 * 703 * @param contentSearchId the primary key of the current journal content search 704 * @param groupId the group ID 705 * @param privateLayout the private layout 706 * @param layoutId the layout ID 707 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 708 * @return the previous, current, and next journal content search 709 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 710 * @throws SystemException if a system exception occurred 711 */ 712 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_L_PrevAndNext( 713 long contentSearchId, long groupId, boolean privateLayout, 714 long layoutId, 715 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 716 throws com.liferay.portal.kernel.exception.SystemException, 717 com.liferay.portlet.journal.NoSuchContentSearchException { 718 return getPersistence() 719 .findByG_P_L_PrevAndNext(contentSearchId, groupId, 720 privateLayout, layoutId, orderByComparator); 721 } 722 723 /** 724 * Returns all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 725 * 726 * @param groupId the group ID 727 * @param privateLayout the private layout 728 * @param articleId the article ID 729 * @return the matching journal content searchs 730 * @throws SystemException if a system exception occurred 731 */ 732 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A( 733 long groupId, boolean privateLayout, java.lang.String articleId) 734 throws com.liferay.portal.kernel.exception.SystemException { 735 return getPersistence().findByG_P_A(groupId, privateLayout, articleId); 736 } 737 738 /** 739 * Returns a range of all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 740 * 741 * <p> 742 * 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. 743 * </p> 744 * 745 * @param groupId the group ID 746 * @param privateLayout the private layout 747 * @param articleId the article ID 748 * @param start the lower bound of the range of journal content searchs 749 * @param end the upper bound of the range of journal content searchs (not inclusive) 750 * @return the range of matching journal content searchs 751 * @throws SystemException if a system exception occurred 752 */ 753 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A( 754 long groupId, boolean privateLayout, java.lang.String articleId, 755 int start, int end) 756 throws com.liferay.portal.kernel.exception.SystemException { 757 return getPersistence() 758 .findByG_P_A(groupId, privateLayout, articleId, start, end); 759 } 760 761 /** 762 * Returns an ordered range of all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 763 * 764 * <p> 765 * 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. 766 * </p> 767 * 768 * @param groupId the group ID 769 * @param privateLayout the private layout 770 * @param articleId the article ID 771 * @param start the lower bound of the range of journal content searchs 772 * @param end the upper bound of the range of journal content searchs (not inclusive) 773 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 774 * @return the ordered range of matching journal content searchs 775 * @throws SystemException if a system exception occurred 776 */ 777 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A( 778 long groupId, boolean privateLayout, java.lang.String articleId, 779 int start, int end, 780 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 781 throws com.liferay.portal.kernel.exception.SystemException { 782 return getPersistence() 783 .findByG_P_A(groupId, privateLayout, articleId, start, end, 784 orderByComparator); 785 } 786 787 /** 788 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 789 * 790 * <p> 791 * 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. 792 * </p> 793 * 794 * @param groupId the group ID 795 * @param privateLayout the private layout 796 * @param articleId the article ID 797 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 798 * @return the first matching journal content search 799 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_A_First( 803 long groupId, boolean privateLayout, java.lang.String articleId, 804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 805 throws com.liferay.portal.kernel.exception.SystemException, 806 com.liferay.portlet.journal.NoSuchContentSearchException { 807 return getPersistence() 808 .findByG_P_A_First(groupId, privateLayout, articleId, 809 orderByComparator); 810 } 811 812 /** 813 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 814 * 815 * <p> 816 * 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. 817 * </p> 818 * 819 * @param groupId the group ID 820 * @param privateLayout the private layout 821 * @param articleId the article ID 822 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 823 * @return the last matching journal content search 824 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 825 * @throws SystemException if a system exception occurred 826 */ 827 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_A_Last( 828 long groupId, boolean privateLayout, java.lang.String articleId, 829 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 830 throws com.liferay.portal.kernel.exception.SystemException, 831 com.liferay.portlet.journal.NoSuchContentSearchException { 832 return getPersistence() 833 .findByG_P_A_Last(groupId, privateLayout, articleId, 834 orderByComparator); 835 } 836 837 /** 838 * Returns the journal content searchs before and after the current journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 839 * 840 * <p> 841 * 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. 842 * </p> 843 * 844 * @param contentSearchId the primary key of the current journal content search 845 * @param groupId the group ID 846 * @param privateLayout the private layout 847 * @param articleId the article ID 848 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 849 * @return the previous, current, and next journal content search 850 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 851 * @throws SystemException if a system exception occurred 852 */ 853 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_A_PrevAndNext( 854 long contentSearchId, long groupId, boolean privateLayout, 855 java.lang.String articleId, 856 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 857 throws com.liferay.portal.kernel.exception.SystemException, 858 com.liferay.portlet.journal.NoSuchContentSearchException { 859 return getPersistence() 860 .findByG_P_A_PrevAndNext(contentSearchId, groupId, 861 privateLayout, articleId, orderByComparator); 862 } 863 864 /** 865 * Returns all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 866 * 867 * @param groupId the group ID 868 * @param privateLayout the private layout 869 * @param layoutId the layout ID 870 * @param portletId the portlet ID 871 * @return the matching journal content searchs 872 * @throws SystemException if a system exception occurred 873 */ 874 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P( 875 long groupId, boolean privateLayout, long layoutId, 876 java.lang.String portletId) 877 throws com.liferay.portal.kernel.exception.SystemException { 878 return getPersistence() 879 .findByG_P_L_P(groupId, privateLayout, layoutId, portletId); 880 } 881 882 /** 883 * Returns a range of all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 884 * 885 * <p> 886 * 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. 887 * </p> 888 * 889 * @param groupId the group ID 890 * @param privateLayout the private layout 891 * @param layoutId the layout ID 892 * @param portletId the portlet ID 893 * @param start the lower bound of the range of journal content searchs 894 * @param end the upper bound of the range of journal content searchs (not inclusive) 895 * @return the range of matching journal content searchs 896 * @throws SystemException if a system exception occurred 897 */ 898 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P( 899 long groupId, boolean privateLayout, long layoutId, 900 java.lang.String portletId, int start, int end) 901 throws com.liferay.portal.kernel.exception.SystemException { 902 return getPersistence() 903 .findByG_P_L_P(groupId, privateLayout, layoutId, portletId, 904 start, end); 905 } 906 907 /** 908 * Returns an ordered range of all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 909 * 910 * <p> 911 * 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. 912 * </p> 913 * 914 * @param groupId the group ID 915 * @param privateLayout the private layout 916 * @param layoutId the layout ID 917 * @param portletId the portlet ID 918 * @param start the lower bound of the range of journal content searchs 919 * @param end the upper bound of the range of journal content searchs (not inclusive) 920 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 921 * @return the ordered range of matching journal content searchs 922 * @throws SystemException if a system exception occurred 923 */ 924 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P( 925 long groupId, boolean privateLayout, long layoutId, 926 java.lang.String portletId, int start, int end, 927 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 928 throws com.liferay.portal.kernel.exception.SystemException { 929 return getPersistence() 930 .findByG_P_L_P(groupId, privateLayout, layoutId, portletId, 931 start, end, orderByComparator); 932 } 933 934 /** 935 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 936 * 937 * <p> 938 * 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. 939 * </p> 940 * 941 * @param groupId the group ID 942 * @param privateLayout the private layout 943 * @param layoutId the layout ID 944 * @param portletId the portlet ID 945 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 946 * @return the first matching journal content search 947 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 948 * @throws SystemException if a system exception occurred 949 */ 950 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_First( 951 long groupId, boolean privateLayout, long layoutId, 952 java.lang.String portletId, 953 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 954 throws com.liferay.portal.kernel.exception.SystemException, 955 com.liferay.portlet.journal.NoSuchContentSearchException { 956 return getPersistence() 957 .findByG_P_L_P_First(groupId, privateLayout, layoutId, 958 portletId, orderByComparator); 959 } 960 961 /** 962 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 963 * 964 * <p> 965 * 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. 966 * </p> 967 * 968 * @param groupId the group ID 969 * @param privateLayout the private layout 970 * @param layoutId the layout ID 971 * @param portletId the portlet ID 972 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 973 * @return the last matching journal content search 974 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 975 * @throws SystemException if a system exception occurred 976 */ 977 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_Last( 978 long groupId, boolean privateLayout, long layoutId, 979 java.lang.String portletId, 980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 981 throws com.liferay.portal.kernel.exception.SystemException, 982 com.liferay.portlet.journal.NoSuchContentSearchException { 983 return getPersistence() 984 .findByG_P_L_P_Last(groupId, privateLayout, layoutId, 985 portletId, orderByComparator); 986 } 987 988 /** 989 * Returns the journal content searchs before and after the current journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 990 * 991 * <p> 992 * 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. 993 * </p> 994 * 995 * @param contentSearchId the primary key of the current journal content search 996 * @param groupId the group ID 997 * @param privateLayout the private layout 998 * @param layoutId the layout ID 999 * @param portletId the portlet ID 1000 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1001 * @return the previous, current, and next journal content search 1002 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 1003 * @throws SystemException if a system exception occurred 1004 */ 1005 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_L_P_PrevAndNext( 1006 long contentSearchId, long groupId, boolean privateLayout, 1007 long layoutId, java.lang.String portletId, 1008 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1009 throws com.liferay.portal.kernel.exception.SystemException, 1010 com.liferay.portlet.journal.NoSuchContentSearchException { 1011 return getPersistence() 1012 .findByG_P_L_P_PrevAndNext(contentSearchId, groupId, 1013 privateLayout, layoutId, portletId, orderByComparator); 1014 } 1015 1016 /** 1017 * Returns the journal content search where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ? or throws a {@link com.liferay.portlet.journal.NoSuchContentSearchException} if it could not be found. 1018 * 1019 * @param groupId the group ID 1020 * @param privateLayout the private layout 1021 * @param layoutId the layout ID 1022 * @param portletId the portlet ID 1023 * @param articleId the article ID 1024 * @return the matching journal content search 1025 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 1026 * @throws SystemException if a system exception occurred 1027 */ 1028 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_A( 1029 long groupId, boolean privateLayout, long layoutId, 1030 java.lang.String portletId, java.lang.String articleId) 1031 throws com.liferay.portal.kernel.exception.SystemException, 1032 com.liferay.portlet.journal.NoSuchContentSearchException { 1033 return getPersistence() 1034 .findByG_P_L_P_A(groupId, privateLayout, layoutId, 1035 portletId, articleId); 1036 } 1037 1038 /** 1039 * Returns the journal content search where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1040 * 1041 * @param groupId the group ID 1042 * @param privateLayout the private layout 1043 * @param layoutId the layout ID 1044 * @param portletId the portlet ID 1045 * @param articleId the article ID 1046 * @return the matching journal content search, or <code>null</code> if a matching journal content search could not be found 1047 * @throws SystemException if a system exception occurred 1048 */ 1049 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_A( 1050 long groupId, boolean privateLayout, long layoutId, 1051 java.lang.String portletId, java.lang.String articleId) 1052 throws com.liferay.portal.kernel.exception.SystemException { 1053 return getPersistence() 1054 .fetchByG_P_L_P_A(groupId, privateLayout, layoutId, 1055 portletId, articleId); 1056 } 1057 1058 /** 1059 * Returns the journal content search where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1060 * 1061 * @param groupId the group ID 1062 * @param privateLayout the private layout 1063 * @param layoutId the layout ID 1064 * @param portletId the portlet ID 1065 * @param articleId the article ID 1066 * @param retrieveFromCache whether to use the finder cache 1067 * @return the matching journal content search, or <code>null</code> if a matching journal content search could not be found 1068 * @throws SystemException if a system exception occurred 1069 */ 1070 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_A( 1071 long groupId, boolean privateLayout, long layoutId, 1072 java.lang.String portletId, java.lang.String articleId, 1073 boolean retrieveFromCache) 1074 throws com.liferay.portal.kernel.exception.SystemException { 1075 return getPersistence() 1076 .fetchByG_P_L_P_A(groupId, privateLayout, layoutId, 1077 portletId, articleId, retrieveFromCache); 1078 } 1079 1080 /** 1081 * Returns all the journal content searchs. 1082 * 1083 * @return the journal content searchs 1084 * @throws SystemException if a system exception occurred 1085 */ 1086 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll() 1087 throws com.liferay.portal.kernel.exception.SystemException { 1088 return getPersistence().findAll(); 1089 } 1090 1091 /** 1092 * Returns a range of all the journal content searchs. 1093 * 1094 * <p> 1095 * 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. 1096 * </p> 1097 * 1098 * @param start the lower bound of the range of journal content searchs 1099 * @param end the upper bound of the range of journal content searchs (not inclusive) 1100 * @return the range of journal content searchs 1101 * @throws SystemException if a system exception occurred 1102 */ 1103 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll( 1104 int start, int end) 1105 throws com.liferay.portal.kernel.exception.SystemException { 1106 return getPersistence().findAll(start, end); 1107 } 1108 1109 /** 1110 * Returns an ordered range of all the journal content searchs. 1111 * 1112 * <p> 1113 * 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. 1114 * </p> 1115 * 1116 * @param start the lower bound of the range of journal content searchs 1117 * @param end the upper bound of the range of journal content searchs (not inclusive) 1118 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1119 * @return the ordered range of journal content searchs 1120 * @throws SystemException if a system exception occurred 1121 */ 1122 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll( 1123 int start, int end, 1124 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1125 throws com.liferay.portal.kernel.exception.SystemException { 1126 return getPersistence().findAll(start, end, orderByComparator); 1127 } 1128 1129 /** 1130 * Removes all the journal content searchs where articleId = ? from the database. 1131 * 1132 * @param articleId the article ID 1133 * @throws SystemException if a system exception occurred 1134 */ 1135 public static void removeByArticleId(java.lang.String articleId) 1136 throws com.liferay.portal.kernel.exception.SystemException { 1137 getPersistence().removeByArticleId(articleId); 1138 } 1139 1140 /** 1141 * Removes all the journal content searchs where groupId = ? and privateLayout = ? from the database. 1142 * 1143 * @param groupId the group ID 1144 * @param privateLayout the private layout 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static void removeByG_P(long groupId, boolean privateLayout) 1148 throws com.liferay.portal.kernel.exception.SystemException { 1149 getPersistence().removeByG_P(groupId, privateLayout); 1150 } 1151 1152 /** 1153 * Removes all the journal content searchs where groupId = ? and articleId = ? from the database. 1154 * 1155 * @param groupId the group ID 1156 * @param articleId the article ID 1157 * @throws SystemException if a system exception occurred 1158 */ 1159 public static void removeByG_A(long groupId, java.lang.String articleId) 1160 throws com.liferay.portal.kernel.exception.SystemException { 1161 getPersistence().removeByG_A(groupId, articleId); 1162 } 1163 1164 /** 1165 * Removes all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? from the database. 1166 * 1167 * @param groupId the group ID 1168 * @param privateLayout the private layout 1169 * @param layoutId the layout ID 1170 * @throws SystemException if a system exception occurred 1171 */ 1172 public static void removeByG_P_L(long groupId, boolean privateLayout, 1173 long layoutId) 1174 throws com.liferay.portal.kernel.exception.SystemException { 1175 getPersistence().removeByG_P_L(groupId, privateLayout, layoutId); 1176 } 1177 1178 /** 1179 * Removes all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ? from the database. 1180 * 1181 * @param groupId the group ID 1182 * @param privateLayout the private layout 1183 * @param articleId the article ID 1184 * @throws SystemException if a system exception occurred 1185 */ 1186 public static void removeByG_P_A(long groupId, boolean privateLayout, 1187 java.lang.String articleId) 1188 throws com.liferay.portal.kernel.exception.SystemException { 1189 getPersistence().removeByG_P_A(groupId, privateLayout, articleId); 1190 } 1191 1192 /** 1193 * Removes all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? from the database. 1194 * 1195 * @param groupId the group ID 1196 * @param privateLayout the private layout 1197 * @param layoutId the layout ID 1198 * @param portletId the portlet ID 1199 * @throws SystemException if a system exception occurred 1200 */ 1201 public static void removeByG_P_L_P(long groupId, boolean privateLayout, 1202 long layoutId, java.lang.String portletId) 1203 throws com.liferay.portal.kernel.exception.SystemException { 1204 getPersistence() 1205 .removeByG_P_L_P(groupId, privateLayout, layoutId, portletId); 1206 } 1207 1208 /** 1209 * Removes the journal content search where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ? from the database. 1210 * 1211 * @param groupId the group ID 1212 * @param privateLayout the private layout 1213 * @param layoutId the layout ID 1214 * @param portletId the portlet ID 1215 * @param articleId the article ID 1216 * @throws SystemException if a system exception occurred 1217 */ 1218 public static void removeByG_P_L_P_A(long groupId, boolean privateLayout, 1219 long layoutId, java.lang.String portletId, java.lang.String articleId) 1220 throws com.liferay.portal.kernel.exception.SystemException, 1221 com.liferay.portlet.journal.NoSuchContentSearchException { 1222 getPersistence() 1223 .removeByG_P_L_P_A(groupId, privateLayout, layoutId, portletId, 1224 articleId); 1225 } 1226 1227 /** 1228 * Removes all the journal content searchs from the database. 1229 * 1230 * @throws SystemException if a system exception occurred 1231 */ 1232 public static void removeAll() 1233 throws com.liferay.portal.kernel.exception.SystemException { 1234 getPersistence().removeAll(); 1235 } 1236 1237 /** 1238 * Returns the number of journal content searchs where articleId = ?. 1239 * 1240 * @param articleId the article ID 1241 * @return the number of matching journal content searchs 1242 * @throws SystemException if a system exception occurred 1243 */ 1244 public static int countByArticleId(java.lang.String articleId) 1245 throws com.liferay.portal.kernel.exception.SystemException { 1246 return getPersistence().countByArticleId(articleId); 1247 } 1248 1249 /** 1250 * Returns the number of journal content searchs where groupId = ? and privateLayout = ?. 1251 * 1252 * @param groupId the group ID 1253 * @param privateLayout the private layout 1254 * @return the number of matching journal content searchs 1255 * @throws SystemException if a system exception occurred 1256 */ 1257 public static int countByG_P(long groupId, boolean privateLayout) 1258 throws com.liferay.portal.kernel.exception.SystemException { 1259 return getPersistence().countByG_P(groupId, privateLayout); 1260 } 1261 1262 /** 1263 * Returns the number of journal content searchs where groupId = ? and articleId = ?. 1264 * 1265 * @param groupId the group ID 1266 * @param articleId the article ID 1267 * @return the number of matching journal content searchs 1268 * @throws SystemException if a system exception occurred 1269 */ 1270 public static int countByG_A(long groupId, java.lang.String articleId) 1271 throws com.liferay.portal.kernel.exception.SystemException { 1272 return getPersistence().countByG_A(groupId, articleId); 1273 } 1274 1275 /** 1276 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and layoutId = ?. 1277 * 1278 * @param groupId the group ID 1279 * @param privateLayout the private layout 1280 * @param layoutId the layout ID 1281 * @return the number of matching journal content searchs 1282 * @throws SystemException if a system exception occurred 1283 */ 1284 public static int countByG_P_L(long groupId, boolean privateLayout, 1285 long layoutId) 1286 throws com.liferay.portal.kernel.exception.SystemException { 1287 return getPersistence().countByG_P_L(groupId, privateLayout, layoutId); 1288 } 1289 1290 /** 1291 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 1292 * 1293 * @param groupId the group ID 1294 * @param privateLayout the private layout 1295 * @param articleId the article ID 1296 * @return the number of matching journal content searchs 1297 * @throws SystemException if a system exception occurred 1298 */ 1299 public static int countByG_P_A(long groupId, boolean privateLayout, 1300 java.lang.String articleId) 1301 throws com.liferay.portal.kernel.exception.SystemException { 1302 return getPersistence().countByG_P_A(groupId, privateLayout, articleId); 1303 } 1304 1305 /** 1306 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1307 * 1308 * @param groupId the group ID 1309 * @param privateLayout the private layout 1310 * @param layoutId the layout ID 1311 * @param portletId the portlet ID 1312 * @return the number of matching journal content searchs 1313 * @throws SystemException if a system exception occurred 1314 */ 1315 public static int countByG_P_L_P(long groupId, boolean privateLayout, 1316 long layoutId, java.lang.String portletId) 1317 throws com.liferay.portal.kernel.exception.SystemException { 1318 return getPersistence() 1319 .countByG_P_L_P(groupId, privateLayout, layoutId, portletId); 1320 } 1321 1322 /** 1323 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ?. 1324 * 1325 * @param groupId the group ID 1326 * @param privateLayout the private layout 1327 * @param layoutId the layout ID 1328 * @param portletId the portlet ID 1329 * @param articleId the article ID 1330 * @return the number of matching journal content searchs 1331 * @throws SystemException if a system exception occurred 1332 */ 1333 public static int countByG_P_L_P_A(long groupId, boolean privateLayout, 1334 long layoutId, java.lang.String portletId, java.lang.String articleId) 1335 throws com.liferay.portal.kernel.exception.SystemException { 1336 return getPersistence() 1337 .countByG_P_L_P_A(groupId, privateLayout, layoutId, 1338 portletId, articleId); 1339 } 1340 1341 /** 1342 * Returns the number of journal content searchs. 1343 * 1344 * @return the number of journal content searchs 1345 * @throws SystemException if a system exception occurred 1346 */ 1347 public static int countAll() 1348 throws com.liferay.portal.kernel.exception.SystemException { 1349 return getPersistence().countAll(); 1350 } 1351 1352 public static JournalContentSearchPersistence getPersistence() { 1353 if (_persistence == null) { 1354 _persistence = (JournalContentSearchPersistence)PortalBeanLocatorUtil.locate(JournalContentSearchPersistence.class.getName()); 1355 1356 ReferenceRegistry.registerReference(JournalContentSearchUtil.class, 1357 "_persistence"); 1358 } 1359 1360 return _persistence; 1361 } 1362 1363 public void setPersistence(JournalContentSearchPersistence persistence) { 1364 _persistence = persistence; 1365 1366 ReferenceRegistry.registerReference(JournalContentSearchUtil.class, 1367 "_persistence"); 1368 } 1369 1370 private static JournalContentSearchPersistence _persistence; 1371 }