001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.model.LayoutFriendlyURL; 020 021 /** 022 * The persistence interface for the layout friendly u r l service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see com.liferay.portal.service.persistence.impl.LayoutFriendlyURLPersistenceImpl 030 * @see LayoutFriendlyURLUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface LayoutFriendlyURLPersistence extends BasePersistence<LayoutFriendlyURL> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * Never modify or reference this interface directly. Always use {@link LayoutFriendlyURLUtil} to access the layout friendly u r l persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 039 */ 040 041 /** 042 * Returns all the layout friendly u r ls where uuid = ?. 043 * 044 * @param uuid the uuid 045 * @return the matching layout friendly u r ls 046 */ 047 public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid); 048 049 /** 050 * Returns a range of all the layout friendly u r ls where uuid = ?. 051 * 052 * <p> 053 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 054 * </p> 055 * 056 * @param uuid the uuid 057 * @param start the lower bound of the range of layout friendly u r ls 058 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 059 * @return the range of matching layout friendly u r ls 060 */ 061 public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid, 062 int start, int end); 063 064 /** 065 * Returns an ordered range of all the layout friendly u r ls where uuid = ?. 066 * 067 * <p> 068 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 069 * </p> 070 * 071 * @param uuid the uuid 072 * @param start the lower bound of the range of layout friendly u r ls 073 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 075 * @return the ordered range of matching layout friendly u r ls 076 */ 077 public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid, 078 int start, int end, 079 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 080 081 /** 082 * Returns an ordered range of all the layout friendly u r ls where uuid = ?. 083 * 084 * <p> 085 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 086 * </p> 087 * 088 * @param uuid the uuid 089 * @param start the lower bound of the range of layout friendly u r ls 090 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 091 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 092 * @param retrieveFromCache whether to retrieve from the finder cache 093 * @return the ordered range of matching layout friendly u r ls 094 */ 095 public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid, 096 int start, int end, 097 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 098 boolean retrieveFromCache); 099 100 /** 101 * Returns the first layout friendly u r l in the ordered set where uuid = ?. 102 * 103 * @param uuid the uuid 104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 105 * @return the first matching layout friendly u r l 106 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 107 */ 108 public LayoutFriendlyURL findByUuid_First(java.lang.String uuid, 109 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 110 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 111 112 /** 113 * Returns the first layout friendly u r l in the ordered set where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 117 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 118 */ 119 public LayoutFriendlyURL fetchByUuid_First(java.lang.String uuid, 120 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 121 122 /** 123 * Returns the last layout friendly u r l in the ordered set where uuid = ?. 124 * 125 * @param uuid the uuid 126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 127 * @return the last matching layout friendly u r l 128 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 129 */ 130 public LayoutFriendlyURL findByUuid_Last(java.lang.String uuid, 131 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 132 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 133 134 /** 135 * Returns the last layout friendly u r l in the ordered set where uuid = ?. 136 * 137 * @param uuid the uuid 138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 139 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 140 */ 141 public LayoutFriendlyURL fetchByUuid_Last(java.lang.String uuid, 142 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 143 144 /** 145 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where uuid = ?. 146 * 147 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 148 * @param uuid the uuid 149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 150 * @return the previous, current, and next layout friendly u r l 151 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 152 */ 153 public LayoutFriendlyURL[] findByUuid_PrevAndNext( 154 long layoutFriendlyURLId, java.lang.String uuid, 155 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 156 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 157 158 /** 159 * Removes all the layout friendly u r ls where uuid = ? from the database. 160 * 161 * @param uuid the uuid 162 */ 163 public void removeByUuid(java.lang.String uuid); 164 165 /** 166 * Returns the number of layout friendly u r ls where uuid = ?. 167 * 168 * @param uuid the uuid 169 * @return the number of matching layout friendly u r ls 170 */ 171 public int countByUuid(java.lang.String uuid); 172 173 /** 174 * Returns the layout friendly u r l where uuid = ? and groupId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 175 * 176 * @param uuid the uuid 177 * @param groupId the group ID 178 * @return the matching layout friendly u r l 179 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 180 */ 181 public LayoutFriendlyURL findByUUID_G(java.lang.String uuid, long groupId) 182 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 183 184 /** 185 * Returns the layout friendly u r l where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 186 * 187 * @param uuid the uuid 188 * @param groupId the group ID 189 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 190 */ 191 public LayoutFriendlyURL fetchByUUID_G(java.lang.String uuid, long groupId); 192 193 /** 194 * Returns the layout friendly u r l where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 195 * 196 * @param uuid the uuid 197 * @param groupId the group ID 198 * @param retrieveFromCache whether to retrieve from the finder cache 199 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 200 */ 201 public LayoutFriendlyURL fetchByUUID_G(java.lang.String uuid, long groupId, 202 boolean retrieveFromCache); 203 204 /** 205 * Removes the layout friendly u r l where uuid = ? and groupId = ? from the database. 206 * 207 * @param uuid the uuid 208 * @param groupId the group ID 209 * @return the layout friendly u r l that was removed 210 */ 211 public LayoutFriendlyURL removeByUUID_G(java.lang.String uuid, long groupId) 212 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 213 214 /** 215 * Returns the number of layout friendly u r ls where uuid = ? and groupId = ?. 216 * 217 * @param uuid the uuid 218 * @param groupId the group ID 219 * @return the number of matching layout friendly u r ls 220 */ 221 public int countByUUID_G(java.lang.String uuid, long groupId); 222 223 /** 224 * Returns all the layout friendly u r ls where uuid = ? and companyId = ?. 225 * 226 * @param uuid the uuid 227 * @param companyId the company ID 228 * @return the matching layout friendly u r ls 229 */ 230 public java.util.List<LayoutFriendlyURL> findByUuid_C( 231 java.lang.String uuid, long companyId); 232 233 /** 234 * Returns a range of all the layout friendly u r ls where uuid = ? and companyId = ?. 235 * 236 * <p> 237 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 238 * </p> 239 * 240 * @param uuid the uuid 241 * @param companyId the company ID 242 * @param start the lower bound of the range of layout friendly u r ls 243 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 244 * @return the range of matching layout friendly u r ls 245 */ 246 public java.util.List<LayoutFriendlyURL> findByUuid_C( 247 java.lang.String uuid, long companyId, int start, int end); 248 249 /** 250 * Returns an ordered range of all the layout friendly u r ls where uuid = ? and companyId = ?. 251 * 252 * <p> 253 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 254 * </p> 255 * 256 * @param uuid the uuid 257 * @param companyId the company ID 258 * @param start the lower bound of the range of layout friendly u r ls 259 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 260 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 261 * @return the ordered range of matching layout friendly u r ls 262 */ 263 public java.util.List<LayoutFriendlyURL> findByUuid_C( 264 java.lang.String uuid, long companyId, int start, int end, 265 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 266 267 /** 268 * Returns an ordered range of all the layout friendly u r ls where uuid = ? and companyId = ?. 269 * 270 * <p> 271 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 272 * </p> 273 * 274 * @param uuid the uuid 275 * @param companyId the company ID 276 * @param start the lower bound of the range of layout friendly u r ls 277 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 278 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 279 * @param retrieveFromCache whether to retrieve from the finder cache 280 * @return the ordered range of matching layout friendly u r ls 281 */ 282 public java.util.List<LayoutFriendlyURL> findByUuid_C( 283 java.lang.String uuid, long companyId, int start, int end, 284 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 285 boolean retrieveFromCache); 286 287 /** 288 * Returns the first layout friendly u r l in the ordered set where uuid = ? and companyId = ?. 289 * 290 * @param uuid the uuid 291 * @param companyId the company ID 292 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 293 * @return the first matching layout friendly u r l 294 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 295 */ 296 public LayoutFriendlyURL findByUuid_C_First(java.lang.String uuid, 297 long companyId, 298 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 299 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 300 301 /** 302 * Returns the first layout friendly u r l in the ordered set where uuid = ? and companyId = ?. 303 * 304 * @param uuid the uuid 305 * @param companyId the company ID 306 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 307 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 308 */ 309 public LayoutFriendlyURL fetchByUuid_C_First(java.lang.String uuid, 310 long companyId, 311 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 312 313 /** 314 * Returns the last layout friendly u r l in the ordered set where uuid = ? and companyId = ?. 315 * 316 * @param uuid the uuid 317 * @param companyId the company ID 318 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 319 * @return the last matching layout friendly u r l 320 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 321 */ 322 public LayoutFriendlyURL findByUuid_C_Last(java.lang.String uuid, 323 long companyId, 324 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 325 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 326 327 /** 328 * Returns the last layout friendly u r l in the ordered set where uuid = ? and companyId = ?. 329 * 330 * @param uuid the uuid 331 * @param companyId the company ID 332 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 333 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 334 */ 335 public LayoutFriendlyURL fetchByUuid_C_Last(java.lang.String uuid, 336 long companyId, 337 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 338 339 /** 340 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where uuid = ? and companyId = ?. 341 * 342 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 343 * @param uuid the uuid 344 * @param companyId the company ID 345 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 346 * @return the previous, current, and next layout friendly u r l 347 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 348 */ 349 public LayoutFriendlyURL[] findByUuid_C_PrevAndNext( 350 long layoutFriendlyURLId, java.lang.String uuid, long companyId, 351 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 352 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 353 354 /** 355 * Removes all the layout friendly u r ls where uuid = ? and companyId = ? from the database. 356 * 357 * @param uuid the uuid 358 * @param companyId the company ID 359 */ 360 public void removeByUuid_C(java.lang.String uuid, long companyId); 361 362 /** 363 * Returns the number of layout friendly u r ls where uuid = ? and companyId = ?. 364 * 365 * @param uuid the uuid 366 * @param companyId the company ID 367 * @return the number of matching layout friendly u r ls 368 */ 369 public int countByUuid_C(java.lang.String uuid, long companyId); 370 371 /** 372 * Returns all the layout friendly u r ls where groupId = ?. 373 * 374 * @param groupId the group ID 375 * @return the matching layout friendly u r ls 376 */ 377 public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId); 378 379 /** 380 * Returns a range of all the layout friendly u r ls where groupId = ?. 381 * 382 * <p> 383 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 384 * </p> 385 * 386 * @param groupId the group ID 387 * @param start the lower bound of the range of layout friendly u r ls 388 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 389 * @return the range of matching layout friendly u r ls 390 */ 391 public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId, 392 int start, int end); 393 394 /** 395 * Returns an ordered range of all the layout friendly u r ls where groupId = ?. 396 * 397 * <p> 398 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 399 * </p> 400 * 401 * @param groupId the group ID 402 * @param start the lower bound of the range of layout friendly u r ls 403 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 404 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 405 * @return the ordered range of matching layout friendly u r ls 406 */ 407 public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId, 408 int start, int end, 409 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 410 411 /** 412 * Returns an ordered range of all the layout friendly u r ls where groupId = ?. 413 * 414 * <p> 415 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 416 * </p> 417 * 418 * @param groupId the group ID 419 * @param start the lower bound of the range of layout friendly u r ls 420 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 421 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 422 * @param retrieveFromCache whether to retrieve from the finder cache 423 * @return the ordered range of matching layout friendly u r ls 424 */ 425 public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId, 426 int start, int end, 427 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 428 boolean retrieveFromCache); 429 430 /** 431 * Returns the first layout friendly u r l in the ordered set where groupId = ?. 432 * 433 * @param groupId the group ID 434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 435 * @return the first matching layout friendly u r l 436 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 437 */ 438 public LayoutFriendlyURL findByGroupId_First(long groupId, 439 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 440 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 441 442 /** 443 * Returns the first layout friendly u r l in the ordered set where groupId = ?. 444 * 445 * @param groupId the group ID 446 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 447 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 448 */ 449 public LayoutFriendlyURL fetchByGroupId_First(long groupId, 450 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 451 452 /** 453 * Returns the last layout friendly u r l in the ordered set where groupId = ?. 454 * 455 * @param groupId the group ID 456 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 457 * @return the last matching layout friendly u r l 458 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 459 */ 460 public LayoutFriendlyURL findByGroupId_Last(long groupId, 461 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 462 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 463 464 /** 465 * Returns the last layout friendly u r l in the ordered set where groupId = ?. 466 * 467 * @param groupId the group ID 468 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 469 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 470 */ 471 public LayoutFriendlyURL fetchByGroupId_Last(long groupId, 472 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 473 474 /** 475 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where groupId = ?. 476 * 477 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 478 * @param groupId the group ID 479 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 480 * @return the previous, current, and next layout friendly u r l 481 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 482 */ 483 public LayoutFriendlyURL[] findByGroupId_PrevAndNext( 484 long layoutFriendlyURLId, long groupId, 485 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 486 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 487 488 /** 489 * Removes all the layout friendly u r ls where groupId = ? from the database. 490 * 491 * @param groupId the group ID 492 */ 493 public void removeByGroupId(long groupId); 494 495 /** 496 * Returns the number of layout friendly u r ls where groupId = ?. 497 * 498 * @param groupId the group ID 499 * @return the number of matching layout friendly u r ls 500 */ 501 public int countByGroupId(long groupId); 502 503 /** 504 * Returns all the layout friendly u r ls where companyId = ?. 505 * 506 * @param companyId the company ID 507 * @return the matching layout friendly u r ls 508 */ 509 public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId); 510 511 /** 512 * Returns a range of all the layout friendly u r ls where companyId = ?. 513 * 514 * <p> 515 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 516 * </p> 517 * 518 * @param companyId the company ID 519 * @param start the lower bound of the range of layout friendly u r ls 520 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 521 * @return the range of matching layout friendly u r ls 522 */ 523 public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId, 524 int start, int end); 525 526 /** 527 * Returns an ordered range of all the layout friendly u r ls where companyId = ?. 528 * 529 * <p> 530 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 531 * </p> 532 * 533 * @param companyId the company ID 534 * @param start the lower bound of the range of layout friendly u r ls 535 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 536 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 537 * @return the ordered range of matching layout friendly u r ls 538 */ 539 public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId, 540 int start, int end, 541 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 542 543 /** 544 * Returns an ordered range of all the layout friendly u r ls where companyId = ?. 545 * 546 * <p> 547 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 548 * </p> 549 * 550 * @param companyId the company ID 551 * @param start the lower bound of the range of layout friendly u r ls 552 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 553 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 554 * @param retrieveFromCache whether to retrieve from the finder cache 555 * @return the ordered range of matching layout friendly u r ls 556 */ 557 public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId, 558 int start, int end, 559 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 560 boolean retrieveFromCache); 561 562 /** 563 * Returns the first layout friendly u r l in the ordered set where companyId = ?. 564 * 565 * @param companyId the company ID 566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 567 * @return the first matching layout friendly u r l 568 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 569 */ 570 public LayoutFriendlyURL findByCompanyId_First(long companyId, 571 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 572 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 573 574 /** 575 * Returns the first layout friendly u r l in the ordered set where companyId = ?. 576 * 577 * @param companyId the company ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 580 */ 581 public LayoutFriendlyURL fetchByCompanyId_First(long companyId, 582 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 583 584 /** 585 * Returns the last layout friendly u r l in the ordered set where companyId = ?. 586 * 587 * @param companyId the company ID 588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 589 * @return the last matching layout friendly u r l 590 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 591 */ 592 public LayoutFriendlyURL findByCompanyId_Last(long companyId, 593 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 594 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 595 596 /** 597 * Returns the last layout friendly u r l in the ordered set where companyId = ?. 598 * 599 * @param companyId the company ID 600 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 601 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 602 */ 603 public LayoutFriendlyURL fetchByCompanyId_Last(long companyId, 604 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 605 606 /** 607 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where companyId = ?. 608 * 609 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 610 * @param companyId the company ID 611 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 612 * @return the previous, current, and next layout friendly u r l 613 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 614 */ 615 public LayoutFriendlyURL[] findByCompanyId_PrevAndNext( 616 long layoutFriendlyURLId, long companyId, 617 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 618 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 619 620 /** 621 * Removes all the layout friendly u r ls where companyId = ? from the database. 622 * 623 * @param companyId the company ID 624 */ 625 public void removeByCompanyId(long companyId); 626 627 /** 628 * Returns the number of layout friendly u r ls where companyId = ?. 629 * 630 * @param companyId the company ID 631 * @return the number of matching layout friendly u r ls 632 */ 633 public int countByCompanyId(long companyId); 634 635 /** 636 * Returns all the layout friendly u r ls where plid = ?. 637 * 638 * @param plid the plid 639 * @return the matching layout friendly u r ls 640 */ 641 public java.util.List<LayoutFriendlyURL> findByPlid(long plid); 642 643 /** 644 * Returns a range of all the layout friendly u r ls where plid = ?. 645 * 646 * <p> 647 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 648 * </p> 649 * 650 * @param plid the plid 651 * @param start the lower bound of the range of layout friendly u r ls 652 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 653 * @return the range of matching layout friendly u r ls 654 */ 655 public java.util.List<LayoutFriendlyURL> findByPlid(long plid, int start, 656 int end); 657 658 /** 659 * Returns an ordered range of all the layout friendly u r ls where plid = ?. 660 * 661 * <p> 662 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 663 * </p> 664 * 665 * @param plid the plid 666 * @param start the lower bound of the range of layout friendly u r ls 667 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 668 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 669 * @return the ordered range of matching layout friendly u r ls 670 */ 671 public java.util.List<LayoutFriendlyURL> findByPlid(long plid, int start, 672 int end, 673 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 674 675 /** 676 * Returns an ordered range of all the layout friendly u r ls where plid = ?. 677 * 678 * <p> 679 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 680 * </p> 681 * 682 * @param plid the plid 683 * @param start the lower bound of the range of layout friendly u r ls 684 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 685 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 686 * @param retrieveFromCache whether to retrieve from the finder cache 687 * @return the ordered range of matching layout friendly u r ls 688 */ 689 public java.util.List<LayoutFriendlyURL> findByPlid(long plid, int start, 690 int end, 691 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 692 boolean retrieveFromCache); 693 694 /** 695 * Returns the first layout friendly u r l in the ordered set where plid = ?. 696 * 697 * @param plid the plid 698 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 699 * @return the first matching layout friendly u r l 700 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 701 */ 702 public LayoutFriendlyURL findByPlid_First(long plid, 703 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 704 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 705 706 /** 707 * Returns the first layout friendly u r l in the ordered set where plid = ?. 708 * 709 * @param plid the plid 710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 711 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 712 */ 713 public LayoutFriendlyURL fetchByPlid_First(long plid, 714 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 715 716 /** 717 * Returns the last layout friendly u r l in the ordered set where plid = ?. 718 * 719 * @param plid the plid 720 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 721 * @return the last matching layout friendly u r l 722 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 723 */ 724 public LayoutFriendlyURL findByPlid_Last(long plid, 725 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 726 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 727 728 /** 729 * Returns the last layout friendly u r l in the ordered set where plid = ?. 730 * 731 * @param plid the plid 732 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 733 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 734 */ 735 public LayoutFriendlyURL fetchByPlid_Last(long plid, 736 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 737 738 /** 739 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where plid = ?. 740 * 741 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 742 * @param plid the plid 743 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 744 * @return the previous, current, and next layout friendly u r l 745 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 746 */ 747 public LayoutFriendlyURL[] findByPlid_PrevAndNext( 748 long layoutFriendlyURLId, long plid, 749 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 750 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 751 752 /** 753 * Removes all the layout friendly u r ls where plid = ? from the database. 754 * 755 * @param plid the plid 756 */ 757 public void removeByPlid(long plid); 758 759 /** 760 * Returns the number of layout friendly u r ls where plid = ?. 761 * 762 * @param plid the plid 763 * @return the number of matching layout friendly u r ls 764 */ 765 public int countByPlid(long plid); 766 767 /** 768 * Returns all the layout friendly u r ls where plid = ? and friendlyURL = ?. 769 * 770 * @param plid the plid 771 * @param friendlyURL the friendly u r l 772 * @return the matching layout friendly u r ls 773 */ 774 public java.util.List<LayoutFriendlyURL> findByP_F(long plid, 775 java.lang.String friendlyURL); 776 777 /** 778 * Returns a range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 779 * 780 * <p> 781 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 782 * </p> 783 * 784 * @param plid the plid 785 * @param friendlyURL the friendly u r l 786 * @param start the lower bound of the range of layout friendly u r ls 787 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 788 * @return the range of matching layout friendly u r ls 789 */ 790 public java.util.List<LayoutFriendlyURL> findByP_F(long plid, 791 java.lang.String friendlyURL, int start, int end); 792 793 /** 794 * Returns an ordered range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 795 * 796 * <p> 797 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 798 * </p> 799 * 800 * @param plid the plid 801 * @param friendlyURL the friendly u r l 802 * @param start the lower bound of the range of layout friendly u r ls 803 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 804 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 805 * @return the ordered range of matching layout friendly u r ls 806 */ 807 public java.util.List<LayoutFriendlyURL> findByP_F(long plid, 808 java.lang.String friendlyURL, int start, int end, 809 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 810 811 /** 812 * Returns an ordered range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 813 * 814 * <p> 815 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 816 * </p> 817 * 818 * @param plid the plid 819 * @param friendlyURL the friendly u r l 820 * @param start the lower bound of the range of layout friendly u r ls 821 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 822 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 823 * @param retrieveFromCache whether to retrieve from the finder cache 824 * @return the ordered range of matching layout friendly u r ls 825 */ 826 public java.util.List<LayoutFriendlyURL> findByP_F(long plid, 827 java.lang.String friendlyURL, int start, int end, 828 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 829 boolean retrieveFromCache); 830 831 /** 832 * Returns the first layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 833 * 834 * @param plid the plid 835 * @param friendlyURL the friendly u r l 836 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 837 * @return the first matching layout friendly u r l 838 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 839 */ 840 public LayoutFriendlyURL findByP_F_First(long plid, 841 java.lang.String friendlyURL, 842 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 843 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 844 845 /** 846 * Returns the first layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 847 * 848 * @param plid the plid 849 * @param friendlyURL the friendly u r l 850 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 851 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 852 */ 853 public LayoutFriendlyURL fetchByP_F_First(long plid, 854 java.lang.String friendlyURL, 855 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 856 857 /** 858 * Returns the last layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 859 * 860 * @param plid the plid 861 * @param friendlyURL the friendly u r l 862 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 863 * @return the last matching layout friendly u r l 864 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 865 */ 866 public LayoutFriendlyURL findByP_F_Last(long plid, 867 java.lang.String friendlyURL, 868 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 869 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 870 871 /** 872 * Returns the last layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 873 * 874 * @param plid the plid 875 * @param friendlyURL the friendly u r l 876 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 877 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 878 */ 879 public LayoutFriendlyURL fetchByP_F_Last(long plid, 880 java.lang.String friendlyURL, 881 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 882 883 /** 884 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 885 * 886 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 887 * @param plid the plid 888 * @param friendlyURL the friendly u r l 889 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 890 * @return the previous, current, and next layout friendly u r l 891 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 892 */ 893 public LayoutFriendlyURL[] findByP_F_PrevAndNext(long layoutFriendlyURLId, 894 long plid, java.lang.String friendlyURL, 895 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 896 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 897 898 /** 899 * Removes all the layout friendly u r ls where plid = ? and friendlyURL = ? from the database. 900 * 901 * @param plid the plid 902 * @param friendlyURL the friendly u r l 903 */ 904 public void removeByP_F(long plid, java.lang.String friendlyURL); 905 906 /** 907 * Returns the number of layout friendly u r ls where plid = ? and friendlyURL = ?. 908 * 909 * @param plid the plid 910 * @param friendlyURL the friendly u r l 911 * @return the number of matching layout friendly u r ls 912 */ 913 public int countByP_F(long plid, java.lang.String friendlyURL); 914 915 /** 916 * Returns the layout friendly u r l where plid = ? and languageId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 917 * 918 * @param plid the plid 919 * @param languageId the language ID 920 * @return the matching layout friendly u r l 921 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 922 */ 923 public LayoutFriendlyURL findByP_L(long plid, java.lang.String languageId) 924 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 925 926 /** 927 * Returns the layout friendly u r l where plid = ? and languageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 928 * 929 * @param plid the plid 930 * @param languageId the language ID 931 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 932 */ 933 public LayoutFriendlyURL fetchByP_L(long plid, java.lang.String languageId); 934 935 /** 936 * Returns the layout friendly u r l where plid = ? and languageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 937 * 938 * @param plid the plid 939 * @param languageId the language ID 940 * @param retrieveFromCache whether to retrieve from the finder cache 941 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 942 */ 943 public LayoutFriendlyURL fetchByP_L(long plid, java.lang.String languageId, 944 boolean retrieveFromCache); 945 946 /** 947 * Removes the layout friendly u r l where plid = ? and languageId = ? from the database. 948 * 949 * @param plid the plid 950 * @param languageId the language ID 951 * @return the layout friendly u r l that was removed 952 */ 953 public LayoutFriendlyURL removeByP_L(long plid, java.lang.String languageId) 954 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 955 956 /** 957 * Returns the number of layout friendly u r ls where plid = ? and languageId = ?. 958 * 959 * @param plid the plid 960 * @param languageId the language ID 961 * @return the number of matching layout friendly u r ls 962 */ 963 public int countByP_L(long plid, java.lang.String languageId); 964 965 /** 966 * Returns all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 967 * 968 * @param groupId the group ID 969 * @param privateLayout the private layout 970 * @param friendlyURL the friendly u r l 971 * @return the matching layout friendly u r ls 972 */ 973 public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId, 974 boolean privateLayout, java.lang.String friendlyURL); 975 976 /** 977 * Returns a range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 978 * 979 * <p> 980 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 981 * </p> 982 * 983 * @param groupId the group ID 984 * @param privateLayout the private layout 985 * @param friendlyURL the friendly u r l 986 * @param start the lower bound of the range of layout friendly u r ls 987 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 988 * @return the range of matching layout friendly u r ls 989 */ 990 public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId, 991 boolean privateLayout, java.lang.String friendlyURL, int start, int end); 992 993 /** 994 * Returns an ordered range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 995 * 996 * <p> 997 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 998 * </p> 999 * 1000 * @param groupId the group ID 1001 * @param privateLayout the private layout 1002 * @param friendlyURL the friendly u r l 1003 * @param start the lower bound of the range of layout friendly u r ls 1004 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1005 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1006 * @return the ordered range of matching layout friendly u r ls 1007 */ 1008 public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId, 1009 boolean privateLayout, java.lang.String friendlyURL, int start, 1010 int end, 1011 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 1012 1013 /** 1014 * Returns an ordered range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1015 * 1016 * <p> 1017 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1018 * </p> 1019 * 1020 * @param groupId the group ID 1021 * @param privateLayout the private layout 1022 * @param friendlyURL the friendly u r l 1023 * @param start the lower bound of the range of layout friendly u r ls 1024 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1025 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1026 * @param retrieveFromCache whether to retrieve from the finder cache 1027 * @return the ordered range of matching layout friendly u r ls 1028 */ 1029 public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId, 1030 boolean privateLayout, java.lang.String friendlyURL, int start, 1031 int end, 1032 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 1033 boolean retrieveFromCache); 1034 1035 /** 1036 * Returns the first layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1037 * 1038 * @param groupId the group ID 1039 * @param privateLayout the private layout 1040 * @param friendlyURL the friendly u r l 1041 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1042 * @return the first matching layout friendly u r l 1043 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1044 */ 1045 public LayoutFriendlyURL findByG_P_F_First(long groupId, 1046 boolean privateLayout, java.lang.String friendlyURL, 1047 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 1048 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 1049 1050 /** 1051 * Returns the first layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1052 * 1053 * @param groupId the group ID 1054 * @param privateLayout the private layout 1055 * @param friendlyURL the friendly u r l 1056 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1057 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1058 */ 1059 public LayoutFriendlyURL fetchByG_P_F_First(long groupId, 1060 boolean privateLayout, java.lang.String friendlyURL, 1061 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 1062 1063 /** 1064 * Returns the last layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1065 * 1066 * @param groupId the group ID 1067 * @param privateLayout the private layout 1068 * @param friendlyURL the friendly u r l 1069 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1070 * @return the last matching layout friendly u r l 1071 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1072 */ 1073 public LayoutFriendlyURL findByG_P_F_Last(long groupId, 1074 boolean privateLayout, java.lang.String friendlyURL, 1075 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 1076 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 1077 1078 /** 1079 * Returns the last layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1080 * 1081 * @param groupId the group ID 1082 * @param privateLayout the private layout 1083 * @param friendlyURL the friendly u r l 1084 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1085 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1086 */ 1087 public LayoutFriendlyURL fetchByG_P_F_Last(long groupId, 1088 boolean privateLayout, java.lang.String friendlyURL, 1089 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 1090 1091 /** 1092 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1093 * 1094 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 1095 * @param groupId the group ID 1096 * @param privateLayout the private layout 1097 * @param friendlyURL the friendly u r l 1098 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1099 * @return the previous, current, and next layout friendly u r l 1100 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1101 */ 1102 public LayoutFriendlyURL[] findByG_P_F_PrevAndNext( 1103 long layoutFriendlyURLId, long groupId, boolean privateLayout, 1104 java.lang.String friendlyURL, 1105 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator) 1106 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 1107 1108 /** 1109 * Removes all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ? from the database. 1110 * 1111 * @param groupId the group ID 1112 * @param privateLayout the private layout 1113 * @param friendlyURL the friendly u r l 1114 */ 1115 public void removeByG_P_F(long groupId, boolean privateLayout, 1116 java.lang.String friendlyURL); 1117 1118 /** 1119 * Returns the number of layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1120 * 1121 * @param groupId the group ID 1122 * @param privateLayout the private layout 1123 * @param friendlyURL the friendly u r l 1124 * @return the number of matching layout friendly u r ls 1125 */ 1126 public int countByG_P_F(long groupId, boolean privateLayout, 1127 java.lang.String friendlyURL); 1128 1129 /** 1130 * Returns the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 1131 * 1132 * @param groupId the group ID 1133 * @param privateLayout the private layout 1134 * @param friendlyURL the friendly u r l 1135 * @param languageId the language ID 1136 * @return the matching layout friendly u r l 1137 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1138 */ 1139 public LayoutFriendlyURL findByG_P_F_L(long groupId, boolean privateLayout, 1140 java.lang.String friendlyURL, java.lang.String languageId) 1141 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 1142 1143 /** 1144 * Returns the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1145 * 1146 * @param groupId the group ID 1147 * @param privateLayout the private layout 1148 * @param friendlyURL the friendly u r l 1149 * @param languageId the language ID 1150 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1151 */ 1152 public LayoutFriendlyURL fetchByG_P_F_L(long groupId, 1153 boolean privateLayout, java.lang.String friendlyURL, 1154 java.lang.String languageId); 1155 1156 /** 1157 * Returns the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1158 * 1159 * @param groupId the group ID 1160 * @param privateLayout the private layout 1161 * @param friendlyURL the friendly u r l 1162 * @param languageId the language ID 1163 * @param retrieveFromCache whether to retrieve from the finder cache 1164 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1165 */ 1166 public LayoutFriendlyURL fetchByG_P_F_L(long groupId, 1167 boolean privateLayout, java.lang.String friendlyURL, 1168 java.lang.String languageId, boolean retrieveFromCache); 1169 1170 /** 1171 * Removes the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? from the database. 1172 * 1173 * @param groupId the group ID 1174 * @param privateLayout the private layout 1175 * @param friendlyURL the friendly u r l 1176 * @param languageId the language ID 1177 * @return the layout friendly u r l that was removed 1178 */ 1179 public LayoutFriendlyURL removeByG_P_F_L(long groupId, 1180 boolean privateLayout, java.lang.String friendlyURL, 1181 java.lang.String languageId) 1182 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 1183 1184 /** 1185 * Returns the number of layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ?. 1186 * 1187 * @param groupId the group ID 1188 * @param privateLayout the private layout 1189 * @param friendlyURL the friendly u r l 1190 * @param languageId the language ID 1191 * @return the number of matching layout friendly u r ls 1192 */ 1193 public int countByG_P_F_L(long groupId, boolean privateLayout, 1194 java.lang.String friendlyURL, java.lang.String languageId); 1195 1196 /** 1197 * Caches the layout friendly u r l in the entity cache if it is enabled. 1198 * 1199 * @param layoutFriendlyURL the layout friendly u r l 1200 */ 1201 public void cacheResult(LayoutFriendlyURL layoutFriendlyURL); 1202 1203 /** 1204 * Caches the layout friendly u r ls in the entity cache if it is enabled. 1205 * 1206 * @param layoutFriendlyURLs the layout friendly u r ls 1207 */ 1208 public void cacheResult( 1209 java.util.List<LayoutFriendlyURL> layoutFriendlyURLs); 1210 1211 /** 1212 * Creates a new layout friendly u r l with the primary key. Does not add the layout friendly u r l to the database. 1213 * 1214 * @param layoutFriendlyURLId the primary key for the new layout friendly u r l 1215 * @return the new layout friendly u r l 1216 */ 1217 public LayoutFriendlyURL create(long layoutFriendlyURLId); 1218 1219 /** 1220 * Removes the layout friendly u r l with the primary key from the database. Also notifies the appropriate model listeners. 1221 * 1222 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1223 * @return the layout friendly u r l that was removed 1224 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1225 */ 1226 public LayoutFriendlyURL remove(long layoutFriendlyURLId) 1227 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 1228 1229 public LayoutFriendlyURL updateImpl(LayoutFriendlyURL layoutFriendlyURL); 1230 1231 /** 1232 * Returns the layout friendly u r l with the primary key or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 1233 * 1234 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1235 * @return the layout friendly u r l 1236 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1237 */ 1238 public LayoutFriendlyURL findByPrimaryKey(long layoutFriendlyURLId) 1239 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException; 1240 1241 /** 1242 * Returns the layout friendly u r l with the primary key or returns <code>null</code> if it could not be found. 1243 * 1244 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1245 * @return the layout friendly u r l, or <code>null</code> if a layout friendly u r l with the primary key could not be found 1246 */ 1247 public LayoutFriendlyURL fetchByPrimaryKey(long layoutFriendlyURLId); 1248 1249 @Override 1250 public java.util.Map<java.io.Serializable, LayoutFriendlyURL> fetchByPrimaryKeys( 1251 java.util.Set<java.io.Serializable> primaryKeys); 1252 1253 /** 1254 * Returns all the layout friendly u r ls. 1255 * 1256 * @return the layout friendly u r ls 1257 */ 1258 public java.util.List<LayoutFriendlyURL> findAll(); 1259 1260 /** 1261 * Returns a range of all the layout friendly u r ls. 1262 * 1263 * <p> 1264 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1265 * </p> 1266 * 1267 * @param start the lower bound of the range of layout friendly u r ls 1268 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1269 * @return the range of layout friendly u r ls 1270 */ 1271 public java.util.List<LayoutFriendlyURL> findAll(int start, int end); 1272 1273 /** 1274 * Returns an ordered range of all the layout friendly u r ls. 1275 * 1276 * <p> 1277 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1278 * </p> 1279 * 1280 * @param start the lower bound of the range of layout friendly u r ls 1281 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1282 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1283 * @return the ordered range of layout friendly u r ls 1284 */ 1285 public java.util.List<LayoutFriendlyURL> findAll(int start, int end, 1286 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator); 1287 1288 /** 1289 * Returns an ordered range of all the layout friendly u r ls. 1290 * 1291 * <p> 1292 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1293 * </p> 1294 * 1295 * @param start the lower bound of the range of layout friendly u r ls 1296 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1297 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1298 * @param retrieveFromCache whether to retrieve from the finder cache 1299 * @return the ordered range of layout friendly u r ls 1300 */ 1301 public java.util.List<LayoutFriendlyURL> findAll(int start, int end, 1302 com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator, 1303 boolean retrieveFromCache); 1304 1305 /** 1306 * Removes all the layout friendly u r ls from the database. 1307 */ 1308 public void removeAll(); 1309 1310 /** 1311 * Returns the number of layout friendly u r ls. 1312 * 1313 * @return the number of layout friendly u r ls 1314 */ 1315 public int countAll(); 1316 1317 @Override 1318 public java.util.Set<java.lang.String> getBadColumnNames(); 1319 }