001// --------------------------------------------------------------------------------
002// Copyright 2002-2024 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
039public class PartyTrainingClassSessionPageValue
040        extends BaseValue<PartyTrainingClassSessionPagePK>
041        implements Cloneable, Serializable {
042    
043    private PartyTrainingClassSessionPK partyTrainingClassSessionPK;
044    private boolean partyTrainingClassSessionPKHasBeenModified = false;
045    private Integer partyTrainingClassSessionPageSequence;
046    private boolean partyTrainingClassSessionPageSequenceHasBeenModified = false;
047    private TrainingClassPagePK trainingClassPagePK;
048    private boolean trainingClassPagePKHasBeenModified = false;
049    private Long readingStartTime;
050    private boolean readingStartTimeHasBeenModified = false;
051    private Long readingEndTime;
052    private boolean readingEndTimeHasBeenModified = false;
053    private Long fromTime;
054    private boolean fromTimeHasBeenModified = false;
055    private Long thruTime;
056    private boolean thruTimeHasBeenModified = false;
057    
058    private transient Integer _hashCode = null;
059    private transient String _stringValue = null;
060    
061    private void constructFields(PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionPageSequence, TrainingClassPagePK trainingClassPagePK, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
062            throws PersistenceNotNullException {
063        checkForNull(partyTrainingClassSessionPK);
064        this.partyTrainingClassSessionPK = partyTrainingClassSessionPK;
065        checkForNull(partyTrainingClassSessionPageSequence);
066        this.partyTrainingClassSessionPageSequence = partyTrainingClassSessionPageSequence;
067        checkForNull(trainingClassPagePK);
068        this.trainingClassPagePK = trainingClassPagePK;
069        checkForNull(readingStartTime);
070        this.readingStartTime = readingStartTime;
071        this.readingEndTime = readingEndTime;
072        checkForNull(fromTime);
073        this.fromTime = fromTime;
074        checkForNull(thruTime);
075        this.thruTime = thruTime;
076    }
077    
078    /** Creates a new instance of PartyTrainingClassSessionPageValue */
079    public PartyTrainingClassSessionPageValue(PartyTrainingClassSessionPagePK partyTrainingClassSessionPagePK, PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionPageSequence, TrainingClassPagePK trainingClassPagePK, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
080            throws PersistenceNotNullException {
081        super(partyTrainingClassSessionPagePK);
082        constructFields(partyTrainingClassSessionPK, partyTrainingClassSessionPageSequence, trainingClassPagePK, readingStartTime, readingEndTime, fromTime, thruTime);
083    }
084    
085    /** Creates a new instance of PartyTrainingClassSessionPageValue */
086    public PartyTrainingClassSessionPageValue(PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionPageSequence, TrainingClassPagePK trainingClassPagePK, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
087            throws PersistenceNotNullException {
088        super();
089        constructFields(partyTrainingClassSessionPK, partyTrainingClassSessionPageSequence, trainingClassPagePK, readingStartTime, readingEndTime, fromTime, thruTime);
090    }
091    
092   @Override
093   public PartyTrainingClassSessionPageFactory getBaseFactoryInstance() {
094        return PartyTrainingClassSessionPageFactory.getInstance();
095    }
096    
097    @Override
098    public PartyTrainingClassSessionPageValue clone() {
099        Object result;
100        
101        try {
102            result = super.clone();
103        } catch (CloneNotSupportedException cnse) {
104            // This shouldn't happen, fail when it does.
105            throw new PersistenceCloneException(cnse);
106        }
107        
108        return (PartyTrainingClassSessionPageValue)result;
109    }
110    
111   @Override
112    public PartyTrainingClassSessionPagePK getPrimaryKey() {
113        if(_primaryKey == null) {
114            _primaryKey = new PartyTrainingClassSessionPagePK(entityId);
115        }
116        
117        return _primaryKey;
118    }
119    
120    private void clearHashAndString() {
121        _hashCode = null;
122        _stringValue = null;
123    }
124    
125    @Override
126    public int hashCode() {
127        if(_hashCode == null) {
128            int hashCode = 17;
129            
130            hashCode = 37 * hashCode + ((entityId != null) ? entityId.hashCode() : 0);
131            
132            hashCode = 37 * hashCode + ((partyTrainingClassSessionPK != null) ? partyTrainingClassSessionPK.hashCode() : 0);
133            hashCode = 37 * hashCode + ((partyTrainingClassSessionPageSequence != null) ? partyTrainingClassSessionPageSequence.hashCode() : 0);
134            hashCode = 37 * hashCode + ((trainingClassPagePK != null) ? trainingClassPagePK.hashCode() : 0);
135            hashCode = 37 * hashCode + ((readingStartTime != null) ? readingStartTime.hashCode() : 0);
136            hashCode = 37 * hashCode + ((readingEndTime != null) ? readingEndTime.hashCode() : 0);
137            hashCode = 37 * hashCode + ((fromTime != null) ? fromTime.hashCode() : 0);
138            hashCode = 37 * hashCode + ((thruTime != null) ? thruTime.hashCode() : 0);
139            
140            _hashCode = hashCode;
141        }
142        
143        return _hashCode;
144    }
145    
146    @Override
147    public String toString() {
148        if(_stringValue == null) {
149            StringBuilder stringValue = new StringBuilder("{");
150            
151            stringValue.append("entityId=").append(getEntityId());
152            
153            stringValue.append(", partyTrainingClassSessionPK=").append(getPartyTrainingClassSessionPK());
154            stringValue.append(", partyTrainingClassSessionPageSequence=").append(getPartyTrainingClassSessionPageSequence());
155            stringValue.append(", trainingClassPagePK=").append(getTrainingClassPagePK());
156            stringValue.append(", readingStartTime=").append(getReadingStartTime());
157            stringValue.append(", readingEndTime=").append(getReadingEndTime());
158            stringValue.append(", fromTime=").append(getFromTime());
159            stringValue.append(", thruTime=").append(getThruTime());
160            
161            stringValue.append('}');
162            
163            _stringValue = stringValue.toString();
164        }
165        return _stringValue;
166    }
167    
168    @Override
169    public boolean equals(Object other) {
170        if(this == other)
171            return true;
172        
173        if(!hasIdentity())
174            return false;
175        
176        if(other instanceof  PartyTrainingClassSessionPageValue) {
177            PartyTrainingClassSessionPageValue that = (PartyTrainingClassSessionPageValue)other;
178            
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 = 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) {
197            PartyTrainingClassSessionPageValue that = (PartyTrainingClassSessionPageValue)other;
198            boolean objectsEqual = true;
199            
200            
201            if(objectsEqual) {
202                PartyTrainingClassSessionPK thisPartyTrainingClassSessionPK = getPartyTrainingClassSessionPK();
203                PartyTrainingClassSessionPK thatPartyTrainingClassSessionPK = that.getPartyTrainingClassSessionPK();
204                
205                if(thisPartyTrainingClassSessionPK == null) {
206                    objectsEqual = objectsEqual && (thatPartyTrainingClassSessionPK == null);
207                } else {
208                    objectsEqual = objectsEqual && thisPartyTrainingClassSessionPK.equals(thatPartyTrainingClassSessionPK);
209                }
210            }
211            
212            if(objectsEqual) {
213                Integer thisPartyTrainingClassSessionPageSequence = getPartyTrainingClassSessionPageSequence();
214                Integer thatPartyTrainingClassSessionPageSequence = that.getPartyTrainingClassSessionPageSequence();
215                
216                if(thisPartyTrainingClassSessionPageSequence == null) {
217                    objectsEqual = objectsEqual && (thatPartyTrainingClassSessionPageSequence == null);
218                } else {
219                    objectsEqual = objectsEqual && thisPartyTrainingClassSessionPageSequence.equals(thatPartyTrainingClassSessionPageSequence);
220                }
221            }
222            
223            if(objectsEqual) {
224                TrainingClassPagePK thisTrainingClassPagePK = getTrainingClassPagePK();
225                TrainingClassPagePK thatTrainingClassPagePK = that.getTrainingClassPagePK();
226                
227                if(thisTrainingClassPagePK == null) {
228                    objectsEqual = objectsEqual && (thatTrainingClassPagePK == null);
229                } else {
230                    objectsEqual = objectsEqual && thisTrainingClassPagePK.equals(thatTrainingClassPagePK);
231                }
232            }
233            
234            if(objectsEqual) {
235                Long thisReadingStartTime = getReadingStartTime();
236                Long thatReadingStartTime = that.getReadingStartTime();
237                
238                if(thisReadingStartTime == null) {
239                    objectsEqual = objectsEqual && (thatReadingStartTime == null);
240                } else {
241                    objectsEqual = objectsEqual && thisReadingStartTime.equals(thatReadingStartTime);
242                }
243            }
244            
245            if(objectsEqual) {
246                Long thisReadingEndTime = getReadingEndTime();
247                Long thatReadingEndTime = that.getReadingEndTime();
248                
249                if(thisReadingEndTime == null) {
250                    objectsEqual = objectsEqual && (thatReadingEndTime == null);
251                } else {
252                    objectsEqual = objectsEqual && thisReadingEndTime.equals(thatReadingEndTime);
253                }
254            }
255            
256            if(objectsEqual) {
257                Long thisFromTime = getFromTime();
258                Long thatFromTime = that.getFromTime();
259                
260                if(thisFromTime == null) {
261                    objectsEqual = objectsEqual && (thatFromTime == null);
262                } else {
263                    objectsEqual = objectsEqual && thisFromTime.equals(thatFromTime);
264                }
265            }
266            
267            if(objectsEqual) {
268                Long thisThruTime = getThruTime();
269                Long thatThruTime = that.getThruTime();
270                
271                if(thisThruTime == null) {
272                    objectsEqual = objectsEqual && (thatThruTime == null);
273                } else {
274                    objectsEqual = objectsEqual && thisThruTime.equals(thatThruTime);
275                }
276            }
277            
278            return objectsEqual;
279        } else {
280            return false;
281        }
282    }
283    
284    @Override
285    public boolean hasBeenModified() {
286        return partyTrainingClassSessionPKHasBeenModified || partyTrainingClassSessionPageSequenceHasBeenModified || trainingClassPagePKHasBeenModified || readingStartTimeHasBeenModified || readingEndTimeHasBeenModified || fromTimeHasBeenModified || thruTimeHasBeenModified;
287    }
288    
289    @Override
290    public void clearHasBeenModified() {
291        partyTrainingClassSessionPKHasBeenModified = false;
292        partyTrainingClassSessionPageSequenceHasBeenModified = false;
293        trainingClassPagePKHasBeenModified = false;
294        readingStartTimeHasBeenModified = false;
295        readingEndTimeHasBeenModified = false;
296        fromTimeHasBeenModified = false;
297        thruTimeHasBeenModified = false;
298    }
299    
300    public PartyTrainingClassSessionPK getPartyTrainingClassSessionPK() {
301        return partyTrainingClassSessionPK;
302    }
303    
304    public void setPartyTrainingClassSessionPK(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    public Integer getPartyTrainingClassSessionPageSequence() {
330        return partyTrainingClassSessionPageSequence;
331    }
332    
333    public void setPartyTrainingClassSessionPageSequence(Integer partyTrainingClassSessionPageSequence)
334            throws PersistenceNotNullException {
335        checkForNull(partyTrainingClassSessionPageSequence);
336        
337        boolean update = true;
338        
339        if(this.partyTrainingClassSessionPageSequence != null) {
340            if(this.partyTrainingClassSessionPageSequence.equals(partyTrainingClassSessionPageSequence)) {
341                update = false;
342            }
343        } else if(partyTrainingClassSessionPageSequence == null) {
344            update = false;
345        }
346        
347        if(update) {
348            this.partyTrainingClassSessionPageSequence = partyTrainingClassSessionPageSequence;
349            partyTrainingClassSessionPageSequenceHasBeenModified = true;
350            clearHashAndString();
351        }
352    }
353    
354    public boolean getPartyTrainingClassSessionPageSequenceHasBeenModified() {
355        return partyTrainingClassSessionPageSequenceHasBeenModified;
356    }
357    
358    public TrainingClassPagePK getTrainingClassPagePK() {
359        return trainingClassPagePK;
360    }
361    
362    public void setTrainingClassPagePK(TrainingClassPagePK trainingClassPagePK)
363            throws PersistenceNotNullException {
364        checkForNull(trainingClassPagePK);
365        
366        boolean update = true;
367        
368        if(this.trainingClassPagePK != null) {
369            if(this.trainingClassPagePK.equals(trainingClassPagePK)) {
370                update = false;
371            }
372        } else if(trainingClassPagePK == null) {
373            update = false;
374        }
375        
376        if(update) {
377            this.trainingClassPagePK = trainingClassPagePK;
378            trainingClassPagePKHasBeenModified = true;
379            clearHashAndString();
380        }
381    }
382    
383    public boolean getTrainingClassPagePKHasBeenModified() {
384        return trainingClassPagePKHasBeenModified;
385    }
386    
387    public Long getReadingStartTime() {
388        return readingStartTime;
389    }
390    
391    public void setReadingStartTime(Long readingStartTime)
392            throws PersistenceNotNullException {
393        checkForNull(readingStartTime);
394        
395        boolean update = true;
396        
397        if(this.readingStartTime != null) {
398            if(this.readingStartTime.equals(readingStartTime)) {
399                update = false;
400            }
401        } else if(readingStartTime == null) {
402            update = false;
403        }
404        
405        if(update) {
406            this.readingStartTime = readingStartTime;
407            readingStartTimeHasBeenModified = true;
408            clearHashAndString();
409        }
410    }
411    
412    public boolean getReadingStartTimeHasBeenModified() {
413        return readingStartTimeHasBeenModified;
414    }
415    
416    public Long getReadingEndTime() {
417        return readingEndTime;
418    }
419    
420    public void setReadingEndTime(Long readingEndTime) {
421        boolean update = true;
422        
423        if(this.readingEndTime != null) {
424            if(this.readingEndTime.equals(readingEndTime)) {
425                update = false;
426            }
427        } else if(readingEndTime == null) {
428            update = false;
429        }
430        
431        if(update) {
432            this.readingEndTime = readingEndTime;
433            readingEndTimeHasBeenModified = true;
434            clearHashAndString();
435        }
436    }
437    
438    public boolean getReadingEndTimeHasBeenModified() {
439        return readingEndTimeHasBeenModified;
440    }
441    
442    public Long getFromTime() {
443        return fromTime;
444    }
445    
446    public void setFromTime(Long fromTime)
447            throws PersistenceNotNullException {
448        checkForNull(fromTime);
449        
450        boolean update = true;
451        
452        if(this.fromTime != null) {
453            if(this.fromTime.equals(fromTime)) {
454                update = false;
455            }
456        } else if(fromTime == null) {
457            update = false;
458        }
459        
460        if(update) {
461            this.fromTime = fromTime;
462            fromTimeHasBeenModified = true;
463            clearHashAndString();
464        }
465    }
466    
467    public boolean getFromTimeHasBeenModified() {
468        return fromTimeHasBeenModified;
469    }
470    
471    public Long getThruTime() {
472        return thruTime;
473    }
474    
475    public void setThruTime(Long thruTime)
476            throws PersistenceNotNullException {
477        checkForNull(thruTime);
478        
479        boolean update = true;
480        
481        if(this.thruTime != null) {
482            if(this.thruTime.equals(thruTime)) {
483                update = false;
484            }
485        } else if(thruTime == null) {
486            update = false;
487        }
488        
489        if(update) {
490            this.thruTime = thruTime;
491            thruTimeHasBeenModified = true;
492            clearHashAndString();
493        }
494    }
495    
496    public boolean getThruTimeHasBeenModified() {
497        return thruTimeHasBeenModified;
498    }
499    
500}