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 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 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 java.util.List<com.liferay.portlet.journal.model.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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByPortletId( 155 java.lang.String portletId, int start, int end, 156 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 168 */ 169 public static com.liferay.portlet.journal.model.JournalContentSearch findByPortletId_First( 170 java.lang.String portletId, 171 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByPortletId_First( 185 java.lang.String portletId, 186 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 198 */ 199 public static com.liferay.portlet.journal.model.JournalContentSearch findByPortletId_Last( 200 java.lang.String portletId, 201 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByPortletId_Last( 215 java.lang.String portletId, 216 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 229 */ 230 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByPortletId_PrevAndNext( 231 long contentSearchId, java.lang.String portletId, 232 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 java.util.List<com.liferay.portlet.journal.model.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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByArticleId( 300 java.lang.String articleId, int start, int end, 301 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 313 */ 314 public static com.liferay.portlet.journal.model.JournalContentSearch findByArticleId_First( 315 java.lang.String articleId, 316 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByArticleId_First( 330 java.lang.String articleId, 331 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 343 */ 344 public static com.liferay.portlet.journal.model.JournalContentSearch findByArticleId_Last( 345 java.lang.String articleId, 346 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByArticleId_Last( 360 java.lang.String articleId, 361 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 374 */ 375 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByArticleId_PrevAndNext( 376 long contentSearchId, java.lang.String articleId, 377 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P( 411 long groupId, 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P( 429 long groupId, 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P( 448 long groupId, boolean privateLayout, int start, int end, 449 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 463 */ 464 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_First( 465 long groupId, boolean privateLayout, 466 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_First( 481 long groupId, boolean privateLayout, 482 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 495 */ 496 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_Last( 497 long groupId, boolean privateLayout, 498 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_Last( 513 long groupId, boolean privateLayout, 514 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 528 */ 529 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_PrevAndNext( 530 long contentSearchId, long groupId, boolean privateLayout, 531 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A( 567 long groupId, 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A( 585 long groupId, 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A( 604 long groupId, java.lang.String articleId, int start, int end, 605 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 618 */ 619 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_A_First( 620 long groupId, java.lang.String articleId, 621 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByG_A_First( 636 long groupId, java.lang.String articleId, 637 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 650 */ 651 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_A_Last( 652 long groupId, java.lang.String articleId, 653 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByG_A_Last( 668 long groupId, java.lang.String articleId, 669 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 683 */ 684 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_A_PrevAndNext( 685 long contentSearchId, long groupId, java.lang.String articleId, 686 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L( 723 long groupId, 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L( 742 long groupId, 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L( 763 long groupId, boolean privateLayout, long layoutId, int start, int end, 764 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 779 */ 780 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_First( 781 long groupId, boolean privateLayout, long layoutId, 782 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_First( 799 long groupId, boolean privateLayout, long layoutId, 800 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 815 */ 816 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_Last( 817 long groupId, boolean privateLayout, long layoutId, 818 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_Last( 835 long groupId, boolean privateLayout, long layoutId, 836 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.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 com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 852 */ 853 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_L_PrevAndNext( 854 long contentSearchId, long groupId, boolean privateLayout, 855 long layoutId, 856 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) 857 throws com.liferay.portlet.journal.NoSuchContentSearchException { 858 return getPersistence() 859 .findByG_P_L_PrevAndNext(contentSearchId, groupId, 860 privateLayout, layoutId, orderByComparator); 861 } 862 863 /** 864 * Removes all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? from the database. 865 * 866 * @param groupId the group ID 867 * @param privateLayout the private layout 868 * @param layoutId the layout ID 869 */ 870 public static void removeByG_P_L(long groupId, boolean privateLayout, 871 long layoutId) { 872 getPersistence().removeByG_P_L(groupId, privateLayout, layoutId); 873 } 874 875 /** 876 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and layoutId = ?. 877 * 878 * @param groupId the group ID 879 * @param privateLayout the private layout 880 * @param layoutId the layout ID 881 * @return the number of matching journal content searchs 882 */ 883 public static int countByG_P_L(long groupId, boolean privateLayout, 884 long layoutId) { 885 return getPersistence().countByG_P_L(groupId, privateLayout, layoutId); 886 } 887 888 /** 889 * Returns all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 890 * 891 * @param groupId the group ID 892 * @param privateLayout the private layout 893 * @param articleId the article ID 894 * @return the matching journal content searchs 895 */ 896 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A( 897 long groupId, boolean privateLayout, java.lang.String articleId) { 898 return getPersistence().findByG_P_A(groupId, privateLayout, articleId); 899 } 900 901 /** 902 * Returns a range of all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 903 * 904 * <p> 905 * 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. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 906 * </p> 907 * 908 * @param groupId the group ID 909 * @param privateLayout the private layout 910 * @param articleId the article ID 911 * @param start the lower bound of the range of journal content searchs 912 * @param end the upper bound of the range of journal content searchs (not inclusive) 913 * @return the range of matching journal content searchs 914 */ 915 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A( 916 long groupId, boolean privateLayout, java.lang.String articleId, 917 int start, int end) { 918 return getPersistence() 919 .findByG_P_A(groupId, privateLayout, articleId, start, end); 920 } 921 922 /** 923 * Returns an ordered range of all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 924 * 925 * <p> 926 * 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. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 927 * </p> 928 * 929 * @param groupId the group ID 930 * @param privateLayout the private layout 931 * @param articleId the article ID 932 * @param start the lower bound of the range of journal content searchs 933 * @param end the upper bound of the range of journal content searchs (not inclusive) 934 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 935 * @return the ordered range of matching journal content searchs 936 */ 937 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A( 938 long groupId, boolean privateLayout, java.lang.String articleId, 939 int start, int end, 940 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) { 941 return getPersistence() 942 .findByG_P_A(groupId, privateLayout, articleId, start, end, 943 orderByComparator); 944 } 945 946 /** 947 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 948 * 949 * @param groupId the group ID 950 * @param privateLayout the private layout 951 * @param articleId the article ID 952 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 953 * @return the first matching journal content search 954 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 955 */ 956 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_A_First( 957 long groupId, boolean privateLayout, java.lang.String articleId, 958 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) 959 throws com.liferay.portlet.journal.NoSuchContentSearchException { 960 return getPersistence() 961 .findByG_P_A_First(groupId, privateLayout, articleId, 962 orderByComparator); 963 } 964 965 /** 966 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 967 * 968 * @param groupId the group ID 969 * @param privateLayout the private layout 970 * @param articleId the article ID 971 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 972 * @return the first matching journal content search, or <code>null</code> if a matching journal content search could not be found 973 */ 974 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_A_First( 975 long groupId, boolean privateLayout, java.lang.String articleId, 976 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) { 977 return getPersistence() 978 .fetchByG_P_A_First(groupId, privateLayout, articleId, 979 orderByComparator); 980 } 981 982 /** 983 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 984 * 985 * @param groupId the group ID 986 * @param privateLayout the private layout 987 * @param articleId the article ID 988 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 989 * @return the last matching journal content search 990 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 991 */ 992 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_A_Last( 993 long groupId, boolean privateLayout, java.lang.String articleId, 994 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) 995 throws com.liferay.portlet.journal.NoSuchContentSearchException { 996 return getPersistence() 997 .findByG_P_A_Last(groupId, privateLayout, articleId, 998 orderByComparator); 999 } 1000 1001 /** 1002 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 1003 * 1004 * @param groupId the group ID 1005 * @param privateLayout the private layout 1006 * @param articleId the article ID 1007 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1008 * @return the last matching journal content search, or <code>null</code> if a matching journal content search could not be found 1009 */ 1010 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_A_Last( 1011 long groupId, boolean privateLayout, java.lang.String articleId, 1012 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) { 1013 return getPersistence() 1014 .fetchByG_P_A_Last(groupId, privateLayout, articleId, 1015 orderByComparator); 1016 } 1017 1018 /** 1019 * Returns the journal content searchs before and after the current journal content search in the ordered set where groupId = ? and privateLayout = ? and articleId = ?. 1020 * 1021 * @param contentSearchId the primary key of the current journal content search 1022 * @param groupId the group ID 1023 * @param privateLayout the private layout 1024 * @param articleId the article ID 1025 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1026 * @return the previous, current, and next journal content search 1027 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 1028 */ 1029 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_A_PrevAndNext( 1030 long contentSearchId, long groupId, boolean privateLayout, 1031 java.lang.String articleId, 1032 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) 1033 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1034 return getPersistence() 1035 .findByG_P_A_PrevAndNext(contentSearchId, groupId, 1036 privateLayout, articleId, orderByComparator); 1037 } 1038 1039 /** 1040 * Removes all the journal content searchs where groupId = ? and privateLayout = ? and articleId = ? from the database. 1041 * 1042 * @param groupId the group ID 1043 * @param privateLayout the private layout 1044 * @param articleId the article ID 1045 */ 1046 public static void removeByG_P_A(long groupId, boolean privateLayout, 1047 java.lang.String articleId) { 1048 getPersistence().removeByG_P_A(groupId, privateLayout, articleId); 1049 } 1050 1051 /** 1052 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and articleId = ?. 1053 * 1054 * @param groupId the group ID 1055 * @param privateLayout the private layout 1056 * @param articleId the article ID 1057 * @return the number of matching journal content searchs 1058 */ 1059 public static int countByG_P_A(long groupId, boolean privateLayout, 1060 java.lang.String articleId) { 1061 return getPersistence().countByG_P_A(groupId, privateLayout, articleId); 1062 } 1063 1064 /** 1065 * Returns all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1066 * 1067 * @param groupId the group ID 1068 * @param privateLayout the private layout 1069 * @param layoutId the layout ID 1070 * @param portletId the portlet ID 1071 * @return the matching journal content searchs 1072 */ 1073 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P( 1074 long groupId, boolean privateLayout, long layoutId, 1075 java.lang.String portletId) { 1076 return getPersistence() 1077 .findByG_P_L_P(groupId, privateLayout, layoutId, portletId); 1078 } 1079 1080 /** 1081 * Returns a range of all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1082 * 1083 * <p> 1084 * 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. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1085 * </p> 1086 * 1087 * @param groupId the group ID 1088 * @param privateLayout the private layout 1089 * @param layoutId the layout ID 1090 * @param portletId the portlet ID 1091 * @param start the lower bound of the range of journal content searchs 1092 * @param end the upper bound of the range of journal content searchs (not inclusive) 1093 * @return the range of matching journal content searchs 1094 */ 1095 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P( 1096 long groupId, boolean privateLayout, long layoutId, 1097 java.lang.String portletId, int start, int end) { 1098 return getPersistence() 1099 .findByG_P_L_P(groupId, privateLayout, layoutId, portletId, 1100 start, end); 1101 } 1102 1103 /** 1104 * Returns an ordered range of all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1105 * 1106 * <p> 1107 * 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. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1108 * </p> 1109 * 1110 * @param groupId the group ID 1111 * @param privateLayout the private layout 1112 * @param layoutId the layout ID 1113 * @param portletId the portlet ID 1114 * @param start the lower bound of the range of journal content searchs 1115 * @param end the upper bound of the range of journal content searchs (not inclusive) 1116 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1117 * @return the ordered range of matching journal content searchs 1118 */ 1119 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P( 1120 long groupId, boolean privateLayout, long layoutId, 1121 java.lang.String portletId, int start, int end, 1122 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) { 1123 return getPersistence() 1124 .findByG_P_L_P(groupId, privateLayout, layoutId, portletId, 1125 start, end, orderByComparator); 1126 } 1127 1128 /** 1129 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1130 * 1131 * @param groupId the group ID 1132 * @param privateLayout the private layout 1133 * @param layoutId the layout ID 1134 * @param portletId the portlet ID 1135 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1136 * @return the first matching journal content search 1137 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 1138 */ 1139 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_First( 1140 long groupId, boolean privateLayout, long layoutId, 1141 java.lang.String portletId, 1142 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) 1143 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1144 return getPersistence() 1145 .findByG_P_L_P_First(groupId, privateLayout, layoutId, 1146 portletId, orderByComparator); 1147 } 1148 1149 /** 1150 * Returns the first journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1151 * 1152 * @param groupId the group ID 1153 * @param privateLayout the private layout 1154 * @param layoutId the layout ID 1155 * @param portletId the portlet ID 1156 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1157 * @return the first matching journal content search, or <code>null</code> if a matching journal content search could not be found 1158 */ 1159 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_First( 1160 long groupId, boolean privateLayout, long layoutId, 1161 java.lang.String portletId, 1162 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) { 1163 return getPersistence() 1164 .fetchByG_P_L_P_First(groupId, privateLayout, layoutId, 1165 portletId, orderByComparator); 1166 } 1167 1168 /** 1169 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1170 * 1171 * @param groupId the group ID 1172 * @param privateLayout the private layout 1173 * @param layoutId the layout ID 1174 * @param portletId the portlet ID 1175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1176 * @return the last matching journal content search 1177 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 1178 */ 1179 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_Last( 1180 long groupId, boolean privateLayout, long layoutId, 1181 java.lang.String portletId, 1182 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) 1183 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1184 return getPersistence() 1185 .findByG_P_L_P_Last(groupId, privateLayout, layoutId, 1186 portletId, orderByComparator); 1187 } 1188 1189 /** 1190 * Returns the last journal content search in the ordered set where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1191 * 1192 * @param groupId the group ID 1193 * @param privateLayout the private layout 1194 * @param layoutId the layout ID 1195 * @param portletId the portlet ID 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the last matching journal content search, or <code>null</code> if a matching journal content search could not be found 1198 */ 1199 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_Last( 1200 long groupId, boolean privateLayout, long layoutId, 1201 java.lang.String portletId, 1202 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) { 1203 return getPersistence() 1204 .fetchByG_P_L_P_Last(groupId, privateLayout, layoutId, 1205 portletId, orderByComparator); 1206 } 1207 1208 /** 1209 * 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 = ?. 1210 * 1211 * @param contentSearchId the primary key of the current journal content search 1212 * @param groupId the group ID 1213 * @param privateLayout the private layout 1214 * @param layoutId the layout ID 1215 * @param portletId the portlet ID 1216 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1217 * @return the previous, current, and next journal content search 1218 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 1219 */ 1220 public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_L_P_PrevAndNext( 1221 long contentSearchId, long groupId, boolean privateLayout, 1222 long layoutId, java.lang.String portletId, 1223 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) 1224 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1225 return getPersistence() 1226 .findByG_P_L_P_PrevAndNext(contentSearchId, groupId, 1227 privateLayout, layoutId, portletId, orderByComparator); 1228 } 1229 1230 /** 1231 * Removes all the journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? from the database. 1232 * 1233 * @param groupId the group ID 1234 * @param privateLayout the private layout 1235 * @param layoutId the layout ID 1236 * @param portletId the portlet ID 1237 */ 1238 public static void removeByG_P_L_P(long groupId, boolean privateLayout, 1239 long layoutId, java.lang.String portletId) { 1240 getPersistence() 1241 .removeByG_P_L_P(groupId, privateLayout, layoutId, portletId); 1242 } 1243 1244 /** 1245 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ?. 1246 * 1247 * @param groupId the group ID 1248 * @param privateLayout the private layout 1249 * @param layoutId the layout ID 1250 * @param portletId the portlet ID 1251 * @return the number of matching journal content searchs 1252 */ 1253 public static int countByG_P_L_P(long groupId, boolean privateLayout, 1254 long layoutId, java.lang.String portletId) { 1255 return getPersistence() 1256 .countByG_P_L_P(groupId, privateLayout, layoutId, portletId); 1257 } 1258 1259 /** 1260 * Returns the journal content search where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ? or throws a {@link com.liferay.portlet.journal.NoSuchContentSearchException} if it could not be found. 1261 * 1262 * @param groupId the group ID 1263 * @param privateLayout the private layout 1264 * @param layoutId the layout ID 1265 * @param portletId the portlet ID 1266 * @param articleId the article ID 1267 * @return the matching journal content search 1268 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found 1269 */ 1270 public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_A( 1271 long groupId, boolean privateLayout, long layoutId, 1272 java.lang.String portletId, java.lang.String articleId) 1273 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1274 return getPersistence() 1275 .findByG_P_L_P_A(groupId, privateLayout, layoutId, 1276 portletId, articleId); 1277 } 1278 1279 /** 1280 * 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. 1281 * 1282 * @param groupId the group ID 1283 * @param privateLayout the private layout 1284 * @param layoutId the layout ID 1285 * @param portletId the portlet ID 1286 * @param articleId the article ID 1287 * @return the matching journal content search, or <code>null</code> if a matching journal content search could not be found 1288 */ 1289 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_A( 1290 long groupId, boolean privateLayout, long layoutId, 1291 java.lang.String portletId, java.lang.String articleId) { 1292 return getPersistence() 1293 .fetchByG_P_L_P_A(groupId, privateLayout, layoutId, 1294 portletId, articleId); 1295 } 1296 1297 /** 1298 * 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. 1299 * 1300 * @param groupId the group ID 1301 * @param privateLayout the private layout 1302 * @param layoutId the layout ID 1303 * @param portletId the portlet ID 1304 * @param articleId the article ID 1305 * @param retrieveFromCache whether to use the finder cache 1306 * @return the matching journal content search, or <code>null</code> if a matching journal content search could not be found 1307 */ 1308 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_A( 1309 long groupId, boolean privateLayout, long layoutId, 1310 java.lang.String portletId, java.lang.String articleId, 1311 boolean retrieveFromCache) { 1312 return getPersistence() 1313 .fetchByG_P_L_P_A(groupId, privateLayout, layoutId, 1314 portletId, articleId, retrieveFromCache); 1315 } 1316 1317 /** 1318 * Removes the journal content search where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ? from the database. 1319 * 1320 * @param groupId the group ID 1321 * @param privateLayout the private layout 1322 * @param layoutId the layout ID 1323 * @param portletId the portlet ID 1324 * @param articleId the article ID 1325 * @return the journal content search that was removed 1326 */ 1327 public static com.liferay.portlet.journal.model.JournalContentSearch removeByG_P_L_P_A( 1328 long groupId, boolean privateLayout, long layoutId, 1329 java.lang.String portletId, java.lang.String articleId) 1330 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1331 return getPersistence() 1332 .removeByG_P_L_P_A(groupId, privateLayout, layoutId, 1333 portletId, articleId); 1334 } 1335 1336 /** 1337 * Returns the number of journal content searchs where groupId = ? and privateLayout = ? and layoutId = ? and portletId = ? and articleId = ?. 1338 * 1339 * @param groupId the group ID 1340 * @param privateLayout the private layout 1341 * @param layoutId the layout ID 1342 * @param portletId the portlet ID 1343 * @param articleId the article ID 1344 * @return the number of matching journal content searchs 1345 */ 1346 public static int countByG_P_L_P_A(long groupId, boolean privateLayout, 1347 long layoutId, java.lang.String portletId, java.lang.String articleId) { 1348 return getPersistence() 1349 .countByG_P_L_P_A(groupId, privateLayout, layoutId, 1350 portletId, articleId); 1351 } 1352 1353 /** 1354 * Caches the journal content search in the entity cache if it is enabled. 1355 * 1356 * @param journalContentSearch the journal content search 1357 */ 1358 public static void cacheResult( 1359 com.liferay.portlet.journal.model.JournalContentSearch journalContentSearch) { 1360 getPersistence().cacheResult(journalContentSearch); 1361 } 1362 1363 /** 1364 * Caches the journal content searchs in the entity cache if it is enabled. 1365 * 1366 * @param journalContentSearchs the journal content searchs 1367 */ 1368 public static void cacheResult( 1369 java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> journalContentSearchs) { 1370 getPersistence().cacheResult(journalContentSearchs); 1371 } 1372 1373 /** 1374 * Creates a new journal content search with the primary key. Does not add the journal content search to the database. 1375 * 1376 * @param contentSearchId the primary key for the new journal content search 1377 * @return the new journal content search 1378 */ 1379 public static com.liferay.portlet.journal.model.JournalContentSearch create( 1380 long contentSearchId) { 1381 return getPersistence().create(contentSearchId); 1382 } 1383 1384 /** 1385 * Removes the journal content search with the primary key from the database. Also notifies the appropriate model listeners. 1386 * 1387 * @param contentSearchId the primary key of the journal content search 1388 * @return the journal content search that was removed 1389 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 1390 */ 1391 public static com.liferay.portlet.journal.model.JournalContentSearch remove( 1392 long contentSearchId) 1393 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1394 return getPersistence().remove(contentSearchId); 1395 } 1396 1397 public static com.liferay.portlet.journal.model.JournalContentSearch updateImpl( 1398 com.liferay.portlet.journal.model.JournalContentSearch journalContentSearch) { 1399 return getPersistence().updateImpl(journalContentSearch); 1400 } 1401 1402 /** 1403 * Returns the journal content search with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchContentSearchException} if it could not be found. 1404 * 1405 * @param contentSearchId the primary key of the journal content search 1406 * @return the journal content search 1407 * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found 1408 */ 1409 public static com.liferay.portlet.journal.model.JournalContentSearch findByPrimaryKey( 1410 long contentSearchId) 1411 throws com.liferay.portlet.journal.NoSuchContentSearchException { 1412 return getPersistence().findByPrimaryKey(contentSearchId); 1413 } 1414 1415 /** 1416 * Returns the journal content search with the primary key or returns <code>null</code> if it could not be found. 1417 * 1418 * @param contentSearchId the primary key of the journal content search 1419 * @return the journal content search, or <code>null</code> if a journal content search with the primary key could not be found 1420 */ 1421 public static com.liferay.portlet.journal.model.JournalContentSearch fetchByPrimaryKey( 1422 long contentSearchId) { 1423 return getPersistence().fetchByPrimaryKey(contentSearchId); 1424 } 1425 1426 public static java.util.Map<java.io.Serializable, com.liferay.portlet.journal.model.JournalContentSearch> fetchByPrimaryKeys( 1427 java.util.Set<java.io.Serializable> primaryKeys) { 1428 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1429 } 1430 1431 /** 1432 * Returns all the journal content searchs. 1433 * 1434 * @return the journal content searchs 1435 */ 1436 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll() { 1437 return getPersistence().findAll(); 1438 } 1439 1440 /** 1441 * Returns a range of all the journal content searchs. 1442 * 1443 * <p> 1444 * 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. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1445 * </p> 1446 * 1447 * @param start the lower bound of the range of journal content searchs 1448 * @param end the upper bound of the range of journal content searchs (not inclusive) 1449 * @return the range of journal content searchs 1450 */ 1451 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll( 1452 int start, int end) { 1453 return getPersistence().findAll(start, end); 1454 } 1455 1456 /** 1457 * Returns an ordered range of all the journal content searchs. 1458 * 1459 * <p> 1460 * 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. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1461 * </p> 1462 * 1463 * @param start the lower bound of the range of journal content searchs 1464 * @param end the upper bound of the range of journal content searchs (not inclusive) 1465 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1466 * @return the ordered range of journal content searchs 1467 */ 1468 public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll( 1469 int start, int end, 1470 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalContentSearch> orderByComparator) { 1471 return getPersistence().findAll(start, end, orderByComparator); 1472 } 1473 1474 /** 1475 * Removes all the journal content searchs from the database. 1476 */ 1477 public static void removeAll() { 1478 getPersistence().removeAll(); 1479 } 1480 1481 /** 1482 * Returns the number of journal content searchs. 1483 * 1484 * @return the number of journal content searchs 1485 */ 1486 public static int countAll() { 1487 return getPersistence().countAll(); 1488 } 1489 1490 public static JournalContentSearchPersistence getPersistence() { 1491 if (_persistence == null) { 1492 _persistence = (JournalContentSearchPersistence)PortalBeanLocatorUtil.locate(JournalContentSearchPersistence.class.getName()); 1493 1494 ReferenceRegistry.registerReference(JournalContentSearchUtil.class, 1495 "_persistence"); 1496 } 1497 1498 return _persistence; 1499 } 1500 1501 /** 1502 * @deprecated As of 6.2.0 1503 */ 1504 @Deprecated 1505 public void setPersistence(JournalContentSearchPersistence persistence) { 1506 } 1507 1508 private static JournalContentSearchPersistence _persistence; 1509 }