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