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)
099             */
100            public static JournalStructure update(JournalStructure journalStructure)
101                    throws SystemException {
102                    return getPersistence().update(journalStructure);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static JournalStructure update(JournalStructure journalStructure,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(journalStructure, 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                    throws com.liferay.portal.kernel.exception.SystemException {
162                    return getPersistence().updateImpl(journalStructure);
163            }
164    
165            /**
166            * Returns the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
167            *
168            * @param id the primary key of the journal structure
169            * @return the journal structure
170            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
171            * @throws SystemException if a system exception occurred
172            */
173            public static com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey(
174                    long id)
175                    throws com.liferay.portal.kernel.exception.SystemException,
176                            com.liferay.portlet.journal.NoSuchStructureException {
177                    return getPersistence().findByPrimaryKey(id);
178            }
179    
180            /**
181            * Returns the journal structure with the primary key or returns <code>null</code> if it could not be found.
182            *
183            * @param id the primary key of the journal structure
184            * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found
185            * @throws SystemException if a system exception occurred
186            */
187            public static com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey(
188                    long id) throws com.liferay.portal.kernel.exception.SystemException {
189                    return getPersistence().fetchByPrimaryKey(id);
190            }
191    
192            /**
193            * Returns all the journal structures where uuid = &#63;.
194            *
195            * @param uuid the uuid
196            * @return the matching journal structures
197            * @throws SystemException if a system exception occurred
198            */
199            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
200                    java.lang.String uuid)
201                    throws com.liferay.portal.kernel.exception.SystemException {
202                    return getPersistence().findByUuid(uuid);
203            }
204    
205            /**
206            * Returns a range of all the journal structures where uuid = &#63;.
207            *
208            * <p>
209            * 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.
210            * </p>
211            *
212            * @param uuid the uuid
213            * @param start the lower bound of the range of journal structures
214            * @param end the upper bound of the range of journal structures (not inclusive)
215            * @return the range of matching journal structures
216            * @throws SystemException if a system exception occurred
217            */
218            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
219                    java.lang.String uuid, int start, int end)
220                    throws com.liferay.portal.kernel.exception.SystemException {
221                    return getPersistence().findByUuid(uuid, start, end);
222            }
223    
224            /**
225            * Returns an ordered range of all the journal structures where uuid = &#63;.
226            *
227            * <p>
228            * 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.
229            * </p>
230            *
231            * @param uuid the uuid
232            * @param start the lower bound of the range of journal structures
233            * @param end the upper bound of the range of journal structures (not inclusive)
234            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
235            * @return the ordered range of matching journal structures
236            * @throws SystemException if a system exception occurred
237            */
238            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
239                    java.lang.String uuid, int start, int end,
240                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
241                    throws com.liferay.portal.kernel.exception.SystemException {
242                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
243            }
244    
245            /**
246            * Returns the first journal structure in the ordered set where uuid = &#63;.
247            *
248            * @param uuid the uuid
249            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
250            * @return the first matching journal structure
251            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
252            * @throws SystemException if a system exception occurred
253            */
254            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First(
255                    java.lang.String uuid,
256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
257                    throws com.liferay.portal.kernel.exception.SystemException,
258                            com.liferay.portlet.journal.NoSuchStructureException {
259                    return getPersistence().findByUuid_First(uuid, orderByComparator);
260            }
261    
262            /**
263            * Returns the first journal structure in the ordered set where uuid = &#63;.
264            *
265            * @param uuid the uuid
266            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
267            * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found
268            * @throws SystemException if a system exception occurred
269            */
270            public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_First(
271                    java.lang.String uuid,
272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
273                    throws com.liferay.portal.kernel.exception.SystemException {
274                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
275            }
276    
277            /**
278            * Returns the last journal structure in the ordered set where uuid = &#63;.
279            *
280            * @param uuid the uuid
281            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
282            * @return the last matching journal structure
283            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
284            * @throws SystemException if a system exception occurred
285            */
286            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last(
287                    java.lang.String uuid,
288                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
289                    throws com.liferay.portal.kernel.exception.SystemException,
290                            com.liferay.portlet.journal.NoSuchStructureException {
291                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
292            }
293    
294            /**
295            * Returns the last journal structure in the ordered set where uuid = &#63;.
296            *
297            * @param uuid the uuid
298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
299            * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found
300            * @throws SystemException if a system exception occurred
301            */
302            public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_Last(
303                    java.lang.String uuid,
304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
305                    throws com.liferay.portal.kernel.exception.SystemException {
306                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
307            }
308    
309            /**
310            * Returns the journal structures before and after the current journal structure in the ordered set where uuid = &#63;.
311            *
312            * @param id the primary key of the current journal structure
313            * @param uuid the uuid
314            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
315            * @return the previous, current, and next journal structure
316            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
317            * @throws SystemException if a system exception occurred
318            */
319            public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext(
320                    long id, java.lang.String uuid,
321                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
322                    throws com.liferay.portal.kernel.exception.SystemException,
323                            com.liferay.portlet.journal.NoSuchStructureException {
324                    return getPersistence()
325                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
326            }
327    
328            /**
329            * 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.
330            *
331            * @param uuid the uuid
332            * @param groupId the group ID
333            * @return the matching journal structure
334            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
335            * @throws SystemException if a system exception occurred
336            */
337            public static com.liferay.portlet.journal.model.JournalStructure findByUUID_G(
338                    java.lang.String uuid, long groupId)
339                    throws com.liferay.portal.kernel.exception.SystemException,
340                            com.liferay.portlet.journal.NoSuchStructureException {
341                    return getPersistence().findByUUID_G(uuid, groupId);
342            }
343    
344            /**
345            * 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.
346            *
347            * @param uuid the uuid
348            * @param groupId the group ID
349            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
350            * @throws SystemException if a system exception occurred
351            */
352            public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G(
353                    java.lang.String uuid, long groupId)
354                    throws com.liferay.portal.kernel.exception.SystemException {
355                    return getPersistence().fetchByUUID_G(uuid, groupId);
356            }
357    
358            /**
359            * 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.
360            *
361            * @param uuid the uuid
362            * @param groupId the group ID
363            * @param retrieveFromCache whether to use the finder cache
364            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
365            * @throws SystemException if a system exception occurred
366            */
367            public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G(
368                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
369                    throws com.liferay.portal.kernel.exception.SystemException {
370                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
371            }
372    
373            /**
374            * Returns all the journal structures where uuid = &#63; and companyId = &#63;.
375            *
376            * @param uuid the uuid
377            * @param companyId the company ID
378            * @return the matching journal structures
379            * @throws SystemException if a system exception occurred
380            */
381            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C(
382                    java.lang.String uuid, long companyId)
383                    throws com.liferay.portal.kernel.exception.SystemException {
384                    return getPersistence().findByUuid_C(uuid, companyId);
385            }
386    
387            /**
388            * Returns a range of all the journal structures where uuid = &#63; and companyId = &#63;.
389            *
390            * <p>
391            * 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.
392            * </p>
393            *
394            * @param uuid the uuid
395            * @param companyId the company 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            * @return the range of matching journal structures
399            * @throws SystemException if a system exception occurred
400            */
401            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C(
402                    java.lang.String uuid, long companyId, int start, int end)
403                    throws com.liferay.portal.kernel.exception.SystemException {
404                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
405            }
406    
407            /**
408            * Returns an ordered range of all the journal structures where uuid = &#63; and companyId = &#63;.
409            *
410            * <p>
411            * 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.
412            * </p>
413            *
414            * @param uuid the uuid
415            * @param companyId the company ID
416            * @param start the lower bound of the range of journal structures
417            * @param end the upper bound of the range of journal structures (not inclusive)
418            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
419            * @return the ordered range of matching journal structures
420            * @throws SystemException if a system exception occurred
421            */
422            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C(
423                    java.lang.String uuid, long companyId, int start, int end,
424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
425                    throws com.liferay.portal.kernel.exception.SystemException {
426                    return getPersistence()
427                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
428            }
429    
430            /**
431            * Returns the first journal structure in the ordered set where uuid = &#63; and companyId = &#63;.
432            *
433            * @param uuid the uuid
434            * @param companyId the company ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the first matching journal structure
437            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
438            * @throws SystemException if a system exception occurred
439            */
440            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_C_First(
441                    java.lang.String uuid, long companyId,
442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
443                    throws com.liferay.portal.kernel.exception.SystemException,
444                            com.liferay.portlet.journal.NoSuchStructureException {
445                    return getPersistence()
446                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
447            }
448    
449            /**
450            * Returns the first journal structure in the ordered set where uuid = &#63; and companyId = &#63;.
451            *
452            * @param uuid the uuid
453            * @param companyId the company ID
454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
455            * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found
456            * @throws SystemException if a system exception occurred
457            */
458            public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_First(
459                    java.lang.String uuid, long companyId,
460                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
461                    throws com.liferay.portal.kernel.exception.SystemException {
462                    return getPersistence()
463                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
464            }
465    
466            /**
467            * Returns the last journal structure in the ordered set where uuid = &#63; and companyId = &#63;.
468            *
469            * @param uuid the uuid
470            * @param companyId the company ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the last matching journal structure
473            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
474            * @throws SystemException if a system exception occurred
475            */
476            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_C_Last(
477                    java.lang.String uuid, long companyId,
478                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
479                    throws com.liferay.portal.kernel.exception.SystemException,
480                            com.liferay.portlet.journal.NoSuchStructureException {
481                    return getPersistence()
482                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
483            }
484    
485            /**
486            * Returns the last journal structure in the ordered set where uuid = &#63; and companyId = &#63;.
487            *
488            * @param uuid the uuid
489            * @param companyId the company ID
490            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
491            * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found
492            * @throws SystemException if a system exception occurred
493            */
494            public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_Last(
495                    java.lang.String uuid, long companyId,
496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
497                    throws com.liferay.portal.kernel.exception.SystemException {
498                    return getPersistence()
499                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
500            }
501    
502            /**
503            * Returns the journal structures before and after the current journal structure in the ordered set where uuid = &#63; and companyId = &#63;.
504            *
505            * @param id the primary key of the current journal structure
506            * @param uuid the uuid
507            * @param companyId the company ID
508            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
509            * @return the previous, current, and next journal structure
510            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
511            * @throws SystemException if a system exception occurred
512            */
513            public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_C_PrevAndNext(
514                    long id, java.lang.String uuid, long companyId,
515                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
516                    throws com.liferay.portal.kernel.exception.SystemException,
517                            com.liferay.portlet.journal.NoSuchStructureException {
518                    return getPersistence()
519                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
520                            orderByComparator);
521            }
522    
523            /**
524            * Returns all the journal structures where groupId = &#63;.
525            *
526            * @param groupId the group ID
527            * @return the matching journal structures
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
531                    long groupId)
532                    throws com.liferay.portal.kernel.exception.SystemException {
533                    return getPersistence().findByGroupId(groupId);
534            }
535    
536            /**
537            * Returns a range of all the journal structures where groupId = &#63;.
538            *
539            * <p>
540            * 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.
541            * </p>
542            *
543            * @param groupId the group ID
544            * @param start the lower bound of the range of journal structures
545            * @param end the upper bound of the range of journal structures (not inclusive)
546            * @return the range of matching journal structures
547            * @throws SystemException if a system exception occurred
548            */
549            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
550                    long groupId, int start, int end)
551                    throws com.liferay.portal.kernel.exception.SystemException {
552                    return getPersistence().findByGroupId(groupId, start, end);
553            }
554    
555            /**
556            * Returns an ordered range of all the journal structures where groupId = &#63;.
557            *
558            * <p>
559            * 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.
560            * </p>
561            *
562            * @param groupId the group ID
563            * @param start the lower bound of the range of journal structures
564            * @param end the upper bound of the range of journal structures (not inclusive)
565            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
566            * @return the ordered range of matching journal structures
567            * @throws SystemException if a system exception occurred
568            */
569            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
570                    long groupId, int start, int end,
571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
572                    throws com.liferay.portal.kernel.exception.SystemException {
573                    return getPersistence()
574                                       .findByGroupId(groupId, start, end, orderByComparator);
575            }
576    
577            /**
578            * Returns the first journal structure in the ordered set where groupId = &#63;.
579            *
580            * @param groupId the group ID
581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
582            * @return the first matching journal structure
583            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
584            * @throws SystemException if a system exception occurred
585            */
586            public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First(
587                    long groupId,
588                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
589                    throws com.liferay.portal.kernel.exception.SystemException,
590                            com.liferay.portlet.journal.NoSuchStructureException {
591                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
592            }
593    
594            /**
595            * Returns the first journal structure in the ordered set where groupId = &#63;.
596            *
597            * @param groupId the group ID
598            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
599            * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found
600            * @throws SystemException if a system exception occurred
601            */
602            public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_First(
603                    long groupId,
604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
605                    throws com.liferay.portal.kernel.exception.SystemException {
606                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
607            }
608    
609            /**
610            * Returns the last journal structure in the ordered set where groupId = &#63;.
611            *
612            * @param groupId the group ID
613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
614            * @return the last matching journal structure
615            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
616            * @throws SystemException if a system exception occurred
617            */
618            public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last(
619                    long groupId,
620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
621                    throws com.liferay.portal.kernel.exception.SystemException,
622                            com.liferay.portlet.journal.NoSuchStructureException {
623                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
624            }
625    
626            /**
627            * Returns the last journal structure in the ordered set where groupId = &#63;.
628            *
629            * @param groupId the group ID
630            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
631            * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found
632            * @throws SystemException if a system exception occurred
633            */
634            public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_Last(
635                    long groupId,
636                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
637                    throws com.liferay.portal.kernel.exception.SystemException {
638                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
639            }
640    
641            /**
642            * Returns the journal structures before and after the current journal structure in the ordered set where groupId = &#63;.
643            *
644            * @param id the primary key of the current journal structure
645            * @param groupId the group ID
646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
647            * @return the previous, current, and next journal structure
648            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
649            * @throws SystemException if a system exception occurred
650            */
651            public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext(
652                    long id, long groupId,
653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
654                    throws com.liferay.portal.kernel.exception.SystemException,
655                            com.liferay.portlet.journal.NoSuchStructureException {
656                    return getPersistence()
657                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
658            }
659    
660            /**
661            * Returns all the journal structures where groupId = any &#63;.
662            *
663            * <p>
664            * 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.
665            * </p>
666            *
667            * @param groupIds the group IDs
668            * @return the matching journal structures
669            * @throws SystemException if a system exception occurred
670            */
671            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
672                    long[] groupIds)
673                    throws com.liferay.portal.kernel.exception.SystemException {
674                    return getPersistence().findByGroupId(groupIds);
675            }
676    
677            /**
678            * Returns a range of all the journal structures where groupId = any &#63;.
679            *
680            * <p>
681            * 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.
682            * </p>
683            *
684            * @param groupIds the group IDs
685            * @param start the lower bound of the range of journal structures
686            * @param end the upper bound of the range of journal structures (not inclusive)
687            * @return the range of matching journal structures
688            * @throws SystemException if a system exception occurred
689            */
690            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
691                    long[] groupIds, int start, int end)
692                    throws com.liferay.portal.kernel.exception.SystemException {
693                    return getPersistence().findByGroupId(groupIds, start, end);
694            }
695    
696            /**
697            * Returns an ordered range of all the journal structures where groupId = any &#63;.
698            *
699            * <p>
700            * 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.
701            * </p>
702            *
703            * @param groupIds the group IDs
704            * @param start the lower bound of the range of journal structures
705            * @param end the upper bound of the range of journal structures (not inclusive)
706            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
707            * @return the ordered range of matching journal structures
708            * @throws SystemException if a system exception occurred
709            */
710            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
711                    long[] groupIds, int start, int end,
712                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
713                    throws com.liferay.portal.kernel.exception.SystemException {
714                    return getPersistence()
715                                       .findByGroupId(groupIds, start, end, orderByComparator);
716            }
717    
718            /**
719            * Returns all the journal structures that the user has permission to view where groupId = &#63;.
720            *
721            * @param groupId the group ID
722            * @return the matching journal structures that the user has permission to view
723            * @throws SystemException if a system exception occurred
724            */
725            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
726                    long groupId)
727                    throws com.liferay.portal.kernel.exception.SystemException {
728                    return getPersistence().filterFindByGroupId(groupId);
729            }
730    
731            /**
732            * Returns a range of all the journal structures that the user has permission to view where groupId = &#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 start the lower bound of the range of journal structures
740            * @param end the upper bound of the range of journal structures (not inclusive)
741            * @return the range of matching journal structures that the user has permission to view
742            * @throws SystemException if a system exception occurred
743            */
744            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
745                    long groupId, int start, int end)
746                    throws com.liferay.portal.kernel.exception.SystemException {
747                    return getPersistence().filterFindByGroupId(groupId, start, end);
748            }
749    
750            /**
751            * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = &#63;.
752            *
753            * <p>
754            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
755            * </p>
756            *
757            * @param groupId the group ID
758            * @param start the lower bound of the range of journal structures
759            * @param end the upper bound of the range of journal structures (not inclusive)
760            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
761            * @return the ordered range of matching journal structures that the user has permission to view
762            * @throws SystemException if a system exception occurred
763            */
764            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
765                    long groupId, int start, int end,
766                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
767                    throws com.liferay.portal.kernel.exception.SystemException {
768                    return getPersistence()
769                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
770            }
771    
772            /**
773            * 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;.
774            *
775            * @param id the primary key of the current journal structure
776            * @param groupId the group ID
777            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
778            * @return the previous, current, and next journal structure
779            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
780            * @throws SystemException if a system exception occurred
781            */
782            public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext(
783                    long id, long groupId,
784                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
785                    throws com.liferay.portal.kernel.exception.SystemException,
786                            com.liferay.portlet.journal.NoSuchStructureException {
787                    return getPersistence()
788                                       .filterFindByGroupId_PrevAndNext(id, groupId,
789                            orderByComparator);
790            }
791    
792            /**
793            * Returns all the journal structures that the user has permission to view where groupId = any &#63;.
794            *
795            * @param groupIds the group IDs
796            * @return the matching journal structures that the user has permission to view
797            * @throws SystemException if a system exception occurred
798            */
799            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
800                    long[] groupIds)
801                    throws com.liferay.portal.kernel.exception.SystemException {
802                    return getPersistence().filterFindByGroupId(groupIds);
803            }
804    
805            /**
806            * Returns a range of all the journal structures that the user has permission to view where groupId = any &#63;.
807            *
808            * <p>
809            * 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.
810            * </p>
811            *
812            * @param groupIds the group IDs
813            * @param start the lower bound of the range of journal structures
814            * @param end the upper bound of the range of journal structures (not inclusive)
815            * @return the range of matching journal structures that the user has permission to view
816            * @throws SystemException if a system exception occurred
817            */
818            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
819                    long[] groupIds, int start, int end)
820                    throws com.liferay.portal.kernel.exception.SystemException {
821                    return getPersistence().filterFindByGroupId(groupIds, start, end);
822            }
823    
824            /**
825            * Returns an ordered range of all the journal structures that the user has permission to view where groupId = any &#63;.
826            *
827            * <p>
828            * 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.
829            * </p>
830            *
831            * @param groupIds the group IDs
832            * @param start the lower bound of the range of journal structures
833            * @param end the upper bound of the range of journal structures (not inclusive)
834            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
835            * @return the ordered range of matching journal structures that the user has permission to view
836            * @throws SystemException if a system exception occurred
837            */
838            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
839                    long[] groupIds, int start, int end,
840                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
841                    throws com.liferay.portal.kernel.exception.SystemException {
842                    return getPersistence()
843                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
844            }
845    
846            /**
847            * Returns all the journal structures where structureId = &#63;.
848            *
849            * @param structureId the structure ID
850            * @return the matching journal structures
851            * @throws SystemException if a system exception occurred
852            */
853            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
854                    java.lang.String structureId)
855                    throws com.liferay.portal.kernel.exception.SystemException {
856                    return getPersistence().findByStructureId(structureId);
857            }
858    
859            /**
860            * Returns a range of all the journal structures where structureId = &#63;.
861            *
862            * <p>
863            * 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.
864            * </p>
865            *
866            * @param structureId the structure ID
867            * @param start the lower bound of the range of journal structures
868            * @param end the upper bound of the range of journal structures (not inclusive)
869            * @return the range of matching journal structures
870            * @throws SystemException if a system exception occurred
871            */
872            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
873                    java.lang.String structureId, int start, int end)
874                    throws com.liferay.portal.kernel.exception.SystemException {
875                    return getPersistence().findByStructureId(structureId, start, end);
876            }
877    
878            /**
879            * Returns an ordered range of all the journal structures where structureId = &#63;.
880            *
881            * <p>
882            * 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.
883            * </p>
884            *
885            * @param structureId the structure ID
886            * @param start the lower bound of the range of journal structures
887            * @param end the upper bound of the range of journal structures (not inclusive)
888            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
889            * @return the ordered range of matching journal structures
890            * @throws SystemException if a system exception occurred
891            */
892            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
893                    java.lang.String structureId, int start, int end,
894                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
895                    throws com.liferay.portal.kernel.exception.SystemException {
896                    return getPersistence()
897                                       .findByStructureId(structureId, start, end, orderByComparator);
898            }
899    
900            /**
901            * Returns the first journal structure in the ordered set where structureId = &#63;.
902            *
903            * @param structureId the structure ID
904            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
905            * @return the first matching journal structure
906            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
907            * @throws SystemException if a system exception occurred
908            */
909            public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First(
910                    java.lang.String structureId,
911                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
912                    throws com.liferay.portal.kernel.exception.SystemException,
913                            com.liferay.portlet.journal.NoSuchStructureException {
914                    return getPersistence()
915                                       .findByStructureId_First(structureId, orderByComparator);
916            }
917    
918            /**
919            * Returns the first journal structure in the ordered set where structureId = &#63;.
920            *
921            * @param structureId the structure ID
922            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
923            * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found
924            * @throws SystemException if a system exception occurred
925            */
926            public static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_First(
927                    java.lang.String structureId,
928                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
929                    throws com.liferay.portal.kernel.exception.SystemException {
930                    return getPersistence()
931                                       .fetchByStructureId_First(structureId, orderByComparator);
932            }
933    
934            /**
935            * Returns the last journal structure in the ordered set where structureId = &#63;.
936            *
937            * @param structureId the structure ID
938            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
939            * @return the last matching journal structure
940            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
941            * @throws SystemException if a system exception occurred
942            */
943            public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last(
944                    java.lang.String structureId,
945                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
946                    throws com.liferay.portal.kernel.exception.SystemException,
947                            com.liferay.portlet.journal.NoSuchStructureException {
948                    return getPersistence()
949                                       .findByStructureId_Last(structureId, orderByComparator);
950            }
951    
952            /**
953            * Returns the last journal structure in the ordered set where structureId = &#63;.
954            *
955            * @param structureId the structure ID
956            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
957            * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found
958            * @throws SystemException if a system exception occurred
959            */
960            public static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_Last(
961                    java.lang.String structureId,
962                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
963                    throws com.liferay.portal.kernel.exception.SystemException {
964                    return getPersistence()
965                                       .fetchByStructureId_Last(structureId, orderByComparator);
966            }
967    
968            /**
969            * Returns the journal structures before and after the current journal structure in the ordered set where structureId = &#63;.
970            *
971            * @param id the primary key of the current journal structure
972            * @param structureId the structure ID
973            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
974            * @return the previous, current, and next journal structure
975            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
976            * @throws SystemException if a system exception occurred
977            */
978            public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext(
979                    long id, java.lang.String structureId,
980                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
981                    throws com.liferay.portal.kernel.exception.SystemException,
982                            com.liferay.portlet.journal.NoSuchStructureException {
983                    return getPersistence()
984                                       .findByStructureId_PrevAndNext(id, structureId,
985                            orderByComparator);
986            }
987    
988            /**
989            * Returns all the journal structures where parentStructureId = &#63;.
990            *
991            * @param parentStructureId the parent structure ID
992            * @return the matching journal structures
993            * @throws SystemException if a system exception occurred
994            */
995            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId(
996                    java.lang.String parentStructureId)
997                    throws com.liferay.portal.kernel.exception.SystemException {
998                    return getPersistence().findByParentStructureId(parentStructureId);
999            }
1000    
1001            /**
1002            * Returns a range of all the journal structures where parentStructureId = &#63;.
1003            *
1004            * <p>
1005            * 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.
1006            * </p>
1007            *
1008            * @param parentStructureId the parent structure ID
1009            * @param start the lower bound of the range of journal structures
1010            * @param end the upper bound of the range of journal structures (not inclusive)
1011            * @return the range of matching journal structures
1012            * @throws SystemException if a system exception occurred
1013            */
1014            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId(
1015                    java.lang.String parentStructureId, int start, int end)
1016                    throws com.liferay.portal.kernel.exception.SystemException {
1017                    return getPersistence()
1018                                       .findByParentStructureId(parentStructureId, start, end);
1019            }
1020    
1021            /**
1022            * Returns an ordered range of all the journal structures where parentStructureId = &#63;.
1023            *
1024            * <p>
1025            * 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.
1026            * </p>
1027            *
1028            * @param parentStructureId the parent structure ID
1029            * @param start the lower bound of the range of journal structures
1030            * @param end the upper bound of the range of journal structures (not inclusive)
1031            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1032            * @return the ordered range of matching journal structures
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId(
1036                    java.lang.String parentStructureId, int start, int end,
1037                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1038                    throws com.liferay.portal.kernel.exception.SystemException {
1039                    return getPersistence()
1040                                       .findByParentStructureId(parentStructureId, start, end,
1041                            orderByComparator);
1042            }
1043    
1044            /**
1045            * Returns the first journal structure in the ordered set where parentStructureId = &#63;.
1046            *
1047            * @param parentStructureId the parent structure ID
1048            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1049            * @return the first matching journal structure
1050            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
1051            * @throws SystemException if a system exception occurred
1052            */
1053            public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_First(
1054                    java.lang.String parentStructureId,
1055                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1056                    throws com.liferay.portal.kernel.exception.SystemException,
1057                            com.liferay.portlet.journal.NoSuchStructureException {
1058                    return getPersistence()
1059                                       .findByParentStructureId_First(parentStructureId,
1060                            orderByComparator);
1061            }
1062    
1063            /**
1064            * Returns the first journal structure in the ordered set where parentStructureId = &#63;.
1065            *
1066            * @param parentStructureId the parent structure ID
1067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1068            * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found
1069            * @throws SystemException if a system exception occurred
1070            */
1071            public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_First(
1072                    java.lang.String parentStructureId,
1073                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1074                    throws com.liferay.portal.kernel.exception.SystemException {
1075                    return getPersistence()
1076                                       .fetchByParentStructureId_First(parentStructureId,
1077                            orderByComparator);
1078            }
1079    
1080            /**
1081            * Returns the last journal structure in the ordered set where parentStructureId = &#63;.
1082            *
1083            * @param parentStructureId the parent structure ID
1084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1085            * @return the last matching journal structure
1086            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
1087            * @throws SystemException if a system exception occurred
1088            */
1089            public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_Last(
1090                    java.lang.String parentStructureId,
1091                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1092                    throws com.liferay.portal.kernel.exception.SystemException,
1093                            com.liferay.portlet.journal.NoSuchStructureException {
1094                    return getPersistence()
1095                                       .findByParentStructureId_Last(parentStructureId,
1096                            orderByComparator);
1097            }
1098    
1099            /**
1100            * Returns the last journal structure in the ordered set where parentStructureId = &#63;.
1101            *
1102            * @param parentStructureId the parent structure ID
1103            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1104            * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found
1105            * @throws SystemException if a system exception occurred
1106            */
1107            public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_Last(
1108                    java.lang.String parentStructureId,
1109                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1110                    throws com.liferay.portal.kernel.exception.SystemException {
1111                    return getPersistence()
1112                                       .fetchByParentStructureId_Last(parentStructureId,
1113                            orderByComparator);
1114            }
1115    
1116            /**
1117            * Returns the journal structures before and after the current journal structure in the ordered set where parentStructureId = &#63;.
1118            *
1119            * @param id the primary key of the current journal structure
1120            * @param parentStructureId the parent structure ID
1121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1122            * @return the previous, current, and next journal structure
1123            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
1124            * @throws SystemException if a system exception occurred
1125            */
1126            public static com.liferay.portlet.journal.model.JournalStructure[] findByParentStructureId_PrevAndNext(
1127                    long id, java.lang.String parentStructureId,
1128                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1129                    throws com.liferay.portal.kernel.exception.SystemException,
1130                            com.liferay.portlet.journal.NoSuchStructureException {
1131                    return getPersistence()
1132                                       .findByParentStructureId_PrevAndNext(id, parentStructureId,
1133                            orderByComparator);
1134            }
1135    
1136            /**
1137            * 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.
1138            *
1139            * @param groupId the group ID
1140            * @param structureId the structure ID
1141            * @return the matching journal structure
1142            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
1143            * @throws SystemException if a system exception occurred
1144            */
1145            public static com.liferay.portlet.journal.model.JournalStructure findByG_S(
1146                    long groupId, java.lang.String structureId)
1147                    throws com.liferay.portal.kernel.exception.SystemException,
1148                            com.liferay.portlet.journal.NoSuchStructureException {
1149                    return getPersistence().findByG_S(groupId, structureId);
1150            }
1151    
1152            /**
1153            * 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.
1154            *
1155            * @param groupId the group ID
1156            * @param structureId the structure ID
1157            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
1158            * @throws SystemException if a system exception occurred
1159            */
1160            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
1161                    long groupId, java.lang.String structureId)
1162                    throws com.liferay.portal.kernel.exception.SystemException {
1163                    return getPersistence().fetchByG_S(groupId, structureId);
1164            }
1165    
1166            /**
1167            * 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.
1168            *
1169            * @param groupId the group ID
1170            * @param structureId the structure ID
1171            * @param retrieveFromCache whether to use the finder cache
1172            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
1173            * @throws SystemException if a system exception occurred
1174            */
1175            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
1176                    long groupId, java.lang.String structureId, boolean retrieveFromCache)
1177                    throws com.liferay.portal.kernel.exception.SystemException {
1178                    return getPersistence()
1179                                       .fetchByG_S(groupId, structureId, retrieveFromCache);
1180            }
1181    
1182            /**
1183            * Returns all the journal structures where groupId = &#63; and parentStructureId = &#63;.
1184            *
1185            * @param groupId the group ID
1186            * @param parentStructureId the parent structure ID
1187            * @return the matching journal structures
1188            * @throws SystemException if a system exception occurred
1189            */
1190            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
1191                    long groupId, java.lang.String parentStructureId)
1192                    throws com.liferay.portal.kernel.exception.SystemException {
1193                    return getPersistence().findByG_P(groupId, parentStructureId);
1194            }
1195    
1196            /**
1197            * Returns a range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
1198            *
1199            * <p>
1200            * 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.
1201            * </p>
1202            *
1203            * @param groupId the group ID
1204            * @param parentStructureId the parent structure ID
1205            * @param start the lower bound of the range of journal structures
1206            * @param end the upper bound of the range of journal structures (not inclusive)
1207            * @return the range of matching journal structures
1208            * @throws SystemException if a system exception occurred
1209            */
1210            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
1211                    long groupId, java.lang.String parentStructureId, int start, int end)
1212                    throws com.liferay.portal.kernel.exception.SystemException {
1213                    return getPersistence().findByG_P(groupId, parentStructureId, start, end);
1214            }
1215    
1216            /**
1217            * Returns an ordered range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
1218            *
1219            * <p>
1220            * 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.
1221            * </p>
1222            *
1223            * @param groupId the group ID
1224            * @param parentStructureId the parent structure ID
1225            * @param start the lower bound of the range of journal structures
1226            * @param end the upper bound of the range of journal structures (not inclusive)
1227            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1228            * @return the ordered range of matching journal structures
1229            * @throws SystemException if a system exception occurred
1230            */
1231            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
1232                    long groupId, java.lang.String parentStructureId, int start, int end,
1233                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1234                    throws com.liferay.portal.kernel.exception.SystemException {
1235                    return getPersistence()
1236                                       .findByG_P(groupId, parentStructureId, start, end,
1237                            orderByComparator);
1238            }
1239    
1240            /**
1241            * Returns the first journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1242            *
1243            * @param groupId the group ID
1244            * @param parentStructureId the parent structure ID
1245            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1246            * @return the first matching journal structure
1247            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
1248            * @throws SystemException if a system exception occurred
1249            */
1250            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First(
1251                    long groupId, java.lang.String parentStructureId,
1252                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1253                    throws com.liferay.portal.kernel.exception.SystemException,
1254                            com.liferay.portlet.journal.NoSuchStructureException {
1255                    return getPersistence()
1256                                       .findByG_P_First(groupId, parentStructureId,
1257                            orderByComparator);
1258            }
1259    
1260            /**
1261            * Returns the first journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1262            *
1263            * @param groupId the group ID
1264            * @param parentStructureId the parent structure ID
1265            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1266            * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found
1267            * @throws SystemException if a system exception occurred
1268            */
1269            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_First(
1270                    long groupId, java.lang.String parentStructureId,
1271                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1272                    throws com.liferay.portal.kernel.exception.SystemException {
1273                    return getPersistence()
1274                                       .fetchByG_P_First(groupId, parentStructureId,
1275                            orderByComparator);
1276            }
1277    
1278            /**
1279            * Returns the last journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1280            *
1281            * @param groupId the group ID
1282            * @param parentStructureId the parent structure ID
1283            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1284            * @return the last matching journal structure
1285            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
1286            * @throws SystemException if a system exception occurred
1287            */
1288            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last(
1289                    long groupId, java.lang.String parentStructureId,
1290                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1291                    throws com.liferay.portal.kernel.exception.SystemException,
1292                            com.liferay.portlet.journal.NoSuchStructureException {
1293                    return getPersistence()
1294                                       .findByG_P_Last(groupId, parentStructureId, orderByComparator);
1295            }
1296    
1297            /**
1298            * Returns the last journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1299            *
1300            * @param groupId the group ID
1301            * @param parentStructureId the parent structure ID
1302            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1303            * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found
1304            * @throws SystemException if a system exception occurred
1305            */
1306            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_Last(
1307                    long groupId, java.lang.String parentStructureId,
1308                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1309                    throws com.liferay.portal.kernel.exception.SystemException {
1310                    return getPersistence()
1311                                       .fetchByG_P_Last(groupId, parentStructureId,
1312                            orderByComparator);
1313            }
1314    
1315            /**
1316            * Returns the journal structures before and after the current journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1317            *
1318            * @param id the primary key of the current journal structure
1319            * @param groupId the group ID
1320            * @param parentStructureId the parent structure ID
1321            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1322            * @return the previous, current, and next journal structure
1323            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
1324            * @throws SystemException if a system exception occurred
1325            */
1326            public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext(
1327                    long id, long groupId, java.lang.String parentStructureId,
1328                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1329                    throws com.liferay.portal.kernel.exception.SystemException,
1330                            com.liferay.portlet.journal.NoSuchStructureException {
1331                    return getPersistence()
1332                                       .findByG_P_PrevAndNext(id, groupId, parentStructureId,
1333                            orderByComparator);
1334            }
1335    
1336            /**
1337            * Returns all the journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1338            *
1339            * @param groupId the group ID
1340            * @param parentStructureId the parent structure ID
1341            * @return the matching journal structures that the user has permission to view
1342            * @throws SystemException if a system exception occurred
1343            */
1344            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
1345                    long groupId, java.lang.String parentStructureId)
1346                    throws com.liferay.portal.kernel.exception.SystemException {
1347                    return getPersistence().filterFindByG_P(groupId, parentStructureId);
1348            }
1349    
1350            /**
1351            * Returns a range of all the journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1352            *
1353            * <p>
1354            * 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.
1355            * </p>
1356            *
1357            * @param groupId the group ID
1358            * @param parentStructureId the parent structure ID
1359            * @param start the lower bound of the range of journal structures
1360            * @param end the upper bound of the range of journal structures (not inclusive)
1361            * @return the range of matching journal structures that the user has permission to view
1362            * @throws SystemException if a system exception occurred
1363            */
1364            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
1365                    long groupId, java.lang.String parentStructureId, int start, int end)
1366                    throws com.liferay.portal.kernel.exception.SystemException {
1367                    return getPersistence()
1368                                       .filterFindByG_P(groupId, parentStructureId, start, end);
1369            }
1370    
1371            /**
1372            * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = &#63; and parentStructureId = &#63;.
1373            *
1374            * <p>
1375            * 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.
1376            * </p>
1377            *
1378            * @param groupId the group ID
1379            * @param parentStructureId the parent structure ID
1380            * @param start the lower bound of the range of journal structures
1381            * @param end the upper bound of the range of journal structures (not inclusive)
1382            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1383            * @return the ordered range of matching journal structures that the user has permission to view
1384            * @throws SystemException if a system exception occurred
1385            */
1386            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
1387                    long groupId, java.lang.String parentStructureId, int start, int end,
1388                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1389                    throws com.liferay.portal.kernel.exception.SystemException {
1390                    return getPersistence()
1391                                       .filterFindByG_P(groupId, parentStructureId, start, end,
1392                            orderByComparator);
1393            }
1394    
1395            /**
1396            * 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;.
1397            *
1398            * @param id the primary key of the current journal structure
1399            * @param groupId the group ID
1400            * @param parentStructureId the parent structure ID
1401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1402            * @return the previous, current, and next journal structure
1403            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
1404            * @throws SystemException if a system exception occurred
1405            */
1406            public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext(
1407                    long id, long groupId, java.lang.String parentStructureId,
1408                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1409                    throws com.liferay.portal.kernel.exception.SystemException,
1410                            com.liferay.portlet.journal.NoSuchStructureException {
1411                    return getPersistence()
1412                                       .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId,
1413                            orderByComparator);
1414            }
1415    
1416            /**
1417            * Returns all the journal structures.
1418            *
1419            * @return the journal structures
1420            * @throws SystemException if a system exception occurred
1421            */
1422            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll()
1423                    throws com.liferay.portal.kernel.exception.SystemException {
1424                    return getPersistence().findAll();
1425            }
1426    
1427            /**
1428            * Returns a range of all the journal structures.
1429            *
1430            * <p>
1431            * 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.
1432            * </p>
1433            *
1434            * @param start the lower bound of the range of journal structures
1435            * @param end the upper bound of the range of journal structures (not inclusive)
1436            * @return the range of journal structures
1437            * @throws SystemException if a system exception occurred
1438            */
1439            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
1440                    int start, int end)
1441                    throws com.liferay.portal.kernel.exception.SystemException {
1442                    return getPersistence().findAll(start, end);
1443            }
1444    
1445            /**
1446            * Returns an ordered range of all the journal structures.
1447            *
1448            * <p>
1449            * 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.
1450            * </p>
1451            *
1452            * @param start the lower bound of the range of journal structures
1453            * @param end the upper bound of the range of journal structures (not inclusive)
1454            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1455            * @return the ordered range of journal structures
1456            * @throws SystemException if a system exception occurred
1457            */
1458            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
1459                    int start, int end,
1460                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1461                    throws com.liferay.portal.kernel.exception.SystemException {
1462                    return getPersistence().findAll(start, end, orderByComparator);
1463            }
1464    
1465            /**
1466            * Removes all the journal structures where uuid = &#63; from the database.
1467            *
1468            * @param uuid the uuid
1469            * @throws SystemException if a system exception occurred
1470            */
1471            public static void removeByUuid(java.lang.String uuid)
1472                    throws com.liferay.portal.kernel.exception.SystemException {
1473                    getPersistence().removeByUuid(uuid);
1474            }
1475    
1476            /**
1477            * Removes the journal structure where uuid = &#63; and groupId = &#63; from the database.
1478            *
1479            * @param uuid the uuid
1480            * @param groupId the group ID
1481            * @return the journal structure that was removed
1482            * @throws SystemException if a system exception occurred
1483            */
1484            public static com.liferay.portlet.journal.model.JournalStructure removeByUUID_G(
1485                    java.lang.String uuid, long groupId)
1486                    throws com.liferay.portal.kernel.exception.SystemException,
1487                            com.liferay.portlet.journal.NoSuchStructureException {
1488                    return getPersistence().removeByUUID_G(uuid, groupId);
1489            }
1490    
1491            /**
1492            * Removes all the journal structures where uuid = &#63; and companyId = &#63; from the database.
1493            *
1494            * @param uuid the uuid
1495            * @param companyId the company ID
1496            * @throws SystemException if a system exception occurred
1497            */
1498            public static void removeByUuid_C(java.lang.String uuid, long companyId)
1499                    throws com.liferay.portal.kernel.exception.SystemException {
1500                    getPersistence().removeByUuid_C(uuid, companyId);
1501            }
1502    
1503            /**
1504            * Removes all the journal structures where groupId = &#63; from the database.
1505            *
1506            * @param groupId the group ID
1507            * @throws SystemException if a system exception occurred
1508            */
1509            public static void removeByGroupId(long groupId)
1510                    throws com.liferay.portal.kernel.exception.SystemException {
1511                    getPersistence().removeByGroupId(groupId);
1512            }
1513    
1514            /**
1515            * Removes all the journal structures where structureId = &#63; from the database.
1516            *
1517            * @param structureId the structure ID
1518            * @throws SystemException if a system exception occurred
1519            */
1520            public static void removeByStructureId(java.lang.String structureId)
1521                    throws com.liferay.portal.kernel.exception.SystemException {
1522                    getPersistence().removeByStructureId(structureId);
1523            }
1524    
1525            /**
1526            * Removes all the journal structures where parentStructureId = &#63; from the database.
1527            *
1528            * @param parentStructureId the parent structure ID
1529            * @throws SystemException if a system exception occurred
1530            */
1531            public static void removeByParentStructureId(
1532                    java.lang.String parentStructureId)
1533                    throws com.liferay.portal.kernel.exception.SystemException {
1534                    getPersistence().removeByParentStructureId(parentStructureId);
1535            }
1536    
1537            /**
1538            * Removes the journal structure where groupId = &#63; and structureId = &#63; from the database.
1539            *
1540            * @param groupId the group ID
1541            * @param structureId the structure ID
1542            * @return the journal structure that was removed
1543            * @throws SystemException if a system exception occurred
1544            */
1545            public static com.liferay.portlet.journal.model.JournalStructure removeByG_S(
1546                    long groupId, java.lang.String structureId)
1547                    throws com.liferay.portal.kernel.exception.SystemException,
1548                            com.liferay.portlet.journal.NoSuchStructureException {
1549                    return getPersistence().removeByG_S(groupId, structureId);
1550            }
1551    
1552            /**
1553            * Removes all the journal structures where groupId = &#63; and parentStructureId = &#63; from the database.
1554            *
1555            * @param groupId the group ID
1556            * @param parentStructureId the parent structure ID
1557            * @throws SystemException if a system exception occurred
1558            */
1559            public static void removeByG_P(long groupId,
1560                    java.lang.String parentStructureId)
1561                    throws com.liferay.portal.kernel.exception.SystemException {
1562                    getPersistence().removeByG_P(groupId, parentStructureId);
1563            }
1564    
1565            /**
1566            * Removes all the journal structures from the database.
1567            *
1568            * @throws SystemException if a system exception occurred
1569            */
1570            public static void removeAll()
1571                    throws com.liferay.portal.kernel.exception.SystemException {
1572                    getPersistence().removeAll();
1573            }
1574    
1575            /**
1576            * Returns the number of journal structures where uuid = &#63;.
1577            *
1578            * @param uuid the uuid
1579            * @return the number of matching journal structures
1580            * @throws SystemException if a system exception occurred
1581            */
1582            public static int countByUuid(java.lang.String uuid)
1583                    throws com.liferay.portal.kernel.exception.SystemException {
1584                    return getPersistence().countByUuid(uuid);
1585            }
1586    
1587            /**
1588            * Returns the number of journal structures where uuid = &#63; and groupId = &#63;.
1589            *
1590            * @param uuid the uuid
1591            * @param groupId the group ID
1592            * @return the number of matching journal structures
1593            * @throws SystemException if a system exception occurred
1594            */
1595            public static int countByUUID_G(java.lang.String uuid, long groupId)
1596                    throws com.liferay.portal.kernel.exception.SystemException {
1597                    return getPersistence().countByUUID_G(uuid, groupId);
1598            }
1599    
1600            /**
1601            * Returns the number of journal structures where uuid = &#63; and companyId = &#63;.
1602            *
1603            * @param uuid the uuid
1604            * @param companyId the company ID
1605            * @return the number of matching journal structures
1606            * @throws SystemException if a system exception occurred
1607            */
1608            public static int countByUuid_C(java.lang.String uuid, long companyId)
1609                    throws com.liferay.portal.kernel.exception.SystemException {
1610                    return getPersistence().countByUuid_C(uuid, companyId);
1611            }
1612    
1613            /**
1614            * Returns the number of journal structures where groupId = &#63;.
1615            *
1616            * @param groupId the group ID
1617            * @return the number of matching journal structures
1618            * @throws SystemException if a system exception occurred
1619            */
1620            public static int countByGroupId(long groupId)
1621                    throws com.liferay.portal.kernel.exception.SystemException {
1622                    return getPersistence().countByGroupId(groupId);
1623            }
1624    
1625            /**
1626            * Returns the number of journal structures where groupId = any &#63;.
1627            *
1628            * @param groupIds the group IDs
1629            * @return the number of matching journal structures
1630            * @throws SystemException if a system exception occurred
1631            */
1632            public static int countByGroupId(long[] groupIds)
1633                    throws com.liferay.portal.kernel.exception.SystemException {
1634                    return getPersistence().countByGroupId(groupIds);
1635            }
1636    
1637            /**
1638            * Returns the number of journal structures that the user has permission to view where groupId = &#63;.
1639            *
1640            * @param groupId the group ID
1641            * @return the number of matching journal structures that the user has permission to view
1642            * @throws SystemException if a system exception occurred
1643            */
1644            public static int filterCountByGroupId(long groupId)
1645                    throws com.liferay.portal.kernel.exception.SystemException {
1646                    return getPersistence().filterCountByGroupId(groupId);
1647            }
1648    
1649            /**
1650            * Returns the number of journal structures that the user has permission to view where groupId = any &#63;.
1651            *
1652            * @param groupIds the group IDs
1653            * @return the number of matching journal structures that the user has permission to view
1654            * @throws SystemException if a system exception occurred
1655            */
1656            public static int filterCountByGroupId(long[] groupIds)
1657                    throws com.liferay.portal.kernel.exception.SystemException {
1658                    return getPersistence().filterCountByGroupId(groupIds);
1659            }
1660    
1661            /**
1662            * Returns the number of journal structures where structureId = &#63;.
1663            *
1664            * @param structureId the structure ID
1665            * @return the number of matching journal structures
1666            * @throws SystemException if a system exception occurred
1667            */
1668            public static int countByStructureId(java.lang.String structureId)
1669                    throws com.liferay.portal.kernel.exception.SystemException {
1670                    return getPersistence().countByStructureId(structureId);
1671            }
1672    
1673            /**
1674            * Returns the number of journal structures where parentStructureId = &#63;.
1675            *
1676            * @param parentStructureId the parent structure ID
1677            * @return the number of matching journal structures
1678            * @throws SystemException if a system exception occurred
1679            */
1680            public static int countByParentStructureId(
1681                    java.lang.String parentStructureId)
1682                    throws com.liferay.portal.kernel.exception.SystemException {
1683                    return getPersistence().countByParentStructureId(parentStructureId);
1684            }
1685    
1686            /**
1687            * Returns the number of journal structures where groupId = &#63; and structureId = &#63;.
1688            *
1689            * @param groupId the group ID
1690            * @param structureId the structure ID
1691            * @return the number of matching journal structures
1692            * @throws SystemException if a system exception occurred
1693            */
1694            public static int countByG_S(long groupId, java.lang.String structureId)
1695                    throws com.liferay.portal.kernel.exception.SystemException {
1696                    return getPersistence().countByG_S(groupId, structureId);
1697            }
1698    
1699            /**
1700            * Returns the number of journal structures where groupId = &#63; and parentStructureId = &#63;.
1701            *
1702            * @param groupId the group ID
1703            * @param parentStructureId the parent structure ID
1704            * @return the number of matching journal structures
1705            * @throws SystemException if a system exception occurred
1706            */
1707            public static int countByG_P(long groupId,
1708                    java.lang.String parentStructureId)
1709                    throws com.liferay.portal.kernel.exception.SystemException {
1710                    return getPersistence().countByG_P(groupId, parentStructureId);
1711            }
1712    
1713            /**
1714            * Returns the number of journal structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1715            *
1716            * @param groupId the group ID
1717            * @param parentStructureId the parent structure ID
1718            * @return the number of matching journal structures that the user has permission to view
1719            * @throws SystemException if a system exception occurred
1720            */
1721            public static int filterCountByG_P(long groupId,
1722                    java.lang.String parentStructureId)
1723                    throws com.liferay.portal.kernel.exception.SystemException {
1724                    return getPersistence().filterCountByG_P(groupId, parentStructureId);
1725            }
1726    
1727            /**
1728            * Returns the number of journal structures.
1729            *
1730            * @return the number of journal structures
1731            * @throws SystemException if a system exception occurred
1732            */
1733            public static int countAll()
1734                    throws com.liferay.portal.kernel.exception.SystemException {
1735                    return getPersistence().countAll();
1736            }
1737    
1738            public static JournalStructurePersistence getPersistence() {
1739                    if (_persistence == null) {
1740                            _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName());
1741    
1742                            ReferenceRegistry.registerReference(JournalStructureUtil.class,
1743                                    "_persistence");
1744                    }
1745    
1746                    return _persistence;
1747            }
1748    
1749            /**
1750             * @deprecated
1751             */
1752            public void setPersistence(JournalStructurePersistence persistence) {
1753            }
1754    
1755            private static JournalStructurePersistence _persistence;
1756    }