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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; and groupId = &#63; 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 = &#63; and groupId = &#63; 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 = &#63; and groupId = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; and structureId = &#63; 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 = &#63; and structureId = &#63; 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 = &#63; and structureId = &#63; 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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; 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 = &#63; and groupId = &#63; 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 = &#63; 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 = &#63; 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 = &#63; and structureId = &#63; 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 = &#63; and parentStructureId = &#63; 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 = &#63;.
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 = &#63; and groupId = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; and structureId = &#63;.
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 = &#63; and structureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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    }