litesoft

URLs

Explore

Commits

Diff Revisions 2 vs 21 for /trunk/Java/core/Server/src/org/litesoft/orsup/nonpublic/PersistentObjectImpl.java

         return getFinder().getSequenceSource();
     }
+    @Override
     public SymmetricEncryptorManager getEncryptorManager()
     {
         return getFinder().getEncryptorManager();
     /**
      * @return the Finder associated with this PO, either the Transaction of the NonTransactionalFinder
      */
+    @Override
     public final Finder getFinder()
     {
         Transaction transaction = getTransaction();
         return (transaction != null) ? transaction : getNonTransactionalFinder();
     }
+    @Override
     public final NonTransactionalFinder<?> getNonTransactionalFinder()
     {
         return mNonTransactionalFinder;
     }
+    @Override
     public final Transaction getTransaction()
     {
         return mTransaction;
     }
+    @Override
     public String getObjectName()
     {
         return getMetaDataForPO().getIdentifierName();
     }
+    @Override
     public String getRegisteredName()
     {
         return getClass().getName();
     }
+    @Override
     public final boolean isImmortal()
     {
         MetaDataForPO md = getMetaDataForPO();
         }
     }
+    @Override
     public final boolean isUpdatable()
     {
         MetaDataForPO md = getMetaDataForPO();
         return true;
     }
+    @Override
     public void requestDelete()
     {
         verifyMutability();
         pAcdToPO.clrValueOnPO( this );
     }
+    @Override
     public final boolean isDeleteRequested()
     {
         return mDeleteRequested;
     }
+    @Override
     public final boolean isNew()
     {
         return mNew;
     }
+    @Override
     public final boolean isAnyAttributeChanged()
     {
         return mChangeTracker.hasChanges();
     }
+    @Override
     public boolean isAttributeChanged( String pAttributeName )
     {
         return isAttributeChanged( getAccessorSCDoptional( pAttributeName ) );
     }
+    @Override
     public boolean isAttributeChanged( AttributeAccessorSCD pAttributeAccessorSCD )
     {
         return (pAttributeAccessorSCD != null) && mChangeTracker.hasChangeFor( pAttributeAccessorSCD.getName() );
     }
+    @Override
     public String[] getChangedAttributeNames()
     {
         return mChangeTracker.getChangedAttributeNames();
     }
+    @Override
     public Object getOriginalValueFor( String pAttributeName )
     {
         AttributeAccessorSCD<T> zSCD = getAccessorSCDoptional( pAttributeName );
         return getAttributeValue( pAttributeName );
     }
+    @Override
     public final boolean willTossFromTransactionCommit()
     {
         return (isNew() && isDeleteRequested()) || !isDirty();
     }
+    @Override
     public final boolean isDirty()
     {
         return isDeleteRequested() || isNew() || mForcedUpdate || isAnyAttributeChanged();
     }
+    @Override
     public void forceUpdate()
     {
         verifyMutability();
         }
     }
+    @Override
     public void forceChangeNotification()
     {
         verifyMutability();
         mForcedChangeNotification = true;
     }
+    @Override
     public boolean isForcedChangeNotification()
     {
         return mForcedChangeNotification;
     }
+    @Override
     public Object getAttributeValue( String pAttributeName )
             throws NoSuchElementException
     {
         return getAccessorSCDrequired( pAttributeName ).getValueOnPO( (T) this );
     }
+    @Override
     public void setAttributeValue( String pAttributeName, Object pValue )
             throws NoSuchElementException, AttributeIllegalArgumentException
     {
         }
     }
+    @Override
     public void addToAttributeSet( String pAttributeName, PersistentObject<?> pPOtoAdd )
             throws NoSuchElementException, AttributeIllegalArgumentException
     {
         }
     }
+    @Override
     public void removeFromAttributeSet( String pAttributeName, PersistentObject<?> pPOtoRemove )
             throws NoSuchElementException, AttributeIllegalArgumentException
     {
         throw new NoSuchElementException( "'" + pAttributeName + "' Not a 'Set' on PO type: " + getMetaDataForPO().getIdentifierName() );
     }
+    @Override
     public final ObjectHandle getObjectHandle()
     {
         return new ObjectHandle( getPersistentObjectURL(), getDisplayValue() );
     }
