001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.journal.model.JournalStructure;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the journal structure service. This utility wraps {@link JournalStructurePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see JournalStructurePersistence
037     * @see JournalStructurePersistenceImpl
038     * @generated
039     */
040    public class JournalStructureUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(JournalStructure journalStructure) {
058                    getPersistence().clearCache(journalStructure);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<JournalStructure> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<JournalStructure> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<JournalStructure> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
099             */
100            public static JournalStructure update(JournalStructure journalStructure,
101                    boolean merge) throws SystemException {
102                    return getPersistence().update(journalStructure, merge);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
107             */
108            public static JournalStructure update(JournalStructure journalStructure,
109                    boolean merge, ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(journalStructure, merge, serviceContext);
111            }
112    
113            /**
114            * Caches the journal structure in the entity cache if it is enabled.
115            *
116            * @param journalStructure the journal structure
117            */
118            public static void cacheResult(
119                    com.liferay.portlet.journal.model.JournalStructure journalStructure) {
120                    getPersistence().cacheResult(journalStructure);
121            }
122    
123            /**
124            * Caches the journal structures in the entity cache if it is enabled.
125            *
126            * @param journalStructures the journal structures
127            */
128            public static void cacheResult(
129                    java.util.List<com.liferay.portlet.journal.model.JournalStructure> journalStructures) {
130                    getPersistence().cacheResult(journalStructures);
131            }
132    
133            /**
134            * Creates a new journal structure with the primary key. Does not add the journal structure to the database.
135            *
136            * @param id the primary key for the new journal structure
137            * @return the new journal structure
138            */
139            public static com.liferay.portlet.journal.model.JournalStructure create(
140                    long id) {
141                    return getPersistence().create(id);
142            }
143    
144            /**
145            * Removes the journal structure with the primary key from the database. Also notifies the appropriate model listeners.
146            *
147            * @param id the primary key of the journal structure
148            * @return the journal structure that was removed
149            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
150            * @throws SystemException if a system exception occurred
151            */
152            public static com.liferay.portlet.journal.model.JournalStructure remove(
153                    long id)
154                    throws com.liferay.portal.kernel.exception.SystemException,
155                            com.liferay.portlet.journal.NoSuchStructureException {
156                    return getPersistence().remove(id);
157            }
158    
159            public static com.liferay.portlet.journal.model.JournalStructure updateImpl(
160                    com.liferay.portlet.journal.model.JournalStructure journalStructure,
161                    boolean merge)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().updateImpl(journalStructure, merge);
164            }
165    
166            /**
167            * Returns the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
168            *
169            * @param id the primary key of the journal structure
170            * @return the journal structure
171            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
172            * @throws SystemException if a system exception occurred
173            */
174            public static com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey(
175                    long id)
176                    throws com.liferay.portal.kernel.exception.SystemException,
177                            com.liferay.portlet.journal.NoSuchStructureException {
178                    return getPersistence().findByPrimaryKey(id);
179            }
180    
181            /**
182            * Returns the journal structure with the primary key or returns <code>null</code> if it could not be found.
183            *
184            * @param id the primary key of the journal structure
185            * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found
186            * @throws SystemException if a system exception occurred
187            */
188            public static com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey(
189                    long id) throws com.liferay.portal.kernel.exception.SystemException {
190                    return getPersistence().fetchByPrimaryKey(id);
191            }
192    
193            /**
194            * Returns all the journal structures where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @return the matching journal structures
198            * @throws SystemException if a system exception occurred
199            */
200            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
201                    java.lang.String uuid)
202                    throws com.liferay.portal.kernel.exception.SystemException {
203                    return getPersistence().findByUuid(uuid);
204            }
205    
206            /**
207            * Returns a range of all the journal structures where uuid = &#63;.
208            *
209            * <p>
210            * 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.
211            * </p>
212            *
213            * @param uuid the uuid
214            * @param start the lower bound of the range of journal structures
215            * @param end the upper bound of the range of journal structures (not inclusive)
216            * @return the range of matching journal structures
217            * @throws SystemException if a system exception occurred
218            */
219            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
220                    java.lang.String uuid, int start, int end)
221                    throws com.liferay.portal.kernel.exception.SystemException {
222                    return getPersistence().findByUuid(uuid, start, end);
223            }
224    
225            /**
226            * Returns an ordered range of all the journal structures where uuid = &#63;.
227            *
228            * <p>
229            * 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.
230            * </p>
231            *
232            * @param uuid the uuid
233            * @param start the lower bound of the range of journal structures
234            * @param end the upper bound of the range of journal structures (not inclusive)
235            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
236            * @return the ordered range of matching journal structures
237            * @throws SystemException if a system exception occurred
238            */
239            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
240                    java.lang.String uuid, int start, int end,
241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
242                    throws com.liferay.portal.kernel.exception.SystemException {
243                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
244            }
245    
246            /**
247            * Returns the first journal structure in the ordered set where uuid = &#63;.
248            *
249            * <p>
250            * 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.
251            * </p>
252            *
253            * @param uuid the uuid
254            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
255            * @return the first matching journal structure
256            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
257            * @throws SystemException if a system exception occurred
258            */
259            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First(
260                    java.lang.String uuid,
261                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
262                    throws com.liferay.portal.kernel.exception.SystemException,
263                            com.liferay.portlet.journal.NoSuchStructureException {
264                    return getPersistence().findByUuid_First(uuid, orderByComparator);
265            }
266    
267            /**
268            * Returns the last journal structure in the ordered set where uuid = &#63;.
269            *
270            * <p>
271            * 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.
272            * </p>
273            *
274            * @param uuid the uuid
275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
276            * @return the last matching journal structure
277            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
278            * @throws SystemException if a system exception occurred
279            */
280            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last(
281                    java.lang.String uuid,
282                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.journal.NoSuchStructureException {
285                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
286            }
287    
288            /**
289            * Returns the journal structures before and after the current journal structure in the ordered set where uuid = &#63;.
290            *
291            * <p>
292            * 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.
293            * </p>
294            *
295            * @param id the primary key of the current journal structure
296            * @param uuid the uuid
297            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
298            * @return the previous, current, and next journal structure
299            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
300            * @throws SystemException if a system exception occurred
301            */
302            public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext(
303                    long id, java.lang.String uuid,
304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
305                    throws com.liferay.portal.kernel.exception.SystemException,
306                            com.liferay.portlet.journal.NoSuchStructureException {
307                    return getPersistence()
308                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
309            }
310    
311            /**
312            * Returns the journal structure where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
313            *
314            * @param uuid the uuid
315            * @param groupId the group ID
316            * @return the matching journal structure
317            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
318            * @throws SystemException if a system exception occurred
319            */
320            public static com.liferay.portlet.journal.model.JournalStructure findByUUID_G(
321                    java.lang.String uuid, long groupId)
322                    throws com.liferay.portal.kernel.exception.SystemException,
323                            com.liferay.portlet.journal.NoSuchStructureException {
324                    return getPersistence().findByUUID_G(uuid, groupId);
325            }
326    
327            /**
328            * Returns the journal structure where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
329            *
330            * @param uuid the uuid
331            * @param groupId the group ID
332            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
333            * @throws SystemException if a system exception occurred
334            */
335            public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G(
336                    java.lang.String uuid, long groupId)
337                    throws com.liferay.portal.kernel.exception.SystemException {
338                    return getPersistence().fetchByUUID_G(uuid, groupId);
339            }
340    
341            /**
342            * Returns 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.
343            *
344            * @param uuid the uuid
345            * @param groupId the group ID
346            * @param retrieveFromCache whether to use the finder cache
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            * Returns all the journal structures where groupId = &#63;.
358            *
359            * @param groupId the group ID
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            * Returns 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
377            * @param start the lower bound of the range of journal structures
378            * @param end the upper bound of the range of journal structures (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            * Returns 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
396            * @param start the lower bound of the range of journal structures
397            * @param end the upper bound of the range of journal structures (not inclusive)
398            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
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            * Returns 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
418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
461            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns all the journal structures that the user has permission to view where groupId = &#63;.
477            *
478            * @param groupId the group ID
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            * Returns a range of all the journal structures that the user has permission to view 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
496            * @param start the lower bound of the range of journal structures
497            * @param end the upper bound of the range of journal structures (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            * Returns an ordered range of all the journal structures that the user has permissions to view 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
515            * @param start the lower bound of the range of journal structures
516            * @param end the upper bound of the range of journal structures (not inclusive)
517            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
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            * Returns the journal structures before and after the current journal structure in the ordered set of journal structures that the user has permission to view where groupId = &#63;.
531            *
532            * @param id the primary key of the current journal structure
533            * @param groupId the group ID
534            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
535            * @return the previous, current, and next journal structure
536            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
537            * @throws SystemException if a system exception occurred
538            */
539            public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext(
540                    long id, long groupId,
541                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
542                    throws com.liferay.portal.kernel.exception.SystemException,
543                            com.liferay.portlet.journal.NoSuchStructureException {
544                    return getPersistence()
545                                       .filterFindByGroupId_PrevAndNext(id, groupId,
546                            orderByComparator);
547            }
548    
549            /**
550            * Returns all the journal structures where structureId = &#63;.
551            *
552            * @param structureId the structure ID
553            * @return the matching journal structures
554            * @throws SystemException if a system exception occurred
555            */
556            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
557                    java.lang.String structureId)
558                    throws com.liferay.portal.kernel.exception.SystemException {
559                    return getPersistence().findByStructureId(structureId);
560            }
561    
562            /**
563            * Returns a range of all the journal structures where structureId = &#63;.
564            *
565            * <p>
566            * 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.
567            * </p>
568            *
569            * @param structureId the structure ID
570            * @param start the lower bound of the range of journal structures
571            * @param end the upper bound of the range of journal structures (not inclusive)
572            * @return the 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                    throws com.liferay.portal.kernel.exception.SystemException {
578                    return getPersistence().findByStructureId(structureId, start, end);
579            }
580    
581            /**
582            * Returns an ordered range of all the journal structures where structureId = &#63;.
583            *
584            * <p>
585            * 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.
586            * </p>
587            *
588            * @param structureId the structure ID
589            * @param start the lower bound of the range of journal structures
590            * @param end the upper bound of the range of journal structures (not inclusive)
591            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
592            * @return the ordered range of matching journal structures
593            * @throws SystemException if a system exception occurred
594            */
595            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
596                    java.lang.String structureId, int start, int end,
597                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
598                    throws com.liferay.portal.kernel.exception.SystemException {
599                    return getPersistence()
600                                       .findByStructureId(structureId, start, end, orderByComparator);
601            }
602    
603            /**
604            * Returns the first journal structure in the ordered set where structureId = &#63;.
605            *
606            * <p>
607            * 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.
608            * </p>
609            *
610            * @param structureId the structure ID
611            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
612            * @return the first matching journal structure
613            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
614            * @throws SystemException if a system exception occurred
615            */
616            public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First(
617                    java.lang.String structureId,
618                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
619                    throws com.liferay.portal.kernel.exception.SystemException,
620                            com.liferay.portlet.journal.NoSuchStructureException {
621                    return getPersistence()
622                                       .findByStructureId_First(structureId, orderByComparator);
623            }
624    
625            /**
626            * Returns the last journal structure in the ordered set where structureId = &#63;.
627            *
628            * <p>
629            * 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.
630            * </p>
631            *
632            * @param structureId the structure ID
633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
634            * @return the last matching journal structure
635            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
636            * @throws SystemException if a system exception occurred
637            */
638            public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last(
639                    java.lang.String structureId,
640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
641                    throws com.liferay.portal.kernel.exception.SystemException,
642                            com.liferay.portlet.journal.NoSuchStructureException {
643                    return getPersistence()
644                                       .findByStructureId_Last(structureId, orderByComparator);
645            }
646    
647            /**
648            * Returns the journal structures before and after the current journal structure in the ordered set where structureId = &#63;.
649            *
650            * <p>
651            * 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.
652            * </p>
653            *
654            * @param id the primary key of the current journal structure
655            * @param structureId the structure ID
656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
657            * @return the previous, current, and next journal structure
658            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
659            * @throws SystemException if a system exception occurred
660            */
661            public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext(
662                    long id, java.lang.String structureId,
663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
664                    throws com.liferay.portal.kernel.exception.SystemException,
665                            com.liferay.portlet.journal.NoSuchStructureException {
666                    return getPersistence()
667                                       .findByStructureId_PrevAndNext(id, structureId,
668                            orderByComparator);
669            }
670    
671            /**
672            * Returns all the journal structures where parentStructureId = &#63;.
673            *
674            * @param parentStructureId the parent structure ID
675            * @return the matching journal structures
676            * @throws SystemException if a system exception occurred
677            */
678            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId(
679                    java.lang.String parentStructureId)
680                    throws com.liferay.portal.kernel.exception.SystemException {
681                    return getPersistence().findByParentStructureId(parentStructureId);
682            }
683    
684            /**
685            * Returns a range of all the journal structures where parentStructureId = &#63;.
686            *
687            * <p>
688            * 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.
689            * </p>
690            *
691            * @param parentStructureId the parent structure ID
692            * @param start the lower bound of the range of journal structures
693            * @param end the upper bound of the range of journal structures (not inclusive)
694            * @return the range of matching journal structures
695            * @throws SystemException if a system exception occurred
696            */
697            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId(
698                    java.lang.String parentStructureId, int start, int end)
699                    throws com.liferay.portal.kernel.exception.SystemException {
700                    return getPersistence()
701                                       .findByParentStructureId(parentStructureId, start, end);
702            }
703    
704            /**
705            * Returns an ordered range of all the journal structures where parentStructureId = &#63;.
706            *
707            * <p>
708            * 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.
709            * </p>
710            *
711            * @param parentStructureId the parent structure ID
712            * @param start the lower bound of the range of journal structures
713            * @param end the upper bound of the range of journal structures (not inclusive)
714            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
715            * @return the ordered range of matching journal structures
716            * @throws SystemException if a system exception occurred
717            */
718            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId(
719                    java.lang.String parentStructureId, int start, int end,
720                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
721                    throws com.liferay.portal.kernel.exception.SystemException {
722                    return getPersistence()
723                                       .findByParentStructureId(parentStructureId, start, end,
724                            orderByComparator);
725            }
726    
727            /**
728            * Returns the first journal structure in the ordered set where parentStructureId = &#63;.
729            *
730            * <p>
731            * 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.
732            * </p>
733            *
734            * @param parentStructureId the parent structure ID
735            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
736            * @return the first matching journal structure
737            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
738            * @throws SystemException if a system exception occurred
739            */
740            public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_First(
741                    java.lang.String parentStructureId,
742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
743                    throws com.liferay.portal.kernel.exception.SystemException,
744                            com.liferay.portlet.journal.NoSuchStructureException {
745                    return getPersistence()
746                                       .findByParentStructureId_First(parentStructureId,
747                            orderByComparator);
748            }
749    
750            /**
751            * Returns the last journal structure in the ordered set where parentStructureId = &#63;.
752            *
753            * <p>
754            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
755            * </p>
756            *
757            * @param parentStructureId the parent structure ID
758            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
759            * @return the last matching journal structure
760            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
761            * @throws SystemException if a system exception occurred
762            */
763            public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_Last(
764                    java.lang.String parentStructureId,
765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
766                    throws com.liferay.portal.kernel.exception.SystemException,
767                            com.liferay.portlet.journal.NoSuchStructureException {
768                    return getPersistence()
769                                       .findByParentStructureId_Last(parentStructureId,
770                            orderByComparator);
771            }
772    
773            /**
774            * Returns the journal structures before and after the current journal structure in the ordered set where parentStructureId = &#63;.
775            *
776            * <p>
777            * 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.
778            * </p>
779            *
780            * @param id the primary key of the current journal structure
781            * @param parentStructureId the parent structure ID
782            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
783            * @return the previous, current, and next journal structure
784            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
785            * @throws SystemException if a system exception occurred
786            */
787            public static com.liferay.portlet.journal.model.JournalStructure[] findByParentStructureId_PrevAndNext(
788                    long id, java.lang.String parentStructureId,
789                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
790                    throws com.liferay.portal.kernel.exception.SystemException,
791                            com.liferay.portlet.journal.NoSuchStructureException {
792                    return getPersistence()
793                                       .findByParentStructureId_PrevAndNext(id, parentStructureId,
794                            orderByComparator);
795            }
796    
797            /**
798            * Returns the journal structure where groupId = &#63; and structureId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
799            *
800            * @param groupId the group ID
801            * @param structureId the structure ID
802            * @return the matching journal structure
803            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
804            * @throws SystemException if a system exception occurred
805            */
806            public static com.liferay.portlet.journal.model.JournalStructure findByG_S(
807                    long groupId, java.lang.String structureId)
808                    throws com.liferay.portal.kernel.exception.SystemException,
809                            com.liferay.portlet.journal.NoSuchStructureException {
810                    return getPersistence().findByG_S(groupId, structureId);
811            }
812    
813            /**
814            * Returns the journal structure where groupId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
815            *
816            * @param groupId the group ID
817            * @param structureId the structure ID
818            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
819            * @throws SystemException if a system exception occurred
820            */
821            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
822                    long groupId, java.lang.String structureId)
823                    throws com.liferay.portal.kernel.exception.SystemException {
824                    return getPersistence().fetchByG_S(groupId, structureId);
825            }
826    
827            /**
828            * Returns 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.
829            *
830            * @param groupId the group ID
831            * @param structureId the structure ID
832            * @param retrieveFromCache whether to use the finder cache
833            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
834            * @throws SystemException if a system exception occurred
835            */
836            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
837                    long groupId, java.lang.String structureId, boolean retrieveFromCache)
838                    throws com.liferay.portal.kernel.exception.SystemException {
839                    return getPersistence()
840                                       .fetchByG_S(groupId, structureId, retrieveFromCache);
841            }
842    
843            /**
844            * Returns all the journal structures where groupId = &#63; and parentStructureId = &#63;.
845            *
846            * @param groupId the group ID
847            * @param parentStructureId the parent structure ID
848            * @return the matching journal structures
849            * @throws SystemException if a system exception occurred
850            */
851            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
852                    long groupId, java.lang.String parentStructureId)
853                    throws com.liferay.portal.kernel.exception.SystemException {
854                    return getPersistence().findByG_P(groupId, parentStructureId);
855            }
856    
857            /**
858            * Returns a range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
859            *
860            * <p>
861            * 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.
862            * </p>
863            *
864            * @param groupId the group ID
865            * @param parentStructureId the parent structure ID
866            * @param start the lower bound of the range of journal structures
867            * @param end the upper bound of the range of journal structures (not inclusive)
868            * @return the range of matching journal structures
869            * @throws SystemException if a system exception occurred
870            */
871            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
872                    long groupId, java.lang.String parentStructureId, int start, int end)
873                    throws com.liferay.portal.kernel.exception.SystemException {
874                    return getPersistence().findByG_P(groupId, parentStructureId, start, end);
875            }
876    
877            /**
878            * Returns an ordered range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
879            *
880            * <p>
881            * 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.
882            * </p>
883            *
884            * @param groupId the group ID
885            * @param parentStructureId the parent structure ID
886            * @param start the lower bound of the range of journal structures
887            * @param end the upper bound of the range of journal structures (not inclusive)
888            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
889            * @return the ordered range of matching journal structures
890            * @throws SystemException if a system exception occurred
891            */
892            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
893                    long groupId, java.lang.String parentStructureId, int start, int end,
894                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
895                    throws com.liferay.portal.kernel.exception.SystemException {
896                    return getPersistence()
897                                       .findByG_P(groupId, parentStructureId, start, end,
898                            orderByComparator);
899            }
900    
901            /**
902            * Returns the first journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
903            *
904            * <p>
905            * 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.
906            * </p>
907            *
908            * @param groupId the group ID
909            * @param parentStructureId the parent structure ID
910            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
911            * @return the first matching journal structure
912            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
913            * @throws SystemException if a system exception occurred
914            */
915            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First(
916                    long groupId, java.lang.String parentStructureId,
917                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
918                    throws com.liferay.portal.kernel.exception.SystemException,
919                            com.liferay.portlet.journal.NoSuchStructureException {
920                    return getPersistence()
921                                       .findByG_P_First(groupId, parentStructureId,
922                            orderByComparator);
923            }
924    
925            /**
926            * Returns the last journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
927            *
928            * <p>
929            * 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.
930            * </p>
931            *
932            * @param groupId the group ID
933            * @param parentStructureId the parent structure ID
934            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
935            * @return the last matching journal structure
936            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
937            * @throws SystemException if a system exception occurred
938            */
939            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last(
940                    long groupId, java.lang.String parentStructureId,
941                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
942                    throws com.liferay.portal.kernel.exception.SystemException,
943                            com.liferay.portlet.journal.NoSuchStructureException {
944                    return getPersistence()
945                                       .findByG_P_Last(groupId, parentStructureId, orderByComparator);
946            }
947    
948            /**
949            * Returns the journal structures before and after the current journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
950            *
951            * <p>
952            * 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.
953            * </p>
954            *
955            * @param id the primary key of the current journal structure
956            * @param groupId the group ID
957            * @param parentStructureId the parent structure ID
958            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
959            * @return the previous, current, and next journal structure
960            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
961            * @throws SystemException if a system exception occurred
962            */
963            public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext(
964                    long id, long groupId, java.lang.String parentStructureId,
965                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
966                    throws com.liferay.portal.kernel.exception.SystemException,
967                            com.liferay.portlet.journal.NoSuchStructureException {
968                    return getPersistence()
969                                       .findByG_P_PrevAndNext(id, groupId, parentStructureId,
970                            orderByComparator);
971            }
972    
973            /**
974            * Returns all the journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
975            *
976            * @param groupId the group ID
977            * @param parentStructureId the parent structure ID
978            * @return the matching journal structures that the user has permission to view
979            * @throws SystemException if a system exception occurred
980            */
981            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
982                    long groupId, java.lang.String parentStructureId)
983                    throws com.liferay.portal.kernel.exception.SystemException {
984                    return getPersistence().filterFindByG_P(groupId, parentStructureId);
985            }
986    
987            /**
988            * Returns a range of all the journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
989            *
990            * <p>
991            * 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.
992            * </p>
993            *
994            * @param groupId the group ID
995            * @param parentStructureId the parent structure ID
996            * @param start the lower bound of the range of journal structures
997            * @param end the upper bound of the range of journal structures (not inclusive)
998            * @return the range of matching journal structures that the user has permission to view
999            * @throws SystemException if a system exception occurred
1000            */
1001            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
1002                    long groupId, java.lang.String parentStructureId, int start, int end)
1003                    throws com.liferay.portal.kernel.exception.SystemException {
1004                    return getPersistence()
1005                                       .filterFindByG_P(groupId, parentStructureId, start, end);
1006            }
1007    
1008            /**
1009            * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = &#63; and parentStructureId = &#63;.
1010            *
1011            * <p>
1012            * 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.
1013            * </p>
1014            *
1015            * @param groupId the group ID
1016            * @param parentStructureId the parent structure ID
1017            * @param start the lower bound of the range of journal structures
1018            * @param end the upper bound of the range of journal structures (not inclusive)
1019            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1020            * @return the ordered range of matching journal structures that the user has permission to view
1021            * @throws SystemException if a system exception occurred
1022            */
1023            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
1024                    long groupId, java.lang.String parentStructureId, int start, int end,
1025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1026                    throws com.liferay.portal.kernel.exception.SystemException {
1027                    return getPersistence()
1028                                       .filterFindByG_P(groupId, parentStructureId, start, end,
1029                            orderByComparator);
1030            }
1031    
1032            /**
1033            * Returns the journal structures before and after the current journal structure in the ordered set of journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1034            *
1035            * @param id the primary key of the current journal structure
1036            * @param groupId the group ID
1037            * @param parentStructureId the parent structure ID
1038            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1039            * @return the previous, current, and next journal structure
1040            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
1041            * @throws SystemException if a system exception occurred
1042            */
1043            public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext(
1044                    long id, long groupId, java.lang.String parentStructureId,
1045                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1046                    throws com.liferay.portal.kernel.exception.SystemException,
1047                            com.liferay.portlet.journal.NoSuchStructureException {
1048                    return getPersistence()
1049                                       .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId,
1050                            orderByComparator);
1051            }
1052    
1053            /**
1054            * Returns all the journal structures.
1055            *
1056            * @return the journal structures
1057            * @throws SystemException if a system exception occurred
1058            */
1059            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll()
1060                    throws com.liferay.portal.kernel.exception.SystemException {
1061                    return getPersistence().findAll();
1062            }
1063    
1064            /**
1065            * Returns a range of all the journal structures.
1066            *
1067            * <p>
1068            * 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.
1069            * </p>
1070            *
1071            * @param start the lower bound of the range of journal structures
1072            * @param end the upper bound of the range of journal structures (not inclusive)
1073            * @return the range of journal structures
1074            * @throws SystemException if a system exception occurred
1075            */
1076            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
1077                    int start, int end)
1078                    throws com.liferay.portal.kernel.exception.SystemException {
1079                    return getPersistence().findAll(start, end);
1080            }
1081    
1082            /**
1083            * Returns an ordered range of all the journal structures.
1084            *
1085            * <p>
1086            * 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.
1087            * </p>
1088            *
1089            * @param start the lower bound of the range of journal structures
1090            * @param end the upper bound of the range of journal structures (not inclusive)
1091            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1092            * @return the ordered range of journal structures
1093            * @throws SystemException if a system exception occurred
1094            */
1095            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
1096                    int start, int end,
1097                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1098                    throws com.liferay.portal.kernel.exception.SystemException {
1099                    return getPersistence().findAll(start, end, orderByComparator);
1100            }
1101    
1102            /**
1103            * Removes all the journal structures where uuid = &#63; from the database.
1104            *
1105            * @param uuid the uuid
1106            * @throws SystemException if a system exception occurred
1107            */
1108            public static void removeByUuid(java.lang.String uuid)
1109                    throws com.liferay.portal.kernel.exception.SystemException {
1110                    getPersistence().removeByUuid(uuid);
1111            }
1112    
1113            /**
1114            * Removes the journal structure where uuid = &#63; and groupId = &#63; from the database.
1115            *
1116            * @param uuid the uuid
1117            * @param groupId the group ID
1118            * @throws SystemException if a system exception occurred
1119            */
1120            public static void removeByUUID_G(java.lang.String uuid, long groupId)
1121                    throws com.liferay.portal.kernel.exception.SystemException,
1122                            com.liferay.portlet.journal.NoSuchStructureException {
1123                    getPersistence().removeByUUID_G(uuid, groupId);
1124            }
1125    
1126            /**
1127            * Removes all the journal structures where groupId = &#63; from the database.
1128            *
1129            * @param groupId the group ID
1130            * @throws SystemException if a system exception occurred
1131            */
1132            public static void removeByGroupId(long groupId)
1133                    throws com.liferay.portal.kernel.exception.SystemException {
1134                    getPersistence().removeByGroupId(groupId);
1135            }
1136    
1137            /**
1138            * Removes all the journal structures where structureId = &#63; from the database.
1139            *
1140            * @param structureId the structure ID
1141            * @throws SystemException if a system exception occurred
1142            */
1143            public static void removeByStructureId(java.lang.String structureId)
1144                    throws com.liferay.portal.kernel.exception.SystemException {
1145                    getPersistence().removeByStructureId(structureId);
1146            }
1147    
1148            /**
1149            * Removes all the journal structures where parentStructureId = &#63; from the database.
1150            *
1151            * @param parentStructureId the parent structure ID
1152            * @throws SystemException if a system exception occurred
1153            */
1154            public static void removeByParentStructureId(
1155                    java.lang.String parentStructureId)
1156                    throws com.liferay.portal.kernel.exception.SystemException {
1157                    getPersistence().removeByParentStructureId(parentStructureId);
1158            }
1159    
1160            /**
1161            * Removes the journal structure where groupId = &#63; and structureId = &#63; from the database.
1162            *
1163            * @param groupId the group ID
1164            * @param structureId the structure ID
1165            * @throws SystemException if a system exception occurred
1166            */
1167            public static void removeByG_S(long groupId, java.lang.String structureId)
1168                    throws com.liferay.portal.kernel.exception.SystemException,
1169                            com.liferay.portlet.journal.NoSuchStructureException {
1170                    getPersistence().removeByG_S(groupId, structureId);
1171            }
1172    
1173            /**
1174            * Removes all the journal structures where groupId = &#63; and parentStructureId = &#63; from the database.
1175            *
1176            * @param groupId the group ID
1177            * @param parentStructureId the parent structure ID
1178            * @throws SystemException if a system exception occurred
1179            */
1180            public static void removeByG_P(long groupId,
1181                    java.lang.String parentStructureId)
1182                    throws com.liferay.portal.kernel.exception.SystemException {
1183                    getPersistence().removeByG_P(groupId, parentStructureId);
1184            }
1185    
1186            /**
1187            * Removes all the journal structures from the database.
1188            *
1189            * @throws SystemException if a system exception occurred
1190            */
1191            public static void removeAll()
1192                    throws com.liferay.portal.kernel.exception.SystemException {
1193                    getPersistence().removeAll();
1194            }
1195    
1196            /**
1197            * Returns the number of journal structures where uuid = &#63;.
1198            *
1199            * @param uuid the uuid
1200            * @return the number of matching journal structures
1201            * @throws SystemException if a system exception occurred
1202            */
1203            public static int countByUuid(java.lang.String uuid)
1204                    throws com.liferay.portal.kernel.exception.SystemException {
1205                    return getPersistence().countByUuid(uuid);
1206            }
1207    
1208            /**
1209            * Returns the number of journal structures where uuid = &#63; and groupId = &#63;.
1210            *
1211            * @param uuid the uuid
1212            * @param groupId the group ID
1213            * @return the number of matching journal structures
1214            * @throws SystemException if a system exception occurred
1215            */
1216            public static int countByUUID_G(java.lang.String uuid, long groupId)
1217                    throws com.liferay.portal.kernel.exception.SystemException {
1218                    return getPersistence().countByUUID_G(uuid, groupId);
1219            }
1220    
1221            /**
1222            * Returns the number of journal structures where groupId = &#63;.
1223            *
1224            * @param groupId the group ID
1225            * @return the number of matching journal structures
1226            * @throws SystemException if a system exception occurred
1227            */
1228            public static int countByGroupId(long groupId)
1229                    throws com.liferay.portal.kernel.exception.SystemException {
1230                    return getPersistence().countByGroupId(groupId);
1231            }
1232    
1233            /**
1234            * Returns the number of journal structures that the user has permission to view where groupId = &#63;.
1235            *
1236            * @param groupId the group ID
1237            * @return the number of matching journal structures that the user has permission to view
1238            * @throws SystemException if a system exception occurred
1239            */
1240            public static int filterCountByGroupId(long groupId)
1241                    throws com.liferay.portal.kernel.exception.SystemException {
1242                    return getPersistence().filterCountByGroupId(groupId);
1243            }
1244    
1245            /**
1246            * Returns the number of journal structures where structureId = &#63;.
1247            *
1248            * @param structureId the structure ID
1249            * @return the number of matching journal structures
1250            * @throws SystemException if a system exception occurred
1251            */
1252            public static int countByStructureId(java.lang.String structureId)
1253                    throws com.liferay.portal.kernel.exception.SystemException {
1254                    return getPersistence().countByStructureId(structureId);
1255            }
1256    
1257            /**
1258            * Returns the number of journal structures where parentStructureId = &#63;.
1259            *
1260            * @param parentStructureId the parent structure ID
1261            * @return the number of matching journal structures
1262            * @throws SystemException if a system exception occurred
1263            */
1264            public static int countByParentStructureId(
1265                    java.lang.String parentStructureId)
1266                    throws com.liferay.portal.kernel.exception.SystemException {
1267                    return getPersistence().countByParentStructureId(parentStructureId);
1268            }
1269    
1270            /**
1271            * Returns the number of journal structures where groupId = &#63; and structureId = &#63;.
1272            *
1273            * @param groupId the group ID
1274            * @param structureId the structure ID
1275            * @return the number of matching journal structures
1276            * @throws SystemException if a system exception occurred
1277            */
1278            public static int countByG_S(long groupId, java.lang.String structureId)
1279                    throws com.liferay.portal.kernel.exception.SystemException {
1280                    return getPersistence().countByG_S(groupId, structureId);
1281            }
1282    
1283            /**
1284            * Returns the number of journal structures where groupId = &#63; and parentStructureId = &#63;.
1285            *
1286            * @param groupId the group ID
1287            * @param parentStructureId the parent structure ID
1288            * @return the number of matching journal structures
1289            * @throws SystemException if a system exception occurred
1290            */
1291            public static int countByG_P(long groupId,
1292                    java.lang.String parentStructureId)
1293                    throws com.liferay.portal.kernel.exception.SystemException {
1294                    return getPersistence().countByG_P(groupId, parentStructureId);
1295            }
1296    
1297            /**
1298            * Returns the number of journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1299            *
1300            * @param groupId the group ID
1301            * @param parentStructureId the parent structure ID
1302            * @return the number of matching journal structures that the user has permission to view
1303            * @throws SystemException if a system exception occurred
1304            */
1305            public static int filterCountByG_P(long groupId,
1306                    java.lang.String parentStructureId)
1307                    throws com.liferay.portal.kernel.exception.SystemException {
1308                    return getPersistence().filterCountByG_P(groupId, parentStructureId);
1309            }
1310    
1311            /**
1312            * Returns the number of journal structures.
1313            *
1314            * @return the number of journal structures
1315            * @throws SystemException if a system exception occurred
1316            */
1317            public static int countAll()
1318                    throws com.liferay.portal.kernel.exception.SystemException {
1319                    return getPersistence().countAll();
1320            }
1321    
1322            public static JournalStructurePersistence getPersistence() {
1323                    if (_persistence == null) {
1324                            _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName());
1325    
1326                            ReferenceRegistry.registerReference(JournalStructureUtil.class,
1327                                    "_persistence");
1328                    }
1329    
1330                    return _persistence;
1331            }
1332    
1333            public void setPersistence(JournalStructurePersistence persistence) {
1334                    _persistence = persistence;
1335    
1336                    ReferenceRegistry.registerReference(JournalStructureUtil.class,
1337                            "_persistence");
1338            }
1339    
1340            private static JournalStructurePersistence _persistence;
1341    }