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