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