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 * PartyTrainingClassSessionPageValue.java
021 */
022
023package com.echothree.model.data.training.server.value;
024
025import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionPagePK;
026
027import com.echothree.model.data.training.server.factory.PartyTrainingClassSessionPageFactory;
028
029import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionPK;
030import com.echothree.model.data.training.common.pk.TrainingClassPagePK;
031
032import com.echothree.util.common.exception.PersistenceCloneException;
033import com.echothree.util.common.exception.PersistenceNotNullException;
034
035import com.echothree.util.server.persistence.BaseValue;
036
037import java.io.Serializable;
038
039import javax.annotation.Nonnull;
040import javax.annotation.Nullable;
041
042public class PartyTrainingClassSessionPageValue
043        extends BaseValue<PartyTrainingClassSessionPagePK>
044        implements Cloneable, Serializable {
045    
046    private PartyTrainingClassSessionPK partyTrainingClassSessionPK;
047    private boolean partyTrainingClassSessionPKHasBeenModified = false;
048    private Integer partyTrainingClassSessionPageSequence;
049    private boolean partyTrainingClassSessionPageSequenceHasBeenModified = false;
050    private TrainingClassPagePK trainingClassPagePK;
051    private boolean trainingClassPagePKHasBeenModified = false;
052    private Long readingStartTime;
053    private boolean readingStartTimeHasBeenModified = false;
054    private Long readingEndTime;
055    private boolean readingEndTimeHasBeenModified = false;
056    private Long fromTime;
057    private boolean fromTimeHasBeenModified = false;
058    private Long thruTime;
059    private boolean thruTimeHasBeenModified = false;
060    
061    private transient Integer _hashCode = null;
062    private transient String _stringValue = null;
063    
064    private void constructFields(PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionPageSequence, TrainingClassPagePK trainingClassPagePK, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
065            throws PersistenceNotNullException {
066        checkForNull(partyTrainingClassSessionPK);
067        this.partyTrainingClassSessionPK = partyTrainingClassSessionPK;
068        checkForNull(partyTrainingClassSessionPageSequence);
069        this.partyTrainingClassSessionPageSequence = partyTrainingClassSessionPageSequence;
070        checkForNull(trainingClassPagePK);
071        this.trainingClassPagePK = trainingClassPagePK;
072        checkForNull(readingStartTime);
073        this.readingStartTime = readingStartTime;
074        this.readingEndTime = readingEndTime;
075        checkForNull(fromTime);
076        this.fromTime = fromTime;
077        checkForNull(thruTime);
078        this.thruTime = thruTime;
079    }
080    
081    /** Creates a new instance of PartyTrainingClassSessionPageValue */
082    public PartyTrainingClassSessionPageValue(PartyTrainingClassSessionPagePK partyTrainingClassSessionPagePK, PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionPageSequence, TrainingClassPagePK trainingClassPagePK, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
083            throws PersistenceNotNullException {
084        super(partyTrainingClassSessionPagePK);
085        constructFields(partyTrainingClassSessionPK, partyTrainingClassSessionPageSequence, trainingClassPagePK, readingStartTime, readingEndTime, fromTime, thruTime);
086    }
087    
088    /** Creates a new instance of PartyTrainingClassSessionPageValue */
089    public PartyTrainingClassSessionPageValue(PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionPageSequence, TrainingClassPagePK trainingClassPagePK, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
090            throws PersistenceNotNullException {
091        super();
092        constructFields(partyTrainingClassSessionPK, partyTrainingClassSessionPageSequence, trainingClassPagePK, readingStartTime, readingEndTime, fromTime, thruTime);
093    }
094    
095    @Override
096    @Nonnull
097    public PartyTrainingClassSessionPageFactory getBaseFactoryInstance() {
098        return PartyTrainingClassSessionPageFactory.getInstance();
099    }
100    
101    @Override
102    @Nonnull
103    public PartyTrainingClassSessionPageValue 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 (PartyTrainingClassSessionPageValue)result;
114    }
115    
116    @Override
117    @Nonnull
118    public PartyTrainingClassSessionPagePK getPrimaryKey() {
119        if(_primaryKey == null) {
120            _primaryKey = new PartyTrainingClassSessionPagePK(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 + ((partyTrainingClassSessionPK != null) ? partyTrainingClassSessionPK.hashCode() : 0);
139            hashCode = 37 * hashCode + ((partyTrainingClassSessionPageSequence != null) ? partyTrainingClassSessionPageSequence.hashCode() : 0);
140            hashCode = 37 * hashCode + ((trainingClassPagePK != null) ? trainingClassPagePK.hashCode() : 0);
141            hashCode = 37 * hashCode + ((readingStartTime != null) ? readingStartTime.hashCode() : 0);
142            hashCode = 37 * hashCode + ((readingEndTime != null) ? readingEndTime.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                    ", partyTrainingClassSessionPK=" + getPartyTrainingClassSessionPK() +
159                    ", partyTrainingClassSessionPageSequence=" + getPartyTrainingClassSessionPageSequence() +
160                    ", trainingClassPagePK=" + getTrainingClassPagePK() +
161                    ", readingStartTime=" + getReadingStartTime() +
162                    ", readingEndTime=" + getReadingEndTime() +
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  PartyTrainingClassSessionPageValue 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 PartyTrainingClassSessionPageValue that) {
197            boolean objectsEqual = true;
198            
199            
200            if(objectsEqual) {
201                PartyTrainingClassSessionPK thisPartyTrainingClassSessionPK = getPartyTrainingClassSessionPK();
202                PartyTrainingClassSessionPK thatPartyTrainingClassSessionPK = that.getPartyTrainingClassSessionPK();
203                
204                if(thisPartyTrainingClassSessionPK == null) {
205                    objectsEqual = objectsEqual && (thatPartyTrainingClassSessionPK == null);
206                } else {
207                    objectsEqual = objectsEqual && thisPartyTrainingClassSessionPK.equals(thatPartyTrainingClassSessionPK);
208                }
209            }
210            
211            if(objectsEqual) {
212                Integer thisPartyTrainingClassSessionPageSequence = getPartyTrainingClassSessionPageSequence();
213                Integer thatPartyTrainingClassSessionPageSequence = that.getPartyTrainingClassSessionPageSequence();
214                
215                if(thisPartyTrainingClassSessionPageSequence == null) {
216                    objectsEqual = objectsEqual && (thatPartyTrainingClassSessionPageSequence == null);
217                } else {
218                    objectsEqual = objectsEqual && thisPartyTrainingClassSessionPageSequence.equals(thatPartyTrainingClassSessionPageSequence);
219                }
220            }
221            
222            if(objectsEqual) {
223                TrainingClassPagePK thisTrainingClassPagePK = getTrainingClassPagePK();
224                TrainingClassPagePK thatTrainingClassPagePK = that.getTrainingClassPagePK();
225                
226                if(thisTrainingClassPagePK == null) {
227                    objectsEqual = objectsEqual && (thatTrainingClassPagePK == null);
228                } else {
229                    objectsEqual = objectsEqual && thisTrainingClassPagePK.equals(thatTrainingClassPagePK);
230                }
231            }
232            
233            if(objectsEqual) {
234                Long thisReadingStartTime = getReadingStartTime();
235                Long thatReadingStartTime = that.getReadingStartTime();
236                
237                if(thisReadingStartTime == null) {
238                    objectsEqual = objectsEqual && (thatReadingStartTime == null);
239                } else {
240                    objectsEqual = objectsEqual && thisReadingStartTime.equals(thatReadingStartTime);
241                }
242            }
243            
244            if(objectsEqual) {
245                Long thisReadingEndTime = getReadingEndTime();
246                Long thatReadingEndTime = that.getReadingEndTime();
247                
248                if(thisReadingEndTime == null) {
249                    objectsEqual = objectsEqual && (thatReadingEndTime == null);
250                } else {
251                    objectsEqual = objectsEqual && thisReadingEndTime.equals(thatReadingEndTime);
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 partyTrainingClassSessionPKHasBeenModified || partyTrainingClassSessionPageSequenceHasBeenModified || trainingClassPagePKHasBeenModified || readingStartTimeHasBeenModified || readingEndTimeHasBeenModified || fromTimeHasBeenModified || thruTimeHasBeenModified;
286    }
287    
288    @Override
289    public void clearHasBeenModified() {
290        partyTrainingClassSessionPKHasBeenModified = false;
291        partyTrainingClassSessionPageSequenceHasBeenModified = false;
292        trainingClassPagePKHasBeenModified = false;
293        readingStartTimeHasBeenModified = false;
294        readingEndTimeHasBeenModified = false;
295        fromTimeHasBeenModified = false;
296        thruTimeHasBeenModified = false;
297    }
298    
299    @Nonnull
300    public PartyTrainingClassSessionPK getPartyTrainingClassSessionPK() {
301        return partyTrainingClassSessionPK;
302    }
303    
304    public void setPartyTrainingClassSessionPK(@Nonnull PartyTrainingClassSessionPK partyTrainingClassSessionPK)
305            throws PersistenceNotNullException {
306        checkForNull(partyTrainingClassSessionPK);
307        
308        boolean update = true;
309        
310        if(this.partyTrainingClassSessionPK != null) {
311            if(this.partyTrainingClassSessionPK.equals(partyTrainingClassSessionPK)) {
312                update = false;
313            }
314        } else if(partyTrainingClassSessionPK == null) {
315            update = false;
316        }
317        
318        if(update) {
319            this.partyTrainingClassSessionPK = partyTrainingClassSessionPK;
320            partyTrainingClassSessionPKHasBeenModified = true;
321            clearHashAndString();
322        }
323    }
324    
325    public boolean getPartyTrainingClassSessionPKHasBeenModified() {
326        return partyTrainingClassSessionPKHasBeenModified;
327    }
328    
329    @Nonnull
330    public Integer getPartyTrainingClassSessionPageSequence() {
331        return partyTrainingClassSessionPageSequence;
332    }
333    
334    public void setPartyTrainingClassSessionPageSequence(@Nonnull Integer partyTrainingClassSessionPageSequence)
335            throws PersistenceNotNullException {
336        checkForNull(partyTrainingClassSessionPageSequence);
337        
338        boolean update = true;
339        
340        if(this.partyTrainingClassSessionPageSequence != null) {
341            if(this.partyTrainingClassSessionPageSequence.equals(partyTrainingClassSessionPageSequence)) {
342                update = false;
343            }
344        } else if(partyTrainingClassSessionPageSequence == null) {
345            update = false;
346        }
347        
348        if(update) {
349            this.partyTrainingClassSessionPageSequence = partyTrainingClassSessionPageSequence;
350            partyTrainingClassSessionPageSequenceHasBeenModified = true;
351            clearHashAndString();
352        }
353    }
354    
355    public boolean getPartyTrainingClassSessionPageSequenceHasBeenModified() {
356        return partyTrainingClassSessionPageSequenceHasBeenModified;
357    }
358    
359    @Nonnull
360    public TrainingClassPagePK getTrainingClassPagePK() {
361        return trainingClassPagePK;
362    }
363    
364    public void setTrainingClassPagePK(@Nonnull TrainingClassPagePK trainingClassPagePK)
365            throws PersistenceNotNullException {
366        checkForNull(trainingClassPagePK);
367        
368        boolean update = true;
369        
370        if(this.trainingClassPagePK != null) {
371            if(this.trainingClassPagePK.equals(trainingClassPagePK)) {
372                update = false;
373            }
374        } else if(trainingClassPagePK == null) {
375            update = false;
376        }
377        
378        if(update) {
379            this.trainingClassPagePK = trainingClassPagePK;
380            trainingClassPagePKHasBeenModified = true;
381            clearHashAndString();
382        }
383    }
384    
385    public boolean getTrainingClassPagePKHasBeenModified() {
386        return trainingClassPagePKHasBeenModified;
387    }
388    
389    @Nonnull
390    public Long getReadingStartTime() {
391        return readingStartTime;
392    }
393    
394    public void setReadingStartTime(@Nonnull Long readingStartTime)
395            throws PersistenceNotNullException {
396        checkForNull(readingStartTime);
397        
398        boolean update = true;
399        
400        if(this.readingStartTime != null) {
401            if(this.readingStartTime.equals(readingStartTime)) {
402                update = false;
403            }
404        } else if(readingStartTime == null) {
405            update = false;
406        }
407        
408        if(update) {
409            this.readingStartTime = readingStartTime;
410            readingStartTimeHasBeenModified = true;
411            clearHashAndString();
412        }
413    }
414    
415    public boolean getReadingStartTimeHasBeenModified() {
416        return readingStartTimeHasBeenModified;
417    }
418    
419    @Nullable
420    public Long getReadingEndTime() {
421        return readingEndTime;
422    }
423    
424    public void setReadingEndTime(@Nullable Long readingEndTime) {
425        boolean update = true;
426        
427        if(this.readingEndTime != null) {
428            if(this.readingEndTime.equals(readingEndTime)) {
429                update = false;
430            }
431        } else if(readingEndTime == null) {
432            update = false;
433        }
434        
435        if(update) {
436            this.readingEndTime = readingEndTime;
437            readingEndTimeHasBeenModified = true;
438            clearHashAndString();
439        }
440    }
441    
442    public boolean getReadingEndTimeHasBeenModified() {
443        return readingEndTimeHasBeenModified;
444    }
445    
446    @Nonnull
447    public Long getFromTime() {
448        return fromTime;
449    }
450    
451    public void setFromTime(@Nonnull Long fromTime)
452            throws PersistenceNotNullException {
453        checkForNull(fromTime);
454        
455        boolean update = true;
456        
457        if(this.fromTime != null) {
458            if(this.fromTime.equals(fromTime)) {
459                update = false;
460            }
461        } else if(fromTime == null) {
462            update = false;
463        }
464        
465        if(update) {
466            this.fromTime = fromTime;
467            fromTimeHasBeenModified = true;
468            clearHashAndString();
469        }
470    }
471    
472    public boolean getFromTimeHasBeenModified() {
473        return fromTimeHasBeenModified;
474    }
475    
476    @Nonnull
477    public Long getThruTime() {
478        return thruTime;
479    }
480    
481    public void setThruTime(@Nonnull Long thruTime)
482            throws PersistenceNotNullException {
483        checkForNull(thruTime);
484        
485        boolean update = true;
486        
487        if(this.thruTime != null) {
488            if(this.thruTime.equals(thruTime)) {
489                update = false;
490            }
491        } else if(thruTime == null) {
492            update = false;
493        }
494        
495        if(update) {
496            this.thruTime = thruTime;
497            thruTimeHasBeenModified = true;
498            clearHashAndString();
499        }
500    }
501    
502    public boolean getThruTimeHasBeenModified() {
503        return thruTimeHasBeenModified;
504    }
505    
506}