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 the journal structure where groupId = &#63; and structureId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
673            *
674            * @param groupId the group ID
675            * @param structureId the structure ID
676            * @return the matching journal structure
677            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
678            * @throws SystemException if a system exception occurred
679            */
680            public static com.liferay.portlet.journal.model.JournalStructure findByG_S(
681                    long groupId, java.lang.String structureId)
682                    throws com.liferay.portal.kernel.exception.SystemException,
683                            com.liferay.portlet.journal.NoSuchStructureException {
684                    return getPersistence().findByG_S(groupId, structureId);
685            }
686    
687            /**
688            * 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.
689            *
690            * @param groupId the group ID
691            * @param structureId the structure ID
692            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
693            * @throws SystemException if a system exception occurred
694            */
695            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
696                    long groupId, java.lang.String structureId)
697                    throws com.liferay.portal.kernel.exception.SystemException {
698                    return getPersistence().fetchByG_S(groupId, structureId);
699            }
700    
701            /**
702            * 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.
703            *
704            * @param groupId the group ID
705            * @param structureId the structure ID
706            * @param retrieveFromCache whether to use the finder cache
707            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
708            * @throws SystemException if a system exception occurred
709            */
710            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
711                    long groupId, java.lang.String structureId, boolean retrieveFromCache)
712                    throws com.liferay.portal.kernel.exception.SystemException {
713                    return getPersistence()
714                                       .fetchByG_S(groupId, structureId, retrieveFromCache);
715            }
716    
717            /**
718            * Returns all the journal structures where groupId = &#63; and parentStructureId = &#63;.
719            *
720            * @param groupId the group ID
721            * @param parentStructureId the parent structure ID
722            * @return the matching journal structures
723            * @throws SystemException if a system exception occurred
724            */
725            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
726                    long groupId, java.lang.String parentStructureId)
727                    throws com.liferay.portal.kernel.exception.SystemException {
728                    return getPersistence().findByG_P(groupId, parentStructureId);
729            }
730    
731            /**
732            * Returns a range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
733            *
734            * <p>
735            * 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.
736            * </p>
737            *
738            * @param groupId the group ID
739            * @param parentStructureId the parent structure ID
740            * @param start the lower bound of the range of journal structures
741            * @param end the upper bound of the range of journal structures (not inclusive)
742            * @return the 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                    throws com.liferay.portal.kernel.exception.SystemException {
748                    return getPersistence().findByG_P(groupId, parentStructureId, start, end);
749            }
750    
751            /**
752            * Returns an ordered range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
753            *
754            * <p>
755            * 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.
756            * </p>
757            *
758            * @param groupId the group ID
759            * @param parentStructureId the parent structure ID
760            * @param start the lower bound of the range of journal structures
761            * @param end the upper bound of the range of journal structures (not inclusive)
762            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
763            * @return the ordered range of matching journal structures
764            * @throws SystemException if a system exception occurred
765            */
766            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
767                    long groupId, java.lang.String parentStructureId, int start, int end,
768                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
769                    throws com.liferay.portal.kernel.exception.SystemException {
770                    return getPersistence()
771                                       .findByG_P(groupId, parentStructureId, start, end,
772                            orderByComparator);
773            }
774    
775            /**
776            * Returns the first journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
777            *
778            * <p>
779            * 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.
780            * </p>
781            *
782            * @param groupId the group ID
783            * @param parentStructureId the parent structure ID
784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
785            * @return the first matching journal structure
786            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
787            * @throws SystemException if a system exception occurred
788            */
789            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First(
790                    long groupId, java.lang.String parentStructureId,
791                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
792                    throws com.liferay.portal.kernel.exception.SystemException,
793                            com.liferay.portlet.journal.NoSuchStructureException {
794                    return getPersistence()
795                                       .findByG_P_First(groupId, parentStructureId,
796                            orderByComparator);
797            }
798    
799            /**
800            * Returns the last journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
801            *
802            * <p>
803            * 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.
804            * </p>
805            *
806            * @param groupId the group ID
807            * @param parentStructureId the parent structure ID
808            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
809            * @return the last matching journal structure
810            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
811            * @throws SystemException if a system exception occurred
812            */
813            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last(
814                    long groupId, java.lang.String parentStructureId,
815                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
816                    throws com.liferay.portal.kernel.exception.SystemException,
817                            com.liferay.portlet.journal.NoSuchStructureException {
818                    return getPersistence()
819                                       .findByG_P_Last(groupId, parentStructureId, orderByComparator);
820            }
821    
822            /**
823            * Returns the journal structures before and after the current journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
824            *
825            * <p>
826            * 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.
827            * </p>
828            *
829            * @param id the primary key of the current journal structure
830            * @param groupId the group ID
831            * @param parentStructureId the parent structure ID
832            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
833            * @return the previous, current, and next journal structure
834            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
835            * @throws SystemException if a system exception occurred
836            */
837            public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext(
838                    long id, long groupId, java.lang.String parentStructureId,
839                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
840                    throws com.liferay.portal.kernel.exception.SystemException,
841                            com.liferay.portlet.journal.NoSuchStructureException {
842                    return getPersistence()
843                                       .findByG_P_PrevAndNext(id, groupId, parentStructureId,
844                            orderByComparator);
845            }
846    
847            /**
848            * Returns all the journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
849            *
850            * @param groupId the group ID
851            * @param parentStructureId the parent structure ID
852            * @return the matching journal structures that the user has permission to view
853            * @throws SystemException if a system exception occurred
854            */
855            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
856                    long groupId, java.lang.String parentStructureId)
857                    throws com.liferay.portal.kernel.exception.SystemException {
858                    return getPersistence().filterFindByG_P(groupId, parentStructureId);
859            }
860    
861            /**
862            * Returns a range of all the journal structures that the user has permission to view 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
869            * @param parentStructureId the parent structure ID
870            * @param start the lower bound of the range of journal structures
871            * @param end the upper bound of the range of journal structures (not inclusive)
872            * @return the range of matching journal structures that the user has permission to view
873            * @throws SystemException if a system exception occurred
874            */
875            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
876                    long groupId, java.lang.String parentStructureId, int start, int end)
877                    throws com.liferay.portal.kernel.exception.SystemException {
878                    return getPersistence()
879                                       .filterFindByG_P(groupId, parentStructureId, start, end);
880            }
881    
882            /**
883            * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = &#63; and parentStructureId = &#63;.
884            *
885            * <p>
886            * 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.
887            * </p>
888            *
889            * @param groupId the group ID
890            * @param parentStructureId the parent structure ID
891            * @param start the lower bound of the range of journal structures
892            * @param end the upper bound of the range of journal structures (not inclusive)
893            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
894            * @return the ordered range of matching journal structures that the user has permission to view
895            * @throws SystemException if a system exception occurred
896            */
897            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
898                    long groupId, java.lang.String parentStructureId, int start, int end,
899                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
900                    throws com.liferay.portal.kernel.exception.SystemException {
901                    return getPersistence()
902                                       .filterFindByG_P(groupId, parentStructureId, start, end,
903                            orderByComparator);
904            }
905    
906            /**
907            * 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;.
908            *
909            * @param id the primary key of the current journal structure
910            * @param groupId the group ID
911            * @param parentStructureId the parent structure ID
912            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
913            * @return the previous, current, and next journal structure
914            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
915            * @throws SystemException if a system exception occurred
916            */
917            public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext(
918                    long id, long groupId, java.lang.String parentStructureId,
919                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
920                    throws com.liferay.portal.kernel.exception.SystemException,
921                            com.liferay.portlet.journal.NoSuchStructureException {
922                    return getPersistence()
923                                       .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId,
924                            orderByComparator);
925            }
926    
927            /**
928            * Returns all the journal structures.
929            *
930            * @return the journal structures
931            * @throws SystemException if a system exception occurred
932            */
933            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll()
934                    throws com.liferay.portal.kernel.exception.SystemException {
935                    return getPersistence().findAll();
936            }
937    
938            /**
939            * Returns a range of all the journal structures.
940            *
941            * <p>
942            * 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.
943            * </p>
944            *
945            * @param start the lower bound of the range of journal structures
946            * @param end the upper bound of the range of journal structures (not inclusive)
947            * @return the range of journal structures
948            * @throws SystemException if a system exception occurred
949            */
950            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
951                    int start, int end)
952                    throws com.liferay.portal.kernel.exception.SystemException {
953                    return getPersistence().findAll(start, end);
954            }
955    
956            /**
957            * Returns an ordered range of all the journal structures.
958            *
959            * <p>
960            * 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.
961            * </p>
962            *
963            * @param start the lower bound of the range of journal structures
964            * @param end the upper bound of the range of journal structures (not inclusive)
965            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
966            * @return the ordered range of journal structures
967            * @throws SystemException if a system exception occurred
968            */
969            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
970                    int start, int end,
971                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
972                    throws com.liferay.portal.kernel.exception.SystemException {
973                    return getPersistence().findAll(start, end, orderByComparator);
974            }
975    
976            /**
977            * Removes all the journal structures where uuid = &#63; from the database.
978            *
979            * @param uuid the uuid
980            * @throws SystemException if a system exception occurred
981            */
982            public static void removeByUuid(java.lang.String uuid)
983                    throws com.liferay.portal.kernel.exception.SystemException {
984                    getPersistence().removeByUuid(uuid);
985            }
986    
987            /**
988            * Removes the journal structure where uuid = &#63; and groupId = &#63; from the database.
989            *
990            * @param uuid the uuid
991            * @param groupId the group ID
992            * @throws SystemException if a system exception occurred
993            */
994            public static void removeByUUID_G(java.lang.String uuid, long groupId)
995                    throws com.liferay.portal.kernel.exception.SystemException,
996                            com.liferay.portlet.journal.NoSuchStructureException {
997                    getPersistence().removeByUUID_G(uuid, groupId);
998            }
999    
1000            /**
1001            * Removes all the journal structures where groupId = &#63; from the database.
1002            *
1003            * @param groupId the group ID
1004            * @throws SystemException if a system exception occurred
1005            */
1006            public static void removeByGroupId(long groupId)
1007                    throws com.liferay.portal.kernel.exception.SystemException {
1008                    getPersistence().removeByGroupId(groupId);
1009            }
1010    
1011            /**
1012            * Removes all the journal structures where structureId = &#63; from the database.
1013            *
1014            * @param structureId the structure ID
1015            * @throws SystemException if a system exception occurred
1016            */
1017            public static void removeByStructureId(java.lang.String structureId)
1018                    throws com.liferay.portal.kernel.exception.SystemException {
1019                    getPersistence().removeByStructureId(structureId);
1020            }
1021    
1022            /**
1023            * Removes the journal structure where groupId = &#63; and structureId = &#63; from the database.
1024            *
1025            * @param groupId the group ID
1026            * @param structureId the structure ID
1027            * @throws SystemException if a system exception occurred
1028            */
1029            public static void removeByG_S(long groupId, java.lang.String structureId)
1030                    throws com.liferay.portal.kernel.exception.SystemException,
1031                            com.liferay.portlet.journal.NoSuchStructureException {
1032                    getPersistence().removeByG_S(groupId, structureId);
1033            }
1034    
1035            /**
1036            * Removes all the journal structures where groupId = &#63; and parentStructureId = &#63; from the database.
1037            *
1038            * @param groupId the group ID
1039            * @param parentStructureId the parent structure ID
1040            * @throws SystemException if a system exception occurred
1041            */
1042            public static void removeByG_P(long groupId,
1043                    java.lang.String parentStructureId)
1044                    throws com.liferay.portal.kernel.exception.SystemException {
1045                    getPersistence().removeByG_P(groupId, parentStructureId);
1046            }
1047    
1048            /**
1049            * Removes all the journal structures from the database.
1050            *
1051            * @throws SystemException if a system exception occurred
1052            */
1053            public static void removeAll()
1054                    throws com.liferay.portal.kernel.exception.SystemException {
1055                    getPersistence().removeAll();
1056            }
1057    
1058            /**
1059            * Returns the number of journal structures where uuid = &#63;.
1060            *
1061            * @param uuid the uuid
1062            * @return the number of matching journal structures
1063            * @throws SystemException if a system exception occurred
1064            */
1065            public static int countByUuid(java.lang.String uuid)
1066                    throws com.liferay.portal.kernel.exception.SystemException {
1067                    return getPersistence().countByUuid(uuid);
1068            }
1069    
1070            /**
1071            * Returns the number of journal structures where uuid = &#63; and groupId = &#63;.
1072            *
1073            * @param uuid the uuid
1074            * @param groupId the group ID
1075            * @return the number of matching journal structures
1076            * @throws SystemException if a system exception occurred
1077            */
1078            public static int countByUUID_G(java.lang.String uuid, long groupId)
1079                    throws com.liferay.portal.kernel.exception.SystemException {
1080                    return getPersistence().countByUUID_G(uuid, groupId);
1081            }
1082    
1083            /**
1084            * Returns the number of journal structures where groupId = &#63;.
1085            *
1086            * @param groupId the group ID
1087            * @return the number of matching journal structures
1088            * @throws SystemException if a system exception occurred
1089            */
1090            public static int countByGroupId(long groupId)
1091                    throws com.liferay.portal.kernel.exception.SystemException {
1092                    return getPersistence().countByGroupId(groupId);
1093            }
1094    
1095            /**
1096            * Returns the number of journal structures that the user has permission to view where groupId = &#63;.
1097            *
1098            * @param groupId the group ID
1099            * @return the number of matching journal structures that the user has permission to view
1100            * @throws SystemException if a system exception occurred
1101            */
1102            public static int filterCountByGroupId(long groupId)
1103                    throws com.liferay.portal.kernel.exception.SystemException {
1104                    return getPersistence().filterCountByGroupId(groupId);
1105            }
1106    
1107            /**
1108            * Returns the number of journal structures where structureId = &#63;.
1109            *
1110            * @param structureId the structure ID
1111            * @return the number of matching journal structures
1112            * @throws SystemException if a system exception occurred
1113            */
1114            public static int countByStructureId(java.lang.String structureId)
1115                    throws com.liferay.portal.kernel.exception.SystemException {
1116                    return getPersistence().countByStructureId(structureId);
1117            }
1118    
1119            /**
1120            * Returns the number of journal structures where groupId = &#63; and structureId = &#63;.
1121            *
1122            * @param groupId the group ID
1123            * @param structureId the structure ID
1124            * @return the number of matching journal structures
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static int countByG_S(long groupId, java.lang.String structureId)
1128                    throws com.liferay.portal.kernel.exception.SystemException {
1129                    return getPersistence().countByG_S(groupId, structureId);
1130            }
1131    
1132            /**
1133            * Returns the number of journal structures where groupId = &#63; and parentStructureId = &#63;.
1134            *
1135            * @param groupId the group ID
1136            * @param parentStructureId the parent structure ID
1137            * @return the number of matching journal structures
1138            * @throws SystemException if a system exception occurred
1139            */
1140            public static int countByG_P(long groupId,
1141                    java.lang.String parentStructureId)
1142                    throws com.liferay.portal.kernel.exception.SystemException {
1143                    return getPersistence().countByG_P(groupId, parentStructureId);
1144            }
1145    
1146            /**
1147            * Returns the number of journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1148            *
1149            * @param groupId the group ID
1150            * @param parentStructureId the parent structure ID
1151            * @return the number of matching journal structures that the user has permission to view
1152            * @throws SystemException if a system exception occurred
1153            */
1154            public static int filterCountByG_P(long groupId,
1155                    java.lang.String parentStructureId)
1156                    throws com.liferay.portal.kernel.exception.SystemException {
1157                    return getPersistence().filterCountByG_P(groupId, parentStructureId);
1158            }
1159    
1160            /**
1161            * Returns the number of journal structures.
1162            *
1163            * @return the number of journal structures
1164            * @throws SystemException if a system exception occurred
1165            */
1166            public static int countAll()
1167                    throws com.liferay.portal.kernel.exception.SystemException {
1168                    return getPersistence().countAll();
1169            }
1170    
1171            public static JournalStructurePersistence getPersistence() {
1172                    if (_persistence == null) {
1173                            _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName());
1174    
1175                            ReferenceRegistry.registerReference(JournalStructureUtil.class,
1176                                    "_persistence");
1177                    }
1178    
1179                    return _persistence;
1180            }
1181    
1182            public void setPersistence(JournalStructurePersistence persistence) {
1183                    _persistence = persistence;
1184    
1185                    ReferenceRegistry.registerReference(JournalStructureUtil.class,
1186                            "_persistence");
1187            }
1188    
1189            private static JournalStructurePersistence _persistence;
1190    }