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