+    @Override
     public final PersistentObjectURL getPersistentObjectURL()
     {
         return new PersistentObjectURL( getRegisteredName(), getPersistentObjectUniqueKey() );
     private PersistentObjectUniqueKey mKey = null;
+    @Override
     public final PersistentObjectUniqueKey getPersistentObjectUniqueKey()
     {
         if ( (mKey == null) && (null == (mKey = createPersistentObjectUniqueKey())) )
     /**
      * @return non-Transactional copy of the latest version of this PO, or Null if the PO is in a Transaction and isNew() OR has been deleted
      */
+    @Override
     public final T refreshNonTransactionally()
     {
         return getNonTransactionalFinder().refresh( this );
      *
      * @throws UnsupportedOperationException - if the PO is already in the Transaction
      */
+    @Override
     public final T refreshInto( Transaction pTransaction )
             throws UnsupportedOperationException
     {
     /**
      * @return this if it is already in the Transaction, or a COPY of this in the specified Transaction
      */
+    @Override
     public final T copyInto( Transaction pTransaction )
             throws UnsupportedOperationException
     {
         return null;
     }
+    @Override
     public String getDisplayValue()
     {
         String format = Utils.deNull( getMetaDataForPO().getDisplayValueFormat() ).trim();
         return sb.append( format.substring( from ) ).toString();
     }
+    @Override
     public Object toSqlValueForEquals()
     {
         PersistentObjectUniqueKey key = getPersistentObjectUniqueKey();
         return (this == pThem) || ((pThem != null) && this.getPersistentObjectURL().equals( pThem.getPersistentObjectURL() ));
     }
+    @Override
     public final boolean equals( Object o )
     {
         return (this == o) || ((o instanceof PersistentObject) && equals( (PersistentObject) o ));
     }
+    @Override
     public final int hashCode()
     {
         return getPersistentObjectURL().hashCode();
     }
+    @Override
     public final String toString()
     {
         return getDisplayValue();
                                          new ToOneChangeEntry( pNewThem, pNewKey ) );
     }
+    @Override
     public final void verifyMutability( SupplimentedSCD pSupplimentedSCD, Object pOldValue, Object pNewValue )
             throws UnsupportedOperationException
     {
         mChangeNumber++;
     }
+    @Override
     public final int getChangeNumber()
     {
         return mChangeNumber;
         throw new IllegalStateException( "Transaction(" + mTransaction + "), does NOT implement: TransactionBackdoor" );
     }
+    @Override
     public MetaDataForPO getMetaDataForPO()
     {
         return mMetaDataForPO;
     }
+    @Override
     public Object LL_getDynamicValue( String pName )
     {
         return (mDynamicValueMap != null) ? mDynamicValueMap.get( pName ) : null;
     }
+    @Override
     public void LL_setDynamicValue( String pName, Object pValue )
     {
         if ( mDynamicValueMap == null )
     {
         public static final LazyLoadedsTracker INSTANCE = new LazyLoadedsTrackerNull();
+        @Override
         public LazyLoadedsTracker record( String pAttributeName, AbstractLazyLoadTo pLazyLoadTo )
         {
             return new LazyLoadedsTrackerImpl().record( pAttributeName, pLazyLoadTo );
         }
+        @Override
         public LazyLoadedsTracker clear()
         {
             return this;
     {
         private Map<String, AbstractLazyLoadTo> mLazyLoadeds = new HashMap<String, AbstractLazyLoadTo>();
+        @Override
         public LazyLoadedsTracker record( String pAttributeName, AbstractLazyLoadTo pLazyLoadTo )
         {
             mLazyLoadeds.put( pAttributeName, pLazyLoadTo );
             return this;
         }
+        @Override
         public LazyLoadedsTracker clear()
         {
             mLazyLoadeds.clear();
             return INSTANCE;
         }
+        @Override
         public OriginalValueChangeTracker<T> clear()
         {
             return this;
         }
+        @Override
         public boolean hasChanges()
         {
             return false;
         }
+        @Override
         public boolean hasChangeFor( String pAttributeName )
         {
             return false;
         }
+        @Override
         public Object getOriginalValueFor( String pAttributeName )
         {
             return null;
         }
+        @Override
         public Object getOriginalValueControlObjectFor( String pAttributeName )
         {
             return null;
         }
+        @Override
         public String[] getChangedAttributeNames()
         {
             return Utils.EMPTY_STRING_ARRAY;
             return null;
         }
+        @Override
         public PersistentObjectImpl getTheChangedPo()
         {
             return null;
         }
+        @Override
         public OriginalValueChangeTracker<T> recordChange( T pThePo, String pAttributeName, Object pOldValue, Object pNewValue )
         {
             OriginalValueChangeTrackerImpl<T> tracker = new OriginalValueChangeTrackerImpl<T>( pThePo );
             mTheChangedPo = pTheChangedPo;
         }
+        @Override
         public OriginalValueChangeTracker<T> clear()
         {
             mAttributeNameToOriginalValues.clear();
             return OriginalValueChangeTrackerNull.getInstance();
         }
+        @Override
         public boolean hasChanges()
         {
             return !mAttributeNameToOriginalValues.isEmpty();
         }
+        @Override
         public boolean hasChangeFor( String pAttributeName )
         {
             return mAttributeNameToOriginalValues.containsKey( pAttributeName );
         }
+        @Override
         public Object getOriginalValueFor( String pAttributeName )
         {
             Object rv = getOriginalValueControlObjectFor( pAttributeName );
             return (rv instanceof ToOneChangeEntry) ? ((ToOneChangeEntry) rv).getPO() : rv;
         }
+        @Override
         public Object getOriginalValueControlObjectFor( String pAttributeName )
         {
             return mAttributeNameToOriginalValues.get( pAttributeName );
         }
+        @Override
         public String[] getChangedAttributeNames()
         {
             return mAttributeNameToOriginalValues.isEmpty() ? //
          *
          * @return
          */
+        @Override
         public OriginalValueChangeTracker<T> recordChange( T pThePo, String pAttributeName, Object pOldValue, Object pNewValue )
         {
             if ( !mAttributeNameToOriginalValues.containsKey( pAttributeName ) ) // No Original
             return this;
         }
+        @Override
         public T getTheChangedPo()
         {
             return mTheChangedPo;
             return mPO;
         }
+        @Override
         public String toString()
         {
             return (mPO != null) ? mPO.getDisplayValue() : "";
         }
+        @Override
         public boolean equals( Object o )
         {
             if ( this == o )
                    Utils.areNonArraysEqual( this.mPO, them.mPO );
         }
+        @Override
         public int hashCode()
         {
             int result;
         }
     }
+    @Override
     public int compareTo( PersistentObject pOther )
     {
         return getPersistentObjectURL().compareTo( pOther.getPersistentObjectURL() );
     }
+    @Override
     public Action makeStateChangeAction()
     {
         if ( isDeleteRequested() )
         return null;
     }
+    @Override
     public void rehydationComplete()
     {
     }

View View this file contents

History View the full history

Feeds

Commits for /trunk/Java/core/Server/src/org/litesoft/orsup/nonpublic/PersistentObjectImpl.java