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