001 /** 002 * Copyright (c) 2000-2011 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#remove(com.liferay.portal.model.BaseModel) 099 */ 100 public static JournalStructure remove(JournalStructure journalStructure) 101 throws SystemException { 102 return getPersistence().remove(journalStructure); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 107 */ 108 public static JournalStructure update(JournalStructure journalStructure, 109 boolean merge) throws SystemException { 110 return getPersistence().update(journalStructure, merge); 111 } 112 113 /** 114 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 115 */ 116 public static JournalStructure update(JournalStructure journalStructure, 117 boolean merge, ServiceContext serviceContext) throws SystemException { 118 return getPersistence().update(journalStructure, merge, serviceContext); 119 } 120 121 /** 122 * Caches the journal structure in the entity cache if it is enabled. 123 * 124 * @param journalStructure the journal structure 125 */ 126 public static void cacheResult( 127 com.liferay.portlet.journal.model.JournalStructure journalStructure) { 128 getPersistence().cacheResult(journalStructure); 129 } 130 131 /** 132 * Caches the journal structures in the entity cache if it is enabled. 133 * 134 * @param journalStructures the journal structures 135 */ 136 public static void cacheResult( 137 java.util.List<com.liferay.portlet.journal.model.JournalStructure> journalStructures) { 138 getPersistence().cacheResult(journalStructures); 139 } 140 141 /** 142 * Creates a new journal structure with the primary key. Does not add the journal structure to the database. 143 * 144 * @param id the primary key for the new journal structure 145 * @return the new journal structure 146 */ 147 public static com.liferay.portlet.journal.model.JournalStructure create( 148 long id) { 149 return getPersistence().create(id); 150 } 151 152 /** 153 * Removes the journal structure with the primary key from the database. Also notifies the appropriate model listeners. 154 * 155 * @param id the primary key of the journal structure 156 * @return the journal structure that was removed 157 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 158 * @throws SystemException if a system exception occurred 159 */ 160 public static com.liferay.portlet.journal.model.JournalStructure remove( 161 long id) 162 throws com.liferay.portal.kernel.exception.SystemException, 163 com.liferay.portlet.journal.NoSuchStructureException { 164 return getPersistence().remove(id); 165 } 166 167 public static com.liferay.portlet.journal.model.JournalStructure updateImpl( 168 com.liferay.portlet.journal.model.JournalStructure journalStructure, 169 boolean merge) 170 throws com.liferay.portal.kernel.exception.SystemException { 171 return getPersistence().updateImpl(journalStructure, merge); 172 } 173 174 /** 175 * Returns the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 176 * 177 * @param id the primary key of the journal structure 178 * @return the journal structure 179 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 180 * @throws SystemException if a system exception occurred 181 */ 182 public static com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey( 183 long id) 184 throws com.liferay.portal.kernel.exception.SystemException, 185 com.liferay.portlet.journal.NoSuchStructureException { 186 return getPersistence().findByPrimaryKey(id); 187 } 188 189 /** 190 * Returns the journal structure with the primary key or returns <code>null</code> if it could not be found. 191 * 192 * @param id the primary key of the journal structure 193 * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey( 197 long id) throws com.liferay.portal.kernel.exception.SystemException { 198 return getPersistence().fetchByPrimaryKey(id); 199 } 200 201 /** 202 * Returns all the journal structures where uuid = ?. 203 * 204 * @param uuid the uuid 205 * @return the matching journal structures 206 * @throws SystemException if a system exception occurred 207 */ 208 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 209 java.lang.String uuid) 210 throws com.liferay.portal.kernel.exception.SystemException { 211 return getPersistence().findByUuid(uuid); 212 } 213 214 /** 215 * Returns a range of all the journal structures where uuid = ?. 216 * 217 * <p> 218 * 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. 219 * </p> 220 * 221 * @param uuid the uuid 222 * @param start the lower bound of the range of journal structures 223 * @param end the upper bound of the range of journal structures (not inclusive) 224 * @return the range of matching journal structures 225 * @throws SystemException if a system exception occurred 226 */ 227 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 228 java.lang.String uuid, int start, int end) 229 throws com.liferay.portal.kernel.exception.SystemException { 230 return getPersistence().findByUuid(uuid, start, end); 231 } 232 233 /** 234 * Returns an ordered range of all the journal structures where uuid = ?. 235 * 236 * <p> 237 * 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. 238 * </p> 239 * 240 * @param uuid the uuid 241 * @param start the lower bound of the range of journal structures 242 * @param end the upper bound of the range of journal structures (not inclusive) 243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 244 * @return the ordered range of matching journal structures 245 * @throws SystemException if a system exception occurred 246 */ 247 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 248 java.lang.String uuid, int start, int end, 249 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 250 throws com.liferay.portal.kernel.exception.SystemException { 251 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 252 } 253 254 /** 255 * Returns the first journal structure in the ordered set where uuid = ?. 256 * 257 * <p> 258 * 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. 259 * </p> 260 * 261 * @param uuid the uuid 262 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 263 * @return the first matching journal structure 264 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 265 * @throws SystemException if a system exception occurred 266 */ 267 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First( 268 java.lang.String uuid, 269 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 270 throws com.liferay.portal.kernel.exception.SystemException, 271 com.liferay.portlet.journal.NoSuchStructureException { 272 return getPersistence().findByUuid_First(uuid, orderByComparator); 273 } 274 275 /** 276 * Returns the last journal structure in the ordered set where uuid = ?. 277 * 278 * <p> 279 * 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. 280 * </p> 281 * 282 * @param uuid the uuid 283 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 284 * @return the last matching journal structure 285 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 286 * @throws SystemException if a system exception occurred 287 */ 288 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last( 289 java.lang.String uuid, 290 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 291 throws com.liferay.portal.kernel.exception.SystemException, 292 com.liferay.portlet.journal.NoSuchStructureException { 293 return getPersistence().findByUuid_Last(uuid, orderByComparator); 294 } 295 296 /** 297 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ?. 298 * 299 * <p> 300 * 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. 301 * </p> 302 * 303 * @param id the primary key of the current journal structure 304 * @param uuid the uuid 305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 306 * @return the previous, current, and next journal structure 307 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 308 * @throws SystemException if a system exception occurred 309 */ 310 public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext( 311 long id, java.lang.String uuid, 312 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 313 throws com.liferay.portal.kernel.exception.SystemException, 314 com.liferay.portlet.journal.NoSuchStructureException { 315 return getPersistence() 316 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 317 } 318 319 /** 320 * Returns the journal structure where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 321 * 322 * @param uuid the uuid 323 * @param groupId the group ID 324 * @return the matching journal structure 325 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 326 * @throws SystemException if a system exception occurred 327 */ 328 public static com.liferay.portlet.journal.model.JournalStructure findByUUID_G( 329 java.lang.String uuid, long groupId) 330 throws com.liferay.portal.kernel.exception.SystemException, 331 com.liferay.portlet.journal.NoSuchStructureException { 332 return getPersistence().findByUUID_G(uuid, groupId); 333 } 334 335 /** 336 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 337 * 338 * @param uuid the uuid 339 * @param groupId the group ID 340 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 341 * @throws SystemException if a system exception occurred 342 */ 343 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 344 java.lang.String uuid, long groupId) 345 throws com.liferay.portal.kernel.exception.SystemException { 346 return getPersistence().fetchByUUID_G(uuid, groupId); 347 } 348 349 /** 350 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 351 * 352 * @param uuid the uuid 353 * @param groupId the group ID 354 * @param retrieveFromCache whether to use the finder cache 355 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 356 * @throws SystemException if a system exception occurred 357 */ 358 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 359 java.lang.String uuid, long groupId, boolean retrieveFromCache) 360 throws com.liferay.portal.kernel.exception.SystemException { 361 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 362 } 363 364 /** 365 * Returns all the journal structures where groupId = ?. 366 * 367 * @param groupId the group ID 368 * @return the matching journal structures 369 * @throws SystemException if a system exception occurred 370 */ 371 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 372 long groupId) 373 throws com.liferay.portal.kernel.exception.SystemException { 374 return getPersistence().findByGroupId(groupId); 375 } 376 377 /** 378 * Returns a range of all the journal structures where groupId = ?. 379 * 380 * <p> 381 * 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. 382 * </p> 383 * 384 * @param groupId the group ID 385 * @param start the lower bound of the range of journal structures 386 * @param end the upper bound of the range of journal structures (not inclusive) 387 * @return the range of matching journal structures 388 * @throws SystemException if a system exception occurred 389 */ 390 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 391 long groupId, int start, int end) 392 throws com.liferay.portal.kernel.exception.SystemException { 393 return getPersistence().findByGroupId(groupId, start, end); 394 } 395 396 /** 397 * Returns an ordered range of all the journal structures where groupId = ?. 398 * 399 * <p> 400 * 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. 401 * </p> 402 * 403 * @param groupId the group ID 404 * @param start the lower bound of the range of journal structures 405 * @param end the upper bound of the range of journal structures (not inclusive) 406 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 407 * @return the ordered range of matching journal structures 408 * @throws SystemException if a system exception occurred 409 */ 410 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 411 long groupId, int start, int end, 412 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 413 throws com.liferay.portal.kernel.exception.SystemException { 414 return getPersistence() 415 .findByGroupId(groupId, start, end, orderByComparator); 416 } 417 418 /** 419 * Returns the first journal structure in the ordered set where groupId = ?. 420 * 421 * <p> 422 * 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. 423 * </p> 424 * 425 * @param groupId the group ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching journal structure 428 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 429 * @throws SystemException if a system exception occurred 430 */ 431 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First( 432 long groupId, 433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 434 throws com.liferay.portal.kernel.exception.SystemException, 435 com.liferay.portlet.journal.NoSuchStructureException { 436 return getPersistence().findByGroupId_First(groupId, orderByComparator); 437 } 438 439 /** 440 * Returns the last journal structure in the ordered set where groupId = ?. 441 * 442 * <p> 443 * 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. 444 * </p> 445 * 446 * @param groupId the group ID 447 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 448 * @return the last matching journal structure 449 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 450 * @throws SystemException if a system exception occurred 451 */ 452 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last( 453 long groupId, 454 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 455 throws com.liferay.portal.kernel.exception.SystemException, 456 com.liferay.portlet.journal.NoSuchStructureException { 457 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 458 } 459 460 /** 461 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ?. 462 * 463 * <p> 464 * 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. 465 * </p> 466 * 467 * @param id the primary key of the current journal structure 468 * @param groupId the group ID 469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 470 * @return the previous, current, and next journal structure 471 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 472 * @throws SystemException if a system exception occurred 473 */ 474 public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext( 475 long id, long groupId, 476 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 477 throws com.liferay.portal.kernel.exception.SystemException, 478 com.liferay.portlet.journal.NoSuchStructureException { 479 return getPersistence() 480 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 481 } 482 483 /** 484 * Returns all the journal structures that the user has permission to view where groupId = ?. 485 * 486 * @param groupId the group ID 487 * @return the matching journal structures that the user has permission to view 488 * @throws SystemException if a system exception occurred 489 */ 490 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 491 long groupId) 492 throws com.liferay.portal.kernel.exception.SystemException { 493 return getPersistence().filterFindByGroupId(groupId); 494 } 495 496 /** 497 * Returns a range of all the journal structures that the user has permission to view where groupId = ?. 498 * 499 * <p> 500 * 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. 501 * </p> 502 * 503 * @param groupId the group ID 504 * @param start the lower bound of the range of journal structures 505 * @param end the upper bound of the range of journal structures (not inclusive) 506 * @return the range of matching journal structures that the user has permission to view 507 * @throws SystemException if a system exception occurred 508 */ 509 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 510 long groupId, int start, int end) 511 throws com.liferay.portal.kernel.exception.SystemException { 512 return getPersistence().filterFindByGroupId(groupId, start, end); 513 } 514 515 /** 516 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ?. 517 * 518 * <p> 519 * 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. 520 * </p> 521 * 522 * @param groupId the group ID 523 * @param start the lower bound of the range of journal structures 524 * @param end the upper bound of the range of journal structures (not inclusive) 525 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 526 * @return the ordered range of matching journal structures that the user has permission to view 527 * @throws SystemException if a system exception occurred 528 */ 529 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 530 long groupId, int start, int end, 531 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 532 throws com.liferay.portal.kernel.exception.SystemException { 533 return getPersistence() 534 .filterFindByGroupId(groupId, start, end, orderByComparator); 535 } 536 537 /** 538 * 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 = ?. 539 * 540 * @param id the primary key of the current journal structure 541 * @param groupId the group ID 542 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 543 * @return the previous, current, and next journal structure 544 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 545 * @throws SystemException if a system exception occurred 546 */ 547 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext( 548 long id, long groupId, 549 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 550 throws com.liferay.portal.kernel.exception.SystemException, 551 com.liferay.portlet.journal.NoSuchStructureException { 552 return getPersistence() 553 .filterFindByGroupId_PrevAndNext(id, groupId, 554 orderByComparator); 555 } 556 557 /** 558 * Returns all the journal structures where structureId = ?. 559 * 560 * @param structureId the structure ID 561 * @return the matching journal structures 562 * @throws SystemException if a system exception occurred 563 */ 564 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 565 java.lang.String structureId) 566 throws com.liferay.portal.kernel.exception.SystemException { 567 return getPersistence().findByStructureId(structureId); 568 } 569 570 /** 571 * Returns a range of all the journal structures where structureId = ?. 572 * 573 * <p> 574 * 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. 575 * </p> 576 * 577 * @param structureId the structure ID 578 * @param start the lower bound of the range of journal structures 579 * @param end the upper bound of the range of journal structures (not inclusive) 580 * @return the range of matching journal structures 581 * @throws SystemException if a system exception occurred 582 */ 583 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 584 java.lang.String structureId, int start, int end) 585 throws com.liferay.portal.kernel.exception.SystemException { 586 return getPersistence().findByStructureId(structureId, start, end); 587 } 588 589 /** 590 * Returns an ordered range of all the journal structures where structureId = ?. 591 * 592 * <p> 593 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 594 * </p> 595 * 596 * @param structureId the structure ID 597 * @param start the lower bound of the range of journal structures 598 * @param end the upper bound of the range of journal structures (not inclusive) 599 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 600 * @return the ordered range of matching journal structures 601 * @throws SystemException if a system exception occurred 602 */ 603 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 604 java.lang.String structureId, int start, int end, 605 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 606 throws com.liferay.portal.kernel.exception.SystemException { 607 return getPersistence() 608 .findByStructureId(structureId, start, end, orderByComparator); 609 } 610 611 /** 612 * Returns the first journal structure in the ordered set where structureId = ?. 613 * 614 * <p> 615 * 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. 616 * </p> 617 * 618 * @param structureId the structure ID 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @return the first matching journal structure 621 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 622 * @throws SystemException if a system exception occurred 623 */ 624 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First( 625 java.lang.String structureId, 626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 627 throws com.liferay.portal.kernel.exception.SystemException, 628 com.liferay.portlet.journal.NoSuchStructureException { 629 return getPersistence() 630 .findByStructureId_First(structureId, orderByComparator); 631 } 632 633 /** 634 * Returns the last journal structure in the ordered set where structureId = ?. 635 * 636 * <p> 637 * 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. 638 * </p> 639 * 640 * @param structureId the structure ID 641 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 642 * @return the last matching journal structure 643 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 644 * @throws SystemException if a system exception occurred 645 */ 646 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last( 647 java.lang.String structureId, 648 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 649 throws com.liferay.portal.kernel.exception.SystemException, 650 com.liferay.portlet.journal.NoSuchStructureException { 651 return getPersistence() 652 .findByStructureId_Last(structureId, orderByComparator); 653 } 654 655 /** 656 * Returns the journal structures before and after the current journal structure in the ordered set where structureId = ?. 657 * 658 * <p> 659 * 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. 660 * </p> 661 * 662 * @param id the primary key of the current journal structure 663 * @param structureId the structure ID 664 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 665 * @return the previous, current, and next journal structure 666 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 667 * @throws SystemException if a system exception occurred 668 */ 669 public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext( 670 long id, java.lang.String structureId, 671 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 672 throws com.liferay.portal.kernel.exception.SystemException, 673 com.liferay.portlet.journal.NoSuchStructureException { 674 return getPersistence() 675 .findByStructureId_PrevAndNext(id, structureId, 676 orderByComparator); 677 } 678 679 /** 680 * Returns the journal structure where groupId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 681 * 682 * @param groupId the group ID 683 * @param structureId the structure ID 684 * @return the matching journal structure 685 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 686 * @throws SystemException if a system exception occurred 687 */ 688 public static com.liferay.portlet.journal.model.JournalStructure findByG_S( 689 long groupId, java.lang.String structureId) 690 throws com.liferay.portal.kernel.exception.SystemException, 691 com.liferay.portlet.journal.NoSuchStructureException { 692 return getPersistence().findByG_S(groupId, structureId); 693 } 694 695 /** 696 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 697 * 698 * @param groupId the group ID 699 * @param structureId the structure ID 700 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 701 * @throws SystemException if a system exception occurred 702 */ 703 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 704 long groupId, java.lang.String structureId) 705 throws com.liferay.portal.kernel.exception.SystemException { 706 return getPersistence().fetchByG_S(groupId, structureId); 707 } 708 709 /** 710 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 711 * 712 * @param groupId the group ID 713 * @param structureId the structure ID 714 * @param retrieveFromCache whether to use the finder cache 715 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 716 * @throws SystemException if a system exception occurred 717 */ 718 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 719 long groupId, java.lang.String structureId, boolean retrieveFromCache) 720 throws com.liferay.portal.kernel.exception.SystemException { 721 return getPersistence() 722 .fetchByG_S(groupId, structureId, retrieveFromCache); 723 } 724 725 /** 726 * Returns all the journal structures where groupId = ? and parentStructureId = ?. 727 * 728 * @param groupId the group ID 729 * @param parentStructureId the parent structure ID 730 * @return the matching journal structures 731 * @throws SystemException if a system exception occurred 732 */ 733 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 734 long groupId, java.lang.String parentStructureId) 735 throws com.liferay.portal.kernel.exception.SystemException { 736 return getPersistence().findByG_P(groupId, parentStructureId); 737 } 738 739 /** 740 * Returns a range of all the journal structures where groupId = ? and parentStructureId = ?. 741 * 742 * <p> 743 * 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. 744 * </p> 745 * 746 * @param groupId the group ID 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> findByG_P( 754 long groupId, java.lang.String parentStructureId, int start, int end) 755 throws com.liferay.portal.kernel.exception.SystemException { 756 return getPersistence().findByG_P(groupId, parentStructureId, start, end); 757 } 758 759 /** 760 * Returns an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 761 * 762 * <p> 763 * 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. 764 * </p> 765 * 766 * @param groupId the group ID 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> findByG_P( 775 long groupId, 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 .findByG_P(groupId, parentStructureId, start, end, 780 orderByComparator); 781 } 782 783 /** 784 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 785 * 786 * <p> 787 * 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. 788 * </p> 789 * 790 * @param groupId the group ID 791 * @param parentStructureId the parent structure ID 792 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 793 * @return the first matching journal structure 794 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 795 * @throws SystemException if a system exception occurred 796 */ 797 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First( 798 long groupId, java.lang.String parentStructureId, 799 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 800 throws com.liferay.portal.kernel.exception.SystemException, 801 com.liferay.portlet.journal.NoSuchStructureException { 802 return getPersistence() 803 .findByG_P_First(groupId, parentStructureId, 804 orderByComparator); 805 } 806 807 /** 808 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 809 * 810 * <p> 811 * 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. 812 * </p> 813 * 814 * @param groupId the group ID 815 * @param parentStructureId the parent structure ID 816 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 817 * @return the last matching journal structure 818 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 819 * @throws SystemException if a system exception occurred 820 */ 821 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last( 822 long groupId, java.lang.String parentStructureId, 823 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 824 throws com.liferay.portal.kernel.exception.SystemException, 825 com.liferay.portlet.journal.NoSuchStructureException { 826 return getPersistence() 827 .findByG_P_Last(groupId, parentStructureId, orderByComparator); 828 } 829 830 /** 831 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 832 * 833 * <p> 834 * 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. 835 * </p> 836 * 837 * @param id the primary key of the current journal structure 838 * @param groupId the group ID 839 * @param parentStructureId the parent structure ID 840 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 841 * @return the previous, current, and next journal structure 842 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 843 * @throws SystemException if a system exception occurred 844 */ 845 public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext( 846 long id, long groupId, java.lang.String parentStructureId, 847 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 848 throws com.liferay.portal.kernel.exception.SystemException, 849 com.liferay.portlet.journal.NoSuchStructureException { 850 return getPersistence() 851 .findByG_P_PrevAndNext(id, groupId, parentStructureId, 852 orderByComparator); 853 } 854 855 /** 856 * Returns all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 857 * 858 * @param groupId the group ID 859 * @param parentStructureId the parent structure ID 860 * @return the matching journal structures that the user has permission to view 861 * @throws SystemException if a system exception occurred 862 */ 863 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 864 long groupId, java.lang.String parentStructureId) 865 throws com.liferay.portal.kernel.exception.SystemException { 866 return getPersistence().filterFindByG_P(groupId, parentStructureId); 867 } 868 869 /** 870 * Returns a range of all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 871 * 872 * <p> 873 * 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. 874 * </p> 875 * 876 * @param groupId the group ID 877 * @param parentStructureId the parent structure ID 878 * @param start the lower bound of the range of journal structures 879 * @param end the upper bound of the range of journal structures (not inclusive) 880 * @return the range of matching journal structures that the user has permission to view 881 * @throws SystemException if a system exception occurred 882 */ 883 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 884 long groupId, java.lang.String parentStructureId, int start, int end) 885 throws com.liferay.portal.kernel.exception.SystemException { 886 return getPersistence() 887 .filterFindByG_P(groupId, parentStructureId, start, end); 888 } 889 890 /** 891 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ? and parentStructureId = ?. 892 * 893 * <p> 894 * 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. 895 * </p> 896 * 897 * @param groupId the group ID 898 * @param parentStructureId the parent structure ID 899 * @param start the lower bound of the range of journal structures 900 * @param end the upper bound of the range of journal structures (not inclusive) 901 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 902 * @return the ordered range of matching journal structures that the user has permission to view 903 * @throws SystemException if a system exception occurred 904 */ 905 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 906 long groupId, java.lang.String parentStructureId, int start, int end, 907 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 908 throws com.liferay.portal.kernel.exception.SystemException { 909 return getPersistence() 910 .filterFindByG_P(groupId, parentStructureId, start, end, 911 orderByComparator); 912 } 913 914 /** 915 * 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 = ?. 916 * 917 * @param id the primary key of the current journal structure 918 * @param groupId the group ID 919 * @param parentStructureId the parent structure ID 920 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 921 * @return the previous, current, and next journal structure 922 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 923 * @throws SystemException if a system exception occurred 924 */ 925 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext( 926 long id, long groupId, java.lang.String parentStructureId, 927 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 928 throws com.liferay.portal.kernel.exception.SystemException, 929 com.liferay.portlet.journal.NoSuchStructureException { 930 return getPersistence() 931 .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId, 932 orderByComparator); 933 } 934 935 /** 936 * Returns all the journal structures. 937 * 938 * @return the journal structures 939 * @throws SystemException if a system exception occurred 940 */ 941 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll() 942 throws com.liferay.portal.kernel.exception.SystemException { 943 return getPersistence().findAll(); 944 } 945 946 /** 947 * Returns a range of all the journal structures. 948 * 949 * <p> 950 * 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. 951 * </p> 952 * 953 * @param start the lower bound of the range of journal structures 954 * @param end the upper bound of the range of journal structures (not inclusive) 955 * @return the range of journal structures 956 * @throws SystemException if a system exception occurred 957 */ 958 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 959 int start, int end) 960 throws com.liferay.portal.kernel.exception.SystemException { 961 return getPersistence().findAll(start, end); 962 } 963 964 /** 965 * Returns an ordered range of all the journal structures. 966 * 967 * <p> 968 * 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. 969 * </p> 970 * 971 * @param start the lower bound of the range of journal structures 972 * @param end the upper bound of the range of journal structures (not inclusive) 973 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 974 * @return the ordered range of journal structures 975 * @throws SystemException if a system exception occurred 976 */ 977 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 978 int start, int end, 979 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 980 throws com.liferay.portal.kernel.exception.SystemException { 981 return getPersistence().findAll(start, end, orderByComparator); 982 } 983 984 /** 985 * Removes all the journal structures where uuid = ? from the database. 986 * 987 * @param uuid the uuid 988 * @throws SystemException if a system exception occurred 989 */ 990 public static void removeByUuid(java.lang.String uuid) 991 throws com.liferay.portal.kernel.exception.SystemException { 992 getPersistence().removeByUuid(uuid); 993 } 994 995 /** 996 * Removes the journal structure where uuid = ? and groupId = ? from the database. 997 * 998 * @param uuid the uuid 999 * @param groupId the group ID 1000 * @throws SystemException if a system exception occurred 1001 */ 1002 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.journal.NoSuchStructureException { 1005 getPersistence().removeByUUID_G(uuid, groupId); 1006 } 1007 1008 /** 1009 * Removes all the journal structures where groupId = ? from the database. 1010 * 1011 * @param groupId the group ID 1012 * @throws SystemException if a system exception occurred 1013 */ 1014 public static void removeByGroupId(long groupId) 1015 throws com.liferay.portal.kernel.exception.SystemException { 1016 getPersistence().removeByGroupId(groupId); 1017 } 1018 1019 /** 1020 * Removes all the journal structures where structureId = ? from the database. 1021 * 1022 * @param structureId the structure ID 1023 * @throws SystemException if a system exception occurred 1024 */ 1025 public static void removeByStructureId(java.lang.String structureId) 1026 throws com.liferay.portal.kernel.exception.SystemException { 1027 getPersistence().removeByStructureId(structureId); 1028 } 1029 1030 /** 1031 * Removes the journal structure where groupId = ? and structureId = ? from the database. 1032 * 1033 * @param groupId the group ID 1034 * @param structureId the structure ID 1035 * @throws SystemException if a system exception occurred 1036 */ 1037 public static void removeByG_S(long groupId, java.lang.String structureId) 1038 throws com.liferay.portal.kernel.exception.SystemException, 1039 com.liferay.portlet.journal.NoSuchStructureException { 1040 getPersistence().removeByG_S(groupId, structureId); 1041 } 1042 1043 /** 1044 * Removes all the journal structures where groupId = ? and parentStructureId = ? from the database. 1045 * 1046 * @param groupId the group ID 1047 * @param parentStructureId the parent structure ID 1048 * @throws SystemException if a system exception occurred 1049 */ 1050 public static void removeByG_P(long groupId, 1051 java.lang.String parentStructureId) 1052 throws com.liferay.portal.kernel.exception.SystemException { 1053 getPersistence().removeByG_P(groupId, parentStructureId); 1054 } 1055 1056 /** 1057 * Removes all the journal structures from the database. 1058 * 1059 * @throws SystemException if a system exception occurred 1060 */ 1061 public static void removeAll() 1062 throws com.liferay.portal.kernel.exception.SystemException { 1063 getPersistence().removeAll(); 1064 } 1065 1066 /** 1067 * Returns the number of journal structures where uuid = ?. 1068 * 1069 * @param uuid the uuid 1070 * @return the number of matching journal structures 1071 * @throws SystemException if a system exception occurred 1072 */ 1073 public static int countByUuid(java.lang.String uuid) 1074 throws com.liferay.portal.kernel.exception.SystemException { 1075 return getPersistence().countByUuid(uuid); 1076 } 1077 1078 /** 1079 * Returns the number of journal structures where uuid = ? and groupId = ?. 1080 * 1081 * @param uuid the uuid 1082 * @param groupId the group ID 1083 * @return the number of matching journal structures 1084 * @throws SystemException if a system exception occurred 1085 */ 1086 public static int countByUUID_G(java.lang.String uuid, long groupId) 1087 throws com.liferay.portal.kernel.exception.SystemException { 1088 return getPersistence().countByUUID_G(uuid, groupId); 1089 } 1090 1091 /** 1092 * Returns the number of journal structures where groupId = ?. 1093 * 1094 * @param groupId the group ID 1095 * @return the number of matching journal structures 1096 * @throws SystemException if a system exception occurred 1097 */ 1098 public static int countByGroupId(long groupId) 1099 throws com.liferay.portal.kernel.exception.SystemException { 1100 return getPersistence().countByGroupId(groupId); 1101 } 1102 1103 /** 1104 * Returns the number of journal structures that the user has permission to view where groupId = ?. 1105 * 1106 * @param groupId the group ID 1107 * @return the number of matching journal structures that the user has permission to view 1108 * @throws SystemException if a system exception occurred 1109 */ 1110 public static int filterCountByGroupId(long groupId) 1111 throws com.liferay.portal.kernel.exception.SystemException { 1112 return getPersistence().filterCountByGroupId(groupId); 1113 } 1114 1115 /** 1116 * Returns the number of journal structures where structureId = ?. 1117 * 1118 * @param structureId the structure ID 1119 * @return the number of matching journal structures 1120 * @throws SystemException if a system exception occurred 1121 */ 1122 public static int countByStructureId(java.lang.String structureId) 1123 throws com.liferay.portal.kernel.exception.SystemException { 1124 return getPersistence().countByStructureId(structureId); 1125 } 1126 1127 /** 1128 * Returns the number of journal structures where groupId = ? and structureId = ?. 1129 * 1130 * @param groupId the group ID 1131 * @param structureId the structure ID 1132 * @return the number of matching journal structures 1133 * @throws SystemException if a system exception occurred 1134 */ 1135 public static int countByG_S(long groupId, java.lang.String structureId) 1136 throws com.liferay.portal.kernel.exception.SystemException { 1137 return getPersistence().countByG_S(groupId, structureId); 1138 } 1139 1140 /** 1141 * Returns the number of journal structures where groupId = ? and parentStructureId = ?. 1142 * 1143 * @param groupId the group ID 1144 * @param parentStructureId the parent structure ID 1145 * @return the number of matching journal structures 1146 * @throws SystemException if a system exception occurred 1147 */ 1148 public static int countByG_P(long groupId, 1149 java.lang.String parentStructureId) 1150 throws com.liferay.portal.kernel.exception.SystemException { 1151 return getPersistence().countByG_P(groupId, parentStructureId); 1152 } 1153 1154 /** 1155 * Returns the number of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1156 * 1157 * @param groupId the group ID 1158 * @param parentStructureId the parent structure ID 1159 * @return the number of matching journal structures that the user has permission to view 1160 * @throws SystemException if a system exception occurred 1161 */ 1162 public static int filterCountByG_P(long groupId, 1163 java.lang.String parentStructureId) 1164 throws com.liferay.portal.kernel.exception.SystemException { 1165 return getPersistence().filterCountByG_P(groupId, parentStructureId); 1166 } 1167 1168 /** 1169 * Returns the number of journal structures. 1170 * 1171 * @return the number of journal structures 1172 * @throws SystemException if a system exception occurred 1173 */ 1174 public static int countAll() 1175 throws com.liferay.portal.kernel.exception.SystemException { 1176 return getPersistence().countAll(); 1177 } 1178 1179 public static JournalStructurePersistence getPersistence() { 1180 if (_persistence == null) { 1181 _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName()); 1182 1183 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1184 "_persistence"); 1185 } 1186 1187 return _persistence; 1188 } 1189 1190 public void setPersistence(JournalStructurePersistence persistence) { 1191 _persistence = persistence; 1192 1193 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1194 "_persistence"); 1195 } 1196 1197 private static JournalStructurePersistence _persistence; 1198 }