001 /** 002 * Copyright (c) 2000-2013 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 * @param uuid the uuid 250 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 251 * @return the first matching journal structure 252 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 253 * @throws SystemException if a system exception occurred 254 */ 255 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First( 256 java.lang.String uuid, 257 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 258 throws com.liferay.portal.kernel.exception.SystemException, 259 com.liferay.portlet.journal.NoSuchStructureException { 260 return getPersistence().findByUuid_First(uuid, orderByComparator); 261 } 262 263 /** 264 * Returns the first journal structure in the ordered set where uuid = ?. 265 * 266 * @param uuid the uuid 267 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 268 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 269 * @throws SystemException if a system exception occurred 270 */ 271 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_First( 272 java.lang.String uuid, 273 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 274 throws com.liferay.portal.kernel.exception.SystemException { 275 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 276 } 277 278 /** 279 * Returns the last journal structure in the ordered set where uuid = ?. 280 * 281 * @param uuid the uuid 282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 283 * @return the last matching journal structure 284 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 285 * @throws SystemException if a system exception occurred 286 */ 287 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last( 288 java.lang.String uuid, 289 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 290 throws com.liferay.portal.kernel.exception.SystemException, 291 com.liferay.portlet.journal.NoSuchStructureException { 292 return getPersistence().findByUuid_Last(uuid, orderByComparator); 293 } 294 295 /** 296 * Returns the last journal structure in the ordered set where uuid = ?. 297 * 298 * @param uuid the uuid 299 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 300 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 301 * @throws SystemException if a system exception occurred 302 */ 303 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_Last( 304 java.lang.String uuid, 305 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 306 throws com.liferay.portal.kernel.exception.SystemException { 307 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 308 } 309 310 /** 311 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ?. 312 * 313 * @param id the primary key of the current journal structure 314 * @param uuid the uuid 315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 316 * @return the previous, current, and next journal structure 317 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 318 * @throws SystemException if a system exception occurred 319 */ 320 public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext( 321 long id, java.lang.String uuid, 322 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 323 throws com.liferay.portal.kernel.exception.SystemException, 324 com.liferay.portlet.journal.NoSuchStructureException { 325 return getPersistence() 326 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 327 } 328 329 /** 330 * Returns the journal structure where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 331 * 332 * @param uuid the uuid 333 * @param groupId the group ID 334 * @return the matching journal structure 335 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 336 * @throws SystemException if a system exception occurred 337 */ 338 public static com.liferay.portlet.journal.model.JournalStructure findByUUID_G( 339 java.lang.String uuid, long groupId) 340 throws com.liferay.portal.kernel.exception.SystemException, 341 com.liferay.portlet.journal.NoSuchStructureException { 342 return getPersistence().findByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 347 * 348 * @param uuid the uuid 349 * @param groupId the group ID 350 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 351 * @throws SystemException if a system exception occurred 352 */ 353 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 354 java.lang.String uuid, long groupId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().fetchByUUID_G(uuid, groupId); 357 } 358 359 /** 360 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 361 * 362 * @param uuid the uuid 363 * @param groupId the group ID 364 * @param retrieveFromCache whether to use the finder cache 365 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 366 * @throws SystemException if a system exception occurred 367 */ 368 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 369 java.lang.String uuid, long groupId, boolean retrieveFromCache) 370 throws com.liferay.portal.kernel.exception.SystemException { 371 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 372 } 373 374 /** 375 * Returns all the journal structures where groupId = ?. 376 * 377 * @param groupId the group ID 378 * @return the matching journal structures 379 * @throws SystemException if a system exception occurred 380 */ 381 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 382 long groupId) 383 throws com.liferay.portal.kernel.exception.SystemException { 384 return getPersistence().findByGroupId(groupId); 385 } 386 387 /** 388 * Returns a range of all the journal structures where groupId = ?. 389 * 390 * <p> 391 * 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. 392 * </p> 393 * 394 * @param groupId the group ID 395 * @param start the lower bound of the range of journal structures 396 * @param end the upper bound of the range of journal structures (not inclusive) 397 * @return the range of matching journal structures 398 * @throws SystemException if a system exception occurred 399 */ 400 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 401 long groupId, int start, int end) 402 throws com.liferay.portal.kernel.exception.SystemException { 403 return getPersistence().findByGroupId(groupId, start, end); 404 } 405 406 /** 407 * Returns an ordered range of all the journal structures where groupId = ?. 408 * 409 * <p> 410 * 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. 411 * </p> 412 * 413 * @param groupId the group ID 414 * @param start the lower bound of the range of journal structures 415 * @param end the upper bound of the range of journal structures (not inclusive) 416 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 417 * @return the ordered range of matching journal structures 418 * @throws SystemException if a system exception occurred 419 */ 420 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 421 long groupId, int start, int end, 422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 423 throws com.liferay.portal.kernel.exception.SystemException { 424 return getPersistence() 425 .findByGroupId(groupId, start, end, orderByComparator); 426 } 427 428 /** 429 * Returns the first journal structure in the ordered set where groupId = ?. 430 * 431 * @param groupId the group ID 432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 433 * @return the first matching journal structure 434 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 435 * @throws SystemException if a system exception occurred 436 */ 437 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First( 438 long groupId, 439 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 440 throws com.liferay.portal.kernel.exception.SystemException, 441 com.liferay.portlet.journal.NoSuchStructureException { 442 return getPersistence().findByGroupId_First(groupId, orderByComparator); 443 } 444 445 /** 446 * Returns the first journal structure in the ordered set where groupId = ?. 447 * 448 * @param groupId the group ID 449 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 450 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 451 * @throws SystemException if a system exception occurred 452 */ 453 public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_First( 454 long groupId, 455 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 456 throws com.liferay.portal.kernel.exception.SystemException { 457 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 458 } 459 460 /** 461 * Returns the last journal structure in the ordered set where groupId = ?. 462 * 463 * @param groupId the group ID 464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 465 * @return the last matching journal structure 466 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 467 * @throws SystemException if a system exception occurred 468 */ 469 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last( 470 long groupId, 471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 472 throws com.liferay.portal.kernel.exception.SystemException, 473 com.liferay.portlet.journal.NoSuchStructureException { 474 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 475 } 476 477 /** 478 * Returns the last journal structure in the ordered set where groupId = ?. 479 * 480 * @param groupId the group ID 481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 482 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_Last( 486 long groupId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException { 489 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 490 } 491 492 /** 493 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ?. 494 * 495 * @param id the primary key of the current journal structure 496 * @param groupId the group ID 497 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 498 * @return the previous, current, and next journal structure 499 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 500 * @throws SystemException if a system exception occurred 501 */ 502 public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext( 503 long id, long groupId, 504 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 505 throws com.liferay.portal.kernel.exception.SystemException, 506 com.liferay.portlet.journal.NoSuchStructureException { 507 return getPersistence() 508 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 509 } 510 511 /** 512 * Returns all the journal structures that the user has permission to view where groupId = ?. 513 * 514 * @param groupId the group ID 515 * @return the matching journal structures that the user has permission to view 516 * @throws SystemException if a system exception occurred 517 */ 518 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 519 long groupId) 520 throws com.liferay.portal.kernel.exception.SystemException { 521 return getPersistence().filterFindByGroupId(groupId); 522 } 523 524 /** 525 * Returns a range of all the journal structures that the user has permission to view where groupId = ?. 526 * 527 * <p> 528 * 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. 529 * </p> 530 * 531 * @param groupId the group ID 532 * @param start the lower bound of the range of journal structures 533 * @param end the upper bound of the range of journal structures (not inclusive) 534 * @return the range of matching journal structures that the user has permission to view 535 * @throws SystemException if a system exception occurred 536 */ 537 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 538 long groupId, int start, int end) 539 throws com.liferay.portal.kernel.exception.SystemException { 540 return getPersistence().filterFindByGroupId(groupId, start, end); 541 } 542 543 /** 544 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ?. 545 * 546 * <p> 547 * 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. 548 * </p> 549 * 550 * @param groupId the group ID 551 * @param start the lower bound of the range of journal structures 552 * @param end the upper bound of the range of journal structures (not inclusive) 553 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 554 * @return the ordered range of matching journal structures that the user has permission to view 555 * @throws SystemException if a system exception occurred 556 */ 557 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 558 long groupId, int start, int end, 559 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 560 throws com.liferay.portal.kernel.exception.SystemException { 561 return getPersistence() 562 .filterFindByGroupId(groupId, start, end, orderByComparator); 563 } 564 565 /** 566 * 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 = ?. 567 * 568 * @param id the primary key of the current journal structure 569 * @param groupId the group ID 570 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 571 * @return the previous, current, and next journal structure 572 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 573 * @throws SystemException if a system exception occurred 574 */ 575 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext( 576 long id, long groupId, 577 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 578 throws com.liferay.portal.kernel.exception.SystemException, 579 com.liferay.portlet.journal.NoSuchStructureException { 580 return getPersistence() 581 .filterFindByGroupId_PrevAndNext(id, groupId, 582 orderByComparator); 583 } 584 585 /** 586 * Returns all the journal structures where structureId = ?. 587 * 588 * @param structureId the structure ID 589 * @return the matching journal structures 590 * @throws SystemException if a system exception occurred 591 */ 592 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 593 java.lang.String structureId) 594 throws com.liferay.portal.kernel.exception.SystemException { 595 return getPersistence().findByStructureId(structureId); 596 } 597 598 /** 599 * Returns a range of all the journal structures where structureId = ?. 600 * 601 * <p> 602 * 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. 603 * </p> 604 * 605 * @param structureId the structure ID 606 * @param start the lower bound of the range of journal structures 607 * @param end the upper bound of the range of journal structures (not inclusive) 608 * @return the range of matching journal structures 609 * @throws SystemException if a system exception occurred 610 */ 611 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 612 java.lang.String structureId, int start, int end) 613 throws com.liferay.portal.kernel.exception.SystemException { 614 return getPersistence().findByStructureId(structureId, start, end); 615 } 616 617 /** 618 * Returns an ordered range of all the journal structures where structureId = ?. 619 * 620 * <p> 621 * 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. 622 * </p> 623 * 624 * @param structureId the structure ID 625 * @param start the lower bound of the range of journal structures 626 * @param end the upper bound of the range of journal structures (not inclusive) 627 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 628 * @return the ordered range of matching journal structures 629 * @throws SystemException if a system exception occurred 630 */ 631 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 632 java.lang.String structureId, int start, int end, 633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 634 throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence() 636 .findByStructureId(structureId, start, end, orderByComparator); 637 } 638 639 /** 640 * Returns the first journal structure in the ordered set where structureId = ?. 641 * 642 * @param structureId the structure ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the first matching journal structure 645 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First( 649 java.lang.String structureId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.journal.NoSuchStructureException { 653 return getPersistence() 654 .findByStructureId_First(structureId, orderByComparator); 655 } 656 657 /** 658 * Returns the first journal structure in the ordered set where structureId = ?. 659 * 660 * @param structureId the structure ID 661 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 662 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 663 * @throws SystemException if a system exception occurred 664 */ 665 public static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_First( 666 java.lang.String structureId, 667 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 668 throws com.liferay.portal.kernel.exception.SystemException { 669 return getPersistence() 670 .fetchByStructureId_First(structureId, orderByComparator); 671 } 672 673 /** 674 * Returns the last journal structure in the ordered set where structureId = ?. 675 * 676 * @param structureId the structure ID 677 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 678 * @return the last matching journal structure 679 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 680 * @throws SystemException if a system exception occurred 681 */ 682 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last( 683 java.lang.String structureId, 684 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 685 throws com.liferay.portal.kernel.exception.SystemException, 686 com.liferay.portlet.journal.NoSuchStructureException { 687 return getPersistence() 688 .findByStructureId_Last(structureId, orderByComparator); 689 } 690 691 /** 692 * Returns the last journal structure in the ordered set where structureId = ?. 693 * 694 * @param structureId the structure ID 695 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 696 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 697 * @throws SystemException if a system exception occurred 698 */ 699 public static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_Last( 700 java.lang.String structureId, 701 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 702 throws com.liferay.portal.kernel.exception.SystemException { 703 return getPersistence() 704 .fetchByStructureId_Last(structureId, orderByComparator); 705 } 706 707 /** 708 * Returns the journal structures before and after the current journal structure in the ordered set where structureId = ?. 709 * 710 * @param id the primary key of the current journal structure 711 * @param structureId the structure ID 712 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 713 * @return the previous, current, and next journal structure 714 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 715 * @throws SystemException if a system exception occurred 716 */ 717 public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext( 718 long id, java.lang.String structureId, 719 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 720 throws com.liferay.portal.kernel.exception.SystemException, 721 com.liferay.portlet.journal.NoSuchStructureException { 722 return getPersistence() 723 .findByStructureId_PrevAndNext(id, structureId, 724 orderByComparator); 725 } 726 727 /** 728 * Returns all the journal structures where parentStructureId = ?. 729 * 730 * @param parentStructureId the parent structure ID 731 * @return the matching journal structures 732 * @throws SystemException if a system exception occurred 733 */ 734 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 735 java.lang.String parentStructureId) 736 throws com.liferay.portal.kernel.exception.SystemException { 737 return getPersistence().findByParentStructureId(parentStructureId); 738 } 739 740 /** 741 * Returns a range of all the journal structures where parentStructureId = ?. 742 * 743 * <p> 744 * 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. 745 * </p> 746 * 747 * @param parentStructureId the parent structure ID 748 * @param start the lower bound of the range of journal structures 749 * @param end the upper bound of the range of journal structures (not inclusive) 750 * @return the range of matching journal structures 751 * @throws SystemException if a system exception occurred 752 */ 753 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 754 java.lang.String parentStructureId, int start, int end) 755 throws com.liferay.portal.kernel.exception.SystemException { 756 return getPersistence() 757 .findByParentStructureId(parentStructureId, start, end); 758 } 759 760 /** 761 * Returns an ordered range of all the journal structures where parentStructureId = ?. 762 * 763 * <p> 764 * 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. 765 * </p> 766 * 767 * @param parentStructureId the parent structure ID 768 * @param start the lower bound of the range of journal structures 769 * @param end the upper bound of the range of journal structures (not inclusive) 770 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 771 * @return the ordered range of matching journal structures 772 * @throws SystemException if a system exception occurred 773 */ 774 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 775 java.lang.String parentStructureId, int start, int end, 776 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 777 throws com.liferay.portal.kernel.exception.SystemException { 778 return getPersistence() 779 .findByParentStructureId(parentStructureId, start, end, 780 orderByComparator); 781 } 782 783 /** 784 * Returns the first journal structure in the ordered set where parentStructureId = ?. 785 * 786 * @param parentStructureId the parent structure ID 787 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 788 * @return the first matching journal structure 789 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 790 * @throws SystemException if a system exception occurred 791 */ 792 public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_First( 793 java.lang.String parentStructureId, 794 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 795 throws com.liferay.portal.kernel.exception.SystemException, 796 com.liferay.portlet.journal.NoSuchStructureException { 797 return getPersistence() 798 .findByParentStructureId_First(parentStructureId, 799 orderByComparator); 800 } 801 802 /** 803 * Returns the first journal structure in the ordered set where parentStructureId = ?. 804 * 805 * @param parentStructureId the parent structure ID 806 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 807 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 808 * @throws SystemException if a system exception occurred 809 */ 810 public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_First( 811 java.lang.String parentStructureId, 812 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 813 throws com.liferay.portal.kernel.exception.SystemException { 814 return getPersistence() 815 .fetchByParentStructureId_First(parentStructureId, 816 orderByComparator); 817 } 818 819 /** 820 * Returns the last journal structure in the ordered set where parentStructureId = ?. 821 * 822 * @param parentStructureId the parent structure ID 823 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 824 * @return the last matching journal structure 825 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 826 * @throws SystemException if a system exception occurred 827 */ 828 public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_Last( 829 java.lang.String parentStructureId, 830 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 831 throws com.liferay.portal.kernel.exception.SystemException, 832 com.liferay.portlet.journal.NoSuchStructureException { 833 return getPersistence() 834 .findByParentStructureId_Last(parentStructureId, 835 orderByComparator); 836 } 837 838 /** 839 * Returns the last journal structure in the ordered set where parentStructureId = ?. 840 * 841 * @param parentStructureId the parent structure ID 842 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 843 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 844 * @throws SystemException if a system exception occurred 845 */ 846 public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_Last( 847 java.lang.String parentStructureId, 848 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 849 throws com.liferay.portal.kernel.exception.SystemException { 850 return getPersistence() 851 .fetchByParentStructureId_Last(parentStructureId, 852 orderByComparator); 853 } 854 855 /** 856 * Returns the journal structures before and after the current journal structure in the ordered set where parentStructureId = ?. 857 * 858 * @param id the primary key of the current journal structure 859 * @param parentStructureId the parent structure ID 860 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 861 * @return the previous, current, and next journal structure 862 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 863 * @throws SystemException if a system exception occurred 864 */ 865 public static com.liferay.portlet.journal.model.JournalStructure[] findByParentStructureId_PrevAndNext( 866 long id, java.lang.String parentStructureId, 867 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 868 throws com.liferay.portal.kernel.exception.SystemException, 869 com.liferay.portlet.journal.NoSuchStructureException { 870 return getPersistence() 871 .findByParentStructureId_PrevAndNext(id, parentStructureId, 872 orderByComparator); 873 } 874 875 /** 876 * Returns the journal structure where groupId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 877 * 878 * @param groupId the group ID 879 * @param structureId the structure ID 880 * @return the matching journal structure 881 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 882 * @throws SystemException if a system exception occurred 883 */ 884 public static com.liferay.portlet.journal.model.JournalStructure findByG_S( 885 long groupId, java.lang.String structureId) 886 throws com.liferay.portal.kernel.exception.SystemException, 887 com.liferay.portlet.journal.NoSuchStructureException { 888 return getPersistence().findByG_S(groupId, structureId); 889 } 890 891 /** 892 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 893 * 894 * @param groupId the group ID 895 * @param structureId the structure ID 896 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 897 * @throws SystemException if a system exception occurred 898 */ 899 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 900 long groupId, java.lang.String structureId) 901 throws com.liferay.portal.kernel.exception.SystemException { 902 return getPersistence().fetchByG_S(groupId, structureId); 903 } 904 905 /** 906 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 907 * 908 * @param groupId the group ID 909 * @param structureId the structure ID 910 * @param retrieveFromCache whether to use the finder cache 911 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 912 * @throws SystemException if a system exception occurred 913 */ 914 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 915 long groupId, java.lang.String structureId, boolean retrieveFromCache) 916 throws com.liferay.portal.kernel.exception.SystemException { 917 return getPersistence() 918 .fetchByG_S(groupId, structureId, retrieveFromCache); 919 } 920 921 /** 922 * Returns all the journal structures where groupId = ? and parentStructureId = ?. 923 * 924 * @param groupId the group ID 925 * @param parentStructureId the parent structure ID 926 * @return the matching journal structures 927 * @throws SystemException if a system exception occurred 928 */ 929 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 930 long groupId, java.lang.String parentStructureId) 931 throws com.liferay.portal.kernel.exception.SystemException { 932 return getPersistence().findByG_P(groupId, parentStructureId); 933 } 934 935 /** 936 * Returns a range of all the journal structures where groupId = ? and parentStructureId = ?. 937 * 938 * <p> 939 * 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. 940 * </p> 941 * 942 * @param groupId the group ID 943 * @param parentStructureId the parent structure ID 944 * @param start the lower bound of the range of journal structures 945 * @param end the upper bound of the range of journal structures (not inclusive) 946 * @return the range of matching journal structures 947 * @throws SystemException if a system exception occurred 948 */ 949 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 950 long groupId, java.lang.String parentStructureId, int start, int end) 951 throws com.liferay.portal.kernel.exception.SystemException { 952 return getPersistence().findByG_P(groupId, parentStructureId, start, end); 953 } 954 955 /** 956 * Returns an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 957 * 958 * <p> 959 * 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. 960 * </p> 961 * 962 * @param groupId the group ID 963 * @param parentStructureId the parent structure ID 964 * @param start the lower bound of the range of journal structures 965 * @param end the upper bound of the range of journal structures (not inclusive) 966 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 967 * @return the ordered range of matching journal structures 968 * @throws SystemException if a system exception occurred 969 */ 970 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 971 long groupId, java.lang.String parentStructureId, int start, int end, 972 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 973 throws com.liferay.portal.kernel.exception.SystemException { 974 return getPersistence() 975 .findByG_P(groupId, parentStructureId, start, end, 976 orderByComparator); 977 } 978 979 /** 980 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 981 * 982 * @param groupId the group ID 983 * @param parentStructureId the parent structure ID 984 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 985 * @return the first matching journal structure 986 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 987 * @throws SystemException if a system exception occurred 988 */ 989 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First( 990 long groupId, java.lang.String parentStructureId, 991 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 992 throws com.liferay.portal.kernel.exception.SystemException, 993 com.liferay.portlet.journal.NoSuchStructureException { 994 return getPersistence() 995 .findByG_P_First(groupId, parentStructureId, 996 orderByComparator); 997 } 998 999 /** 1000 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1001 * 1002 * @param groupId the group ID 1003 * @param parentStructureId the parent structure ID 1004 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1005 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 1006 * @throws SystemException if a system exception occurred 1007 */ 1008 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_First( 1009 long groupId, java.lang.String parentStructureId, 1010 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1011 throws com.liferay.portal.kernel.exception.SystemException { 1012 return getPersistence() 1013 .fetchByG_P_First(groupId, parentStructureId, 1014 orderByComparator); 1015 } 1016 1017 /** 1018 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1019 * 1020 * @param groupId the group ID 1021 * @param parentStructureId the parent structure ID 1022 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1023 * @return the last matching journal structure 1024 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1025 * @throws SystemException if a system exception occurred 1026 */ 1027 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last( 1028 long groupId, java.lang.String parentStructureId, 1029 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1030 throws com.liferay.portal.kernel.exception.SystemException, 1031 com.liferay.portlet.journal.NoSuchStructureException { 1032 return getPersistence() 1033 .findByG_P_Last(groupId, parentStructureId, orderByComparator); 1034 } 1035 1036 /** 1037 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1038 * 1039 * @param groupId the group ID 1040 * @param parentStructureId the parent structure ID 1041 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1042 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 1043 * @throws SystemException if a system exception occurred 1044 */ 1045 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_Last( 1046 long groupId, java.lang.String parentStructureId, 1047 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1048 throws com.liferay.portal.kernel.exception.SystemException { 1049 return getPersistence() 1050 .fetchByG_P_Last(groupId, parentStructureId, 1051 orderByComparator); 1052 } 1053 1054 /** 1055 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1056 * 1057 * @param id the primary key of the current journal structure 1058 * @param groupId the group ID 1059 * @param parentStructureId the parent structure ID 1060 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1061 * @return the previous, current, and next journal structure 1062 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1063 * @throws SystemException if a system exception occurred 1064 */ 1065 public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext( 1066 long id, long groupId, java.lang.String parentStructureId, 1067 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1068 throws com.liferay.portal.kernel.exception.SystemException, 1069 com.liferay.portlet.journal.NoSuchStructureException { 1070 return getPersistence() 1071 .findByG_P_PrevAndNext(id, groupId, parentStructureId, 1072 orderByComparator); 1073 } 1074 1075 /** 1076 * Returns all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1077 * 1078 * @param groupId the group ID 1079 * @param parentStructureId the parent structure ID 1080 * @return the matching journal structures that the user has permission to view 1081 * @throws SystemException if a system exception occurred 1082 */ 1083 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1084 long groupId, java.lang.String parentStructureId) 1085 throws com.liferay.portal.kernel.exception.SystemException { 1086 return getPersistence().filterFindByG_P(groupId, parentStructureId); 1087 } 1088 1089 /** 1090 * Returns a range of all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1091 * 1092 * <p> 1093 * 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. 1094 * </p> 1095 * 1096 * @param groupId the group ID 1097 * @param parentStructureId the parent structure ID 1098 * @param start the lower bound of the range of journal structures 1099 * @param end the upper bound of the range of journal structures (not inclusive) 1100 * @return the range of matching journal structures that the user has permission to view 1101 * @throws SystemException if a system exception occurred 1102 */ 1103 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1104 long groupId, java.lang.String parentStructureId, int start, int end) 1105 throws com.liferay.portal.kernel.exception.SystemException { 1106 return getPersistence() 1107 .filterFindByG_P(groupId, parentStructureId, start, end); 1108 } 1109 1110 /** 1111 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ? and parentStructureId = ?. 1112 * 1113 * <p> 1114 * 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. 1115 * </p> 1116 * 1117 * @param groupId the group ID 1118 * @param parentStructureId the parent structure ID 1119 * @param start the lower bound of the range of journal structures 1120 * @param end the upper bound of the range of journal structures (not inclusive) 1121 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1122 * @return the ordered range of matching journal structures that the user has permission to view 1123 * @throws SystemException if a system exception occurred 1124 */ 1125 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1126 long groupId, java.lang.String parentStructureId, int start, int end, 1127 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1128 throws com.liferay.portal.kernel.exception.SystemException { 1129 return getPersistence() 1130 .filterFindByG_P(groupId, parentStructureId, start, end, 1131 orderByComparator); 1132 } 1133 1134 /** 1135 * 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 = ?. 1136 * 1137 * @param id the primary key of the current journal structure 1138 * @param groupId the group ID 1139 * @param parentStructureId the parent structure ID 1140 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1141 * @return the previous, current, and next journal structure 1142 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1143 * @throws SystemException if a system exception occurred 1144 */ 1145 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext( 1146 long id, long groupId, java.lang.String parentStructureId, 1147 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1148 throws com.liferay.portal.kernel.exception.SystemException, 1149 com.liferay.portlet.journal.NoSuchStructureException { 1150 return getPersistence() 1151 .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId, 1152 orderByComparator); 1153 } 1154 1155 /** 1156 * Returns all the journal structures. 1157 * 1158 * @return the journal structures 1159 * @throws SystemException if a system exception occurred 1160 */ 1161 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll() 1162 throws com.liferay.portal.kernel.exception.SystemException { 1163 return getPersistence().findAll(); 1164 } 1165 1166 /** 1167 * Returns a range of all the journal structures. 1168 * 1169 * <p> 1170 * 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. 1171 * </p> 1172 * 1173 * @param start the lower bound of the range of journal structures 1174 * @param end the upper bound of the range of journal structures (not inclusive) 1175 * @return the range of journal structures 1176 * @throws SystemException if a system exception occurred 1177 */ 1178 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1179 int start, int end) 1180 throws com.liferay.portal.kernel.exception.SystemException { 1181 return getPersistence().findAll(start, end); 1182 } 1183 1184 /** 1185 * Returns an ordered range of all the journal structures. 1186 * 1187 * <p> 1188 * 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. 1189 * </p> 1190 * 1191 * @param start the lower bound of the range of journal structures 1192 * @param end the upper bound of the range of journal structures (not inclusive) 1193 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1194 * @return the ordered range of journal structures 1195 * @throws SystemException if a system exception occurred 1196 */ 1197 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1198 int start, int end, 1199 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1200 throws com.liferay.portal.kernel.exception.SystemException { 1201 return getPersistence().findAll(start, end, orderByComparator); 1202 } 1203 1204 /** 1205 * Removes all the journal structures where uuid = ? from the database. 1206 * 1207 * @param uuid the uuid 1208 * @throws SystemException if a system exception occurred 1209 */ 1210 public static void removeByUuid(java.lang.String uuid) 1211 throws com.liferay.portal.kernel.exception.SystemException { 1212 getPersistence().removeByUuid(uuid); 1213 } 1214 1215 /** 1216 * Removes the journal structure where uuid = ? and groupId = ? from the database. 1217 * 1218 * @param uuid the uuid 1219 * @param groupId the group ID 1220 * @return the journal structure that was removed 1221 * @throws SystemException if a system exception occurred 1222 */ 1223 public static com.liferay.portlet.journal.model.JournalStructure removeByUUID_G( 1224 java.lang.String uuid, long groupId) 1225 throws com.liferay.portal.kernel.exception.SystemException, 1226 com.liferay.portlet.journal.NoSuchStructureException { 1227 return getPersistence().removeByUUID_G(uuid, groupId); 1228 } 1229 1230 /** 1231 * Removes all the journal structures where groupId = ? from the database. 1232 * 1233 * @param groupId the group ID 1234 * @throws SystemException if a system exception occurred 1235 */ 1236 public static void removeByGroupId(long groupId) 1237 throws com.liferay.portal.kernel.exception.SystemException { 1238 getPersistence().removeByGroupId(groupId); 1239 } 1240 1241 /** 1242 * Removes all the journal structures where structureId = ? from the database. 1243 * 1244 * @param structureId the structure ID 1245 * @throws SystemException if a system exception occurred 1246 */ 1247 public static void removeByStructureId(java.lang.String structureId) 1248 throws com.liferay.portal.kernel.exception.SystemException { 1249 getPersistence().removeByStructureId(structureId); 1250 } 1251 1252 /** 1253 * Removes all the journal structures where parentStructureId = ? from the database. 1254 * 1255 * @param parentStructureId the parent structure ID 1256 * @throws SystemException if a system exception occurred 1257 */ 1258 public static void removeByParentStructureId( 1259 java.lang.String parentStructureId) 1260 throws com.liferay.portal.kernel.exception.SystemException { 1261 getPersistence().removeByParentStructureId(parentStructureId); 1262 } 1263 1264 /** 1265 * Removes the journal structure where groupId = ? and structureId = ? from the database. 1266 * 1267 * @param groupId the group ID 1268 * @param structureId the structure ID 1269 * @return the journal structure that was removed 1270 * @throws SystemException if a system exception occurred 1271 */ 1272 public static com.liferay.portlet.journal.model.JournalStructure removeByG_S( 1273 long groupId, java.lang.String structureId) 1274 throws com.liferay.portal.kernel.exception.SystemException, 1275 com.liferay.portlet.journal.NoSuchStructureException { 1276 return getPersistence().removeByG_S(groupId, structureId); 1277 } 1278 1279 /** 1280 * Removes all the journal structures where groupId = ? and parentStructureId = ? from the database. 1281 * 1282 * @param groupId the group ID 1283 * @param parentStructureId the parent structure ID 1284 * @throws SystemException if a system exception occurred 1285 */ 1286 public static void removeByG_P(long groupId, 1287 java.lang.String parentStructureId) 1288 throws com.liferay.portal.kernel.exception.SystemException { 1289 getPersistence().removeByG_P(groupId, parentStructureId); 1290 } 1291 1292 /** 1293 * Removes all the journal structures from the database. 1294 * 1295 * @throws SystemException if a system exception occurred 1296 */ 1297 public static void removeAll() 1298 throws com.liferay.portal.kernel.exception.SystemException { 1299 getPersistence().removeAll(); 1300 } 1301 1302 /** 1303 * Returns the number of journal structures where uuid = ?. 1304 * 1305 * @param uuid the uuid 1306 * @return the number of matching journal structures 1307 * @throws SystemException if a system exception occurred 1308 */ 1309 public static int countByUuid(java.lang.String uuid) 1310 throws com.liferay.portal.kernel.exception.SystemException { 1311 return getPersistence().countByUuid(uuid); 1312 } 1313 1314 /** 1315 * Returns the number of journal structures where uuid = ? and groupId = ?. 1316 * 1317 * @param uuid the uuid 1318 * @param groupId the group ID 1319 * @return the number of matching journal structures 1320 * @throws SystemException if a system exception occurred 1321 */ 1322 public static int countByUUID_G(java.lang.String uuid, long groupId) 1323 throws com.liferay.portal.kernel.exception.SystemException { 1324 return getPersistence().countByUUID_G(uuid, groupId); 1325 } 1326 1327 /** 1328 * Returns the number of journal structures where groupId = ?. 1329 * 1330 * @param groupId the group ID 1331 * @return the number of matching journal structures 1332 * @throws SystemException if a system exception occurred 1333 */ 1334 public static int countByGroupId(long groupId) 1335 throws com.liferay.portal.kernel.exception.SystemException { 1336 return getPersistence().countByGroupId(groupId); 1337 } 1338 1339 /** 1340 * Returns the number of journal structures that the user has permission to view where groupId = ?. 1341 * 1342 * @param groupId the group ID 1343 * @return the number of matching journal structures that the user has permission to view 1344 * @throws SystemException if a system exception occurred 1345 */ 1346 public static int filterCountByGroupId(long groupId) 1347 throws com.liferay.portal.kernel.exception.SystemException { 1348 return getPersistence().filterCountByGroupId(groupId); 1349 } 1350 1351 /** 1352 * Returns the number of journal structures where structureId = ?. 1353 * 1354 * @param structureId the structure ID 1355 * @return the number of matching journal structures 1356 * @throws SystemException if a system exception occurred 1357 */ 1358 public static int countByStructureId(java.lang.String structureId) 1359 throws com.liferay.portal.kernel.exception.SystemException { 1360 return getPersistence().countByStructureId(structureId); 1361 } 1362 1363 /** 1364 * Returns the number of journal structures where parentStructureId = ?. 1365 * 1366 * @param parentStructureId the parent structure ID 1367 * @return the number of matching journal structures 1368 * @throws SystemException if a system exception occurred 1369 */ 1370 public static int countByParentStructureId( 1371 java.lang.String parentStructureId) 1372 throws com.liferay.portal.kernel.exception.SystemException { 1373 return getPersistence().countByParentStructureId(parentStructureId); 1374 } 1375 1376 /** 1377 * Returns the number of journal structures where groupId = ? and structureId = ?. 1378 * 1379 * @param groupId the group ID 1380 * @param structureId the structure ID 1381 * @return the number of matching journal structures 1382 * @throws SystemException if a system exception occurred 1383 */ 1384 public static int countByG_S(long groupId, java.lang.String structureId) 1385 throws com.liferay.portal.kernel.exception.SystemException { 1386 return getPersistence().countByG_S(groupId, structureId); 1387 } 1388 1389 /** 1390 * Returns the number of journal structures where groupId = ? and parentStructureId = ?. 1391 * 1392 * @param groupId the group ID 1393 * @param parentStructureId the parent structure ID 1394 * @return the number of matching journal structures 1395 * @throws SystemException if a system exception occurred 1396 */ 1397 public static int countByG_P(long groupId, 1398 java.lang.String parentStructureId) 1399 throws com.liferay.portal.kernel.exception.SystemException { 1400 return getPersistence().countByG_P(groupId, parentStructureId); 1401 } 1402 1403 /** 1404 * Returns the number of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1405 * 1406 * @param groupId the group ID 1407 * @param parentStructureId the parent structure ID 1408 * @return the number of matching journal structures that the user has permission to view 1409 * @throws SystemException if a system exception occurred 1410 */ 1411 public static int filterCountByG_P(long groupId, 1412 java.lang.String parentStructureId) 1413 throws com.liferay.portal.kernel.exception.SystemException { 1414 return getPersistence().filterCountByG_P(groupId, parentStructureId); 1415 } 1416 1417 /** 1418 * Returns the number of journal structures. 1419 * 1420 * @return the number of journal structures 1421 * @throws SystemException if a system exception occurred 1422 */ 1423 public static int countAll() 1424 throws com.liferay.portal.kernel.exception.SystemException { 1425 return getPersistence().countAll(); 1426 } 1427 1428 public static JournalStructurePersistence getPersistence() { 1429 if (_persistence == null) { 1430 _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName()); 1431 1432 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1433 "_persistence"); 1434 } 1435 1436 return _persistence; 1437 } 1438 1439 /** 1440 * @deprecated 1441 */ 1442 public void setPersistence(JournalStructurePersistence persistence) { 1443 } 1444 1445 private static JournalStructurePersistence _persistence; 1446 }