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) 099 */ 100 public static JournalStructure update(JournalStructure journalStructure) 101 throws SystemException { 102 return getPersistence().update(journalStructure); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static JournalStructure update(JournalStructure journalStructure, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(journalStructure, 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 throws com.liferay.portal.kernel.exception.SystemException { 162 return getPersistence().updateImpl(journalStructure); 163 } 164 165 /** 166 * Returns the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 167 * 168 * @param id the primary key of the journal structure 169 * @return the journal structure 170 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 171 * @throws SystemException if a system exception occurred 172 */ 173 public static com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey( 174 long id) 175 throws com.liferay.portal.kernel.exception.SystemException, 176 com.liferay.portlet.journal.NoSuchStructureException { 177 return getPersistence().findByPrimaryKey(id); 178 } 179 180 /** 181 * Returns the journal structure with the primary key or returns <code>null</code> if it could not be found. 182 * 183 * @param id the primary key of the journal structure 184 * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found 185 * @throws SystemException if a system exception occurred 186 */ 187 public static com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey( 188 long id) throws com.liferay.portal.kernel.exception.SystemException { 189 return getPersistence().fetchByPrimaryKey(id); 190 } 191 192 /** 193 * Returns all the journal structures where uuid = ?. 194 * 195 * @param uuid the uuid 196 * @return the matching journal structures 197 * @throws SystemException if a system exception occurred 198 */ 199 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 200 java.lang.String uuid) 201 throws com.liferay.portal.kernel.exception.SystemException { 202 return getPersistence().findByUuid(uuid); 203 } 204 205 /** 206 * Returns a range of all the journal structures where uuid = ?. 207 * 208 * <p> 209 * 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. 210 * </p> 211 * 212 * @param uuid the uuid 213 * @param start the lower bound of the range of journal structures 214 * @param end the upper bound of the range of journal structures (not inclusive) 215 * @return the range of matching journal structures 216 * @throws SystemException if a system exception occurred 217 */ 218 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 219 java.lang.String uuid, int start, int end) 220 throws com.liferay.portal.kernel.exception.SystemException { 221 return getPersistence().findByUuid(uuid, start, end); 222 } 223 224 /** 225 * Returns an ordered range of all the journal structures where uuid = ?. 226 * 227 * <p> 228 * 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. 229 * </p> 230 * 231 * @param uuid the uuid 232 * @param start the lower bound of the range of journal structures 233 * @param end the upper bound of the range of journal structures (not inclusive) 234 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 235 * @return the ordered range of matching journal structures 236 * @throws SystemException if a system exception occurred 237 */ 238 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 239 java.lang.String uuid, int start, int end, 240 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 241 throws com.liferay.portal.kernel.exception.SystemException { 242 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 243 } 244 245 /** 246 * Returns the first journal structure in the ordered set where uuid = ?. 247 * 248 * @param uuid the uuid 249 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 250 * @return the first matching journal structure 251 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 252 * @throws SystemException if a system exception occurred 253 */ 254 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First( 255 java.lang.String uuid, 256 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 257 throws com.liferay.portal.kernel.exception.SystemException, 258 com.liferay.portlet.journal.NoSuchStructureException { 259 return getPersistence().findByUuid_First(uuid, orderByComparator); 260 } 261 262 /** 263 * Returns the first journal structure in the ordered set where uuid = ?. 264 * 265 * @param uuid the uuid 266 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 267 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 268 * @throws SystemException if a system exception occurred 269 */ 270 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_First( 271 java.lang.String uuid, 272 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 273 throws com.liferay.portal.kernel.exception.SystemException { 274 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 275 } 276 277 /** 278 * Returns the last journal structure in the ordered set where uuid = ?. 279 * 280 * @param uuid the uuid 281 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 282 * @return the last matching journal structure 283 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 284 * @throws SystemException if a system exception occurred 285 */ 286 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last( 287 java.lang.String uuid, 288 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 289 throws com.liferay.portal.kernel.exception.SystemException, 290 com.liferay.portlet.journal.NoSuchStructureException { 291 return getPersistence().findByUuid_Last(uuid, orderByComparator); 292 } 293 294 /** 295 * Returns the last journal structure in the ordered set where uuid = ?. 296 * 297 * @param uuid the uuid 298 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 299 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 300 * @throws SystemException if a system exception occurred 301 */ 302 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_Last( 303 java.lang.String uuid, 304 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 305 throws com.liferay.portal.kernel.exception.SystemException { 306 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 307 } 308 309 /** 310 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ?. 311 * 312 * @param id the primary key of the current journal structure 313 * @param uuid the uuid 314 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 315 * @return the previous, current, and next journal structure 316 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 317 * @throws SystemException if a system exception occurred 318 */ 319 public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext( 320 long id, java.lang.String uuid, 321 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 322 throws com.liferay.portal.kernel.exception.SystemException, 323 com.liferay.portlet.journal.NoSuchStructureException { 324 return getPersistence() 325 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 326 } 327 328 /** 329 * Returns the journal structure where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 330 * 331 * @param uuid the uuid 332 * @param groupId the group ID 333 * @return the matching journal structure 334 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 335 * @throws SystemException if a system exception occurred 336 */ 337 public static com.liferay.portlet.journal.model.JournalStructure findByUUID_G( 338 java.lang.String uuid, long groupId) 339 throws com.liferay.portal.kernel.exception.SystemException, 340 com.liferay.portlet.journal.NoSuchStructureException { 341 return getPersistence().findByUUID_G(uuid, groupId); 342 } 343 344 /** 345 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 346 * 347 * @param uuid the uuid 348 * @param groupId the group ID 349 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 350 * @throws SystemException if a system exception occurred 351 */ 352 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 353 java.lang.String uuid, long groupId) 354 throws com.liferay.portal.kernel.exception.SystemException { 355 return getPersistence().fetchByUUID_G(uuid, groupId); 356 } 357 358 /** 359 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 360 * 361 * @param uuid the uuid 362 * @param groupId the group ID 363 * @param retrieveFromCache whether to use the finder cache 364 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 365 * @throws SystemException if a system exception occurred 366 */ 367 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 368 java.lang.String uuid, long groupId, boolean retrieveFromCache) 369 throws com.liferay.portal.kernel.exception.SystemException { 370 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 371 } 372 373 /** 374 * Returns all the journal structures where uuid = ? and companyId = ?. 375 * 376 * @param uuid the uuid 377 * @param companyId the company 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> findByUuid_C( 382 java.lang.String uuid, long companyId) 383 throws com.liferay.portal.kernel.exception.SystemException { 384 return getPersistence().findByUuid_C(uuid, companyId); 385 } 386 387 /** 388 * Returns a range of all the journal structures where uuid = ? and companyId = ?. 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 uuid the uuid 395 * @param companyId the company 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 * @return the range of matching journal structures 399 * @throws SystemException if a system exception occurred 400 */ 401 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 402 java.lang.String uuid, long companyId, int start, int end) 403 throws com.liferay.portal.kernel.exception.SystemException { 404 return getPersistence().findByUuid_C(uuid, companyId, start, end); 405 } 406 407 /** 408 * Returns an ordered range of all the journal structures where uuid = ? and companyId = ?. 409 * 410 * <p> 411 * 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. 412 * </p> 413 * 414 * @param uuid the uuid 415 * @param companyId the company ID 416 * @param start the lower bound of the range of journal structures 417 * @param end the upper bound of the range of journal structures (not inclusive) 418 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 419 * @return the ordered range of matching journal structures 420 * @throws SystemException if a system exception occurred 421 */ 422 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 423 java.lang.String uuid, long companyId, int start, int end, 424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 425 throws com.liferay.portal.kernel.exception.SystemException { 426 return getPersistence() 427 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 428 } 429 430 /** 431 * Returns the first journal structure in the ordered set where uuid = ? and companyId = ?. 432 * 433 * @param uuid the uuid 434 * @param companyId the company ID 435 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 436 * @return the first matching journal structure 437 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 438 * @throws SystemException if a system exception occurred 439 */ 440 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_C_First( 441 java.lang.String uuid, long companyId, 442 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 443 throws com.liferay.portal.kernel.exception.SystemException, 444 com.liferay.portlet.journal.NoSuchStructureException { 445 return getPersistence() 446 .findByUuid_C_First(uuid, companyId, orderByComparator); 447 } 448 449 /** 450 * Returns the first journal structure in the ordered set where uuid = ? and companyId = ?. 451 * 452 * @param uuid the uuid 453 * @param companyId the company ID 454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 455 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 456 * @throws SystemException if a system exception occurred 457 */ 458 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_First( 459 java.lang.String uuid, long companyId, 460 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 461 throws com.liferay.portal.kernel.exception.SystemException { 462 return getPersistence() 463 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 464 } 465 466 /** 467 * Returns the last journal structure in the ordered set where uuid = ? and companyId = ?. 468 * 469 * @param uuid the uuid 470 * @param companyId the company ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the last matching journal structure 473 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 474 * @throws SystemException if a system exception occurred 475 */ 476 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_C_Last( 477 java.lang.String uuid, long companyId, 478 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 479 throws com.liferay.portal.kernel.exception.SystemException, 480 com.liferay.portlet.journal.NoSuchStructureException { 481 return getPersistence() 482 .findByUuid_C_Last(uuid, companyId, orderByComparator); 483 } 484 485 /** 486 * Returns the last journal structure in the ordered set where uuid = ? and companyId = ?. 487 * 488 * @param uuid the uuid 489 * @param companyId the company ID 490 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 491 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 492 * @throws SystemException if a system exception occurred 493 */ 494 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_Last( 495 java.lang.String uuid, long companyId, 496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 497 throws com.liferay.portal.kernel.exception.SystemException { 498 return getPersistence() 499 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 500 } 501 502 /** 503 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ? and companyId = ?. 504 * 505 * @param id the primary key of the current journal structure 506 * @param uuid the uuid 507 * @param companyId the company ID 508 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 509 * @return the previous, current, and next journal structure 510 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 511 * @throws SystemException if a system exception occurred 512 */ 513 public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_C_PrevAndNext( 514 long id, java.lang.String uuid, long companyId, 515 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 516 throws com.liferay.portal.kernel.exception.SystemException, 517 com.liferay.portlet.journal.NoSuchStructureException { 518 return getPersistence() 519 .findByUuid_C_PrevAndNext(id, uuid, companyId, 520 orderByComparator); 521 } 522 523 /** 524 * Returns all the journal structures where groupId = ?. 525 * 526 * @param groupId the group ID 527 * @return the matching journal structures 528 * @throws SystemException if a system exception occurred 529 */ 530 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 531 long groupId) 532 throws com.liferay.portal.kernel.exception.SystemException { 533 return getPersistence().findByGroupId(groupId); 534 } 535 536 /** 537 * Returns a range of all the journal structures where groupId = ?. 538 * 539 * <p> 540 * 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. 541 * </p> 542 * 543 * @param groupId the group ID 544 * @param start the lower bound of the range of journal structures 545 * @param end the upper bound of the range of journal structures (not inclusive) 546 * @return the range of matching journal structures 547 * @throws SystemException if a system exception occurred 548 */ 549 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 550 long groupId, int start, int end) 551 throws com.liferay.portal.kernel.exception.SystemException { 552 return getPersistence().findByGroupId(groupId, start, end); 553 } 554 555 /** 556 * Returns an ordered range of all the journal structures where groupId = ?. 557 * 558 * <p> 559 * 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. 560 * </p> 561 * 562 * @param groupId the group ID 563 * @param start the lower bound of the range of journal structures 564 * @param end the upper bound of the range of journal structures (not inclusive) 565 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 566 * @return the ordered range of matching journal structures 567 * @throws SystemException if a system exception occurred 568 */ 569 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 570 long groupId, int start, int end, 571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 572 throws com.liferay.portal.kernel.exception.SystemException { 573 return getPersistence() 574 .findByGroupId(groupId, start, end, orderByComparator); 575 } 576 577 /** 578 * Returns the first journal structure in the ordered set where groupId = ?. 579 * 580 * @param groupId the group ID 581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 582 * @return the first matching journal structure 583 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 584 * @throws SystemException if a system exception occurred 585 */ 586 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First( 587 long groupId, 588 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 589 throws com.liferay.portal.kernel.exception.SystemException, 590 com.liferay.portlet.journal.NoSuchStructureException { 591 return getPersistence().findByGroupId_First(groupId, orderByComparator); 592 } 593 594 /** 595 * Returns the first journal structure in the ordered set where groupId = ?. 596 * 597 * @param groupId the group ID 598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 599 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 600 * @throws SystemException if a system exception occurred 601 */ 602 public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_First( 603 long groupId, 604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 605 throws com.liferay.portal.kernel.exception.SystemException { 606 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 607 } 608 609 /** 610 * Returns the last journal structure in the ordered set where groupId = ?. 611 * 612 * @param groupId the group ID 613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 614 * @return the last matching journal structure 615 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 616 * @throws SystemException if a system exception occurred 617 */ 618 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last( 619 long groupId, 620 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 621 throws com.liferay.portal.kernel.exception.SystemException, 622 com.liferay.portlet.journal.NoSuchStructureException { 623 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 624 } 625 626 /** 627 * Returns the last journal structure in the ordered set where groupId = ?. 628 * 629 * @param groupId the group ID 630 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 631 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 632 * @throws SystemException if a system exception occurred 633 */ 634 public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_Last( 635 long groupId, 636 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 637 throws com.liferay.portal.kernel.exception.SystemException { 638 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 639 } 640 641 /** 642 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ?. 643 * 644 * @param id the primary key of the current journal structure 645 * @param groupId the group ID 646 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 647 * @return the previous, current, and next journal structure 648 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 649 * @throws SystemException if a system exception occurred 650 */ 651 public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext( 652 long id, long groupId, 653 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 654 throws com.liferay.portal.kernel.exception.SystemException, 655 com.liferay.portlet.journal.NoSuchStructureException { 656 return getPersistence() 657 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 658 } 659 660 /** 661 * Returns all the journal structures where groupId = any ?. 662 * 663 * <p> 664 * 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. 665 * </p> 666 * 667 * @param groupIds the group IDs 668 * @return the matching journal structures 669 * @throws SystemException if a system exception occurred 670 */ 671 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 672 long[] groupIds) 673 throws com.liferay.portal.kernel.exception.SystemException { 674 return getPersistence().findByGroupId(groupIds); 675 } 676 677 /** 678 * Returns a range of all the journal structures where groupId = any ?. 679 * 680 * <p> 681 * 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. 682 * </p> 683 * 684 * @param groupIds the group IDs 685 * @param start the lower bound of the range of journal structures 686 * @param end the upper bound of the range of journal structures (not inclusive) 687 * @return the range of matching journal structures 688 * @throws SystemException if a system exception occurred 689 */ 690 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 691 long[] groupIds, int start, int end) 692 throws com.liferay.portal.kernel.exception.SystemException { 693 return getPersistence().findByGroupId(groupIds, start, end); 694 } 695 696 /** 697 * Returns an ordered range of all the journal structures where groupId = any ?. 698 * 699 * <p> 700 * 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. 701 * </p> 702 * 703 * @param groupIds the group IDs 704 * @param start the lower bound of the range of journal structures 705 * @param end the upper bound of the range of journal structures (not inclusive) 706 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 707 * @return the ordered range of matching journal structures 708 * @throws SystemException if a system exception occurred 709 */ 710 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 711 long[] groupIds, int start, int end, 712 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 713 throws com.liferay.portal.kernel.exception.SystemException { 714 return getPersistence() 715 .findByGroupId(groupIds, start, end, orderByComparator); 716 } 717 718 /** 719 * Returns all the journal structures that the user has permission to view where groupId = ?. 720 * 721 * @param groupId the group ID 722 * @return the matching journal structures that the user has permission to view 723 * @throws SystemException if a system exception occurred 724 */ 725 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 726 long groupId) 727 throws com.liferay.portal.kernel.exception.SystemException { 728 return getPersistence().filterFindByGroupId(groupId); 729 } 730 731 /** 732 * Returns a range of all the journal structures that the user has permission to view where groupId = ?. 733 * 734 * <p> 735 * 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. 736 * </p> 737 * 738 * @param groupId the group ID 739 * @param start the lower bound of the range of journal structures 740 * @param end the upper bound of the range of journal structures (not inclusive) 741 * @return the range of matching journal structures that the user has permission to view 742 * @throws SystemException if a system exception occurred 743 */ 744 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 745 long groupId, int start, int end) 746 throws com.liferay.portal.kernel.exception.SystemException { 747 return getPersistence().filterFindByGroupId(groupId, start, end); 748 } 749 750 /** 751 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ?. 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 groupId the group ID 758 * @param start the lower bound of the range of journal structures 759 * @param end the upper bound of the range of journal structures (not inclusive) 760 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 761 * @return the ordered range of matching journal structures that the user has permission to view 762 * @throws SystemException if a system exception occurred 763 */ 764 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 765 long groupId, int start, int end, 766 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 767 throws com.liferay.portal.kernel.exception.SystemException { 768 return getPersistence() 769 .filterFindByGroupId(groupId, start, end, orderByComparator); 770 } 771 772 /** 773 * 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 = ?. 774 * 775 * @param id the primary key of the current journal structure 776 * @param groupId the group ID 777 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 778 * @return the previous, current, and next journal structure 779 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 780 * @throws SystemException if a system exception occurred 781 */ 782 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext( 783 long id, long groupId, 784 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 785 throws com.liferay.portal.kernel.exception.SystemException, 786 com.liferay.portlet.journal.NoSuchStructureException { 787 return getPersistence() 788 .filterFindByGroupId_PrevAndNext(id, groupId, 789 orderByComparator); 790 } 791 792 /** 793 * Returns all the journal structures that the user has permission to view where groupId = any ?. 794 * 795 * @param groupIds the group IDs 796 * @return the matching journal structures that the user has permission to view 797 * @throws SystemException if a system exception occurred 798 */ 799 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 800 long[] groupIds) 801 throws com.liferay.portal.kernel.exception.SystemException { 802 return getPersistence().filterFindByGroupId(groupIds); 803 } 804 805 /** 806 * Returns a range of all the journal structures that the user has permission to view where groupId = any ?. 807 * 808 * <p> 809 * 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. 810 * </p> 811 * 812 * @param groupIds the group IDs 813 * @param start the lower bound of the range of journal structures 814 * @param end the upper bound of the range of journal structures (not inclusive) 815 * @return the range of matching journal structures that the user has permission to view 816 * @throws SystemException if a system exception occurred 817 */ 818 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 819 long[] groupIds, int start, int end) 820 throws com.liferay.portal.kernel.exception.SystemException { 821 return getPersistence().filterFindByGroupId(groupIds, start, end); 822 } 823 824 /** 825 * Returns an ordered range of all the journal structures that the user has permission to view where groupId = any ?. 826 * 827 * <p> 828 * 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. 829 * </p> 830 * 831 * @param groupIds the group IDs 832 * @param start the lower bound of the range of journal structures 833 * @param end the upper bound of the range of journal structures (not inclusive) 834 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 835 * @return the ordered range of matching journal structures that the user has permission to view 836 * @throws SystemException if a system exception occurred 837 */ 838 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 839 long[] groupIds, int start, int end, 840 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 841 throws com.liferay.portal.kernel.exception.SystemException { 842 return getPersistence() 843 .filterFindByGroupId(groupIds, start, end, orderByComparator); 844 } 845 846 /** 847 * Returns all the journal structures where structureId = ?. 848 * 849 * @param structureId the structure ID 850 * @return the matching journal structures 851 * @throws SystemException if a system exception occurred 852 */ 853 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 854 java.lang.String structureId) 855 throws com.liferay.portal.kernel.exception.SystemException { 856 return getPersistence().findByStructureId(structureId); 857 } 858 859 /** 860 * Returns a range of all the journal structures where structureId = ?. 861 * 862 * <p> 863 * 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. 864 * </p> 865 * 866 * @param structureId the structure ID 867 * @param start the lower bound of the range of journal structures 868 * @param end the upper bound of the range of journal structures (not inclusive) 869 * @return the range of matching journal structures 870 * @throws SystemException if a system exception occurred 871 */ 872 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 873 java.lang.String structureId, int start, int end) 874 throws com.liferay.portal.kernel.exception.SystemException { 875 return getPersistence().findByStructureId(structureId, start, end); 876 } 877 878 /** 879 * Returns an ordered range of all the journal structures where structureId = ?. 880 * 881 * <p> 882 * 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. 883 * </p> 884 * 885 * @param structureId the 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> findByStructureId( 893 java.lang.String structureId, int start, int end, 894 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 895 throws com.liferay.portal.kernel.exception.SystemException { 896 return getPersistence() 897 .findByStructureId(structureId, start, end, orderByComparator); 898 } 899 900 /** 901 * Returns the first journal structure in the ordered set where structureId = ?. 902 * 903 * @param structureId the structure ID 904 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 905 * @return the first matching journal structure 906 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 907 * @throws SystemException if a system exception occurred 908 */ 909 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First( 910 java.lang.String structureId, 911 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 912 throws com.liferay.portal.kernel.exception.SystemException, 913 com.liferay.portlet.journal.NoSuchStructureException { 914 return getPersistence() 915 .findByStructureId_First(structureId, orderByComparator); 916 } 917 918 /** 919 * Returns the first journal structure in the ordered set where structureId = ?. 920 * 921 * @param structureId the structure ID 922 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 923 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 924 * @throws SystemException if a system exception occurred 925 */ 926 public static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_First( 927 java.lang.String structureId, 928 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 929 throws com.liferay.portal.kernel.exception.SystemException { 930 return getPersistence() 931 .fetchByStructureId_First(structureId, orderByComparator); 932 } 933 934 /** 935 * Returns the last journal structure in the ordered set where structureId = ?. 936 * 937 * @param structureId the structure ID 938 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 939 * @return the last matching journal structure 940 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 941 * @throws SystemException if a system exception occurred 942 */ 943 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last( 944 java.lang.String structureId, 945 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 946 throws com.liferay.portal.kernel.exception.SystemException, 947 com.liferay.portlet.journal.NoSuchStructureException { 948 return getPersistence() 949 .findByStructureId_Last(structureId, orderByComparator); 950 } 951 952 /** 953 * Returns the last journal structure in the ordered set where structureId = ?. 954 * 955 * @param structureId the structure ID 956 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 957 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 958 * @throws SystemException if a system exception occurred 959 */ 960 public static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_Last( 961 java.lang.String structureId, 962 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 963 throws com.liferay.portal.kernel.exception.SystemException { 964 return getPersistence() 965 .fetchByStructureId_Last(structureId, orderByComparator); 966 } 967 968 /** 969 * Returns the journal structures before and after the current journal structure in the ordered set where structureId = ?. 970 * 971 * @param id the primary key of the current journal structure 972 * @param structureId the structure ID 973 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 974 * @return the previous, current, and next journal structure 975 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 976 * @throws SystemException if a system exception occurred 977 */ 978 public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext( 979 long id, java.lang.String structureId, 980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 981 throws com.liferay.portal.kernel.exception.SystemException, 982 com.liferay.portlet.journal.NoSuchStructureException { 983 return getPersistence() 984 .findByStructureId_PrevAndNext(id, structureId, 985 orderByComparator); 986 } 987 988 /** 989 * Returns all the journal structures where parentStructureId = ?. 990 * 991 * @param parentStructureId the parent structure ID 992 * @return the matching journal structures 993 * @throws SystemException if a system exception occurred 994 */ 995 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 996 java.lang.String parentStructureId) 997 throws com.liferay.portal.kernel.exception.SystemException { 998 return getPersistence().findByParentStructureId(parentStructureId); 999 } 1000 1001 /** 1002 * Returns a range of all the journal structures where parentStructureId = ?. 1003 * 1004 * <p> 1005 * 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. 1006 * </p> 1007 * 1008 * @param parentStructureId the parent structure ID 1009 * @param start the lower bound of the range of journal structures 1010 * @param end the upper bound of the range of journal structures (not inclusive) 1011 * @return the range of matching journal structures 1012 * @throws SystemException if a system exception occurred 1013 */ 1014 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 1015 java.lang.String parentStructureId, int start, int end) 1016 throws com.liferay.portal.kernel.exception.SystemException { 1017 return getPersistence() 1018 .findByParentStructureId(parentStructureId, start, end); 1019 } 1020 1021 /** 1022 * Returns an ordered range of all the journal structures where parentStructureId = ?. 1023 * 1024 * <p> 1025 * 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. 1026 * </p> 1027 * 1028 * @param parentStructureId the parent structure ID 1029 * @param start the lower bound of the range of journal structures 1030 * @param end the upper bound of the range of journal structures (not inclusive) 1031 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1032 * @return the ordered range of matching journal structures 1033 * @throws SystemException if a system exception occurred 1034 */ 1035 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 1036 java.lang.String parentStructureId, int start, int end, 1037 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1038 throws com.liferay.portal.kernel.exception.SystemException { 1039 return getPersistence() 1040 .findByParentStructureId(parentStructureId, start, end, 1041 orderByComparator); 1042 } 1043 1044 /** 1045 * Returns the first journal structure in the ordered set where parentStructureId = ?. 1046 * 1047 * @param parentStructureId the parent structure ID 1048 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1049 * @return the first matching journal structure 1050 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1051 * @throws SystemException if a system exception occurred 1052 */ 1053 public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_First( 1054 java.lang.String parentStructureId, 1055 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1056 throws com.liferay.portal.kernel.exception.SystemException, 1057 com.liferay.portlet.journal.NoSuchStructureException { 1058 return getPersistence() 1059 .findByParentStructureId_First(parentStructureId, 1060 orderByComparator); 1061 } 1062 1063 /** 1064 * Returns the first journal structure in the ordered set where parentStructureId = ?. 1065 * 1066 * @param parentStructureId the parent structure ID 1067 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1068 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 1069 * @throws SystemException if a system exception occurred 1070 */ 1071 public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_First( 1072 java.lang.String parentStructureId, 1073 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1074 throws com.liferay.portal.kernel.exception.SystemException { 1075 return getPersistence() 1076 .fetchByParentStructureId_First(parentStructureId, 1077 orderByComparator); 1078 } 1079 1080 /** 1081 * Returns the last journal structure in the ordered set where parentStructureId = ?. 1082 * 1083 * @param parentStructureId the parent structure ID 1084 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1085 * @return the last matching journal structure 1086 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1087 * @throws SystemException if a system exception occurred 1088 */ 1089 public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_Last( 1090 java.lang.String parentStructureId, 1091 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1092 throws com.liferay.portal.kernel.exception.SystemException, 1093 com.liferay.portlet.journal.NoSuchStructureException { 1094 return getPersistence() 1095 .findByParentStructureId_Last(parentStructureId, 1096 orderByComparator); 1097 } 1098 1099 /** 1100 * Returns the last journal structure in the ordered set where parentStructureId = ?. 1101 * 1102 * @param parentStructureId the parent structure ID 1103 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1104 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 1105 * @throws SystemException if a system exception occurred 1106 */ 1107 public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_Last( 1108 java.lang.String parentStructureId, 1109 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1110 throws com.liferay.portal.kernel.exception.SystemException { 1111 return getPersistence() 1112 .fetchByParentStructureId_Last(parentStructureId, 1113 orderByComparator); 1114 } 1115 1116 /** 1117 * Returns the journal structures before and after the current journal structure in the ordered set where parentStructureId = ?. 1118 * 1119 * @param id the primary key of the current journal structure 1120 * @param parentStructureId the parent structure ID 1121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1122 * @return the previous, current, and next journal structure 1123 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1124 * @throws SystemException if a system exception occurred 1125 */ 1126 public static com.liferay.portlet.journal.model.JournalStructure[] findByParentStructureId_PrevAndNext( 1127 long id, java.lang.String parentStructureId, 1128 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1129 throws com.liferay.portal.kernel.exception.SystemException, 1130 com.liferay.portlet.journal.NoSuchStructureException { 1131 return getPersistence() 1132 .findByParentStructureId_PrevAndNext(id, parentStructureId, 1133 orderByComparator); 1134 } 1135 1136 /** 1137 * Returns the journal structure where groupId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 1138 * 1139 * @param groupId the group ID 1140 * @param structureId the structure ID 1141 * @return the matching journal structure 1142 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1143 * @throws SystemException if a system exception occurred 1144 */ 1145 public static com.liferay.portlet.journal.model.JournalStructure findByG_S( 1146 long groupId, java.lang.String structureId) 1147 throws com.liferay.portal.kernel.exception.SystemException, 1148 com.liferay.portlet.journal.NoSuchStructureException { 1149 return getPersistence().findByG_S(groupId, structureId); 1150 } 1151 1152 /** 1153 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1154 * 1155 * @param groupId the group ID 1156 * @param structureId the structure ID 1157 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 1158 * @throws SystemException if a system exception occurred 1159 */ 1160 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 1161 long groupId, java.lang.String structureId) 1162 throws com.liferay.portal.kernel.exception.SystemException { 1163 return getPersistence().fetchByG_S(groupId, structureId); 1164 } 1165 1166 /** 1167 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1168 * 1169 * @param groupId the group ID 1170 * @param structureId the structure ID 1171 * @param retrieveFromCache whether to use the finder cache 1172 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 1173 * @throws SystemException if a system exception occurred 1174 */ 1175 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 1176 long groupId, java.lang.String structureId, boolean retrieveFromCache) 1177 throws com.liferay.portal.kernel.exception.SystemException { 1178 return getPersistence() 1179 .fetchByG_S(groupId, structureId, retrieveFromCache); 1180 } 1181 1182 /** 1183 * Returns all the journal structures where groupId = ? and parentStructureId = ?. 1184 * 1185 * @param groupId the group ID 1186 * @param parentStructureId the parent structure ID 1187 * @return the matching journal structures 1188 * @throws SystemException if a system exception occurred 1189 */ 1190 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1191 long groupId, java.lang.String parentStructureId) 1192 throws com.liferay.portal.kernel.exception.SystemException { 1193 return getPersistence().findByG_P(groupId, parentStructureId); 1194 } 1195 1196 /** 1197 * Returns a range of all the journal structures where groupId = ? and parentStructureId = ?. 1198 * 1199 * <p> 1200 * 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. 1201 * </p> 1202 * 1203 * @param groupId the group ID 1204 * @param parentStructureId the parent structure ID 1205 * @param start the lower bound of the range of journal structures 1206 * @param end the upper bound of the range of journal structures (not inclusive) 1207 * @return the range of matching journal structures 1208 * @throws SystemException if a system exception occurred 1209 */ 1210 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1211 long groupId, java.lang.String parentStructureId, int start, int end) 1212 throws com.liferay.portal.kernel.exception.SystemException { 1213 return getPersistence().findByG_P(groupId, parentStructureId, start, end); 1214 } 1215 1216 /** 1217 * Returns an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 1218 * 1219 * <p> 1220 * 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. 1221 * </p> 1222 * 1223 * @param groupId the group ID 1224 * @param parentStructureId the parent structure ID 1225 * @param start the lower bound of the range of journal structures 1226 * @param end the upper bound of the range of journal structures (not inclusive) 1227 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1228 * @return the ordered range of matching journal structures 1229 * @throws SystemException if a system exception occurred 1230 */ 1231 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1232 long groupId, java.lang.String parentStructureId, int start, int end, 1233 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1234 throws com.liferay.portal.kernel.exception.SystemException { 1235 return getPersistence() 1236 .findByG_P(groupId, parentStructureId, start, end, 1237 orderByComparator); 1238 } 1239 1240 /** 1241 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1242 * 1243 * @param groupId the group ID 1244 * @param parentStructureId the parent structure ID 1245 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1246 * @return the first matching journal structure 1247 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1248 * @throws SystemException if a system exception occurred 1249 */ 1250 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First( 1251 long groupId, java.lang.String parentStructureId, 1252 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1253 throws com.liferay.portal.kernel.exception.SystemException, 1254 com.liferay.portlet.journal.NoSuchStructureException { 1255 return getPersistence() 1256 .findByG_P_First(groupId, parentStructureId, 1257 orderByComparator); 1258 } 1259 1260 /** 1261 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1262 * 1263 * @param groupId the group ID 1264 * @param parentStructureId the parent structure ID 1265 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1266 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 1267 * @throws SystemException if a system exception occurred 1268 */ 1269 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_First( 1270 long groupId, java.lang.String parentStructureId, 1271 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1272 throws com.liferay.portal.kernel.exception.SystemException { 1273 return getPersistence() 1274 .fetchByG_P_First(groupId, parentStructureId, 1275 orderByComparator); 1276 } 1277 1278 /** 1279 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1280 * 1281 * @param groupId the group ID 1282 * @param parentStructureId the parent structure ID 1283 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1284 * @return the last matching journal structure 1285 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1286 * @throws SystemException if a system exception occurred 1287 */ 1288 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last( 1289 long groupId, java.lang.String parentStructureId, 1290 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1291 throws com.liferay.portal.kernel.exception.SystemException, 1292 com.liferay.portlet.journal.NoSuchStructureException { 1293 return getPersistence() 1294 .findByG_P_Last(groupId, parentStructureId, orderByComparator); 1295 } 1296 1297 /** 1298 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1299 * 1300 * @param groupId the group ID 1301 * @param parentStructureId the parent structure ID 1302 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1303 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 1304 * @throws SystemException if a system exception occurred 1305 */ 1306 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_Last( 1307 long groupId, java.lang.String parentStructureId, 1308 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1309 throws com.liferay.portal.kernel.exception.SystemException { 1310 return getPersistence() 1311 .fetchByG_P_Last(groupId, parentStructureId, 1312 orderByComparator); 1313 } 1314 1315 /** 1316 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1317 * 1318 * @param id the primary key of the current journal structure 1319 * @param groupId the group ID 1320 * @param parentStructureId the parent structure ID 1321 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1322 * @return the previous, current, and next journal structure 1323 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1324 * @throws SystemException if a system exception occurred 1325 */ 1326 public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext( 1327 long id, long groupId, java.lang.String parentStructureId, 1328 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1329 throws com.liferay.portal.kernel.exception.SystemException, 1330 com.liferay.portlet.journal.NoSuchStructureException { 1331 return getPersistence() 1332 .findByG_P_PrevAndNext(id, groupId, parentStructureId, 1333 orderByComparator); 1334 } 1335 1336 /** 1337 * Returns all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1338 * 1339 * @param groupId the group ID 1340 * @param parentStructureId the parent structure ID 1341 * @return the matching journal structures that the user has permission to view 1342 * @throws SystemException if a system exception occurred 1343 */ 1344 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1345 long groupId, java.lang.String parentStructureId) 1346 throws com.liferay.portal.kernel.exception.SystemException { 1347 return getPersistence().filterFindByG_P(groupId, parentStructureId); 1348 } 1349 1350 /** 1351 * Returns a range of all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1352 * 1353 * <p> 1354 * 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. 1355 * </p> 1356 * 1357 * @param groupId the group ID 1358 * @param parentStructureId the parent structure ID 1359 * @param start the lower bound of the range of journal structures 1360 * @param end the upper bound of the range of journal structures (not inclusive) 1361 * @return the range of matching journal structures that the user has permission to view 1362 * @throws SystemException if a system exception occurred 1363 */ 1364 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1365 long groupId, java.lang.String parentStructureId, int start, int end) 1366 throws com.liferay.portal.kernel.exception.SystemException { 1367 return getPersistence() 1368 .filterFindByG_P(groupId, parentStructureId, start, end); 1369 } 1370 1371 /** 1372 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ? and parentStructureId = ?. 1373 * 1374 * <p> 1375 * 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. 1376 * </p> 1377 * 1378 * @param groupId the group ID 1379 * @param parentStructureId the parent structure ID 1380 * @param start the lower bound of the range of journal structures 1381 * @param end the upper bound of the range of journal structures (not inclusive) 1382 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1383 * @return the ordered range of matching journal structures that the user has permission to view 1384 * @throws SystemException if a system exception occurred 1385 */ 1386 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1387 long groupId, java.lang.String parentStructureId, int start, int end, 1388 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1389 throws com.liferay.portal.kernel.exception.SystemException { 1390 return getPersistence() 1391 .filterFindByG_P(groupId, parentStructureId, start, end, 1392 orderByComparator); 1393 } 1394 1395 /** 1396 * 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 = ?. 1397 * 1398 * @param id the primary key of the current journal structure 1399 * @param groupId the group ID 1400 * @param parentStructureId the parent structure ID 1401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1402 * @return the previous, current, and next journal structure 1403 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1404 * @throws SystemException if a system exception occurred 1405 */ 1406 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext( 1407 long id, long groupId, java.lang.String parentStructureId, 1408 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1409 throws com.liferay.portal.kernel.exception.SystemException, 1410 com.liferay.portlet.journal.NoSuchStructureException { 1411 return getPersistence() 1412 .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId, 1413 orderByComparator); 1414 } 1415 1416 /** 1417 * Returns all the journal structures. 1418 * 1419 * @return the journal structures 1420 * @throws SystemException if a system exception occurred 1421 */ 1422 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll() 1423 throws com.liferay.portal.kernel.exception.SystemException { 1424 return getPersistence().findAll(); 1425 } 1426 1427 /** 1428 * Returns a range of all the journal structures. 1429 * 1430 * <p> 1431 * 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. 1432 * </p> 1433 * 1434 * @param start the lower bound of the range of journal structures 1435 * @param end the upper bound of the range of journal structures (not inclusive) 1436 * @return the range of journal structures 1437 * @throws SystemException if a system exception occurred 1438 */ 1439 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1440 int start, int end) 1441 throws com.liferay.portal.kernel.exception.SystemException { 1442 return getPersistence().findAll(start, end); 1443 } 1444 1445 /** 1446 * Returns an ordered range of all the journal structures. 1447 * 1448 * <p> 1449 * 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. 1450 * </p> 1451 * 1452 * @param start the lower bound of the range of journal structures 1453 * @param end the upper bound of the range of journal structures (not inclusive) 1454 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1455 * @return the ordered range of journal structures 1456 * @throws SystemException if a system exception occurred 1457 */ 1458 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1459 int start, int end, 1460 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1461 throws com.liferay.portal.kernel.exception.SystemException { 1462 return getPersistence().findAll(start, end, orderByComparator); 1463 } 1464 1465 /** 1466 * Removes all the journal structures where uuid = ? from the database. 1467 * 1468 * @param uuid the uuid 1469 * @throws SystemException if a system exception occurred 1470 */ 1471 public static void removeByUuid(java.lang.String uuid) 1472 throws com.liferay.portal.kernel.exception.SystemException { 1473 getPersistence().removeByUuid(uuid); 1474 } 1475 1476 /** 1477 * Removes the journal structure where uuid = ? and groupId = ? from the database. 1478 * 1479 * @param uuid the uuid 1480 * @param groupId the group ID 1481 * @return the journal structure that was removed 1482 * @throws SystemException if a system exception occurred 1483 */ 1484 public static com.liferay.portlet.journal.model.JournalStructure removeByUUID_G( 1485 java.lang.String uuid, long groupId) 1486 throws com.liferay.portal.kernel.exception.SystemException, 1487 com.liferay.portlet.journal.NoSuchStructureException { 1488 return getPersistence().removeByUUID_G(uuid, groupId); 1489 } 1490 1491 /** 1492 * Removes all the journal structures where uuid = ? and companyId = ? from the database. 1493 * 1494 * @param uuid the uuid 1495 * @param companyId the company ID 1496 * @throws SystemException if a system exception occurred 1497 */ 1498 public static void removeByUuid_C(java.lang.String uuid, long companyId) 1499 throws com.liferay.portal.kernel.exception.SystemException { 1500 getPersistence().removeByUuid_C(uuid, companyId); 1501 } 1502 1503 /** 1504 * Removes all the journal structures where groupId = ? from the database. 1505 * 1506 * @param groupId the group ID 1507 * @throws SystemException if a system exception occurred 1508 */ 1509 public static void removeByGroupId(long groupId) 1510 throws com.liferay.portal.kernel.exception.SystemException { 1511 getPersistence().removeByGroupId(groupId); 1512 } 1513 1514 /** 1515 * Removes all the journal structures where structureId = ? from the database. 1516 * 1517 * @param structureId the structure ID 1518 * @throws SystemException if a system exception occurred 1519 */ 1520 public static void removeByStructureId(java.lang.String structureId) 1521 throws com.liferay.portal.kernel.exception.SystemException { 1522 getPersistence().removeByStructureId(structureId); 1523 } 1524 1525 /** 1526 * Removes all the journal structures where parentStructureId = ? from the database. 1527 * 1528 * @param parentStructureId the parent structure ID 1529 * @throws SystemException if a system exception occurred 1530 */ 1531 public static void removeByParentStructureId( 1532 java.lang.String parentStructureId) 1533 throws com.liferay.portal.kernel.exception.SystemException { 1534 getPersistence().removeByParentStructureId(parentStructureId); 1535 } 1536 1537 /** 1538 * Removes the journal structure where groupId = ? and structureId = ? from the database. 1539 * 1540 * @param groupId the group ID 1541 * @param structureId the structure ID 1542 * @return the journal structure that was removed 1543 * @throws SystemException if a system exception occurred 1544 */ 1545 public static com.liferay.portlet.journal.model.JournalStructure removeByG_S( 1546 long groupId, java.lang.String structureId) 1547 throws com.liferay.portal.kernel.exception.SystemException, 1548 com.liferay.portlet.journal.NoSuchStructureException { 1549 return getPersistence().removeByG_S(groupId, structureId); 1550 } 1551 1552 /** 1553 * Removes all the journal structures where groupId = ? and parentStructureId = ? from the database. 1554 * 1555 * @param groupId the group ID 1556 * @param parentStructureId the parent structure ID 1557 * @throws SystemException if a system exception occurred 1558 */ 1559 public static void removeByG_P(long groupId, 1560 java.lang.String parentStructureId) 1561 throws com.liferay.portal.kernel.exception.SystemException { 1562 getPersistence().removeByG_P(groupId, parentStructureId); 1563 } 1564 1565 /** 1566 * Removes all the journal structures from the database. 1567 * 1568 * @throws SystemException if a system exception occurred 1569 */ 1570 public static void removeAll() 1571 throws com.liferay.portal.kernel.exception.SystemException { 1572 getPersistence().removeAll(); 1573 } 1574 1575 /** 1576 * Returns the number of journal structures where uuid = ?. 1577 * 1578 * @param uuid the uuid 1579 * @return the number of matching journal structures 1580 * @throws SystemException if a system exception occurred 1581 */ 1582 public static int countByUuid(java.lang.String uuid) 1583 throws com.liferay.portal.kernel.exception.SystemException { 1584 return getPersistence().countByUuid(uuid); 1585 } 1586 1587 /** 1588 * Returns the number of journal structures where uuid = ? and groupId = ?. 1589 * 1590 * @param uuid the uuid 1591 * @param groupId the group ID 1592 * @return the number of matching journal structures 1593 * @throws SystemException if a system exception occurred 1594 */ 1595 public static int countByUUID_G(java.lang.String uuid, long groupId) 1596 throws com.liferay.portal.kernel.exception.SystemException { 1597 return getPersistence().countByUUID_G(uuid, groupId); 1598 } 1599 1600 /** 1601 * Returns the number of journal structures where uuid = ? and companyId = ?. 1602 * 1603 * @param uuid the uuid 1604 * @param companyId the company ID 1605 * @return the number of matching journal structures 1606 * @throws SystemException if a system exception occurred 1607 */ 1608 public static int countByUuid_C(java.lang.String uuid, long companyId) 1609 throws com.liferay.portal.kernel.exception.SystemException { 1610 return getPersistence().countByUuid_C(uuid, companyId); 1611 } 1612 1613 /** 1614 * Returns the number of journal structures where groupId = ?. 1615 * 1616 * @param groupId the group ID 1617 * @return the number of matching journal structures 1618 * @throws SystemException if a system exception occurred 1619 */ 1620 public static int countByGroupId(long groupId) 1621 throws com.liferay.portal.kernel.exception.SystemException { 1622 return getPersistence().countByGroupId(groupId); 1623 } 1624 1625 /** 1626 * Returns the number of journal structures where groupId = any ?. 1627 * 1628 * @param groupIds the group IDs 1629 * @return the number of matching journal structures 1630 * @throws SystemException if a system exception occurred 1631 */ 1632 public static int countByGroupId(long[] groupIds) 1633 throws com.liferay.portal.kernel.exception.SystemException { 1634 return getPersistence().countByGroupId(groupIds); 1635 } 1636 1637 /** 1638 * Returns the number of journal structures that the user has permission to view where groupId = ?. 1639 * 1640 * @param groupId the group ID 1641 * @return the number of matching journal structures that the user has permission to view 1642 * @throws SystemException if a system exception occurred 1643 */ 1644 public static int filterCountByGroupId(long groupId) 1645 throws com.liferay.portal.kernel.exception.SystemException { 1646 return getPersistence().filterCountByGroupId(groupId); 1647 } 1648 1649 /** 1650 * Returns the number of journal structures that the user has permission to view where groupId = any ?. 1651 * 1652 * @param groupIds the group IDs 1653 * @return the number of matching journal structures that the user has permission to view 1654 * @throws SystemException if a system exception occurred 1655 */ 1656 public static int filterCountByGroupId(long[] groupIds) 1657 throws com.liferay.portal.kernel.exception.SystemException { 1658 return getPersistence().filterCountByGroupId(groupIds); 1659 } 1660 1661 /** 1662 * Returns the number of journal structures where structureId = ?. 1663 * 1664 * @param structureId the structure ID 1665 * @return the number of matching journal structures 1666 * @throws SystemException if a system exception occurred 1667 */ 1668 public static int countByStructureId(java.lang.String structureId) 1669 throws com.liferay.portal.kernel.exception.SystemException { 1670 return getPersistence().countByStructureId(structureId); 1671 } 1672 1673 /** 1674 * Returns the number of journal structures where parentStructureId = ?. 1675 * 1676 * @param parentStructureId the parent structure ID 1677 * @return the number of matching journal structures 1678 * @throws SystemException if a system exception occurred 1679 */ 1680 public static int countByParentStructureId( 1681 java.lang.String parentStructureId) 1682 throws com.liferay.portal.kernel.exception.SystemException { 1683 return getPersistence().countByParentStructureId(parentStructureId); 1684 } 1685 1686 /** 1687 * Returns the number of journal structures where groupId = ? and structureId = ?. 1688 * 1689 * @param groupId the group ID 1690 * @param structureId the structure ID 1691 * @return the number of matching journal structures 1692 * @throws SystemException if a system exception occurred 1693 */ 1694 public static int countByG_S(long groupId, java.lang.String structureId) 1695 throws com.liferay.portal.kernel.exception.SystemException { 1696 return getPersistence().countByG_S(groupId, structureId); 1697 } 1698 1699 /** 1700 * Returns the number of journal structures where groupId = ? and parentStructureId = ?. 1701 * 1702 * @param groupId the group ID 1703 * @param parentStructureId the parent structure ID 1704 * @return the number of matching journal structures 1705 * @throws SystemException if a system exception occurred 1706 */ 1707 public static int countByG_P(long groupId, 1708 java.lang.String parentStructureId) 1709 throws com.liferay.portal.kernel.exception.SystemException { 1710 return getPersistence().countByG_P(groupId, parentStructureId); 1711 } 1712 1713 /** 1714 * Returns the number of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1715 * 1716 * @param groupId the group ID 1717 * @param parentStructureId the parent structure ID 1718 * @return the number of matching journal structures that the user has permission to view 1719 * @throws SystemException if a system exception occurred 1720 */ 1721 public static int filterCountByG_P(long groupId, 1722 java.lang.String parentStructureId) 1723 throws com.liferay.portal.kernel.exception.SystemException { 1724 return getPersistence().filterCountByG_P(groupId, parentStructureId); 1725 } 1726 1727 /** 1728 * Returns the number of journal structures. 1729 * 1730 * @return the number of journal structures 1731 * @throws SystemException if a system exception occurred 1732 */ 1733 public static int countAll() 1734 throws com.liferay.portal.kernel.exception.SystemException { 1735 return getPersistence().countAll(); 1736 } 1737 1738 public static JournalStructurePersistence getPersistence() { 1739 if (_persistence == null) { 1740 _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName()); 1741 1742 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1743 "_persistence"); 1744 } 1745 1746 return _persistence; 1747 } 1748 1749 /** 1750 * @deprecated 1751 */ 1752 public void setPersistence(JournalStructurePersistence persistence) { 1753 } 1754 1755 private static JournalStructurePersistence _persistence; 1756 }