Source code

001// --------------------------------------------------------------------------------
002// Copyright 2002-2026 Echo Three, LLC
003//
004// Licensed under the Apache License, Version 2.0 (the "License");
005// you may not use this file except in compliance with the License.
006// You may obtain a copy of the License at
007//
008//     http://www.apache.org/licenses/LICENSE-2.0
009//
010// Unless required by applicable law or agreed to in writing, software
011// distributed under the License is distributed on an "AS IS" BASIS,
012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013// See the License for the specific language governing permissions and
014// limitations under the License.
015// --------------------------------------------------------------------------------
016// Generated File -- DO NOT EDIT BY HAND
017// --------------------------------------------------------------------------------
018
019/**
020 * ItemUnitLimitValue.java
021 */
022
023package com.echothree.model.data.item.server.value;
024
025import com.echothree.model.data.item.common.pk.ItemUnitLimitPK;
026
027import com.echothree.model.data.item.server.factory.ItemUnitLimitFactory;
028
029import com.echothree.model.data.item.common.pk.ItemPK;
030import com.echothree.model.data.inventory.common.pk.InventoryConditionPK;
031import com.echothree.model.data.uom.common.pk.UnitOfMeasureTypePK;
032
033import com.echothree.util.common.exception.PersistenceCloneException;
034import com.echothree.util.common.exception.PersistenceNotNullException;
035
036import com.echothree.util.server.persistence.BaseValue;
037
038import java.io.Serializable;
039
040import javax.annotation.Nonnull;
041import javax.annotation.Nullable;
042
043public class ItemUnitLimitValue
044        extends BaseValue<ItemUnitLimitPK>
045        implements Cloneable, Serializable {
046    
047    private ItemPK itemPK;
048    private boolean itemPKHasBeenModified = false;
049    private InventoryConditionPK inventoryConditionPK;
050    private boolean inventoryConditionPKHasBeenModified = false;
051    private UnitOfMeasureTypePK unitOfMeasureTypePK;
052    private boolean unitOfMeasureTypePKHasBeenModified = false;
053    private Long minimumQuantity;
054    private boolean minimumQuantityHasBeenModified = false;
055    private Long maximumQuantity;
056    private boolean maximumQuantityHasBeenModified = false;
057    private Long fromTime;
058    private boolean fromTimeHasBeenModified = false;
059    private Long thruTime;
060    private boolean thruTimeHasBeenModified = false;
061    
062    private transient Integer _hashCode = null;
063    private transient String _stringValue = null;
064    
065    private void constructFields(ItemPK itemPK, InventoryConditionPK inventoryConditionPK, UnitOfMeasureTypePK unitOfMeasureTypePK, Long minimumQuantity, Long maximumQuantity, Long fromTime, Long thruTime)
066            throws PersistenceNotNullException {
067        checkForNull(itemPK);
068        this.itemPK = itemPK;
069        checkForNull(inventoryConditionPK);
070        this.inventoryConditionPK = inventoryConditionPK;
071        checkForNull(unitOfMeasureTypePK);
072        this.unitOfMeasureTypePK = unitOfMeasureTypePK;
073        this.minimumQuantity = minimumQuantity;
074        this.maximumQuantity = maximumQuantity;
075        checkForNull(fromTime);
076        this.fromTime = fromTime;
077        checkForNull(thruTime);
078        this.thruTime = thruTime;
079    }
080    
081    /** Creates a new instance of ItemUnitLimitValue */
082    public ItemUnitLimitValue(ItemUnitLimitPK itemUnitLimitPK, ItemPK itemPK, InventoryConditionPK inventoryConditionPK, UnitOfMeasureTypePK unitOfMeasureTypePK, Long minimumQuantity, Long maximumQuantity, Long fromTime, Long thruTime)
083            throws PersistenceNotNullException {
084        super(itemUnitLimitPK);
085        constructFields(itemPK, inventoryConditionPK, unitOfMeasureTypePK, minimumQuantity, maximumQuantity, fromTime, thruTime);
086    }
087    
088    /** Creates a new instance of ItemUnitLimitValue */
089    public ItemUnitLimitValue(ItemPK itemPK, InventoryConditionPK inventoryConditionPK, UnitOfMeasureTypePK unitOfMeasureTypePK, Long minimumQuantity, Long maximumQuantity, Long fromTime, Long thruTime)
090            throws PersistenceNotNullException {
091        super();
092        constructFields(itemPK, inventoryConditionPK, unitOfMeasureTypePK, minimumQuantity, maximumQuantity, fromTime, thruTime);
093    }
094    
095    @Override
096    @Nonnull
097    public ItemUnitLimitFactory getBaseFactoryInstance() {
098        return ItemUnitLimitFactory.getInstance();
099    }
100    
101    @Override
102    @Nonnull
103    public ItemUnitLimitValue clone() {
104        Object result;
105        
106        try {
107            result = super.clone();
108        } catch (CloneNotSupportedException cnse) {
109            // This shouldn't happen, fail when it does.
110            throw new PersistenceCloneException(cnse);
111        }
112        
113        return (ItemUnitLimitValue)result;
114    }
115    
116    @Override
117    @Nonnull
118    public ItemUnitLimitPK getPrimaryKey() {
119        if(_primaryKey == null) {
120            _primaryKey = new ItemUnitLimitPK(entityId);
121        }
122        
123        return _primaryKey;
124    }
125    
126    private void clearHashAndString() {
127        _hashCode = null;
128        _stringValue = null;
129    }
130    
131    @Override
132    public int hashCode() {
133        if(_hashCode == null) {
134            int hashCode = 17;
135            
136            hashCode = 37 * hashCode + ((entityId != null) ? entityId.hashCode() : 0);
137            
138            hashCode = 37 * hashCode + ((itemPK != null) ? itemPK.hashCode() : 0);
139            hashCode = 37 * hashCode + ((inventoryConditionPK != null) ? inventoryConditionPK.hashCode() : 0);
140            hashCode = 37 * hashCode + ((unitOfMeasureTypePK != null) ? unitOfMeasureTypePK.hashCode() : 0);
141            hashCode = 37 * hashCode + ((minimumQuantity != null) ? minimumQuantity.hashCode() : 0);
142            hashCode = 37 * hashCode + ((maximumQuantity != null) ? maximumQuantity.hashCode() : 0);
143            hashCode = 37 * hashCode + ((fromTime != null) ? fromTime.hashCode() : 0);
144            hashCode = 37 * hashCode + ((thruTime != null) ? thruTime.hashCode() : 0);
145            
146            _hashCode = hashCode;
147        }
148        
149        return _hashCode;
150    }
151    
152    @Override
153    @Nonnull
154    public String toString() {
155        if(_stringValue == null) {
156            _stringValue = "{" + 
157                    "entityId=" + getEntityId() +
158                    ", itemPK=" + getItemPK() +
159                    ", inventoryConditionPK=" + getInventoryConditionPK() +
160                    ", unitOfMeasureTypePK=" + getUnitOfMeasureTypePK() +
161                    ", minimumQuantity=" + getMinimumQuantity() +
162                    ", maximumQuantity=" + getMaximumQuantity() +
163                    ", fromTime=" + getFromTime() +
164                    ", thruTime=" + getThruTime() +
165                    "}";
166        }
167        return _stringValue;
168    }
169    
170    @Override
171    public boolean equals(Object other) {
172        if(this == other)
173            return true;
174        
175        if(!hasIdentity())
176            return false;
177        
178        if(other instanceof  ItemUnitLimitValue that) {
179            if(!that.hasIdentity())
180                return false;
181            
182            Long thisEntityId = getEntityId();
183            Long thatEntityId = that.getEntityId();
184            
185            boolean objectsEqual = thisEntityId.equals(thatEntityId);
186            if(objectsEqual)
187                objectsEqual = isIdentical(that);
188            
189            return objectsEqual;
190        } else {
191            return false;
192        }
193    }
194    
195    public boolean isIdentical(Object other) {
196        if(other instanceof ItemUnitLimitValue that) {
197            boolean objectsEqual = true;
198            
199            
200            if(objectsEqual) {
201                ItemPK thisItemPK = getItemPK();
202                ItemPK thatItemPK = that.getItemPK();
203                
204                if(thisItemPK == null) {
205                    objectsEqual = objectsEqual && (thatItemPK == null);
206                } else {
207                    objectsEqual = objectsEqual && thisItemPK.equals(thatItemPK);
208                }
209            }
210            
211            if(objectsEqual) {
212                InventoryConditionPK thisInventoryConditionPK = getInventoryConditionPK();
213                InventoryConditionPK thatInventoryConditionPK = that.getInventoryConditionPK();
214                
215                if(thisInventoryConditionPK == null) {
216                    objectsEqual = objectsEqual && (thatInventoryConditionPK == null);
217                } else {
218                    objectsEqual = objectsEqual && thisInventoryConditionPK.equals(thatInventoryConditionPK);
219                }
220            }
221            
222            if(objectsEqual) {
223                UnitOfMeasureTypePK thisUnitOfMeasureTypePK = getUnitOfMeasureTypePK();
224                UnitOfMeasureTypePK thatUnitOfMeasureTypePK = that.getUnitOfMeasureTypePK();
225                
226                if(thisUnitOfMeasureTypePK == null) {
227                    objectsEqual = objectsEqual && (thatUnitOfMeasureTypePK == null);
228                } else {
229                    objectsEqual = objectsEqual && thisUnitOfMeasureTypePK.equals(thatUnitOfMeasureTypePK);
230                }
231            }
232            
233            if(objectsEqual) {
234                Long thisMinimumQuantity = getMinimumQuantity();
235                Long thatMinimumQuantity = that.getMinimumQuantity();
236                
237                if(thisMinimumQuantity == null) {
238                    objectsEqual = objectsEqual && (thatMinimumQuantity == null);
239                } else {
240                    objectsEqual = objectsEqual && thisMinimumQuantity.equals(thatMinimumQuantity);
241                }
242            }
243            
244            if(objectsEqual) {
245                Long thisMaximumQuantity = getMaximumQuantity();
246                Long thatMaximumQuantity = that.getMaximumQuantity();
247                
248                if(thisMaximumQuantity == null) {
249                    objectsEqual = objectsEqual && (thatMaximumQuantity == null);
250                } else {
251                    objectsEqual = objectsEqual && thisMaximumQuantity.equals(thatMaximumQuantity);
252                }
253            }
254            
255            if(objectsEqual) {
256                Long thisFromTime = getFromTime();
257                Long thatFromTime = that.getFromTime();
258                
259                if(thisFromTime == null) {
260                    objectsEqual = objectsEqual && (thatFromTime == null);
261                } else {
262                    objectsEqual = objectsEqual && thisFromTime.equals(thatFromTime);
263                }
264            }
265            
266            if(objectsEqual) {
267                Long thisThruTime = getThruTime();
268                Long thatThruTime = that.getThruTime();
269                
270                if(thisThruTime == null) {
271                    objectsEqual = objectsEqual && (thatThruTime == null);
272                } else {
273                    objectsEqual = objectsEqual && thisThruTime.equals(thatThruTime);
274                }
275            }
276            
277            return objectsEqual;
278        } else {
279            return false;
280        }
281    }
282    
283    @Override
284    public boolean hasBeenModified() {
285        return itemPKHasBeenModified || inventoryConditionPKHasBeenModified || unitOfMeasureTypePKHasBeenModified || minimumQuantityHasBeenModified || maximumQuantityHasBeenModified || fromTimeHasBeenModified || thruTimeHasBeenModified;
286    }
287    
288    @Override
289    public void clearHasBeenModified() {
290        itemPKHasBeenModified = false;
291        inventoryConditionPKHasBeenModified = false;
292        unitOfMeasureTypePKHasBeenModified = false;
293        minimumQuantityHasBeenModified = false;
294        maximumQuantityHasBeenModified = false;
295        fromTimeHasBeenModified = false;
296        thruTimeHasBeenModified = false;
297    }
298    
299    @Nonnull
300    public ItemPK getItemPK() {
301        return itemPK;
302    }
303    
304    public void setItemPK(@Nonnull ItemPK itemPK)
305            throws PersistenceNotNullException {
306        checkForNull(itemPK);
307        
308        boolean update = true;
309        
310        if(this.itemPK != null) {
311            if(this.itemPK.equals(itemPK)) {
312                update = false;
313            }
314        } else if(itemPK == null) {
315            update = false;
316        }
317        
318        if(update) {
319            this.itemPK = itemPK;
320            itemPKHasBeenModified = true;
321            clearHashAndString();
322        }
323    }
324    
325    public boolean getItemPKHasBeenModified() {
326        return itemPKHasBeenModified;
327    }
328    
329    @Nonnull
330    public InventoryConditionPK getInventoryConditionPK() {
331        return inventoryConditionPK;
332    }
333    
334    public void setInventoryConditionPK(@Nonnull InventoryConditionPK inventoryConditionPK)
335            throws PersistenceNotNullException {
336        checkForNull(inventoryConditionPK);
337        
338        boolean update = true;
339        
340        if(this.inventoryConditionPK != null) {
341            if(this.inventoryConditionPK.equals(inventoryConditionPK)) {
342                update = false;
343            }
344        } else if(inventoryConditionPK == null) {
345            update = false;
346        }
347        
348        if(update) {
349            this.inventoryConditionPK = inventoryConditionPK;
350            inventoryConditionPKHasBeenModified = true;
351            clearHashAndString();
352        }
353    }
354    
355    public boolean getInventoryConditionPKHasBeenModified() {
356        return inventoryConditionPKHasBeenModified;
357    }
358    
359    @Nonnull
360    public UnitOfMeasureTypePK getUnitOfMeasureTypePK() {
361        return unitOfMeasureTypePK;
362    }
363    
364    public void setUnitOfMeasureTypePK(@Nonnull UnitOfMeasureTypePK unitOfMeasureTypePK)
365            throws PersistenceNotNullException {
366        checkForNull(unitOfMeasureTypePK);
367        
368        boolean update = true;
369        
370        if(this.unitOfMeasureTypePK != null) {
371            if(this.unitOfMeasureTypePK.equals(unitOfMeasureTypePK)) {
372                update = false;
373            }
374        } else if(unitOfMeasureTypePK == null) {
375            update = false;
376        }
377        
378        if(update) {
379            this.unitOfMeasureTypePK = unitOfMeasureTypePK;
380            unitOfMeasureTypePKHasBeenModified = true;
381            clearHashAndString();
382        }
383    }
384    
385    public boolean getUnitOfMeasureTypePKHasBeenModified() {
386        return unitOfMeasureTypePKHasBeenModified;
387    }
388    
389    @Nullable
390    public Long getMinimumQuantity() {
391        return minimumQuantity;
392    }
393    
394    public void setMinimumQuantity(@Nullable Long minimumQuantity) {
395        boolean update = true;
396        
397        if(this.minimumQuantity != null) {
398            if(this.minimumQuantity.equals(minimumQuantity)) {
399                update = false;
400            }
401        } else if(minimumQuantity == null) {
402            update = false;
403        }
404        
405        if(update) {
406            this.minimumQuantity = minimumQuantity;
407            minimumQuantityHasBeenModified = true;
408            clearHashAndString();
409        }
410    }
411    
412    public boolean getMinimumQuantityHasBeenModified() {
413        return minimumQuantityHasBeenModified;
414    }
415    
416    @Nullable
417    public Long getMaximumQuantity() {
418        return maximumQuantity;
419    }
420    
421    public void setMaximumQuantity(@Nullable Long maximumQuantity) {
422        boolean update = true;
423        
424        if(this.maximumQuantity != null) {
425            if(this.maximumQuantity.equals(maximumQuantity)) {
426                update = false;
427            }
428        } else if(maximumQuantity == null) {
429            update = false;
430        }
431        
432        if(update) {
433            this.maximumQuantity = maximumQuantity;
434            maximumQuantityHasBeenModified = true;
435            clearHashAndString();
436        }
437    }
438    
439    public boolean getMaximumQuantityHasBeenModified() {
440        return maximumQuantityHasBeenModified;
441    }
442    
443    @Nonnull
444    public Long getFromTime() {
445        return fromTime;
446    }
447    
448    public void setFromTime(@Nonnull Long fromTime)
449            throws PersistenceNotNullException {
450        checkForNull(fromTime);
451        
452        boolean update = true;
453        
454        if(this.fromTime != null) {
455            if(this.fromTime.equals(fromTime)) {
456                update = false;
457            }
458        } else if(fromTime == null) {
459            update = false;
460        }
461        
462        if(update) {
463            this.fromTime = fromTime;
464            fromTimeHasBeenModified = true;
465            clearHashAndString();
466        }
467    }
468    
469    public boolean getFromTimeHasBeenModified() {
470        return fromTimeHasBeenModified;
471    }
472    
473    @Nonnull
474    public Long getThruTime() {
475        return thruTime;
476    }
477    
478    public void setThruTime(@Nonnull Long thruTime)
479            throws PersistenceNotNullException {
480        checkForNull(thruTime);
481        
482        boolean update = true;
483        
484        if(this.thruTime != null) {
485            if(this.thruTime.equals(thruTime)) {
486                update = false;
487            }
488        } else if(thruTime == null) {
489            update = false;
490        }
491        
492        if(update) {
493            this.thruTime = thruTime;
494            thruTimeHasBeenModified = true;
495            clearHashAndString();
496        }
497    }
498    
499    public boolean getThruTimeHasBeenModified() {
500        return thruTimeHasBeenModified;
501    }
502    
503}