001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.wiki.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.service.ServiceContext;
022    
023    import com.liferay.portlet.wiki.model.WikiPage;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the wiki page service.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class.
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see WikiPagePersistence
036     * @see WikiPagePersistenceImpl
037     * @generated
038     */
039    public class WikiPageUtil {
040            /**
041             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
042             */
043            public static void clearCache() {
044                    getPersistence().clearCache();
045            }
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
049             */
050            public static void clearCache(WikiPage wikiPage) {
051                    getPersistence().clearCache(wikiPage);
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
056             */
057            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
058                    throws SystemException {
059                    return getPersistence().countWithDynamicQuery(dynamicQuery);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
064             */
065            public static List<WikiPage> findWithDynamicQuery(DynamicQuery dynamicQuery)
066                    throws SystemException {
067                    return getPersistence().findWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
072             */
073            public static List<WikiPage> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery, int start, int end)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
081             */
082            public static List<WikiPage> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end,
084                    OrderByComparator orderByComparator) throws SystemException {
085                    return getPersistence()
086                                       .findWithDynamicQuery(dynamicQuery, start, end,
087                            orderByComparator);
088            }
089    
090            /**
091             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
092             */
093            public static WikiPage remove(WikiPage wikiPage) throws SystemException {
094                    return getPersistence().remove(wikiPage);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
099             */
100            public static WikiPage update(WikiPage wikiPage, boolean merge)
101                    throws SystemException {
102                    return getPersistence().update(wikiPage, merge);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
107             */
108            public static WikiPage update(WikiPage wikiPage, boolean merge,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(wikiPage, merge, serviceContext);
111            }
112    
113            /**
114            * Caches the wiki page in the entity cache if it is enabled.
115            *
116            * @param wikiPage the wiki page to cache
117            */
118            public static void cacheResult(
119                    com.liferay.portlet.wiki.model.WikiPage wikiPage) {
120                    getPersistence().cacheResult(wikiPage);
121            }
122    
123            /**
124            * Caches the wiki pages in the entity cache if it is enabled.
125            *
126            * @param wikiPages the wiki pages to cache
127            */
128            public static void cacheResult(
129                    java.util.List<com.liferay.portlet.wiki.model.WikiPage> wikiPages) {
130                    getPersistence().cacheResult(wikiPages);
131            }
132    
133            /**
134            * Creates a new wiki page with the primary key.
135            *
136            * @param pageId the primary key for the new wiki page
137            * @return the new wiki page
138            */
139            public static com.liferay.portlet.wiki.model.WikiPage create(long pageId) {
140                    return getPersistence().create(pageId);
141            }
142    
143            /**
144            * Removes the wiki page with the primary key from the database. Also notifies the appropriate model listeners.
145            *
146            * @param pageId the primary key of the wiki page to remove
147            * @return the wiki page that was removed
148            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
149            * @throws SystemException if a system exception occurred
150            */
151            public static com.liferay.portlet.wiki.model.WikiPage remove(long pageId)
152                    throws com.liferay.portal.kernel.exception.SystemException,
153                            com.liferay.portlet.wiki.NoSuchPageException {
154                    return getPersistence().remove(pageId);
155            }
156    
157            public static com.liferay.portlet.wiki.model.WikiPage updateImpl(
158                    com.liferay.portlet.wiki.model.WikiPage wikiPage, boolean merge)
159                    throws com.liferay.portal.kernel.exception.SystemException {
160                    return getPersistence().updateImpl(wikiPage, merge);
161            }
162    
163            /**
164            * Finds the wiki page with the primary key or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
165            *
166            * @param pageId the primary key of the wiki page to find
167            * @return the wiki page
168            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
169            * @throws SystemException if a system exception occurred
170            */
171            public static com.liferay.portlet.wiki.model.WikiPage findByPrimaryKey(
172                    long pageId)
173                    throws com.liferay.portal.kernel.exception.SystemException,
174                            com.liferay.portlet.wiki.NoSuchPageException {
175                    return getPersistence().findByPrimaryKey(pageId);
176            }
177    
178            /**
179            * Finds the wiki page with the primary key or returns <code>null</code> if it could not be found.
180            *
181            * @param pageId the primary key of the wiki page to find
182            * @return the wiki page, or <code>null</code> if a wiki page with the primary key could not be found
183            * @throws SystemException if a system exception occurred
184            */
185            public static com.liferay.portlet.wiki.model.WikiPage fetchByPrimaryKey(
186                    long pageId) throws com.liferay.portal.kernel.exception.SystemException {
187                    return getPersistence().fetchByPrimaryKey(pageId);
188            }
189    
190            /**
191            * Finds all the wiki pages where uuid = &#63;.
192            *
193            * @param uuid the uuid to search with
194            * @return the matching wiki pages
195            * @throws SystemException if a system exception occurred
196            */
197            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByUuid(
198                    java.lang.String uuid)
199                    throws com.liferay.portal.kernel.exception.SystemException {
200                    return getPersistence().findByUuid(uuid);
201            }
202    
203            /**
204            * Finds a range of all the wiki pages where uuid = &#63;.
205            *
206            * <p>
207            * 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.
208            * </p>
209            *
210            * @param uuid the uuid to search with
211            * @param start the lower bound of the range of wiki pages to return
212            * @param end the upper bound of the range of wiki pages to return (not inclusive)
213            * @return the range of matching wiki pages
214            * @throws SystemException if a system exception occurred
215            */
216            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByUuid(
217                    java.lang.String uuid, int start, int end)
218                    throws com.liferay.portal.kernel.exception.SystemException {
219                    return getPersistence().findByUuid(uuid, start, end);
220            }
221    
222            /**
223            * Finds an ordered range of all the wiki pages where uuid = &#63;.
224            *
225            * <p>
226            * 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.
227            * </p>
228            *
229            * @param uuid the uuid to search with
230            * @param start the lower bound of the range of wiki pages to return
231            * @param end the upper bound of the range of wiki pages to return (not inclusive)
232            * @param orderByComparator the comparator to order the results by
233            * @return the ordered range of matching wiki pages
234            * @throws SystemException if a system exception occurred
235            */
236            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByUuid(
237                    java.lang.String uuid, int start, int end,
238                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
239                    throws com.liferay.portal.kernel.exception.SystemException {
240                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
241            }
242    
243            /**
244            * Finds the first wiki page in the ordered set where uuid = &#63;.
245            *
246            * <p>
247            * 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.
248            * </p>
249            *
250            * @param uuid the uuid to search with
251            * @param orderByComparator the comparator to order the set by
252            * @return the first matching wiki page
253            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
254            * @throws SystemException if a system exception occurred
255            */
256            public static com.liferay.portlet.wiki.model.WikiPage findByUuid_First(
257                    java.lang.String uuid,
258                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
259                    throws com.liferay.portal.kernel.exception.SystemException,
260                            com.liferay.portlet.wiki.NoSuchPageException {
261                    return getPersistence().findByUuid_First(uuid, orderByComparator);
262            }
263    
264            /**
265            * Finds the last wiki page in the ordered set where uuid = &#63;.
266            *
267            * <p>
268            * 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.
269            * </p>
270            *
271            * @param uuid the uuid to search with
272            * @param orderByComparator the comparator to order the set by
273            * @return the last matching wiki page
274            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
275            * @throws SystemException if a system exception occurred
276            */
277            public static com.liferay.portlet.wiki.model.WikiPage findByUuid_Last(
278                    java.lang.String uuid,
279                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
280                    throws com.liferay.portal.kernel.exception.SystemException,
281                            com.liferay.portlet.wiki.NoSuchPageException {
282                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
283            }
284    
285            /**
286            * Finds the wiki pages before and after the current wiki page in the ordered set where uuid = &#63;.
287            *
288            * <p>
289            * 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.
290            * </p>
291            *
292            * @param pageId the primary key of the current wiki page
293            * @param uuid the uuid to search with
294            * @param orderByComparator the comparator to order the set by
295            * @return the previous, current, and next wiki page
296            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
297            * @throws SystemException if a system exception occurred
298            */
299            public static com.liferay.portlet.wiki.model.WikiPage[] findByUuid_PrevAndNext(
300                    long pageId, java.lang.String uuid,
301                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
302                    throws com.liferay.portal.kernel.exception.SystemException,
303                            com.liferay.portlet.wiki.NoSuchPageException {
304                    return getPersistence()
305                                       .findByUuid_PrevAndNext(pageId, uuid, orderByComparator);
306            }
307    
308            /**
309            * Finds the wiki page where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
310            *
311            * @param uuid the uuid to search with
312            * @param groupId the group id to search with
313            * @return the matching wiki page
314            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
315            * @throws SystemException if a system exception occurred
316            */
317            public static com.liferay.portlet.wiki.model.WikiPage findByUUID_G(
318                    java.lang.String uuid, long groupId)
319                    throws com.liferay.portal.kernel.exception.SystemException,
320                            com.liferay.portlet.wiki.NoSuchPageException {
321                    return getPersistence().findByUUID_G(uuid, groupId);
322            }
323    
324            /**
325            * Finds the wiki page where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
326            *
327            * @param uuid the uuid to search with
328            * @param groupId the group id to search with
329            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
330            * @throws SystemException if a system exception occurred
331            */
332            public static com.liferay.portlet.wiki.model.WikiPage fetchByUUID_G(
333                    java.lang.String uuid, long groupId)
334                    throws com.liferay.portal.kernel.exception.SystemException {
335                    return getPersistence().fetchByUUID_G(uuid, groupId);
336            }
337    
338            /**
339            * Finds the wiki page where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
340            *
341            * @param uuid the uuid to search with
342            * @param groupId the group id to search with
343            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
344            * @throws SystemException if a system exception occurred
345            */
346            public static com.liferay.portlet.wiki.model.WikiPage fetchByUUID_G(
347                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
348                    throws com.liferay.portal.kernel.exception.SystemException {
349                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
350            }
351    
352            /**
353            * Finds all the wiki pages where nodeId = &#63;.
354            *
355            * @param nodeId the node id to search with
356            * @return the matching wiki pages
357            * @throws SystemException if a system exception occurred
358            */
359            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByNodeId(
360                    long nodeId) throws com.liferay.portal.kernel.exception.SystemException {
361                    return getPersistence().findByNodeId(nodeId);
362            }
363    
364            /**
365            * Finds a range of all the wiki pages where nodeId = &#63;.
366            *
367            * <p>
368            * 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.
369            * </p>
370            *
371            * @param nodeId the node id to search with
372            * @param start the lower bound of the range of wiki pages to return
373            * @param end the upper bound of the range of wiki pages to return (not inclusive)
374            * @return the range of matching wiki pages
375            * @throws SystemException if a system exception occurred
376            */
377            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByNodeId(
378                    long nodeId, int start, int end)
379                    throws com.liferay.portal.kernel.exception.SystemException {
380                    return getPersistence().findByNodeId(nodeId, start, end);
381            }
382    
383            /**
384            * Finds an ordered range of all the wiki pages where nodeId = &#63;.
385            *
386            * <p>
387            * 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.
388            * </p>
389            *
390            * @param nodeId the node id to search with
391            * @param start the lower bound of the range of wiki pages to return
392            * @param end the upper bound of the range of wiki pages to return (not inclusive)
393            * @param orderByComparator the comparator to order the results by
394            * @return the ordered range of matching wiki pages
395            * @throws SystemException if a system exception occurred
396            */
397            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByNodeId(
398                    long nodeId, int start, int end,
399                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
400                    throws com.liferay.portal.kernel.exception.SystemException {
401                    return getPersistence()
402                                       .findByNodeId(nodeId, start, end, orderByComparator);
403            }
404    
405            /**
406            * Finds the first wiki page in the ordered set where nodeId = &#63;.
407            *
408            * <p>
409            * 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.
410            * </p>
411            *
412            * @param nodeId the node id to search with
413            * @param orderByComparator the comparator to order the set by
414            * @return the first matching wiki page
415            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
416            * @throws SystemException if a system exception occurred
417            */
418            public static com.liferay.portlet.wiki.model.WikiPage findByNodeId_First(
419                    long nodeId,
420                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
421                    throws com.liferay.portal.kernel.exception.SystemException,
422                            com.liferay.portlet.wiki.NoSuchPageException {
423                    return getPersistence().findByNodeId_First(nodeId, orderByComparator);
424            }
425    
426            /**
427            * Finds the last wiki page in the ordered set where nodeId = &#63;.
428            *
429            * <p>
430            * 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.
431            * </p>
432            *
433            * @param nodeId the node id to search with
434            * @param orderByComparator the comparator to order the set by
435            * @return the last matching wiki page
436            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
437            * @throws SystemException if a system exception occurred
438            */
439            public static com.liferay.portlet.wiki.model.WikiPage findByNodeId_Last(
440                    long nodeId,
441                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
442                    throws com.liferay.portal.kernel.exception.SystemException,
443                            com.liferay.portlet.wiki.NoSuchPageException {
444                    return getPersistence().findByNodeId_Last(nodeId, orderByComparator);
445            }
446    
447            /**
448            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63;.
449            *
450            * <p>
451            * 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.
452            * </p>
453            *
454            * @param pageId the primary key of the current wiki page
455            * @param nodeId the node id to search with
456            * @param orderByComparator the comparator to order the set by
457            * @return the previous, current, and next wiki page
458            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
459            * @throws SystemException if a system exception occurred
460            */
461            public static com.liferay.portlet.wiki.model.WikiPage[] findByNodeId_PrevAndNext(
462                    long pageId, long nodeId,
463                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
464                    throws com.liferay.portal.kernel.exception.SystemException,
465                            com.liferay.portlet.wiki.NoSuchPageException {
466                    return getPersistence()
467                                       .findByNodeId_PrevAndNext(pageId, nodeId, orderByComparator);
468            }
469    
470            /**
471            * Finds all the wiki pages where format = &#63;.
472            *
473            * @param format the format to search with
474            * @return the matching wiki pages
475            * @throws SystemException if a system exception occurred
476            */
477            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByFormat(
478                    java.lang.String format)
479                    throws com.liferay.portal.kernel.exception.SystemException {
480                    return getPersistence().findByFormat(format);
481            }
482    
483            /**
484            * Finds a range of all the wiki pages where format = &#63;.
485            *
486            * <p>
487            * 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.
488            * </p>
489            *
490            * @param format the format to search with
491            * @param start the lower bound of the range of wiki pages to return
492            * @param end the upper bound of the range of wiki pages to return (not inclusive)
493            * @return the range of matching wiki pages
494            * @throws SystemException if a system exception occurred
495            */
496            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByFormat(
497                    java.lang.String format, int start, int end)
498                    throws com.liferay.portal.kernel.exception.SystemException {
499                    return getPersistence().findByFormat(format, start, end);
500            }
501    
502            /**
503            * Finds an ordered range of all the wiki pages where format = &#63;.
504            *
505            * <p>
506            * 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.
507            * </p>
508            *
509            * @param format the format to search with
510            * @param start the lower bound of the range of wiki pages to return
511            * @param end the upper bound of the range of wiki pages to return (not inclusive)
512            * @param orderByComparator the comparator to order the results by
513            * @return the ordered range of matching wiki pages
514            * @throws SystemException if a system exception occurred
515            */
516            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByFormat(
517                    java.lang.String format, int start, int end,
518                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
519                    throws com.liferay.portal.kernel.exception.SystemException {
520                    return getPersistence()
521                                       .findByFormat(format, start, end, orderByComparator);
522            }
523    
524            /**
525            * Finds the first wiki page in the ordered set where format = &#63;.
526            *
527            * <p>
528            * 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.
529            * </p>
530            *
531            * @param format the format to search with
532            * @param orderByComparator the comparator to order the set by
533            * @return the first matching wiki page
534            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
535            * @throws SystemException if a system exception occurred
536            */
537            public static com.liferay.portlet.wiki.model.WikiPage findByFormat_First(
538                    java.lang.String format,
539                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
540                    throws com.liferay.portal.kernel.exception.SystemException,
541                            com.liferay.portlet.wiki.NoSuchPageException {
542                    return getPersistence().findByFormat_First(format, orderByComparator);
543            }
544    
545            /**
546            * Finds the last wiki page in the ordered set where format = &#63;.
547            *
548            * <p>
549            * 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.
550            * </p>
551            *
552            * @param format the format to search with
553            * @param orderByComparator the comparator to order the set by
554            * @return the last matching wiki page
555            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
556            * @throws SystemException if a system exception occurred
557            */
558            public static com.liferay.portlet.wiki.model.WikiPage findByFormat_Last(
559                    java.lang.String format,
560                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
561                    throws com.liferay.portal.kernel.exception.SystemException,
562                            com.liferay.portlet.wiki.NoSuchPageException {
563                    return getPersistence().findByFormat_Last(format, orderByComparator);
564            }
565    
566            /**
567            * Finds the wiki pages before and after the current wiki page in the ordered set where format = &#63;.
568            *
569            * <p>
570            * 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.
571            * </p>
572            *
573            * @param pageId the primary key of the current wiki page
574            * @param format the format to search with
575            * @param orderByComparator the comparator to order the set by
576            * @return the previous, current, and next wiki page
577            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
578            * @throws SystemException if a system exception occurred
579            */
580            public static com.liferay.portlet.wiki.model.WikiPage[] findByFormat_PrevAndNext(
581                    long pageId, java.lang.String format,
582                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
583                    throws com.liferay.portal.kernel.exception.SystemException,
584                            com.liferay.portlet.wiki.NoSuchPageException {
585                    return getPersistence()
586                                       .findByFormat_PrevAndNext(pageId, format, orderByComparator);
587            }
588    
589            /**
590            * Finds all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
591            *
592            * @param resourcePrimKey the resource prim key to search with
593            * @param nodeId the node id to search with
594            * @return the matching wiki pages
595            * @throws SystemException if a system exception occurred
596            */
597            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N(
598                    long resourcePrimKey, long nodeId)
599                    throws com.liferay.portal.kernel.exception.SystemException {
600                    return getPersistence().findByR_N(resourcePrimKey, nodeId);
601            }
602    
603            /**
604            * Finds a range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
605            *
606            * <p>
607            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
608            * </p>
609            *
610            * @param resourcePrimKey the resource prim key to search with
611            * @param nodeId the node id to search with
612            * @param start the lower bound of the range of wiki pages to return
613            * @param end the upper bound of the range of wiki pages to return (not inclusive)
614            * @return the range of matching wiki pages
615            * @throws SystemException if a system exception occurred
616            */
617            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N(
618                    long resourcePrimKey, long nodeId, int start, int end)
619                    throws com.liferay.portal.kernel.exception.SystemException {
620                    return getPersistence().findByR_N(resourcePrimKey, nodeId, start, end);
621            }
622    
623            /**
624            * Finds an ordered range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
625            *
626            * <p>
627            * 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.
628            * </p>
629            *
630            * @param resourcePrimKey the resource prim key to search with
631            * @param nodeId the node id to search with
632            * @param start the lower bound of the range of wiki pages to return
633            * @param end the upper bound of the range of wiki pages to return (not inclusive)
634            * @param orderByComparator the comparator to order the results by
635            * @return the ordered range of matching wiki pages
636            * @throws SystemException if a system exception occurred
637            */
638            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N(
639                    long resourcePrimKey, long nodeId, int start, int end,
640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
641                    throws com.liferay.portal.kernel.exception.SystemException {
642                    return getPersistence()
643                                       .findByR_N(resourcePrimKey, nodeId, start, end,
644                            orderByComparator);
645            }
646    
647            /**
648            * Finds the first wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63;.
649            *
650            * <p>
651            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
652            * </p>
653            *
654            * @param resourcePrimKey the resource prim key to search with
655            * @param nodeId the node id to search with
656            * @param orderByComparator the comparator to order the set by
657            * @return the first matching wiki page
658            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
659            * @throws SystemException if a system exception occurred
660            */
661            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_First(
662                    long resourcePrimKey, long nodeId,
663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
664                    throws com.liferay.portal.kernel.exception.SystemException,
665                            com.liferay.portlet.wiki.NoSuchPageException {
666                    return getPersistence()
667                                       .findByR_N_First(resourcePrimKey, nodeId, orderByComparator);
668            }
669    
670            /**
671            * Finds the last wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63;.
672            *
673            * <p>
674            * 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.
675            * </p>
676            *
677            * @param resourcePrimKey the resource prim key to search with
678            * @param nodeId the node id to search with
679            * @param orderByComparator the comparator to order the set by
680            * @return the last matching wiki page
681            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
682            * @throws SystemException if a system exception occurred
683            */
684            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_Last(
685                    long resourcePrimKey, long nodeId,
686                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
687                    throws com.liferay.portal.kernel.exception.SystemException,
688                            com.liferay.portlet.wiki.NoSuchPageException {
689                    return getPersistence()
690                                       .findByR_N_Last(resourcePrimKey, nodeId, orderByComparator);
691            }
692    
693            /**
694            * Finds the wiki pages before and after the current wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63;.
695            *
696            * <p>
697            * 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.
698            * </p>
699            *
700            * @param pageId the primary key of the current wiki page
701            * @param resourcePrimKey the resource prim key to search with
702            * @param nodeId the node id to search with
703            * @param orderByComparator the comparator to order the set by
704            * @return the previous, current, and next wiki page
705            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
706            * @throws SystemException if a system exception occurred
707            */
708            public static com.liferay.portlet.wiki.model.WikiPage[] findByR_N_PrevAndNext(
709                    long pageId, long resourcePrimKey, long nodeId,
710                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
711                    throws com.liferay.portal.kernel.exception.SystemException,
712                            com.liferay.portlet.wiki.NoSuchPageException {
713                    return getPersistence()
714                                       .findByR_N_PrevAndNext(pageId, resourcePrimKey, nodeId,
715                            orderByComparator);
716            }
717    
718            /**
719            * Finds all the wiki pages where nodeId = &#63; and title = &#63;.
720            *
721            * @param nodeId the node id to search with
722            * @param title the title to search with
723            * @return the matching wiki pages
724            * @throws SystemException if a system exception occurred
725            */
726            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T(
727                    long nodeId, java.lang.String title)
728                    throws com.liferay.portal.kernel.exception.SystemException {
729                    return getPersistence().findByN_T(nodeId, title);
730            }
731    
732            /**
733            * Finds a range of all the wiki pages where nodeId = &#63; and title = &#63;.
734            *
735            * <p>
736            * 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.
737            * </p>
738            *
739            * @param nodeId the node id to search with
740            * @param title the title to search with
741            * @param start the lower bound of the range of wiki pages to return
742            * @param end the upper bound of the range of wiki pages to return (not inclusive)
743            * @return the range of matching wiki pages
744            * @throws SystemException if a system exception occurred
745            */
746            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T(
747                    long nodeId, java.lang.String title, int start, int end)
748                    throws com.liferay.portal.kernel.exception.SystemException {
749                    return getPersistence().findByN_T(nodeId, title, start, end);
750            }
751    
752            /**
753            * Finds an ordered range of all the wiki pages where nodeId = &#63; and title = &#63;.
754            *
755            * <p>
756            * 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.
757            * </p>
758            *
759            * @param nodeId the node id to search with
760            * @param title the title to search with
761            * @param start the lower bound of the range of wiki pages to return
762            * @param end the upper bound of the range of wiki pages to return (not inclusive)
763            * @param orderByComparator the comparator to order the results by
764            * @return the ordered range of matching wiki pages
765            * @throws SystemException if a system exception occurred
766            */
767            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T(
768                    long nodeId, java.lang.String title, int start, int end,
769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
770                    throws com.liferay.portal.kernel.exception.SystemException {
771                    return getPersistence()
772                                       .findByN_T(nodeId, title, start, end, orderByComparator);
773            }
774    
775            /**
776            * Finds the first wiki page in the ordered set where nodeId = &#63; and title = &#63;.
777            *
778            * <p>
779            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
780            * </p>
781            *
782            * @param nodeId the node id to search with
783            * @param title the title to search with
784            * @param orderByComparator the comparator to order the set by
785            * @return the first matching wiki page
786            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
787            * @throws SystemException if a system exception occurred
788            */
789            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_First(
790                    long nodeId, java.lang.String title,
791                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
792                    throws com.liferay.portal.kernel.exception.SystemException,
793                            com.liferay.portlet.wiki.NoSuchPageException {
794                    return getPersistence().findByN_T_First(nodeId, title, orderByComparator);
795            }
796    
797            /**
798            * Finds the last wiki page in the ordered set where nodeId = &#63; and title = &#63;.
799            *
800            * <p>
801            * 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.
802            * </p>
803            *
804            * @param nodeId the node id to search with
805            * @param title the title to search with
806            * @param orderByComparator the comparator to order the set by
807            * @return the last matching wiki page
808            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
809            * @throws SystemException if a system exception occurred
810            */
811            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_Last(
812                    long nodeId, java.lang.String title,
813                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
814                    throws com.liferay.portal.kernel.exception.SystemException,
815                            com.liferay.portlet.wiki.NoSuchPageException {
816                    return getPersistence().findByN_T_Last(nodeId, title, orderByComparator);
817            }
818    
819            /**
820            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and title = &#63;.
821            *
822            * <p>
823            * 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.
824            * </p>
825            *
826            * @param pageId the primary key of the current wiki page
827            * @param nodeId the node id to search with
828            * @param title the title to search with
829            * @param orderByComparator the comparator to order the set by
830            * @return the previous, current, and next wiki page
831            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
832            * @throws SystemException if a system exception occurred
833            */
834            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_T_PrevAndNext(
835                    long pageId, long nodeId, java.lang.String title,
836                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
837                    throws com.liferay.portal.kernel.exception.SystemException,
838                            com.liferay.portlet.wiki.NoSuchPageException {
839                    return getPersistence()
840                                       .findByN_T_PrevAndNext(pageId, nodeId, title,
841                            orderByComparator);
842            }
843    
844            /**
845            * Finds all the wiki pages where nodeId = &#63; and head = &#63;.
846            *
847            * @param nodeId the node id to search with
848            * @param head the head to search with
849            * @return the matching wiki pages
850            * @throws SystemException if a system exception occurred
851            */
852            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H(
853                    long nodeId, boolean head)
854                    throws com.liferay.portal.kernel.exception.SystemException {
855                    return getPersistence().findByN_H(nodeId, head);
856            }
857    
858            /**
859            * Finds a range of all the wiki pages where nodeId = &#63; and head = &#63;.
860            *
861            * <p>
862            * 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.
863            * </p>
864            *
865            * @param nodeId the node id to search with
866            * @param head the head to search with
867            * @param start the lower bound of the range of wiki pages to return
868            * @param end the upper bound of the range of wiki pages to return (not inclusive)
869            * @return the range of matching wiki pages
870            * @throws SystemException if a system exception occurred
871            */
872            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H(
873                    long nodeId, boolean head, int start, int end)
874                    throws com.liferay.portal.kernel.exception.SystemException {
875                    return getPersistence().findByN_H(nodeId, head, start, end);
876            }
877    
878            /**
879            * Finds an ordered range of all the wiki pages where nodeId = &#63; and head = &#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 nodeId the node id to search with
886            * @param head the head to search with
887            * @param start the lower bound of the range of wiki pages to return
888            * @param end the upper bound of the range of wiki pages to return (not inclusive)
889            * @param orderByComparator the comparator to order the results by
890            * @return the ordered range of matching wiki pages
891            * @throws SystemException if a system exception occurred
892            */
893            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H(
894                    long nodeId, boolean head, int start, int end,
895                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
896                    throws com.liferay.portal.kernel.exception.SystemException {
897                    return getPersistence()
898                                       .findByN_H(nodeId, head, start, end, orderByComparator);
899            }
900    
901            /**
902            * Finds the first wiki page in the ordered set where nodeId = &#63; and head = &#63;.
903            *
904            * <p>
905            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
906            * </p>
907            *
908            * @param nodeId the node id to search with
909            * @param head the head to search with
910            * @param orderByComparator the comparator to order the set by
911            * @return the first matching wiki page
912            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
913            * @throws SystemException if a system exception occurred
914            */
915            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_First(
916                    long nodeId, boolean head,
917                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
918                    throws com.liferay.portal.kernel.exception.SystemException,
919                            com.liferay.portlet.wiki.NoSuchPageException {
920                    return getPersistence().findByN_H_First(nodeId, head, orderByComparator);
921            }
922    
923            /**
924            * Finds the last wiki page in the ordered set where nodeId = &#63; and head = &#63;.
925            *
926            * <p>
927            * 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.
928            * </p>
929            *
930            * @param nodeId the node id to search with
931            * @param head the head to search with
932            * @param orderByComparator the comparator to order the set by
933            * @return the last matching wiki page
934            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
935            * @throws SystemException if a system exception occurred
936            */
937            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_Last(
938                    long nodeId, boolean head,
939                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
940                    throws com.liferay.portal.kernel.exception.SystemException,
941                            com.liferay.portlet.wiki.NoSuchPageException {
942                    return getPersistence().findByN_H_Last(nodeId, head, orderByComparator);
943            }
944    
945            /**
946            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63;.
947            *
948            * <p>
949            * 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.
950            * </p>
951            *
952            * @param pageId the primary key of the current wiki page
953            * @param nodeId the node id to search with
954            * @param head the head to search with
955            * @param orderByComparator the comparator to order the set by
956            * @return the previous, current, and next wiki page
957            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
958            * @throws SystemException if a system exception occurred
959            */
960            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_PrevAndNext(
961                    long pageId, long nodeId, boolean head,
962                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
963                    throws com.liferay.portal.kernel.exception.SystemException,
964                            com.liferay.portlet.wiki.NoSuchPageException {
965                    return getPersistence()
966                                       .findByN_H_PrevAndNext(pageId, nodeId, head,
967                            orderByComparator);
968            }
969    
970            /**
971            * Finds all the wiki pages where nodeId = &#63; and parentTitle = &#63;.
972            *
973            * @param nodeId the node id to search with
974            * @param parentTitle the parent title to search with
975            * @return the matching wiki pages
976            * @throws SystemException if a system exception occurred
977            */
978            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_P(
979                    long nodeId, java.lang.String parentTitle)
980                    throws com.liferay.portal.kernel.exception.SystemException {
981                    return getPersistence().findByN_P(nodeId, parentTitle);
982            }
983    
984            /**
985            * Finds a range of all the wiki pages where nodeId = &#63; and parentTitle = &#63;.
986            *
987            * <p>
988            * 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.
989            * </p>
990            *
991            * @param nodeId the node id to search with
992            * @param parentTitle the parent title to search with
993            * @param start the lower bound of the range of wiki pages to return
994            * @param end the upper bound of the range of wiki pages to return (not inclusive)
995            * @return the range of matching wiki pages
996            * @throws SystemException if a system exception occurred
997            */
998            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_P(
999                    long nodeId, java.lang.String parentTitle, int start, int end)
1000                    throws com.liferay.portal.kernel.exception.SystemException {
1001                    return getPersistence().findByN_P(nodeId, parentTitle, start, end);
1002            }
1003    
1004            /**
1005            * Finds an ordered range of all the wiki pages where nodeId = &#63; and parentTitle = &#63;.
1006            *
1007            * <p>
1008            * 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.
1009            * </p>
1010            *
1011            * @param nodeId the node id to search with
1012            * @param parentTitle the parent title to search with
1013            * @param start the lower bound of the range of wiki pages to return
1014            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1015            * @param orderByComparator the comparator to order the results by
1016            * @return the ordered range of matching wiki pages
1017            * @throws SystemException if a system exception occurred
1018            */
1019            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_P(
1020                    long nodeId, java.lang.String parentTitle, int start, int end,
1021                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1022                    throws com.liferay.portal.kernel.exception.SystemException {
1023                    return getPersistence()
1024                                       .findByN_P(nodeId, parentTitle, start, end, orderByComparator);
1025            }
1026    
1027            /**
1028            * Finds the first wiki page in the ordered set where nodeId = &#63; and parentTitle = &#63;.
1029            *
1030            * <p>
1031            * 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.
1032            * </p>
1033            *
1034            * @param nodeId the node id to search with
1035            * @param parentTitle the parent title to search with
1036            * @param orderByComparator the comparator to order the set by
1037            * @return the first matching wiki page
1038            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1039            * @throws SystemException if a system exception occurred
1040            */
1041            public static com.liferay.portlet.wiki.model.WikiPage findByN_P_First(
1042                    long nodeId, java.lang.String parentTitle,
1043                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1044                    throws com.liferay.portal.kernel.exception.SystemException,
1045                            com.liferay.portlet.wiki.NoSuchPageException {
1046                    return getPersistence()
1047                                       .findByN_P_First(nodeId, parentTitle, orderByComparator);
1048            }
1049    
1050            /**
1051            * Finds the last wiki page in the ordered set where nodeId = &#63; and parentTitle = &#63;.
1052            *
1053            * <p>
1054            * 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.
1055            * </p>
1056            *
1057            * @param nodeId the node id to search with
1058            * @param parentTitle the parent title to search with
1059            * @param orderByComparator the comparator to order the set by
1060            * @return the last matching wiki page
1061            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1062            * @throws SystemException if a system exception occurred
1063            */
1064            public static com.liferay.portlet.wiki.model.WikiPage findByN_P_Last(
1065                    long nodeId, java.lang.String parentTitle,
1066                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1067                    throws com.liferay.portal.kernel.exception.SystemException,
1068                            com.liferay.portlet.wiki.NoSuchPageException {
1069                    return getPersistence()
1070                                       .findByN_P_Last(nodeId, parentTitle, orderByComparator);
1071            }
1072    
1073            /**
1074            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and parentTitle = &#63;.
1075            *
1076            * <p>
1077            * 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.
1078            * </p>
1079            *
1080            * @param pageId the primary key of the current wiki page
1081            * @param nodeId the node id to search with
1082            * @param parentTitle the parent title to search with
1083            * @param orderByComparator the comparator to order the set by
1084            * @return the previous, current, and next wiki page
1085            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1086            * @throws SystemException if a system exception occurred
1087            */
1088            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_P_PrevAndNext(
1089                    long pageId, long nodeId, java.lang.String parentTitle,
1090                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1091                    throws com.liferay.portal.kernel.exception.SystemException,
1092                            com.liferay.portlet.wiki.NoSuchPageException {
1093                    return getPersistence()
1094                                       .findByN_P_PrevAndNext(pageId, nodeId, parentTitle,
1095                            orderByComparator);
1096            }
1097    
1098            /**
1099            * Finds all the wiki pages where nodeId = &#63; and redirectTitle = &#63;.
1100            *
1101            * @param nodeId the node id to search with
1102            * @param redirectTitle the redirect title to search with
1103            * @return the matching wiki pages
1104            * @throws SystemException if a system exception occurred
1105            */
1106            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_R(
1107                    long nodeId, java.lang.String redirectTitle)
1108                    throws com.liferay.portal.kernel.exception.SystemException {
1109                    return getPersistence().findByN_R(nodeId, redirectTitle);
1110            }
1111    
1112            /**
1113            * Finds a range of all the wiki pages where nodeId = &#63; and redirectTitle = &#63;.
1114            *
1115            * <p>
1116            * 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.
1117            * </p>
1118            *
1119            * @param nodeId the node id to search with
1120            * @param redirectTitle the redirect title to search with
1121            * @param start the lower bound of the range of wiki pages to return
1122            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1123            * @return the range of matching wiki pages
1124            * @throws SystemException if a system exception occurred
1125            */
1126            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_R(
1127                    long nodeId, java.lang.String redirectTitle, int start, int end)
1128                    throws com.liferay.portal.kernel.exception.SystemException {
1129                    return getPersistence().findByN_R(nodeId, redirectTitle, start, end);
1130            }
1131    
1132            /**
1133            * Finds an ordered range of all the wiki pages where nodeId = &#63; and redirectTitle = &#63;.
1134            *
1135            * <p>
1136            * 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.
1137            * </p>
1138            *
1139            * @param nodeId the node id to search with
1140            * @param redirectTitle the redirect title to search with
1141            * @param start the lower bound of the range of wiki pages to return
1142            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1143            * @param orderByComparator the comparator to order the results by
1144            * @return the ordered range of matching wiki pages
1145            * @throws SystemException if a system exception occurred
1146            */
1147            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_R(
1148                    long nodeId, java.lang.String redirectTitle, int start, int end,
1149                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1150                    throws com.liferay.portal.kernel.exception.SystemException {
1151                    return getPersistence()
1152                                       .findByN_R(nodeId, redirectTitle, start, end,
1153                            orderByComparator);
1154            }
1155    
1156            /**
1157            * Finds the first wiki page in the ordered set where nodeId = &#63; and redirectTitle = &#63;.
1158            *
1159            * <p>
1160            * 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.
1161            * </p>
1162            *
1163            * @param nodeId the node id to search with
1164            * @param redirectTitle the redirect title to search with
1165            * @param orderByComparator the comparator to order the set by
1166            * @return the first matching wiki page
1167            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1168            * @throws SystemException if a system exception occurred
1169            */
1170            public static com.liferay.portlet.wiki.model.WikiPage findByN_R_First(
1171                    long nodeId, java.lang.String redirectTitle,
1172                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1173                    throws com.liferay.portal.kernel.exception.SystemException,
1174                            com.liferay.portlet.wiki.NoSuchPageException {
1175                    return getPersistence()
1176                                       .findByN_R_First(nodeId, redirectTitle, orderByComparator);
1177            }
1178    
1179            /**
1180            * Finds the last wiki page in the ordered set where nodeId = &#63; and redirectTitle = &#63;.
1181            *
1182            * <p>
1183            * 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.
1184            * </p>
1185            *
1186            * @param nodeId the node id to search with
1187            * @param redirectTitle the redirect title to search with
1188            * @param orderByComparator the comparator to order the set by
1189            * @return the last matching wiki page
1190            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1191            * @throws SystemException if a system exception occurred
1192            */
1193            public static com.liferay.portlet.wiki.model.WikiPage findByN_R_Last(
1194                    long nodeId, java.lang.String redirectTitle,
1195                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1196                    throws com.liferay.portal.kernel.exception.SystemException,
1197                            com.liferay.portlet.wiki.NoSuchPageException {
1198                    return getPersistence()
1199                                       .findByN_R_Last(nodeId, redirectTitle, orderByComparator);
1200            }
1201    
1202            /**
1203            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and redirectTitle = &#63;.
1204            *
1205            * <p>
1206            * 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.
1207            * </p>
1208            *
1209            * @param pageId the primary key of the current wiki page
1210            * @param nodeId the node id to search with
1211            * @param redirectTitle the redirect title to search with
1212            * @param orderByComparator the comparator to order the set by
1213            * @return the previous, current, and next wiki page
1214            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1215            * @throws SystemException if a system exception occurred
1216            */
1217            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_R_PrevAndNext(
1218                    long pageId, long nodeId, java.lang.String redirectTitle,
1219                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1220                    throws com.liferay.portal.kernel.exception.SystemException,
1221                            com.liferay.portlet.wiki.NoSuchPageException {
1222                    return getPersistence()
1223                                       .findByN_R_PrevAndNext(pageId, nodeId, redirectTitle,
1224                            orderByComparator);
1225            }
1226    
1227            /**
1228            * Finds all the wiki pages where nodeId = &#63; and status = &#63;.
1229            *
1230            * @param nodeId the node id to search with
1231            * @param status the status to search with
1232            * @return the matching wiki pages
1233            * @throws SystemException if a system exception occurred
1234            */
1235            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_S(
1236                    long nodeId, int status)
1237                    throws com.liferay.portal.kernel.exception.SystemException {
1238                    return getPersistence().findByN_S(nodeId, status);
1239            }
1240    
1241            /**
1242            * Finds a range of all the wiki pages where nodeId = &#63; and status = &#63;.
1243            *
1244            * <p>
1245            * 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.
1246            * </p>
1247            *
1248            * @param nodeId the node id to search with
1249            * @param status the status to search with
1250            * @param start the lower bound of the range of wiki pages to return
1251            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1252            * @return the range of matching wiki pages
1253            * @throws SystemException if a system exception occurred
1254            */
1255            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_S(
1256                    long nodeId, int status, int start, int end)
1257                    throws com.liferay.portal.kernel.exception.SystemException {
1258                    return getPersistence().findByN_S(nodeId, status, start, end);
1259            }
1260    
1261            /**
1262            * Finds an ordered range of all the wiki pages where nodeId = &#63; and status = &#63;.
1263            *
1264            * <p>
1265            * 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.
1266            * </p>
1267            *
1268            * @param nodeId the node id to search with
1269            * @param status the status to search with
1270            * @param start the lower bound of the range of wiki pages to return
1271            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1272            * @param orderByComparator the comparator to order the results by
1273            * @return the ordered range of matching wiki pages
1274            * @throws SystemException if a system exception occurred
1275            */
1276            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_S(
1277                    long nodeId, int status, int start, int end,
1278                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1279                    throws com.liferay.portal.kernel.exception.SystemException {
1280                    return getPersistence()
1281                                       .findByN_S(nodeId, status, start, end, orderByComparator);
1282            }
1283    
1284            /**
1285            * Finds the first wiki page in the ordered set where nodeId = &#63; and status = &#63;.
1286            *
1287            * <p>
1288            * 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.
1289            * </p>
1290            *
1291            * @param nodeId the node id to search with
1292            * @param status the status to search with
1293            * @param orderByComparator the comparator to order the set by
1294            * @return the first matching wiki page
1295            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1296            * @throws SystemException if a system exception occurred
1297            */
1298            public static com.liferay.portlet.wiki.model.WikiPage findByN_S_First(
1299                    long nodeId, int status,
1300                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1301                    throws com.liferay.portal.kernel.exception.SystemException,
1302                            com.liferay.portlet.wiki.NoSuchPageException {
1303                    return getPersistence()
1304                                       .findByN_S_First(nodeId, status, orderByComparator);
1305            }
1306    
1307            /**
1308            * Finds the last wiki page in the ordered set where nodeId = &#63; and status = &#63;.
1309            *
1310            * <p>
1311            * 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.
1312            * </p>
1313            *
1314            * @param nodeId the node id to search with
1315            * @param status the status to search with
1316            * @param orderByComparator the comparator to order the set by
1317            * @return the last matching wiki page
1318            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1319            * @throws SystemException if a system exception occurred
1320            */
1321            public static com.liferay.portlet.wiki.model.WikiPage findByN_S_Last(
1322                    long nodeId, int status,
1323                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1324                    throws com.liferay.portal.kernel.exception.SystemException,
1325                            com.liferay.portlet.wiki.NoSuchPageException {
1326                    return getPersistence().findByN_S_Last(nodeId, status, orderByComparator);
1327            }
1328    
1329            /**
1330            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and status = &#63;.
1331            *
1332            * <p>
1333            * 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.
1334            * </p>
1335            *
1336            * @param pageId the primary key of the current wiki page
1337            * @param nodeId the node id to search with
1338            * @param status the status to search with
1339            * @param orderByComparator the comparator to order the set by
1340            * @return the previous, current, and next wiki page
1341            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1342            * @throws SystemException if a system exception occurred
1343            */
1344            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_S_PrevAndNext(
1345                    long pageId, long nodeId, int status,
1346                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1347                    throws com.liferay.portal.kernel.exception.SystemException,
1348                            com.liferay.portlet.wiki.NoSuchPageException {
1349                    return getPersistence()
1350                                       .findByN_S_PrevAndNext(pageId, nodeId, status,
1351                            orderByComparator);
1352            }
1353    
1354            /**
1355            * Finds the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
1356            *
1357            * @param resourcePrimKey the resource prim key to search with
1358            * @param nodeId the node id to search with
1359            * @param version the version to search with
1360            * @return the matching wiki page
1361            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1362            * @throws SystemException if a system exception occurred
1363            */
1364            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_V(
1365                    long resourcePrimKey, long nodeId, double version)
1366                    throws com.liferay.portal.kernel.exception.SystemException,
1367                            com.liferay.portlet.wiki.NoSuchPageException {
1368                    return getPersistence().findByR_N_V(resourcePrimKey, nodeId, version);
1369            }
1370    
1371            /**
1372            * Finds the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1373            *
1374            * @param resourcePrimKey the resource prim key to search with
1375            * @param nodeId the node id to search with
1376            * @param version the version to search with
1377            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1378            * @throws SystemException if a system exception occurred
1379            */
1380            public static com.liferay.portlet.wiki.model.WikiPage fetchByR_N_V(
1381                    long resourcePrimKey, long nodeId, double version)
1382                    throws com.liferay.portal.kernel.exception.SystemException {
1383                    return getPersistence().fetchByR_N_V(resourcePrimKey, nodeId, version);
1384            }
1385    
1386            /**
1387            * Finds the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1388            *
1389            * @param resourcePrimKey the resource prim key to search with
1390            * @param nodeId the node id to search with
1391            * @param version the version to search with
1392            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1393            * @throws SystemException if a system exception occurred
1394            */
1395            public static com.liferay.portlet.wiki.model.WikiPage fetchByR_N_V(
1396                    long resourcePrimKey, long nodeId, double version,
1397                    boolean retrieveFromCache)
1398                    throws com.liferay.portal.kernel.exception.SystemException {
1399                    return getPersistence()
1400                                       .fetchByR_N_V(resourcePrimKey, nodeId, version,
1401                            retrieveFromCache);
1402            }
1403    
1404            /**
1405            * Finds all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1406            *
1407            * @param resourcePrimKey the resource prim key to search with
1408            * @param nodeId the node id to search with
1409            * @param status the status to search with
1410            * @return the matching wiki pages
1411            * @throws SystemException if a system exception occurred
1412            */
1413            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N_S(
1414                    long resourcePrimKey, long nodeId, int status)
1415                    throws com.liferay.portal.kernel.exception.SystemException {
1416                    return getPersistence().findByR_N_S(resourcePrimKey, nodeId, status);
1417            }
1418    
1419            /**
1420            * Finds a range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1421            *
1422            * <p>
1423            * 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.
1424            * </p>
1425            *
1426            * @param resourcePrimKey the resource prim key to search with
1427            * @param nodeId the node id to search with
1428            * @param status the status to search with
1429            * @param start the lower bound of the range of wiki pages to return
1430            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1431            * @return the range of matching wiki pages
1432            * @throws SystemException if a system exception occurred
1433            */
1434            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N_S(
1435                    long resourcePrimKey, long nodeId, int status, int start, int end)
1436                    throws com.liferay.portal.kernel.exception.SystemException {
1437                    return getPersistence()
1438                                       .findByR_N_S(resourcePrimKey, nodeId, status, start, end);
1439            }
1440    
1441            /**
1442            * Finds an ordered range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1443            *
1444            * <p>
1445            * 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.
1446            * </p>
1447            *
1448            * @param resourcePrimKey the resource prim key to search with
1449            * @param nodeId the node id to search with
1450            * @param status the status to search with
1451            * @param start the lower bound of the range of wiki pages to return
1452            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1453            * @param orderByComparator the comparator to order the results by
1454            * @return the ordered range of matching wiki pages
1455            * @throws SystemException if a system exception occurred
1456            */
1457            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N_S(
1458                    long resourcePrimKey, long nodeId, int status, int start, int end,
1459                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1460                    throws com.liferay.portal.kernel.exception.SystemException {
1461                    return getPersistence()
1462                                       .findByR_N_S(resourcePrimKey, nodeId, status, start, end,
1463                            orderByComparator);
1464            }
1465    
1466            /**
1467            * Finds the first wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1468            *
1469            * <p>
1470            * 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.
1471            * </p>
1472            *
1473            * @param resourcePrimKey the resource prim key to search with
1474            * @param nodeId the node id to search with
1475            * @param status the status to search with
1476            * @param orderByComparator the comparator to order the set by
1477            * @return the first matching wiki page
1478            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1479            * @throws SystemException if a system exception occurred
1480            */
1481            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_S_First(
1482                    long resourcePrimKey, long nodeId, int status,
1483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1484                    throws com.liferay.portal.kernel.exception.SystemException,
1485                            com.liferay.portlet.wiki.NoSuchPageException {
1486                    return getPersistence()
1487                                       .findByR_N_S_First(resourcePrimKey, nodeId, status,
1488                            orderByComparator);
1489            }
1490    
1491            /**
1492            * Finds the last wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1493            *
1494            * <p>
1495            * 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.
1496            * </p>
1497            *
1498            * @param resourcePrimKey the resource prim key to search with
1499            * @param nodeId the node id to search with
1500            * @param status the status to search with
1501            * @param orderByComparator the comparator to order the set by
1502            * @return the last matching wiki page
1503            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1504            * @throws SystemException if a system exception occurred
1505            */
1506            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_S_Last(
1507                    long resourcePrimKey, long nodeId, int status,
1508                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1509                    throws com.liferay.portal.kernel.exception.SystemException,
1510                            com.liferay.portlet.wiki.NoSuchPageException {
1511                    return getPersistence()
1512                                       .findByR_N_S_Last(resourcePrimKey, nodeId, status,
1513                            orderByComparator);
1514            }
1515    
1516            /**
1517            * Finds the wiki pages before and after the current wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1518            *
1519            * <p>
1520            * 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.
1521            * </p>
1522            *
1523            * @param pageId the primary key of the current wiki page
1524            * @param resourcePrimKey the resource prim key to search with
1525            * @param nodeId the node id to search with
1526            * @param status the status to search with
1527            * @param orderByComparator the comparator to order the set by
1528            * @return the previous, current, and next wiki page
1529            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1530            * @throws SystemException if a system exception occurred
1531            */
1532            public static com.liferay.portlet.wiki.model.WikiPage[] findByR_N_S_PrevAndNext(
1533                    long pageId, long resourcePrimKey, long nodeId, int status,
1534                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1535                    throws com.liferay.portal.kernel.exception.SystemException,
1536                            com.liferay.portlet.wiki.NoSuchPageException {
1537                    return getPersistence()
1538                                       .findByR_N_S_PrevAndNext(pageId, resourcePrimKey, nodeId,
1539                            status, orderByComparator);
1540            }
1541    
1542            /**
1543            * Finds all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
1544            *
1545            * @param userId the user id to search with
1546            * @param nodeId the node id to search with
1547            * @param status the status to search with
1548            * @return the matching wiki pages
1549            * @throws SystemException if a system exception occurred
1550            */
1551            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByU_N_S(
1552                    long userId, long nodeId, int status)
1553                    throws com.liferay.portal.kernel.exception.SystemException {
1554                    return getPersistence().findByU_N_S(userId, nodeId, status);
1555            }
1556    
1557            /**
1558            * Finds a range of all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
1559            *
1560            * <p>
1561            * 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.
1562            * </p>
1563            *
1564            * @param userId the user id to search with
1565            * @param nodeId the node id to search with
1566            * @param status the status to search with
1567            * @param start the lower bound of the range of wiki pages to return
1568            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1569            * @return the range of matching wiki pages
1570            * @throws SystemException if a system exception occurred
1571            */
1572            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByU_N_S(
1573                    long userId, long nodeId, int status, int start, int end)
1574                    throws com.liferay.portal.kernel.exception.SystemException {
1575                    return getPersistence().findByU_N_S(userId, nodeId, status, start, end);
1576            }
1577    
1578            /**
1579            * Finds an ordered range of all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
1580            *
1581            * <p>
1582            * 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.
1583            * </p>
1584            *
1585            * @param userId the user id to search with
1586            * @param nodeId the node id to search with
1587            * @param status the status to search with
1588            * @param start the lower bound of the range of wiki pages to return
1589            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1590            * @param orderByComparator the comparator to order the results by
1591            * @return the ordered range of matching wiki pages
1592            * @throws SystemException if a system exception occurred
1593            */
1594            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByU_N_S(
1595                    long userId, long nodeId, int status, int start, int end,
1596                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1597                    throws com.liferay.portal.kernel.exception.SystemException {
1598                    return getPersistence()
1599                                       .findByU_N_S(userId, nodeId, status, start, end,
1600                            orderByComparator);
1601            }
1602    
1603            /**
1604            * Finds the first wiki page in the ordered set where userId = &#63; and nodeId = &#63; and status = &#63;.
1605            *
1606            * <p>
1607            * 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.
1608            * </p>
1609            *
1610            * @param userId the user id to search with
1611            * @param nodeId the node id to search with
1612            * @param status the status to search with
1613            * @param orderByComparator the comparator to order the set by
1614            * @return the first matching wiki page
1615            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1616            * @throws SystemException if a system exception occurred
1617            */
1618            public static com.liferay.portlet.wiki.model.WikiPage findByU_N_S_First(
1619                    long userId, long nodeId, int status,
1620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1621                    throws com.liferay.portal.kernel.exception.SystemException,
1622                            com.liferay.portlet.wiki.NoSuchPageException {
1623                    return getPersistence()
1624                                       .findByU_N_S_First(userId, nodeId, status, orderByComparator);
1625            }
1626    
1627            /**
1628            * Finds the last wiki page in the ordered set where userId = &#63; and nodeId = &#63; and status = &#63;.
1629            *
1630            * <p>
1631            * 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.
1632            * </p>
1633            *
1634            * @param userId the user id to search with
1635            * @param nodeId the node id to search with
1636            * @param status the status to search with
1637            * @param orderByComparator the comparator to order the set by
1638            * @return the last matching wiki page
1639            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1640            * @throws SystemException if a system exception occurred
1641            */
1642            public static com.liferay.portlet.wiki.model.WikiPage findByU_N_S_Last(
1643                    long userId, long nodeId, int status,
1644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1645                    throws com.liferay.portal.kernel.exception.SystemException,
1646                            com.liferay.portlet.wiki.NoSuchPageException {
1647                    return getPersistence()
1648                                       .findByU_N_S_Last(userId, nodeId, status, orderByComparator);
1649            }
1650    
1651            /**
1652            * Finds the wiki pages before and after the current wiki page in the ordered set where userId = &#63; and nodeId = &#63; and status = &#63;.
1653            *
1654            * <p>
1655            * 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.
1656            * </p>
1657            *
1658            * @param pageId the primary key of the current wiki page
1659            * @param userId the user id to search with
1660            * @param nodeId the node id to search with
1661            * @param status the status to search with
1662            * @param orderByComparator the comparator to order the set by
1663            * @return the previous, current, and next wiki page
1664            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1665            * @throws SystemException if a system exception occurred
1666            */
1667            public static com.liferay.portlet.wiki.model.WikiPage[] findByU_N_S_PrevAndNext(
1668                    long pageId, long userId, long nodeId, int status,
1669                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1670                    throws com.liferay.portal.kernel.exception.SystemException,
1671                            com.liferay.portlet.wiki.NoSuchPageException {
1672                    return getPersistence()
1673                                       .findByU_N_S_PrevAndNext(pageId, userId, nodeId, status,
1674                            orderByComparator);
1675            }
1676    
1677            /**
1678            * Finds the wiki page where nodeId = &#63; and title = &#63; and version = &#63; or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
1679            *
1680            * @param nodeId the node id to search with
1681            * @param title the title to search with
1682            * @param version the version to search with
1683            * @return the matching wiki page
1684            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1685            * @throws SystemException if a system exception occurred
1686            */
1687            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_V(
1688                    long nodeId, java.lang.String title, double version)
1689                    throws com.liferay.portal.kernel.exception.SystemException,
1690                            com.liferay.portlet.wiki.NoSuchPageException {
1691                    return getPersistence().findByN_T_V(nodeId, title, version);
1692            }
1693    
1694            /**
1695            * Finds the wiki page where nodeId = &#63; and title = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1696            *
1697            * @param nodeId the node id to search with
1698            * @param title the title to search with
1699            * @param version the version to search with
1700            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1701            * @throws SystemException if a system exception occurred
1702            */
1703            public static com.liferay.portlet.wiki.model.WikiPage fetchByN_T_V(
1704                    long nodeId, java.lang.String title, double version)
1705                    throws com.liferay.portal.kernel.exception.SystemException {
1706                    return getPersistence().fetchByN_T_V(nodeId, title, version);
1707            }
1708    
1709            /**
1710            * Finds the wiki page where nodeId = &#63; and title = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1711            *
1712            * @param nodeId the node id to search with
1713            * @param title the title to search with
1714            * @param version the version to search with
1715            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1716            * @throws SystemException if a system exception occurred
1717            */
1718            public static com.liferay.portlet.wiki.model.WikiPage fetchByN_T_V(
1719                    long nodeId, java.lang.String title, double version,
1720                    boolean retrieveFromCache)
1721                    throws com.liferay.portal.kernel.exception.SystemException {
1722                    return getPersistence()
1723                                       .fetchByN_T_V(nodeId, title, version, retrieveFromCache);
1724            }
1725    
1726            /**
1727            * Finds all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
1728            *
1729            * @param nodeId the node id to search with
1730            * @param title the title to search with
1731            * @param head the head to search with
1732            * @return the matching wiki pages
1733            * @throws SystemException if a system exception occurred
1734            */
1735            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_H(
1736                    long nodeId, java.lang.String title, boolean head)
1737                    throws com.liferay.portal.kernel.exception.SystemException {
1738                    return getPersistence().findByN_T_H(nodeId, title, head);
1739            }
1740    
1741            /**
1742            * Finds a range of all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
1743            *
1744            * <p>
1745            * 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.
1746            * </p>
1747            *
1748            * @param nodeId the node id to search with
1749            * @param title the title to search with
1750            * @param head the head to search with
1751            * @param start the lower bound of the range of wiki pages to return
1752            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1753            * @return the range of matching wiki pages
1754            * @throws SystemException if a system exception occurred
1755            */
1756            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_H(
1757                    long nodeId, java.lang.String title, boolean head, int start, int end)
1758                    throws com.liferay.portal.kernel.exception.SystemException {
1759                    return getPersistence().findByN_T_H(nodeId, title, head, start, end);
1760            }
1761    
1762            /**
1763            * Finds an ordered range of all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
1764            *
1765            * <p>
1766            * 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.
1767            * </p>
1768            *
1769            * @param nodeId the node id to search with
1770            * @param title the title to search with
1771            * @param head the head to search with
1772            * @param start the lower bound of the range of wiki pages to return
1773            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1774            * @param orderByComparator the comparator to order the results by
1775            * @return the ordered range of matching wiki pages
1776            * @throws SystemException if a system exception occurred
1777            */
1778            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_H(
1779                    long nodeId, java.lang.String title, boolean head, int start, int end,
1780                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1781                    throws com.liferay.portal.kernel.exception.SystemException {
1782                    return getPersistence()
1783                                       .findByN_T_H(nodeId, title, head, start, end,
1784                            orderByComparator);
1785            }
1786    
1787            /**
1788            * Finds the first wiki page in the ordered set where nodeId = &#63; and title = &#63; and head = &#63;.
1789            *
1790            * <p>
1791            * 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.
1792            * </p>
1793            *
1794            * @param nodeId the node id to search with
1795            * @param title the title to search with
1796            * @param head the head to search with
1797            * @param orderByComparator the comparator to order the set by
1798            * @return the first matching wiki page
1799            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1800            * @throws SystemException if a system exception occurred
1801            */
1802            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_H_First(
1803                    long nodeId, java.lang.String title, boolean head,
1804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1805                    throws com.liferay.portal.kernel.exception.SystemException,
1806                            com.liferay.portlet.wiki.NoSuchPageException {
1807                    return getPersistence()
1808                                       .findByN_T_H_First(nodeId, title, head, orderByComparator);
1809            }
1810    
1811            /**
1812            * Finds the last wiki page in the ordered set where nodeId = &#63; and title = &#63; and head = &#63;.
1813            *
1814            * <p>
1815            * 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.
1816            * </p>
1817            *
1818            * @param nodeId the node id to search with
1819            * @param title the title to search with
1820            * @param head the head to search with
1821            * @param orderByComparator the comparator to order the set by
1822            * @return the last matching wiki page
1823            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1824            * @throws SystemException if a system exception occurred
1825            */
1826            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_H_Last(
1827                    long nodeId, java.lang.String title, boolean head,
1828                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1829                    throws com.liferay.portal.kernel.exception.SystemException,
1830                            com.liferay.portlet.wiki.NoSuchPageException {
1831                    return getPersistence()
1832                                       .findByN_T_H_Last(nodeId, title, head, orderByComparator);
1833            }
1834    
1835            /**
1836            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and title = &#63; and head = &#63;.
1837            *
1838            * <p>
1839            * 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.
1840            * </p>
1841            *
1842            * @param pageId the primary key of the current wiki page
1843            * @param nodeId the node id to search with
1844            * @param title the title to search with
1845            * @param head the head to search with
1846            * @param orderByComparator the comparator to order the set by
1847            * @return the previous, current, and next wiki page
1848            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1849            * @throws SystemException if a system exception occurred
1850            */
1851            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_T_H_PrevAndNext(
1852                    long pageId, long nodeId, java.lang.String title, boolean head,
1853                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1854                    throws com.liferay.portal.kernel.exception.SystemException,
1855                            com.liferay.portlet.wiki.NoSuchPageException {
1856                    return getPersistence()
1857                                       .findByN_T_H_PrevAndNext(pageId, nodeId, title, head,
1858                            orderByComparator);
1859            }
1860    
1861            /**
1862            * Finds all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
1863            *
1864            * @param nodeId the node id to search with
1865            * @param title the title to search with
1866            * @param status the status to search with
1867            * @return the matching wiki pages
1868            * @throws SystemException if a system exception occurred
1869            */
1870            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_S(
1871                    long nodeId, java.lang.String title, int status)
1872                    throws com.liferay.portal.kernel.exception.SystemException {
1873                    return getPersistence().findByN_T_S(nodeId, title, status);
1874            }
1875    
1876            /**
1877            * Finds a range of all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
1878            *
1879            * <p>
1880            * 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.
1881            * </p>
1882            *
1883            * @param nodeId the node id to search with
1884            * @param title the title to search with
1885            * @param status the status to search with
1886            * @param start the lower bound of the range of wiki pages to return
1887            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1888            * @return the range of matching wiki pages
1889            * @throws SystemException if a system exception occurred
1890            */
1891            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_S(
1892                    long nodeId, java.lang.String title, int status, int start, int end)
1893                    throws com.liferay.portal.kernel.exception.SystemException {
1894                    return getPersistence().findByN_T_S(nodeId, title, status, start, end);
1895            }
1896    
1897            /**
1898            * Finds an ordered range of all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
1899            *
1900            * <p>
1901            * 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.
1902            * </p>
1903            *
1904            * @param nodeId the node id to search with
1905            * @param title the title to search with
1906            * @param status the status to search with
1907            * @param start the lower bound of the range of wiki pages to return
1908            * @param end the upper bound of the range of wiki pages to return (not inclusive)
1909            * @param orderByComparator the comparator to order the results by
1910            * @return the ordered range of matching wiki pages
1911            * @throws SystemException if a system exception occurred
1912            */
1913            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_S(
1914                    long nodeId, java.lang.String title, int status, int start, int end,
1915                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1916                    throws com.liferay.portal.kernel.exception.SystemException {
1917                    return getPersistence()
1918                                       .findByN_T_S(nodeId, title, status, start, end,
1919                            orderByComparator);
1920            }
1921    
1922            /**
1923            * Finds the first wiki page in the ordered set where nodeId = &#63; and title = &#63; and status = &#63;.
1924            *
1925            * <p>
1926            * 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.
1927            * </p>
1928            *
1929            * @param nodeId the node id to search with
1930            * @param title the title to search with
1931            * @param status the status to search with
1932            * @param orderByComparator the comparator to order the set by
1933            * @return the first matching wiki page
1934            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1935            * @throws SystemException if a system exception occurred
1936            */
1937            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_S_First(
1938                    long nodeId, java.lang.String title, int status,
1939                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1940                    throws com.liferay.portal.kernel.exception.SystemException,
1941                            com.liferay.portlet.wiki.NoSuchPageException {
1942                    return getPersistence()
1943                                       .findByN_T_S_First(nodeId, title, status, orderByComparator);
1944            }
1945    
1946            /**
1947            * Finds the last wiki page in the ordered set where nodeId = &#63; and title = &#63; and status = &#63;.
1948            *
1949            * <p>
1950            * 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.
1951            * </p>
1952            *
1953            * @param nodeId the node id to search with
1954            * @param title the title to search with
1955            * @param status the status to search with
1956            * @param orderByComparator the comparator to order the set by
1957            * @return the last matching wiki page
1958            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1959            * @throws SystemException if a system exception occurred
1960            */
1961            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_S_Last(
1962                    long nodeId, java.lang.String title, int status,
1963                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1964                    throws com.liferay.portal.kernel.exception.SystemException,
1965                            com.liferay.portlet.wiki.NoSuchPageException {
1966                    return getPersistence()
1967                                       .findByN_T_S_Last(nodeId, title, status, orderByComparator);
1968            }
1969    
1970            /**
1971            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and title = &#63; and status = &#63;.
1972            *
1973            * <p>
1974            * 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.
1975            * </p>
1976            *
1977            * @param pageId the primary key of the current wiki page
1978            * @param nodeId the node id to search with
1979            * @param title the title to search with
1980            * @param status the status to search with
1981            * @param orderByComparator the comparator to order the set by
1982            * @return the previous, current, and next wiki page
1983            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1984            * @throws SystemException if a system exception occurred
1985            */
1986            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_T_S_PrevAndNext(
1987                    long pageId, long nodeId, java.lang.String title, int status,
1988                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1989                    throws com.liferay.portal.kernel.exception.SystemException,
1990                            com.liferay.portlet.wiki.NoSuchPageException {
1991                    return getPersistence()
1992                                       .findByN_T_S_PrevAndNext(pageId, nodeId, title, status,
1993                            orderByComparator);
1994            }
1995    
1996            /**
1997            * Finds all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
1998            *
1999            * @param nodeId the node id to search with
2000            * @param head the head to search with
2001            * @param parentTitle the parent title to search with
2002            * @return the matching wiki pages
2003            * @throws SystemException if a system exception occurred
2004            */
2005            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P(
2006                    long nodeId, boolean head, java.lang.String parentTitle)
2007                    throws com.liferay.portal.kernel.exception.SystemException {
2008                    return getPersistence().findByN_H_P(nodeId, head, parentTitle);
2009            }
2010    
2011            /**
2012            * Finds a range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2013            *
2014            * <p>
2015            * 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.
2016            * </p>
2017            *
2018            * @param nodeId the node id to search with
2019            * @param head the head to search with
2020            * @param parentTitle the parent title to search with
2021            * @param start the lower bound of the range of wiki pages to return
2022            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2023            * @return the range of matching wiki pages
2024            * @throws SystemException if a system exception occurred
2025            */
2026            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P(
2027                    long nodeId, boolean head, java.lang.String parentTitle, int start,
2028                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2029                    return getPersistence()
2030                                       .findByN_H_P(nodeId, head, parentTitle, start, end);
2031            }
2032    
2033            /**
2034            * Finds an ordered range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2035            *
2036            * <p>
2037            * 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.
2038            * </p>
2039            *
2040            * @param nodeId the node id to search with
2041            * @param head the head to search with
2042            * @param parentTitle the parent title to search with
2043            * @param start the lower bound of the range of wiki pages to return
2044            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2045            * @param orderByComparator the comparator to order the results by
2046            * @return the ordered range of matching wiki pages
2047            * @throws SystemException if a system exception occurred
2048            */
2049            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P(
2050                    long nodeId, boolean head, java.lang.String parentTitle, int start,
2051                    int end,
2052                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2053                    throws com.liferay.portal.kernel.exception.SystemException {
2054                    return getPersistence()
2055                                       .findByN_H_P(nodeId, head, parentTitle, start, end,
2056                            orderByComparator);
2057            }
2058    
2059            /**
2060            * Finds the first wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2061            *
2062            * <p>
2063            * 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.
2064            * </p>
2065            *
2066            * @param nodeId the node id to search with
2067            * @param head the head to search with
2068            * @param parentTitle the parent title to search with
2069            * @param orderByComparator the comparator to order the set by
2070            * @return the first matching wiki page
2071            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2072            * @throws SystemException if a system exception occurred
2073            */
2074            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_First(
2075                    long nodeId, boolean head, java.lang.String parentTitle,
2076                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2077                    throws com.liferay.portal.kernel.exception.SystemException,
2078                            com.liferay.portlet.wiki.NoSuchPageException {
2079                    return getPersistence()
2080                                       .findByN_H_P_First(nodeId, head, parentTitle,
2081                            orderByComparator);
2082            }
2083    
2084            /**
2085            * Finds the last wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2086            *
2087            * <p>
2088            * 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.
2089            * </p>
2090            *
2091            * @param nodeId the node id to search with
2092            * @param head the head to search with
2093            * @param parentTitle the parent title to search with
2094            * @param orderByComparator the comparator to order the set by
2095            * @return the last matching wiki page
2096            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2097            * @throws SystemException if a system exception occurred
2098            */
2099            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_Last(
2100                    long nodeId, boolean head, java.lang.String parentTitle,
2101                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2102                    throws com.liferay.portal.kernel.exception.SystemException,
2103                            com.liferay.portlet.wiki.NoSuchPageException {
2104                    return getPersistence()
2105                                       .findByN_H_P_Last(nodeId, head, parentTitle,
2106                            orderByComparator);
2107            }
2108    
2109            /**
2110            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2111            *
2112            * <p>
2113            * 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.
2114            * </p>
2115            *
2116            * @param pageId the primary key of the current wiki page
2117            * @param nodeId the node id to search with
2118            * @param head the head to search with
2119            * @param parentTitle the parent title to search with
2120            * @param orderByComparator the comparator to order the set by
2121            * @return the previous, current, and next wiki page
2122            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
2123            * @throws SystemException if a system exception occurred
2124            */
2125            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_P_PrevAndNext(
2126                    long pageId, long nodeId, boolean head, java.lang.String parentTitle,
2127                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2128                    throws com.liferay.portal.kernel.exception.SystemException,
2129                            com.liferay.portlet.wiki.NoSuchPageException {
2130                    return getPersistence()
2131                                       .findByN_H_P_PrevAndNext(pageId, nodeId, head, parentTitle,
2132                            orderByComparator);
2133            }
2134    
2135            /**
2136            * Finds all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2137            *
2138            * @param nodeId the node id to search with
2139            * @param head the head to search with
2140            * @param status the status to search with
2141            * @return the matching wiki pages
2142            * @throws SystemException if a system exception occurred
2143            */
2144            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_S(
2145                    long nodeId, boolean head, int status)
2146                    throws com.liferay.portal.kernel.exception.SystemException {
2147                    return getPersistence().findByN_H_S(nodeId, head, status);
2148            }
2149    
2150            /**
2151            * Finds a range of all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2152            *
2153            * <p>
2154            * 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.
2155            * </p>
2156            *
2157            * @param nodeId the node id to search with
2158            * @param head the head to search with
2159            * @param status the status to search with
2160            * @param start the lower bound of the range of wiki pages to return
2161            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2162            * @return the range of matching wiki pages
2163            * @throws SystemException if a system exception occurred
2164            */
2165            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_S(
2166                    long nodeId, boolean head, int status, int start, int end)
2167                    throws com.liferay.portal.kernel.exception.SystemException {
2168                    return getPersistence().findByN_H_S(nodeId, head, status, start, end);
2169            }
2170    
2171            /**
2172            * Finds an ordered range of all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2173            *
2174            * <p>
2175            * 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.
2176            * </p>
2177            *
2178            * @param nodeId the node id to search with
2179            * @param head the head to search with
2180            * @param status the status to search with
2181            * @param start the lower bound of the range of wiki pages to return
2182            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2183            * @param orderByComparator the comparator to order the results by
2184            * @return the ordered range of matching wiki pages
2185            * @throws SystemException if a system exception occurred
2186            */
2187            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_S(
2188                    long nodeId, boolean head, int status, int start, int end,
2189                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2190                    throws com.liferay.portal.kernel.exception.SystemException {
2191                    return getPersistence()
2192                                       .findByN_H_S(nodeId, head, status, start, end,
2193                            orderByComparator);
2194            }
2195    
2196            /**
2197            * Finds the first wiki page in the ordered set where nodeId = &#63; and head = &#63; and status = &#63;.
2198            *
2199            * <p>
2200            * 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.
2201            * </p>
2202            *
2203            * @param nodeId the node id to search with
2204            * @param head the head to search with
2205            * @param status the status to search with
2206            * @param orderByComparator the comparator to order the set by
2207            * @return the first matching wiki page
2208            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2209            * @throws SystemException if a system exception occurred
2210            */
2211            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_S_First(
2212                    long nodeId, boolean head, int status,
2213                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2214                    throws com.liferay.portal.kernel.exception.SystemException,
2215                            com.liferay.portlet.wiki.NoSuchPageException {
2216                    return getPersistence()
2217                                       .findByN_H_S_First(nodeId, head, status, orderByComparator);
2218            }
2219    
2220            /**
2221            * Finds the last wiki page in the ordered set where nodeId = &#63; and head = &#63; and status = &#63;.
2222            *
2223            * <p>
2224            * 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.
2225            * </p>
2226            *
2227            * @param nodeId the node id to search with
2228            * @param head the head to search with
2229            * @param status the status to search with
2230            * @param orderByComparator the comparator to order the set by
2231            * @return the last matching wiki page
2232            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2233            * @throws SystemException if a system exception occurred
2234            */
2235            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_S_Last(
2236                    long nodeId, boolean head, int status,
2237                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2238                    throws com.liferay.portal.kernel.exception.SystemException,
2239                            com.liferay.portlet.wiki.NoSuchPageException {
2240                    return getPersistence()
2241                                       .findByN_H_S_Last(nodeId, head, status, orderByComparator);
2242            }
2243    
2244            /**
2245            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63; and status = &#63;.
2246            *
2247            * <p>
2248            * 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.
2249            * </p>
2250            *
2251            * @param pageId the primary key of the current wiki page
2252            * @param nodeId the node id to search with
2253            * @param head the head to search with
2254            * @param status the status to search with
2255            * @param orderByComparator the comparator to order the set by
2256            * @return the previous, current, and next wiki page
2257            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
2258            * @throws SystemException if a system exception occurred
2259            */
2260            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_S_PrevAndNext(
2261                    long pageId, long nodeId, boolean head, int status,
2262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2263                    throws com.liferay.portal.kernel.exception.SystemException,
2264                            com.liferay.portlet.wiki.NoSuchPageException {
2265                    return getPersistence()
2266                                       .findByN_H_S_PrevAndNext(pageId, nodeId, head, status,
2267                            orderByComparator);
2268            }
2269    
2270            /**
2271            * Finds all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2272            *
2273            * @param nodeId the node id to search with
2274            * @param head the head to search with
2275            * @param parentTitle the parent title to search with
2276            * @param status the status to search with
2277            * @return the matching wiki pages
2278            * @throws SystemException if a system exception occurred
2279            */
2280            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P_S(
2281                    long nodeId, boolean head, java.lang.String parentTitle, int status)
2282                    throws com.liferay.portal.kernel.exception.SystemException {
2283                    return getPersistence().findByN_H_P_S(nodeId, head, parentTitle, status);
2284            }
2285    
2286            /**
2287            * Finds a range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2288            *
2289            * <p>
2290            * 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.
2291            * </p>
2292            *
2293            * @param nodeId the node id to search with
2294            * @param head the head to search with
2295            * @param parentTitle the parent title to search with
2296            * @param status the status to search with
2297            * @param start the lower bound of the range of wiki pages to return
2298            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2299            * @return the range of matching wiki pages
2300            * @throws SystemException if a system exception occurred
2301            */
2302            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P_S(
2303                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2304                    int start, int end)
2305                    throws com.liferay.portal.kernel.exception.SystemException {
2306                    return getPersistence()
2307                                       .findByN_H_P_S(nodeId, head, parentTitle, status, start, end);
2308            }
2309    
2310            /**
2311            * Finds an ordered range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2312            *
2313            * <p>
2314            * 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.
2315            * </p>
2316            *
2317            * @param nodeId the node id to search with
2318            * @param head the head to search with
2319            * @param parentTitle the parent title to search with
2320            * @param status the status to search with
2321            * @param start the lower bound of the range of wiki pages to return
2322            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2323            * @param orderByComparator the comparator to order the results by
2324            * @return the ordered range of matching wiki pages
2325            * @throws SystemException if a system exception occurred
2326            */
2327            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P_S(
2328                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2329                    int start, int end,
2330                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2331                    throws com.liferay.portal.kernel.exception.SystemException {
2332                    return getPersistence()
2333                                       .findByN_H_P_S(nodeId, head, parentTitle, status, start,
2334                            end, orderByComparator);
2335            }
2336    
2337            /**
2338            * Finds the first wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2339            *
2340            * <p>
2341            * 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.
2342            * </p>
2343            *
2344            * @param nodeId the node id to search with
2345            * @param head the head to search with
2346            * @param parentTitle the parent title to search with
2347            * @param status the status to search with
2348            * @param orderByComparator the comparator to order the set by
2349            * @return the first matching wiki page
2350            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2351            * @throws SystemException if a system exception occurred
2352            */
2353            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_S_First(
2354                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2355                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2356                    throws com.liferay.portal.kernel.exception.SystemException,
2357                            com.liferay.portlet.wiki.NoSuchPageException {
2358                    return getPersistence()
2359                                       .findByN_H_P_S_First(nodeId, head, parentTitle, status,
2360                            orderByComparator);
2361            }
2362    
2363            /**
2364            * Finds the last wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2365            *
2366            * <p>
2367            * 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.
2368            * </p>
2369            *
2370            * @param nodeId the node id to search with
2371            * @param head the head to search with
2372            * @param parentTitle the parent title to search with
2373            * @param status the status to search with
2374            * @param orderByComparator the comparator to order the set by
2375            * @return the last matching wiki page
2376            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2377            * @throws SystemException if a system exception occurred
2378            */
2379            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_S_Last(
2380                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2381                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2382                    throws com.liferay.portal.kernel.exception.SystemException,
2383                            com.liferay.portlet.wiki.NoSuchPageException {
2384                    return getPersistence()
2385                                       .findByN_H_P_S_Last(nodeId, head, parentTitle, status,
2386                            orderByComparator);
2387            }
2388    
2389            /**
2390            * Finds the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2391            *
2392            * <p>
2393            * 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.
2394            * </p>
2395            *
2396            * @param pageId the primary key of the current wiki page
2397            * @param nodeId the node id to search with
2398            * @param head the head to search with
2399            * @param parentTitle the parent title to search with
2400            * @param status the status to search with
2401            * @param orderByComparator the comparator to order the set by
2402            * @return the previous, current, and next wiki page
2403            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
2404            * @throws SystemException if a system exception occurred
2405            */
2406            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_P_S_PrevAndNext(
2407                    long pageId, long nodeId, boolean head, java.lang.String parentTitle,
2408                    int status,
2409                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2410                    throws com.liferay.portal.kernel.exception.SystemException,
2411                            com.liferay.portlet.wiki.NoSuchPageException {
2412                    return getPersistence()
2413                                       .findByN_H_P_S_PrevAndNext(pageId, nodeId, head,
2414                            parentTitle, status, orderByComparator);
2415            }
2416    
2417            /**
2418            * Finds all the wiki pages.
2419            *
2420            * @return the wiki pages
2421            * @throws SystemException if a system exception occurred
2422            */
2423            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findAll()
2424                    throws com.liferay.portal.kernel.exception.SystemException {
2425                    return getPersistence().findAll();
2426            }
2427    
2428            /**
2429            * Finds a range of all the wiki pages.
2430            *
2431            * <p>
2432            * 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.
2433            * </p>
2434            *
2435            * @param start the lower bound of the range of wiki pages to return
2436            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2437            * @return the range of wiki pages
2438            * @throws SystemException if a system exception occurred
2439            */
2440            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findAll(
2441                    int start, int end)
2442                    throws com.liferay.portal.kernel.exception.SystemException {
2443                    return getPersistence().findAll(start, end);
2444            }
2445    
2446            /**
2447            * Finds an ordered range of all the wiki pages.
2448            *
2449            * <p>
2450            * 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.
2451            * </p>
2452            *
2453            * @param start the lower bound of the range of wiki pages to return
2454            * @param end the upper bound of the range of wiki pages to return (not inclusive)
2455            * @param orderByComparator the comparator to order the results by
2456            * @return the ordered range of wiki pages
2457            * @throws SystemException if a system exception occurred
2458            */
2459            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findAll(
2460                    int start, int end,
2461                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2462                    throws com.liferay.portal.kernel.exception.SystemException {
2463                    return getPersistence().findAll(start, end, orderByComparator);
2464            }
2465    
2466            /**
2467            * Removes all the wiki pages where uuid = &#63; from the database.
2468            *
2469            * @param uuid the uuid to search with
2470            * @throws SystemException if a system exception occurred
2471            */
2472            public static void removeByUuid(java.lang.String uuid)
2473                    throws com.liferay.portal.kernel.exception.SystemException {
2474                    getPersistence().removeByUuid(uuid);
2475            }
2476    
2477            /**
2478            * Removes the wiki page where uuid = &#63; and groupId = &#63; from the database.
2479            *
2480            * @param uuid the uuid to search with
2481            * @param groupId the group id to search with
2482            * @throws SystemException if a system exception occurred
2483            */
2484            public static void removeByUUID_G(java.lang.String uuid, long groupId)
2485                    throws com.liferay.portal.kernel.exception.SystemException,
2486                            com.liferay.portlet.wiki.NoSuchPageException {
2487                    getPersistence().removeByUUID_G(uuid, groupId);
2488            }
2489    
2490            /**
2491            * Removes all the wiki pages where nodeId = &#63; from the database.
2492            *
2493            * @param nodeId the node id to search with
2494            * @throws SystemException if a system exception occurred
2495            */
2496            public static void removeByNodeId(long nodeId)
2497                    throws com.liferay.portal.kernel.exception.SystemException {
2498                    getPersistence().removeByNodeId(nodeId);
2499            }
2500    
2501            /**
2502            * Removes all the wiki pages where format = &#63; from the database.
2503            *
2504            * @param format the format to search with
2505            * @throws SystemException if a system exception occurred
2506            */
2507            public static void removeByFormat(java.lang.String format)
2508                    throws com.liferay.portal.kernel.exception.SystemException {
2509                    getPersistence().removeByFormat(format);
2510            }
2511    
2512            /**
2513            * Removes all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; from the database.
2514            *
2515            * @param resourcePrimKey the resource prim key to search with
2516            * @param nodeId the node id to search with
2517            * @throws SystemException if a system exception occurred
2518            */
2519            public static void removeByR_N(long resourcePrimKey, long nodeId)
2520                    throws com.liferay.portal.kernel.exception.SystemException {
2521                    getPersistence().removeByR_N(resourcePrimKey, nodeId);
2522            }
2523    
2524            /**
2525            * Removes all the wiki pages where nodeId = &#63; and title = &#63; from the database.
2526            *
2527            * @param nodeId the node id to search with
2528            * @param title the title to search with
2529            * @throws SystemException if a system exception occurred
2530            */
2531            public static void removeByN_T(long nodeId, java.lang.String title)
2532                    throws com.liferay.portal.kernel.exception.SystemException {
2533                    getPersistence().removeByN_T(nodeId, title);
2534            }
2535    
2536            /**
2537            * Removes all the wiki pages where nodeId = &#63; and head = &#63; from the database.
2538            *
2539            * @param nodeId the node id to search with
2540            * @param head the head to search with
2541            * @throws SystemException if a system exception occurred
2542            */
2543            public static void removeByN_H(long nodeId, boolean head)
2544                    throws com.liferay.portal.kernel.exception.SystemException {
2545                    getPersistence().removeByN_H(nodeId, head);
2546            }
2547    
2548            /**
2549            * Removes all the wiki pages where nodeId = &#63; and parentTitle = &#63; from the database.
2550            *
2551            * @param nodeId the node id to search with
2552            * @param parentTitle the parent title to search with
2553            * @throws SystemException if a system exception occurred
2554            */
2555            public static void removeByN_P(long nodeId, java.lang.String parentTitle)
2556                    throws com.liferay.portal.kernel.exception.SystemException {
2557                    getPersistence().removeByN_P(nodeId, parentTitle);
2558            }
2559    
2560            /**
2561            * Removes all the wiki pages where nodeId = &#63; and redirectTitle = &#63; from the database.
2562            *
2563            * @param nodeId the node id to search with
2564            * @param redirectTitle the redirect title to search with
2565            * @throws SystemException if a system exception occurred
2566            */
2567            public static void removeByN_R(long nodeId, java.lang.String redirectTitle)
2568                    throws com.liferay.portal.kernel.exception.SystemException {
2569                    getPersistence().removeByN_R(nodeId, redirectTitle);
2570            }
2571    
2572            /**
2573            * Removes all the wiki pages where nodeId = &#63; and status = &#63; from the database.
2574            *
2575            * @param nodeId the node id to search with
2576            * @param status the status to search with
2577            * @throws SystemException if a system exception occurred
2578            */
2579            public static void removeByN_S(long nodeId, int status)
2580                    throws com.liferay.portal.kernel.exception.SystemException {
2581                    getPersistence().removeByN_S(nodeId, status);
2582            }
2583    
2584            /**
2585            * Removes the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; from the database.
2586            *
2587            * @param resourcePrimKey the resource prim key to search with
2588            * @param nodeId the node id to search with
2589            * @param version the version to search with
2590            * @throws SystemException if a system exception occurred
2591            */
2592            public static void removeByR_N_V(long resourcePrimKey, long nodeId,
2593                    double version)
2594                    throws com.liferay.portal.kernel.exception.SystemException,
2595                            com.liferay.portlet.wiki.NoSuchPageException {
2596                    getPersistence().removeByR_N_V(resourcePrimKey, nodeId, version);
2597            }
2598    
2599            /**
2600            * Removes all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63; from the database.
2601            *
2602            * @param resourcePrimKey the resource prim key to search with
2603            * @param nodeId the node id to search with
2604            * @param status the status to search with
2605            * @throws SystemException if a system exception occurred
2606            */
2607            public static void removeByR_N_S(long resourcePrimKey, long nodeId,
2608                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2609                    getPersistence().removeByR_N_S(resourcePrimKey, nodeId, status);
2610            }
2611    
2612            /**
2613            * Removes all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63; from the database.
2614            *
2615            * @param userId the user id to search with
2616            * @param nodeId the node id to search with
2617            * @param status the status to search with
2618            * @throws SystemException if a system exception occurred
2619            */
2620            public static void removeByU_N_S(long userId, long nodeId, int status)
2621                    throws com.liferay.portal.kernel.exception.SystemException {
2622                    getPersistence().removeByU_N_S(userId, nodeId, status);
2623            }
2624    
2625            /**
2626            * Removes the wiki page where nodeId = &#63; and title = &#63; and version = &#63; from the database.
2627            *
2628            * @param nodeId the node id to search with
2629            * @param title the title to search with
2630            * @param version the version to search with
2631            * @throws SystemException if a system exception occurred
2632            */
2633            public static void removeByN_T_V(long nodeId, java.lang.String title,
2634                    double version)
2635                    throws com.liferay.portal.kernel.exception.SystemException,
2636                            com.liferay.portlet.wiki.NoSuchPageException {
2637                    getPersistence().removeByN_T_V(nodeId, title, version);
2638            }
2639    
2640            /**
2641            * Removes all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63; from the database.
2642            *
2643            * @param nodeId the node id to search with
2644            * @param title the title to search with
2645            * @param head the head to search with
2646            * @throws SystemException if a system exception occurred
2647            */
2648            public static void removeByN_T_H(long nodeId, java.lang.String title,
2649                    boolean head)
2650                    throws com.liferay.portal.kernel.exception.SystemException {
2651                    getPersistence().removeByN_T_H(nodeId, title, head);
2652            }
2653    
2654            /**
2655            * Removes all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63; from the database.
2656            *
2657            * @param nodeId the node id to search with
2658            * @param title the title to search with
2659            * @param status the status to search with
2660            * @throws SystemException if a system exception occurred
2661            */
2662            public static void removeByN_T_S(long nodeId, java.lang.String title,
2663                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2664                    getPersistence().removeByN_T_S(nodeId, title, status);
2665            }
2666    
2667            /**
2668            * Removes all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; from the database.
2669            *
2670            * @param nodeId the node id to search with
2671            * @param head the head to search with
2672            * @param parentTitle the parent title to search with
2673            * @throws SystemException if a system exception occurred
2674            */
2675            public static void removeByN_H_P(long nodeId, boolean head,
2676                    java.lang.String parentTitle)
2677                    throws com.liferay.portal.kernel.exception.SystemException {
2678                    getPersistence().removeByN_H_P(nodeId, head, parentTitle);
2679            }
2680    
2681            /**
2682            * Removes all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63; from the database.
2683            *
2684            * @param nodeId the node id to search with
2685            * @param head the head to search with
2686            * @param status the status to search with
2687            * @throws SystemException if a system exception occurred
2688            */
2689            public static void removeByN_H_S(long nodeId, boolean head, int status)
2690                    throws com.liferay.portal.kernel.exception.SystemException {
2691                    getPersistence().removeByN_H_S(nodeId, head, status);
2692            }
2693    
2694            /**
2695            * Removes all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63; from the database.
2696            *
2697            * @param nodeId the node id to search with
2698            * @param head the head to search with
2699            * @param parentTitle the parent title to search with
2700            * @param status the status to search with
2701            * @throws SystemException if a system exception occurred
2702            */
2703            public static void removeByN_H_P_S(long nodeId, boolean head,
2704                    java.lang.String parentTitle, int status)
2705                    throws com.liferay.portal.kernel.exception.SystemException {
2706                    getPersistence().removeByN_H_P_S(nodeId, head, parentTitle, status);
2707            }
2708    
2709            /**
2710            * Removes all the wiki pages from the database.
2711            *
2712            * @throws SystemException if a system exception occurred
2713            */
2714            public static void removeAll()
2715                    throws com.liferay.portal.kernel.exception.SystemException {
2716                    getPersistence().removeAll();
2717            }
2718    
2719            /**
2720            * Counts all the wiki pages where uuid = &#63;.
2721            *
2722            * @param uuid the uuid to search with
2723            * @return the number of matching wiki pages
2724            * @throws SystemException if a system exception occurred
2725            */
2726            public static int countByUuid(java.lang.String uuid)
2727                    throws com.liferay.portal.kernel.exception.SystemException {
2728                    return getPersistence().countByUuid(uuid);
2729            }
2730    
2731            /**
2732            * Counts all the wiki pages where uuid = &#63; and groupId = &#63;.
2733            *
2734            * @param uuid the uuid to search with
2735            * @param groupId the group id to search with
2736            * @return the number of matching wiki pages
2737            * @throws SystemException if a system exception occurred
2738            */
2739            public static int countByUUID_G(java.lang.String uuid, long groupId)
2740                    throws com.liferay.portal.kernel.exception.SystemException {
2741                    return getPersistence().countByUUID_G(uuid, groupId);
2742            }
2743    
2744            /**
2745            * Counts all the wiki pages where nodeId = &#63;.
2746            *
2747            * @param nodeId the node id to search with
2748            * @return the number of matching wiki pages
2749            * @throws SystemException if a system exception occurred
2750            */
2751            public static int countByNodeId(long nodeId)
2752                    throws com.liferay.portal.kernel.exception.SystemException {
2753                    return getPersistence().countByNodeId(nodeId);
2754            }
2755    
2756            /**
2757            * Counts all the wiki pages where format = &#63;.
2758            *
2759            * @param format the format to search with
2760            * @return the number of matching wiki pages
2761            * @throws SystemException if a system exception occurred
2762            */
2763            public static int countByFormat(java.lang.String format)
2764                    throws com.liferay.portal.kernel.exception.SystemException {
2765                    return getPersistence().countByFormat(format);
2766            }
2767    
2768            /**
2769            * Counts all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
2770            *
2771            * @param resourcePrimKey the resource prim key to search with
2772            * @param nodeId the node id to search with
2773            * @return the number of matching wiki pages
2774            * @throws SystemException if a system exception occurred
2775            */
2776            public static int countByR_N(long resourcePrimKey, long nodeId)
2777                    throws com.liferay.portal.kernel.exception.SystemException {
2778                    return getPersistence().countByR_N(resourcePrimKey, nodeId);
2779            }
2780    
2781            /**
2782            * Counts all the wiki pages where nodeId = &#63; and title = &#63;.
2783            *
2784            * @param nodeId the node id to search with
2785            * @param title the title to search with
2786            * @return the number of matching wiki pages
2787            * @throws SystemException if a system exception occurred
2788            */
2789            public static int countByN_T(long nodeId, java.lang.String title)
2790                    throws com.liferay.portal.kernel.exception.SystemException {
2791                    return getPersistence().countByN_T(nodeId, title);
2792            }
2793    
2794            /**
2795            * Counts all the wiki pages where nodeId = &#63; and head = &#63;.
2796            *
2797            * @param nodeId the node id to search with
2798            * @param head the head to search with
2799            * @return the number of matching wiki pages
2800            * @throws SystemException if a system exception occurred
2801            */
2802            public static int countByN_H(long nodeId, boolean head)
2803                    throws com.liferay.portal.kernel.exception.SystemException {
2804                    return getPersistence().countByN_H(nodeId, head);
2805            }
2806    
2807            /**
2808            * Counts all the wiki pages where nodeId = &#63; and parentTitle = &#63;.
2809            *
2810            * @param nodeId the node id to search with
2811            * @param parentTitle the parent title to search with
2812            * @return the number of matching wiki pages
2813            * @throws SystemException if a system exception occurred
2814            */
2815            public static int countByN_P(long nodeId, java.lang.String parentTitle)
2816                    throws com.liferay.portal.kernel.exception.SystemException {
2817                    return getPersistence().countByN_P(nodeId, parentTitle);
2818            }
2819    
2820            /**
2821            * Counts all the wiki pages where nodeId = &#63; and redirectTitle = &#63;.
2822            *
2823            * @param nodeId the node id to search with
2824            * @param redirectTitle the redirect title to search with
2825            * @return the number of matching wiki pages
2826            * @throws SystemException if a system exception occurred
2827            */
2828            public static int countByN_R(long nodeId, java.lang.String redirectTitle)
2829                    throws com.liferay.portal.kernel.exception.SystemException {
2830                    return getPersistence().countByN_R(nodeId, redirectTitle);
2831            }
2832    
2833            /**
2834            * Counts all the wiki pages where nodeId = &#63; and status = &#63;.
2835            *
2836            * @param nodeId the node id to search with
2837            * @param status the status to search with
2838            * @return the number of matching wiki pages
2839            * @throws SystemException if a system exception occurred
2840            */
2841            public static int countByN_S(long nodeId, int status)
2842                    throws com.liferay.portal.kernel.exception.SystemException {
2843                    return getPersistence().countByN_S(nodeId, status);
2844            }
2845    
2846            /**
2847            * Counts all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63;.
2848            *
2849            * @param resourcePrimKey the resource prim key to search with
2850            * @param nodeId the node id to search with
2851            * @param version the version to search with
2852            * @return the number of matching wiki pages
2853            * @throws SystemException if a system exception occurred
2854            */
2855            public static int countByR_N_V(long resourcePrimKey, long nodeId,
2856                    double version)
2857                    throws com.liferay.portal.kernel.exception.SystemException {
2858                    return getPersistence().countByR_N_V(resourcePrimKey, nodeId, version);
2859            }
2860    
2861            /**
2862            * Counts all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
2863            *
2864            * @param resourcePrimKey the resource prim key to search with
2865            * @param nodeId the node id to search with
2866            * @param status the status to search with
2867            * @return the number of matching wiki pages
2868            * @throws SystemException if a system exception occurred
2869            */
2870            public static int countByR_N_S(long resourcePrimKey, long nodeId, int status)
2871                    throws com.liferay.portal.kernel.exception.SystemException {
2872                    return getPersistence().countByR_N_S(resourcePrimKey, nodeId, status);
2873            }
2874    
2875            /**
2876            * Counts all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
2877            *
2878            * @param userId the user id to search with
2879            * @param nodeId the node id to search with
2880            * @param status the status to search with
2881            * @return the number of matching wiki pages
2882            * @throws SystemException if a system exception occurred
2883            */
2884            public static int countByU_N_S(long userId, long nodeId, int status)
2885                    throws com.liferay.portal.kernel.exception.SystemException {
2886                    return getPersistence().countByU_N_S(userId, nodeId, status);
2887            }
2888    
2889            /**
2890            * Counts all the wiki pages where nodeId = &#63; and title = &#63; and version = &#63;.
2891            *
2892            * @param nodeId the node id to search with
2893            * @param title the title to search with
2894            * @param version the version to search with
2895            * @return the number of matching wiki pages
2896            * @throws SystemException if a system exception occurred
2897            */
2898            public static int countByN_T_V(long nodeId, java.lang.String title,
2899                    double version)
2900                    throws com.liferay.portal.kernel.exception.SystemException {
2901                    return getPersistence().countByN_T_V(nodeId, title, version);
2902            }
2903    
2904            /**
2905            * Counts all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
2906            *
2907            * @param nodeId the node id to search with
2908            * @param title the title to search with
2909            * @param head the head to search with
2910            * @return the number of matching wiki pages
2911            * @throws SystemException if a system exception occurred
2912            */
2913            public static int countByN_T_H(long nodeId, java.lang.String title,
2914                    boolean head)
2915                    throws com.liferay.portal.kernel.exception.SystemException {
2916                    return getPersistence().countByN_T_H(nodeId, title, head);
2917            }
2918    
2919            /**
2920            * Counts all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
2921            *
2922            * @param nodeId the node id to search with
2923            * @param title the title to search with
2924            * @param status the status to search with
2925            * @return the number of matching wiki pages
2926            * @throws SystemException if a system exception occurred
2927            */
2928            public static int countByN_T_S(long nodeId, java.lang.String title,
2929                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2930                    return getPersistence().countByN_T_S(nodeId, title, status);
2931            }
2932    
2933            /**
2934            * Counts all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2935            *
2936            * @param nodeId the node id to search with
2937            * @param head the head to search with
2938            * @param parentTitle the parent title to search with
2939            * @return the number of matching wiki pages
2940            * @throws SystemException if a system exception occurred
2941            */
2942            public static int countByN_H_P(long nodeId, boolean head,
2943                    java.lang.String parentTitle)
2944                    throws com.liferay.portal.kernel.exception.SystemException {
2945                    return getPersistence().countByN_H_P(nodeId, head, parentTitle);
2946            }
2947    
2948            /**
2949            * Counts all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2950            *
2951            * @param nodeId the node id to search with
2952            * @param head the head to search with
2953            * @param status the status to search with
2954            * @return the number of matching wiki pages
2955            * @throws SystemException if a system exception occurred
2956            */
2957            public static int countByN_H_S(long nodeId, boolean head, int status)
2958                    throws com.liferay.portal.kernel.exception.SystemException {
2959                    return getPersistence().countByN_H_S(nodeId, head, status);
2960            }
2961    
2962            /**
2963            * Counts all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2964            *
2965            * @param nodeId the node id to search with
2966            * @param head the head to search with
2967            * @param parentTitle the parent title to search with
2968            * @param status the status to search with
2969            * @return the number of matching wiki pages
2970            * @throws SystemException if a system exception occurred
2971            */
2972            public static int countByN_H_P_S(long nodeId, boolean head,
2973                    java.lang.String parentTitle, int status)
2974                    throws com.liferay.portal.kernel.exception.SystemException {
2975                    return getPersistence().countByN_H_P_S(nodeId, head, parentTitle, status);
2976            }
2977    
2978            /**
2979            * Counts all the wiki pages.
2980            *
2981            * @return the number of wiki pages
2982            * @throws SystemException if a system exception occurred
2983            */
2984            public static int countAll()
2985                    throws com.liferay.portal.kernel.exception.SystemException {
2986                    return getPersistence().countAll();
2987            }
2988    
2989            public static WikiPagePersistence getPersistence() {
2990                    if (_persistence == null) {
2991                            _persistence = (WikiPagePersistence)PortalBeanLocatorUtil.locate(WikiPagePersistence.class.getName());
2992                    }
2993    
2994                    return _persistence;
2995            }
2996    
2997            public void setPersistence(WikiPagePersistence persistence) {
2998                    _persistence = persistence;
2999            }
3000    
3001            private static WikiPagePersistence _persistence;
3002    }