001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 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 to cache 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 to cache 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 to remove 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 * Finds 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 to find 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 * Finds 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 to find 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 * Finds all the journal structures where uuid = ?. 203 * 204 * @param uuid the uuid to search with 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 * Finds 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 to search with 222 * @param start the lower bound of the range of journal structures to return 223 * @param end the upper bound of the range of journal structures to return (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 * Finds 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 to search with 241 * @param start the lower bound of the range of journal structures to return 242 * @param end the upper bound of the range of journal structures to return (not inclusive) 243 * @param orderByComparator the comparator to order the results by 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 * Finds 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 to search with 262 * @param orderByComparator the comparator to order the set by 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 * Finds 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 to search with 283 * @param orderByComparator the comparator to order the set by 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 * Finds 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 to search with 305 * @param orderByComparator the comparator to order the set by 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 * Finds 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 to search with 323 * @param groupId the group ID to search with 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 * Finds 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 to search with 339 * @param groupId the group ID to search with 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 * Finds 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 to search with 353 * @param groupId the group ID to search with 354 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 355 * @throws SystemException if a system exception occurred 356 */ 357 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 358 java.lang.String uuid, long groupId, boolean retrieveFromCache) 359 throws com.liferay.portal.kernel.exception.SystemException { 360 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 361 } 362 363 /** 364 * Finds all the journal structures where groupId = ?. 365 * 366 * @param groupId the group ID to search with 367 * @return the matching journal structures 368 * @throws SystemException if a system exception occurred 369 */ 370 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 371 long groupId) 372 throws com.liferay.portal.kernel.exception.SystemException { 373 return getPersistence().findByGroupId(groupId); 374 } 375 376 /** 377 * Finds a range of all the journal structures where groupId = ?. 378 * 379 * <p> 380 * 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. 381 * </p> 382 * 383 * @param groupId the group ID to search with 384 * @param start the lower bound of the range of journal structures to return 385 * @param end the upper bound of the range of journal structures to return (not inclusive) 386 * @return the range of matching journal structures 387 * @throws SystemException if a system exception occurred 388 */ 389 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 390 long groupId, int start, int end) 391 throws com.liferay.portal.kernel.exception.SystemException { 392 return getPersistence().findByGroupId(groupId, start, end); 393 } 394 395 /** 396 * Finds an ordered range of all the journal structures where groupId = ?. 397 * 398 * <p> 399 * 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. 400 * </p> 401 * 402 * @param groupId the group ID to search with 403 * @param start the lower bound of the range of journal structures to return 404 * @param end the upper bound of the range of journal structures to return (not inclusive) 405 * @param orderByComparator the comparator to order the results by 406 * @return the ordered range of matching journal structures 407 * @throws SystemException if a system exception occurred 408 */ 409 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 410 long groupId, int start, int end, 411 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 412 throws com.liferay.portal.kernel.exception.SystemException { 413 return getPersistence() 414 .findByGroupId(groupId, start, end, orderByComparator); 415 } 416 417 /** 418 * Finds the first journal structure in the ordered set where groupId = ?. 419 * 420 * <p> 421 * 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. 422 * </p> 423 * 424 * @param groupId the group ID to search with 425 * @param orderByComparator the comparator to order the set by 426 * @return the first matching journal structure 427 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First( 431 long groupId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException, 434 com.liferay.portlet.journal.NoSuchStructureException { 435 return getPersistence().findByGroupId_First(groupId, orderByComparator); 436 } 437 438 /** 439 * Finds the last journal structure in the ordered set where groupId = ?. 440 * 441 * <p> 442 * 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. 443 * </p> 444 * 445 * @param groupId the group ID to search with 446 * @param orderByComparator the comparator to order the set by 447 * @return the last matching journal structure 448 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 449 * @throws SystemException if a system exception occurred 450 */ 451 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last( 452 long groupId, 453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 454 throws com.liferay.portal.kernel.exception.SystemException, 455 com.liferay.portlet.journal.NoSuchStructureException { 456 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 457 } 458 459 /** 460 * Finds the journal structures before and after the current journal structure in the ordered set where groupId = ?. 461 * 462 * <p> 463 * 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. 464 * </p> 465 * 466 * @param id the primary key of the current journal structure 467 * @param groupId the group ID to search with 468 * @param orderByComparator the comparator to order the set by 469 * @return the previous, current, and next journal structure 470 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 471 * @throws SystemException if a system exception occurred 472 */ 473 public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext( 474 long id, long groupId, 475 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 476 throws com.liferay.portal.kernel.exception.SystemException, 477 com.liferay.portlet.journal.NoSuchStructureException { 478 return getPersistence() 479 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 480 } 481 482 /** 483 * Filters by the user's permissions and finds all the journal structures where groupId = ?. 484 * 485 * @param groupId the group ID to search with 486 * @return the matching journal structures that the user has permission to view 487 * @throws SystemException if a system exception occurred 488 */ 489 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 490 long groupId) 491 throws com.liferay.portal.kernel.exception.SystemException { 492 return getPersistence().filterFindByGroupId(groupId); 493 } 494 495 /** 496 * Filters by the user's permissions and finds a range of all the journal structures where groupId = ?. 497 * 498 * <p> 499 * 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. 500 * </p> 501 * 502 * @param groupId the group ID to search with 503 * @param start the lower bound of the range of journal structures to return 504 * @param end the upper bound of the range of journal structures to return (not inclusive) 505 * @return the range of matching journal structures that the user has permission to view 506 * @throws SystemException if a system exception occurred 507 */ 508 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 509 long groupId, int start, int end) 510 throws com.liferay.portal.kernel.exception.SystemException { 511 return getPersistence().filterFindByGroupId(groupId, start, end); 512 } 513 514 /** 515 * Filters by the user's permissions and finds an ordered range of all the journal structures where groupId = ?. 516 * 517 * <p> 518 * 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. 519 * </p> 520 * 521 * @param groupId the group ID to search with 522 * @param start the lower bound of the range of journal structures to return 523 * @param end the upper bound of the range of journal structures to return (not inclusive) 524 * @param orderByComparator the comparator to order the results by 525 * @return the ordered range of matching journal structures that the user has permission to view 526 * @throws SystemException if a system exception occurred 527 */ 528 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 529 long groupId, int start, int end, 530 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 531 throws com.liferay.portal.kernel.exception.SystemException { 532 return getPersistence() 533 .filterFindByGroupId(groupId, start, end, orderByComparator); 534 } 535 536 /** 537 * Filters the journal structures before and after the current journal structure in the ordered set 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 id the primary key of the current journal structure 544 * @param groupId the group ID to search with 545 * @param orderByComparator the comparator to order the set by 546 * @return the previous, current, and next journal structure 547 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 548 * @throws SystemException if a system exception occurred 549 */ 550 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext( 551 long id, long groupId, 552 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 553 throws com.liferay.portal.kernel.exception.SystemException, 554 com.liferay.portlet.journal.NoSuchStructureException { 555 return getPersistence() 556 .filterFindByGroupId_PrevAndNext(id, groupId, 557 orderByComparator); 558 } 559 560 /** 561 * Finds all the journal structures where structureId = ?. 562 * 563 * @param structureId the structure ID to search with 564 * @return the matching journal structures 565 * @throws SystemException if a system exception occurred 566 */ 567 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 568 java.lang.String structureId) 569 throws com.liferay.portal.kernel.exception.SystemException { 570 return getPersistence().findByStructureId(structureId); 571 } 572 573 /** 574 * Finds a range of all the journal structures where structureId = ?. 575 * 576 * <p> 577 * 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. 578 * </p> 579 * 580 * @param structureId the structure ID to search with 581 * @param start the lower bound of the range of journal structures to return 582 * @param end the upper bound of the range of journal structures to return (not inclusive) 583 * @return the range of matching journal structures 584 * @throws SystemException if a system exception occurred 585 */ 586 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 587 java.lang.String structureId, int start, int end) 588 throws com.liferay.portal.kernel.exception.SystemException { 589 return getPersistence().findByStructureId(structureId, start, end); 590 } 591 592 /** 593 * Finds an ordered range of all the journal structures where structureId = ?. 594 * 595 * <p> 596 * 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. 597 * </p> 598 * 599 * @param structureId the structure ID to search with 600 * @param start the lower bound of the range of journal structures to return 601 * @param end the upper bound of the range of journal structures to return (not inclusive) 602 * @param orderByComparator the comparator to order the results by 603 * @return the ordered range of matching journal structures 604 * @throws SystemException if a system exception occurred 605 */ 606 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 607 java.lang.String structureId, int start, int end, 608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 609 throws com.liferay.portal.kernel.exception.SystemException { 610 return getPersistence() 611 .findByStructureId(structureId, start, end, orderByComparator); 612 } 613 614 /** 615 * Finds the first journal structure in the ordered set where structureId = ?. 616 * 617 * <p> 618 * 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. 619 * </p> 620 * 621 * @param structureId the structure ID to search with 622 * @param orderByComparator the comparator to order the set by 623 * @return the first matching journal structure 624 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 625 * @throws SystemException if a system exception occurred 626 */ 627 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First( 628 java.lang.String structureId, 629 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 630 throws com.liferay.portal.kernel.exception.SystemException, 631 com.liferay.portlet.journal.NoSuchStructureException { 632 return getPersistence() 633 .findByStructureId_First(structureId, orderByComparator); 634 } 635 636 /** 637 * Finds the last journal structure in the ordered set where structureId = ?. 638 * 639 * <p> 640 * 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. 641 * </p> 642 * 643 * @param structureId the structure ID to search with 644 * @param orderByComparator the comparator to order the set by 645 * @return the last matching journal structure 646 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 647 * @throws SystemException if a system exception occurred 648 */ 649 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last( 650 java.lang.String structureId, 651 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 652 throws com.liferay.portal.kernel.exception.SystemException, 653 com.liferay.portlet.journal.NoSuchStructureException { 654 return getPersistence() 655 .findByStructureId_Last(structureId, orderByComparator); 656 } 657 658 /** 659 * Finds the journal structures before and after the current journal structure in the ordered set where structureId = ?. 660 * 661 * <p> 662 * 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. 663 * </p> 664 * 665 * @param id the primary key of the current journal structure 666 * @param structureId the structure ID to search with 667 * @param orderByComparator the comparator to order the set by 668 * @return the previous, current, and next journal structure 669 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 670 * @throws SystemException if a system exception occurred 671 */ 672 public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext( 673 long id, java.lang.String structureId, 674 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 675 throws com.liferay.portal.kernel.exception.SystemException, 676 com.liferay.portlet.journal.NoSuchStructureException { 677 return getPersistence() 678 .findByStructureId_PrevAndNext(id, structureId, 679 orderByComparator); 680 } 681 682 /** 683 * Finds the journal structure where groupId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 684 * 685 * @param groupId the group ID to search with 686 * @param structureId the structure ID to search with 687 * @return the matching journal structure 688 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 689 * @throws SystemException if a system exception occurred 690 */ 691 public static com.liferay.portlet.journal.model.JournalStructure findByG_S( 692 long groupId, java.lang.String structureId) 693 throws com.liferay.portal.kernel.exception.SystemException, 694 com.liferay.portlet.journal.NoSuchStructureException { 695 return getPersistence().findByG_S(groupId, structureId); 696 } 697 698 /** 699 * Finds the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 700 * 701 * @param groupId the group ID to search with 702 * @param structureId the structure ID to search with 703 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 704 * @throws SystemException if a system exception occurred 705 */ 706 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 707 long groupId, java.lang.String structureId) 708 throws com.liferay.portal.kernel.exception.SystemException { 709 return getPersistence().fetchByG_S(groupId, structureId); 710 } 711 712 /** 713 * Finds the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 714 * 715 * @param groupId the group ID to search with 716 * @param structureId the structure ID to search with 717 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 718 * @throws SystemException if a system exception occurred 719 */ 720 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 721 long groupId, java.lang.String structureId, boolean retrieveFromCache) 722 throws com.liferay.portal.kernel.exception.SystemException { 723 return getPersistence() 724 .fetchByG_S(groupId, structureId, retrieveFromCache); 725 } 726 727 /** 728 * Finds all the journal structures where groupId = ? and parentStructureId = ?. 729 * 730 * @param groupId the group ID to search with 731 * @param parentStructureId the parent structure ID to search with 732 * @return the matching journal structures 733 * @throws SystemException if a system exception occurred 734 */ 735 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 736 long groupId, java.lang.String parentStructureId) 737 throws com.liferay.portal.kernel.exception.SystemException { 738 return getPersistence().findByG_P(groupId, parentStructureId); 739 } 740 741 /** 742 * Finds a range of all the journal structures where groupId = ? and parentStructureId = ?. 743 * 744 * <p> 745 * 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. 746 * </p> 747 * 748 * @param groupId the group ID to search with 749 * @param parentStructureId the parent structure ID to search with 750 * @param start the lower bound of the range of journal structures to return 751 * @param end the upper bound of the range of journal structures to return (not inclusive) 752 * @return the range of matching journal structures 753 * @throws SystemException if a system exception occurred 754 */ 755 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 756 long groupId, java.lang.String parentStructureId, int start, int end) 757 throws com.liferay.portal.kernel.exception.SystemException { 758 return getPersistence().findByG_P(groupId, parentStructureId, start, end); 759 } 760 761 /** 762 * Finds an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 763 * 764 * <p> 765 * 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. 766 * </p> 767 * 768 * @param groupId the group ID to search with 769 * @param parentStructureId the parent structure ID to search with 770 * @param start the lower bound of the range of journal structures to return 771 * @param end the upper bound of the range of journal structures to return (not inclusive) 772 * @param orderByComparator the comparator to order the results by 773 * @return the ordered range of matching journal structures 774 * @throws SystemException if a system exception occurred 775 */ 776 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 777 long groupId, java.lang.String parentStructureId, int start, int end, 778 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 779 throws com.liferay.portal.kernel.exception.SystemException { 780 return getPersistence() 781 .findByG_P(groupId, parentStructureId, start, end, 782 orderByComparator); 783 } 784 785 /** 786 * Finds the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 787 * 788 * <p> 789 * 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. 790 * </p> 791 * 792 * @param groupId the group ID to search with 793 * @param parentStructureId the parent structure ID to search with 794 * @param orderByComparator the comparator to order the set by 795 * @return the first matching journal structure 796 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 797 * @throws SystemException if a system exception occurred 798 */ 799 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First( 800 long groupId, java.lang.String parentStructureId, 801 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 802 throws com.liferay.portal.kernel.exception.SystemException, 803 com.liferay.portlet.journal.NoSuchStructureException { 804 return getPersistence() 805 .findByG_P_First(groupId, parentStructureId, 806 orderByComparator); 807 } 808 809 /** 810 * Finds the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 811 * 812 * <p> 813 * 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. 814 * </p> 815 * 816 * @param groupId the group ID to search with 817 * @param parentStructureId the parent structure ID to search with 818 * @param orderByComparator the comparator to order the set by 819 * @return the last matching journal structure 820 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 821 * @throws SystemException if a system exception occurred 822 */ 823 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last( 824 long groupId, java.lang.String parentStructureId, 825 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 826 throws com.liferay.portal.kernel.exception.SystemException, 827 com.liferay.portlet.journal.NoSuchStructureException { 828 return getPersistence() 829 .findByG_P_Last(groupId, parentStructureId, orderByComparator); 830 } 831 832 /** 833 * Finds the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 834 * 835 * <p> 836 * 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. 837 * </p> 838 * 839 * @param id the primary key of the current journal structure 840 * @param groupId the group ID to search with 841 * @param parentStructureId the parent structure ID to search with 842 * @param orderByComparator the comparator to order the set by 843 * @return the previous, current, and next journal structure 844 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 845 * @throws SystemException if a system exception occurred 846 */ 847 public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext( 848 long id, long groupId, java.lang.String parentStructureId, 849 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 850 throws com.liferay.portal.kernel.exception.SystemException, 851 com.liferay.portlet.journal.NoSuchStructureException { 852 return getPersistence() 853 .findByG_P_PrevAndNext(id, groupId, parentStructureId, 854 orderByComparator); 855 } 856 857 /** 858 * Filters by the user's permissions and finds all the journal structures where groupId = ? and parentStructureId = ?. 859 * 860 * @param groupId the group ID to search with 861 * @param parentStructureId the parent structure ID to search with 862 * @return the matching journal structures that the user has permission to view 863 * @throws SystemException if a system exception occurred 864 */ 865 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 866 long groupId, java.lang.String parentStructureId) 867 throws com.liferay.portal.kernel.exception.SystemException { 868 return getPersistence().filterFindByG_P(groupId, parentStructureId); 869 } 870 871 /** 872 * Filters by the user's permissions and finds a range of all the journal structures where groupId = ? and parentStructureId = ?. 873 * 874 * <p> 875 * 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. 876 * </p> 877 * 878 * @param groupId the group ID to search with 879 * @param parentStructureId the parent structure ID to search with 880 * @param start the lower bound of the range of journal structures to return 881 * @param end the upper bound of the range of journal structures to return (not inclusive) 882 * @return the range of matching journal structures that the user has permission to view 883 * @throws SystemException if a system exception occurred 884 */ 885 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 886 long groupId, java.lang.String parentStructureId, int start, int end) 887 throws com.liferay.portal.kernel.exception.SystemException { 888 return getPersistence() 889 .filterFindByG_P(groupId, parentStructureId, start, end); 890 } 891 892 /** 893 * Filters by the user's permissions and finds an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 894 * 895 * <p> 896 * 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. 897 * </p> 898 * 899 * @param groupId the group ID to search with 900 * @param parentStructureId the parent structure ID to search with 901 * @param start the lower bound of the range of journal structures to return 902 * @param end the upper bound of the range of journal structures to return (not inclusive) 903 * @param orderByComparator the comparator to order the results by 904 * @return the ordered range of matching journal structures that the user has permission to view 905 * @throws SystemException if a system exception occurred 906 */ 907 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 908 long groupId, java.lang.String parentStructureId, int start, int end, 909 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 910 throws com.liferay.portal.kernel.exception.SystemException { 911 return getPersistence() 912 .filterFindByG_P(groupId, parentStructureId, start, end, 913 orderByComparator); 914 } 915 916 /** 917 * Filters the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 918 * 919 * <p> 920 * 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. 921 * </p> 922 * 923 * @param id the primary key of the current journal structure 924 * @param groupId the group ID to search with 925 * @param parentStructureId the parent structure ID to search with 926 * @param orderByComparator the comparator to order the set by 927 * @return the previous, current, and next journal structure 928 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 929 * @throws SystemException if a system exception occurred 930 */ 931 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext( 932 long id, long groupId, java.lang.String parentStructureId, 933 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 934 throws com.liferay.portal.kernel.exception.SystemException, 935 com.liferay.portlet.journal.NoSuchStructureException { 936 return getPersistence() 937 .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId, 938 orderByComparator); 939 } 940 941 /** 942 * Finds all the journal structures. 943 * 944 * @return the journal structures 945 * @throws SystemException if a system exception occurred 946 */ 947 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll() 948 throws com.liferay.portal.kernel.exception.SystemException { 949 return getPersistence().findAll(); 950 } 951 952 /** 953 * Finds a range of all the journal structures. 954 * 955 * <p> 956 * 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. 957 * </p> 958 * 959 * @param start the lower bound of the range of journal structures to return 960 * @param end the upper bound of the range of journal structures to return (not inclusive) 961 * @return the range of journal structures 962 * @throws SystemException if a system exception occurred 963 */ 964 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 965 int start, int end) 966 throws com.liferay.portal.kernel.exception.SystemException { 967 return getPersistence().findAll(start, end); 968 } 969 970 /** 971 * Finds an ordered range of all the journal structures. 972 * 973 * <p> 974 * 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. 975 * </p> 976 * 977 * @param start the lower bound of the range of journal structures to return 978 * @param end the upper bound of the range of journal structures to return (not inclusive) 979 * @param orderByComparator the comparator to order the results by 980 * @return the ordered range of journal structures 981 * @throws SystemException if a system exception occurred 982 */ 983 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 984 int start, int end, 985 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 986 throws com.liferay.portal.kernel.exception.SystemException { 987 return getPersistence().findAll(start, end, orderByComparator); 988 } 989 990 /** 991 * Removes all the journal structures where uuid = ? from the database. 992 * 993 * @param uuid the uuid to search with 994 * @throws SystemException if a system exception occurred 995 */ 996 public static void removeByUuid(java.lang.String uuid) 997 throws com.liferay.portal.kernel.exception.SystemException { 998 getPersistence().removeByUuid(uuid); 999 } 1000 1001 /** 1002 * Removes the journal structure where uuid = ? and groupId = ? from the database. 1003 * 1004 * @param uuid the uuid to search with 1005 * @param groupId the group ID to search with 1006 * @throws SystemException if a system exception occurred 1007 */ 1008 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1009 throws com.liferay.portal.kernel.exception.SystemException, 1010 com.liferay.portlet.journal.NoSuchStructureException { 1011 getPersistence().removeByUUID_G(uuid, groupId); 1012 } 1013 1014 /** 1015 * Removes all the journal structures where groupId = ? from the database. 1016 * 1017 * @param groupId the group ID to search with 1018 * @throws SystemException if a system exception occurred 1019 */ 1020 public static void removeByGroupId(long groupId) 1021 throws com.liferay.portal.kernel.exception.SystemException { 1022 getPersistence().removeByGroupId(groupId); 1023 } 1024 1025 /** 1026 * Removes all the journal structures where structureId = ? from the database. 1027 * 1028 * @param structureId the structure ID to search with 1029 * @throws SystemException if a system exception occurred 1030 */ 1031 public static void removeByStructureId(java.lang.String structureId) 1032 throws com.liferay.portal.kernel.exception.SystemException { 1033 getPersistence().removeByStructureId(structureId); 1034 } 1035 1036 /** 1037 * Removes the journal structure where groupId = ? and structureId = ? from the database. 1038 * 1039 * @param groupId the group ID to search with 1040 * @param structureId the structure ID to search with 1041 * @throws SystemException if a system exception occurred 1042 */ 1043 public static void removeByG_S(long groupId, java.lang.String structureId) 1044 throws com.liferay.portal.kernel.exception.SystemException, 1045 com.liferay.portlet.journal.NoSuchStructureException { 1046 getPersistence().removeByG_S(groupId, structureId); 1047 } 1048 1049 /** 1050 * Removes all the journal structures where groupId = ? and parentStructureId = ? from the database. 1051 * 1052 * @param groupId the group ID to search with 1053 * @param parentStructureId the parent structure ID to search with 1054 * @throws SystemException if a system exception occurred 1055 */ 1056 public static void removeByG_P(long groupId, 1057 java.lang.String parentStructureId) 1058 throws com.liferay.portal.kernel.exception.SystemException { 1059 getPersistence().removeByG_P(groupId, parentStructureId); 1060 } 1061 1062 /** 1063 * Removes all the journal structures from the database. 1064 * 1065 * @throws SystemException if a system exception occurred 1066 */ 1067 public static void removeAll() 1068 throws com.liferay.portal.kernel.exception.SystemException { 1069 getPersistence().removeAll(); 1070 } 1071 1072 /** 1073 * Counts all the journal structures where uuid = ?. 1074 * 1075 * @param uuid the uuid to search with 1076 * @return the number of matching journal structures 1077 * @throws SystemException if a system exception occurred 1078 */ 1079 public static int countByUuid(java.lang.String uuid) 1080 throws com.liferay.portal.kernel.exception.SystemException { 1081 return getPersistence().countByUuid(uuid); 1082 } 1083 1084 /** 1085 * Counts all the journal structures where uuid = ? and groupId = ?. 1086 * 1087 * @param uuid the uuid to search with 1088 * @param groupId the group ID to search with 1089 * @return the number of matching journal structures 1090 * @throws SystemException if a system exception occurred 1091 */ 1092 public static int countByUUID_G(java.lang.String uuid, long groupId) 1093 throws com.liferay.portal.kernel.exception.SystemException { 1094 return getPersistence().countByUUID_G(uuid, groupId); 1095 } 1096 1097 /** 1098 * Counts all the journal structures where groupId = ?. 1099 * 1100 * @param groupId the group ID to search with 1101 * @return the number of matching journal structures 1102 * @throws SystemException if a system exception occurred 1103 */ 1104 public static int countByGroupId(long groupId) 1105 throws com.liferay.portal.kernel.exception.SystemException { 1106 return getPersistence().countByGroupId(groupId); 1107 } 1108 1109 /** 1110 * Filters by the user's permissions and counts all the journal structures where groupId = ?. 1111 * 1112 * @param groupId the group ID to search with 1113 * @return the number of matching journal structures that the user has permission to view 1114 * @throws SystemException if a system exception occurred 1115 */ 1116 public static int filterCountByGroupId(long groupId) 1117 throws com.liferay.portal.kernel.exception.SystemException { 1118 return getPersistence().filterCountByGroupId(groupId); 1119 } 1120 1121 /** 1122 * Counts all the journal structures where structureId = ?. 1123 * 1124 * @param structureId the structure ID to search with 1125 * @return the number of matching journal structures 1126 * @throws SystemException if a system exception occurred 1127 */ 1128 public static int countByStructureId(java.lang.String structureId) 1129 throws com.liferay.portal.kernel.exception.SystemException { 1130 return getPersistence().countByStructureId(structureId); 1131 } 1132 1133 /** 1134 * Counts all the journal structures where groupId = ? and structureId = ?. 1135 * 1136 * @param groupId the group ID to search with 1137 * @param structureId the structure ID to search with 1138 * @return the number of matching journal structures 1139 * @throws SystemException if a system exception occurred 1140 */ 1141 public static int countByG_S(long groupId, java.lang.String structureId) 1142 throws com.liferay.portal.kernel.exception.SystemException { 1143 return getPersistence().countByG_S(groupId, structureId); 1144 } 1145 1146 /** 1147 * Counts all the journal structures where groupId = ? and parentStructureId = ?. 1148 * 1149 * @param groupId the group ID to search with 1150 * @param parentStructureId the parent structure ID to search with 1151 * @return the number of matching journal structures 1152 * @throws SystemException if a system exception occurred 1153 */ 1154 public static int countByG_P(long groupId, 1155 java.lang.String parentStructureId) 1156 throws com.liferay.portal.kernel.exception.SystemException { 1157 return getPersistence().countByG_P(groupId, parentStructureId); 1158 } 1159 1160 /** 1161 * Filters by the user's permissions and counts all the journal structures where groupId = ? and parentStructureId = ?. 1162 * 1163 * @param groupId the group ID to search with 1164 * @param parentStructureId the parent structure ID to search with 1165 * @return the number of matching journal structures that the user has permission to view 1166 * @throws SystemException if a system exception occurred 1167 */ 1168 public static int filterCountByG_P(long groupId, 1169 java.lang.String parentStructureId) 1170 throws com.liferay.portal.kernel.exception.SystemException { 1171 return getPersistence().filterCountByG_P(groupId, parentStructureId); 1172 } 1173 1174 /** 1175 * Counts all the journal structures. 1176 * 1177 * @return the number of journal structures 1178 * @throws SystemException if a system exception occurred 1179 */ 1180 public static int countAll() 1181 throws com.liferay.portal.kernel.exception.SystemException { 1182 return getPersistence().countAll(); 1183 } 1184 1185 public static JournalStructurePersistence getPersistence() { 1186 if (_persistence == null) { 1187 _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName()); 1188 1189 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1190 "_persistence"); 1191 } 1192 1193 return _persistence; 1194 } 1195 1196 public void setPersistence(JournalStructurePersistence persistence) { 1197 _persistence = persistence; 1198 1199 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1200 "_persistence"); 1201 } 1202 1203 private static JournalStructurePersistence _persistence; 1204 }