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