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