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