/*
    * Copyright 2008 Eric Caspole
    * 
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
    * file except in compliance with the License. You may obtain a copy of the License at
    * 
    * http://www.apache.org/licenses/LICENSE-2.0
    * 
    * Unless required by applicable law or agreed to in writing, software distributed under
   * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied. See the License for the specific language governing
   * permissions and limitations under the License.
   */
   package net.sf.madmap;
  
  import java.util.*;
  
  /**
   * HprofHeapCollectable is the base class for everything that is "collectable"
   * in the target process heap, i.e. objects, arrays and classes. This class
   * has methods to compute the liveness and retained size during the analysis.
   * 
   * @author ecaspole
   *  
   */
  public abstract class HprofHeapCollectable extends HprofHeapElement {
  
    // highest bit is sign bit
    static final long _liveBits     = 0x40000000;
    static final long _claimedBits  = 0x20000000;
    static final long _sizeBits     = 0x1fffffff;
    
    // support for iterative retained size accumulation
    protected Stack  _visitedChildren;
    long      _retainedSize = 0;
  
    public long getRetainedSize()         { return (_retainedSize << 3) >> 3; }
    public void claim()                   { _retainedSize = (_retainedSize | (_claimedBits << 32)); }
    public boolean isClaimed()            { return (_retainedSize & (_claimedBits << 32)) != 0; }
    public void setClaimed( boolean x )   { 
      if ( x ) {
        claim(); 
      } else {
        _retainedSize = (_retainedSize & (~(_claimedBits<<32)));
      }
    }
    
    public boolean  isAlive()             { return (_retainedSize & (_liveBits << 32 )) != 0; }
    public void     setLiveness( boolean lv )   { 
      if ( lv ) {
        _retainedSize = _retainedSize | (_liveBits << 32);
      } else {
        _retainedSize = _retainedSize & (~(_liveBits << 32));    
      }
    }
    
    /**
     * @param newSize the object's retained size, computed in the analysis phase 
     */
    public void setRetainedSize( long newSize) { 
      long oldBits = _retainedSize >> 61;
  	  _retainedSize = newSize | (oldBits << 61); 
    }
  
    /**
     * @param addr address of the object
     */
    public HprofHeapCollectable( long addr ) {
  	  super( addr );
    }
  
    long[]  longArrayListtoLongArray( ArrayList in ) {
      if ( in == null ) {
        return null;
      }      
      if ( in.size() == 0 ) {
        return null;
      }
      long[]  out = new long[ in.size() ];
      for ( int i = 0; i < out.length; i++ ) {
        out[ i ] = ((Long) in.get( i )).longValue();
      }
      return out;
    }
  
  
    public abstract String    className();
    public abstract long      children_size();
    public abstract long[]    children();
    public abstract long      size();
    
    /**
   * @param ref	the address to find in this object
   * @return		true if ref is a member of this object
   */
  public boolean containsRef( long ref ) {
      for ( int i = 0; i < children_size(); i ++ ) {
        if ( children()[i] == ref ) {
          return true;
       }
     }
     return false;
   }
   
   void visited( HprofHeapCollectable child ) {
     if ( _visitedChildren == null ) {
       _visitedChildren = new Stack();
     }
     _visitedChildren.push( child );
   }
   
   Stack getVisitedStack() { return _visitedChildren; }
   int getVisitedCount() { 
     return _visitedChildren == null ? 0 : _visitedChildren.size();
   }
   
   void resetVisited() { 
     _visitedChildren = null;
   }  
 }