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