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