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 * PartyTrainingClassStatusValue.java
021 */
022
023package com.echothree.model.data.training.server.value;
024
025import com.echothree.model.data.training.common.pk.PartyTrainingClassStatusPK;
026
027import com.echothree.model.data.training.server.factory.PartyTrainingClassStatusFactory;
028
029import com.echothree.model.data.training.common.pk.PartyTrainingClassPK;
030import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionPK;
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 PartyTrainingClassStatusValue
043        extends BaseValue<PartyTrainingClassStatusPK>
044        implements Cloneable, Serializable {
045    
046    private PartyTrainingClassPK partyTrainingClassPK;
047    private boolean partyTrainingClassPKHasBeenModified = false;
048    private Integer partyTrainingClassSessionSequence;
049    private boolean partyTrainingClassSessionSequenceHasBeenModified = false;
050    private PartyTrainingClassSessionPK lastPartyTrainingClassSessionPK;
051    private boolean lastPartyTrainingClassSessionPKHasBeenModified = false;
052    
053    private transient Integer _hashCode = null;
054    private transient String _stringValue = null;
055    
056    private void constructFields(PartyTrainingClassPK partyTrainingClassPK, Integer partyTrainingClassSessionSequence, PartyTrainingClassSessionPK lastPartyTrainingClassSessionPK)
057            throws PersistenceNotNullException {
058        checkForNull(partyTrainingClassPK);
059        this.partyTrainingClassPK = partyTrainingClassPK;
060        checkForNull(partyTrainingClassSessionSequence);
061        this.partyTrainingClassSessionSequence = partyTrainingClassSessionSequence;
062        this.lastPartyTrainingClassSessionPK = lastPartyTrainingClassSessionPK;
063    }
064    
065    /** Creates a new instance of PartyTrainingClassStatusValue */
066    public PartyTrainingClassStatusValue(PartyTrainingClassStatusPK partyTrainingClassStatusPK, PartyTrainingClassPK partyTrainingClassPK, Integer partyTrainingClassSessionSequence, PartyTrainingClassSessionPK lastPartyTrainingClassSessionPK)
067            throws PersistenceNotNullException {
068        super(partyTrainingClassStatusPK);
069        constructFields(partyTrainingClassPK, partyTrainingClassSessionSequence, lastPartyTrainingClassSessionPK);
070    }
071    
072    /** Creates a new instance of PartyTrainingClassStatusValue */
073    public PartyTrainingClassStatusValue(PartyTrainingClassPK partyTrainingClassPK, Integer partyTrainingClassSessionSequence, PartyTrainingClassSessionPK lastPartyTrainingClassSessionPK)
074            throws PersistenceNotNullException {
075        super();
076        constructFields(partyTrainingClassPK, partyTrainingClassSessionSequence, lastPartyTrainingClassSessionPK);
077    }
078    
079    @Override
080    @Nonnull
081    public PartyTrainingClassStatusFactory getBaseFactoryInstance() {
082        return PartyTrainingClassStatusFactory.getInstance();
083    }
084    
085    @Override
086    @Nonnull
087    public PartyTrainingClassStatusValue clone() {
088        Object result;
089        
090        try {
091            result = super.clone();
092        } catch (CloneNotSupportedException cnse) {
093            // This shouldn't happen, fail when it does.
094            throw new PersistenceCloneException(cnse);
095        }
096        
097        return (PartyTrainingClassStatusValue)result;
098    }
099    
100    @Override
101    @Nonnull
102    public PartyTrainingClassStatusPK getPrimaryKey() {
103        if(_primaryKey == null) {
104            _primaryKey = new PartyTrainingClassStatusPK(entityId);
105        }
106        
107        return _primaryKey;
108    }
109    
110    private void clearHashAndString() {
111        _hashCode = null;
112        _stringValue = null;
113    }
114    
115    @Override
116    public int hashCode() {
117        if(_hashCode == null) {
118            int hashCode = 17;
119            
120            hashCode = 37 * hashCode + ((entityId != null) ? entityId.hashCode() : 0);
121            
122            hashCode = 37 * hashCode + ((partyTrainingClassPK != null) ? partyTrainingClassPK.hashCode() : 0);
123            hashCode = 37 * hashCode + ((partyTrainingClassSessionSequence != null) ? partyTrainingClassSessionSequence.hashCode() : 0);
124            hashCode = 37 * hashCode + ((lastPartyTrainingClassSessionPK != null) ? lastPartyTrainingClassSessionPK.hashCode() : 0);
125            
126            _hashCode = hashCode;
127        }
128        
129        return _hashCode;
130    }
131    
132    @Override
133    @Nonnull
134    public String toString() {
135        if(_stringValue == null) {
136            _stringValue = "{" + 
137                    "entityId=" + getEntityId() +
138                    ", partyTrainingClassPK=" + getPartyTrainingClassPK() +
139                    ", partyTrainingClassSessionSequence=" + getPartyTrainingClassSessionSequence() +
140                    ", lastPartyTrainingClassSessionPK=" + getLastPartyTrainingClassSessionPK() +
141                    "}";
142        }
143        return _stringValue;
144    }
145    
146    @Override
147    public boolean equals(Object other) {
148        if(this == other)
149            return true;
150        
151        if(!hasIdentity())
152            return false;
153        
154        if(other instanceof  PartyTrainingClassStatusValue that) {
155            if(!that.hasIdentity())
156                return false;
157            
158            Long thisEntityId = getEntityId();
159            Long thatEntityId = that.getEntityId();
160            
161            boolean objectsEqual = thisEntityId.equals(thatEntityId);
162            if(objectsEqual)
163                objectsEqual = isIdentical(that);
164            
165            return objectsEqual;
166        } else {
167            return false;
168        }
169    }
170    
171    public boolean isIdentical(Object other) {
172        if(other instanceof PartyTrainingClassStatusValue that) {
173            boolean objectsEqual = true;
174            
175            
176            if(objectsEqual) {
177                PartyTrainingClassPK thisPartyTrainingClassPK = getPartyTrainingClassPK();
178                PartyTrainingClassPK thatPartyTrainingClassPK = that.getPartyTrainingClassPK();
179                
180                if(thisPartyTrainingClassPK == null) {
181                    objectsEqual = objectsEqual && (thatPartyTrainingClassPK == null);
182                } else {
183                    objectsEqual = objectsEqual && thisPartyTrainingClassPK.equals(thatPartyTrainingClassPK);
184                }
185            }
186            
187            if(objectsEqual) {
188                Integer thisPartyTrainingClassSessionSequence = getPartyTrainingClassSessionSequence();
189                Integer thatPartyTrainingClassSessionSequence = that.getPartyTrainingClassSessionSequence();
190                
191                if(thisPartyTrainingClassSessionSequence == null) {
192                    objectsEqual = objectsEqual && (thatPartyTrainingClassSessionSequence == null);
193                } else {
194                    objectsEqual = objectsEqual && thisPartyTrainingClassSessionSequence.equals(thatPartyTrainingClassSessionSequence);
195                }
196            }
197            
198            if(objectsEqual) {
199                PartyTrainingClassSessionPK thisLastPartyTrainingClassSessionPK = getLastPartyTrainingClassSessionPK();
200                PartyTrainingClassSessionPK thatLastPartyTrainingClassSessionPK = that.getLastPartyTrainingClassSessionPK();
201                
202                if(thisLastPartyTrainingClassSessionPK == null) {
203                    objectsEqual = objectsEqual && (thatLastPartyTrainingClassSessionPK == null);
204                } else {
205                    objectsEqual = objectsEqual && thisLastPartyTrainingClassSessionPK.equals(thatLastPartyTrainingClassSessionPK);
206                }
207            }
208            
209            return objectsEqual;
210        } else {
211            return false;
212        }
213    }
214    
215    @Override
216    public boolean hasBeenModified() {
217        return partyTrainingClassPKHasBeenModified || partyTrainingClassSessionSequenceHasBeenModified || lastPartyTrainingClassSessionPKHasBeenModified;
218    }
219    
220    @Override
221    public void clearHasBeenModified() {
222        partyTrainingClassPKHasBeenModified = false;
223        partyTrainingClassSessionSequenceHasBeenModified = false;
224        lastPartyTrainingClassSessionPKHasBeenModified = false;
225    }
226    
227    @Nonnull
228    public PartyTrainingClassPK getPartyTrainingClassPK() {
229        return partyTrainingClassPK;
230    }
231    
232    public void setPartyTrainingClassPK(@Nonnull PartyTrainingClassPK partyTrainingClassPK)
233            throws PersistenceNotNullException {
234        checkForNull(partyTrainingClassPK);
235        
236        boolean update = true;
237        
238        if(this.partyTrainingClassPK != null) {
239            if(this.partyTrainingClassPK.equals(partyTrainingClassPK)) {
240                update = false;
241            }
242        } else if(partyTrainingClassPK == null) {
243            update = false;
244        }
245        
246        if(update) {
247            this.partyTrainingClassPK = partyTrainingClassPK;
248            partyTrainingClassPKHasBeenModified = true;
249            clearHashAndString();
250        }
251    }
252    
253    public boolean getPartyTrainingClassPKHasBeenModified() {
254        return partyTrainingClassPKHasBeenModified;
255    }
256    
257    @Nonnull
258    public Integer getPartyTrainingClassSessionSequence() {
259        return partyTrainingClassSessionSequence;
260    }
261    
262    public void setPartyTrainingClassSessionSequence(@Nonnull Integer partyTrainingClassSessionSequence)
263            throws PersistenceNotNullException {
264        checkForNull(partyTrainingClassSessionSequence);
265        
266        boolean update = true;
267        
268        if(this.partyTrainingClassSessionSequence != null) {
269            if(this.partyTrainingClassSessionSequence.equals(partyTrainingClassSessionSequence)) {
270                update = false;
271            }
272        } else if(partyTrainingClassSessionSequence == null) {
273            update = false;
274        }
275        
276        if(update) {
277            this.partyTrainingClassSessionSequence = partyTrainingClassSessionSequence;
278            partyTrainingClassSessionSequenceHasBeenModified = true;
279            clearHashAndString();
280        }
281    }
282    
283    public boolean getPartyTrainingClassSessionSequenceHasBeenModified() {
284        return partyTrainingClassSessionSequenceHasBeenModified;
285    }
286    
287    @Nullable
288    public PartyTrainingClassSessionPK getLastPartyTrainingClassSessionPK() {
289        return lastPartyTrainingClassSessionPK;
290    }
291    
292    public void setLastPartyTrainingClassSessionPK(@Nullable PartyTrainingClassSessionPK lastPartyTrainingClassSessionPK) {
293        boolean update = true;
294        
295        if(this.lastPartyTrainingClassSessionPK != null) {
296            if(this.lastPartyTrainingClassSessionPK.equals(lastPartyTrainingClassSessionPK)) {
297                update = false;
298            }
299        } else if(lastPartyTrainingClassSessionPK == null) {
300            update = false;
301        }
302        
303        if(update) {
304            this.lastPartyTrainingClassSessionPK = lastPartyTrainingClassSessionPK;
305            lastPartyTrainingClassSessionPKHasBeenModified = true;
306            clearHashAndString();
307        }
308    }
309    
310    public boolean getLastPartyTrainingClassSessionPKHasBeenModified() {
311        return lastPartyTrainingClassSessionPKHasBeenModified;
312    }
313    
314}