//
//  DirObject.java
//
//  WELD Java Client Persistent Object Management Package
//  Copyright Francis Chan (fchan@ic.eecs.berkeley.edu), 1997
//  University of California, Berkeley
//
//
//  This program is in the public domain.
//  Permission to use, copy, modify, and distribute this software
//  and its documentation for NON-COMMERCIAL purposes and
//  without fee is hereby granted, as long as credit is given.

import java.util.Vector;
import java.io.StreamTokenizer;

/**
 *
 * DirObject Class
 *
 * This is a class which represents a node of the directory 
 * structure of a remote data server
 *
 * @version 1.1 Feb 1997
 * @author  Francis Chan
 */

public class DirObject extends PersistentObject{

  public static final String objectClassName = "DirObject";
  public static final int numField = 1;
  public static final int numObjField = 0;
  
  /**
   * The name of the directory
   */
  private String name;

  /**
   * Vector that contains the contents' info
   */
  public Vector contentsInfo;

  //private Vector objVector;

  /**
   * Constructor for DirObject
   */
  public DirObject(String name){

    this.name = name;
    netObjSetup(numField, numObjField, objectClassName);
  }

  /**
   * Returns the name of the directory (object)
   */
  public String getName(){
    return name;
  }


  /**
   *
   * Delete
   *
   * Removes all references of the PersistentObject in the system
   * (The object is not explicitly deleted (i.e. space freed))
   *
   */

  public void delete() {

    PersistentObject pObj;
    DirObject dObj;

    for (int i=0; i<contents.size(); i++) {

      /// have all children delete "this" from containers vector

      pObj = (PersistentObject) contents.elementAt(i);
      pObj.detachFrom(this);
    }

    for (int i=0; i<containers.size(); i++) {

      /// have all parents delete "this" from contents vector

      dObj = (DirObject) containers.elementAt(i);
      dObj.detach(this);
    }
 
    if (this.isPersistent == true) {
      System.out.println("Locally Deleting a persistent object");
      System.out.println("Use DeleteCommit instead for persistent objects!");
      return;
    }

  }


  /**
   *
   * Committing a Delete, so that the information gets transferred back 
   * to the data server.  Both local and persistent data is updated
   *
   */

  public void deleteCommit() {

    if (this.isPersistent != true) {
      DEBUG("Only a _local_ Delete is required since obj is not persistent");
      delete();
    }

    deleteMe();
  }

  private int policy(PersistentObject pObj1, PersistentObject pObj2) {

    return PO.OK;
  }

  public int getRoot(){
    
    if (connectServer() == false)
      return PO.ERROR;

    outStreamString = comCons.prepareDirCommandString(PO.GETROOTDIR, userId,
						      null, 0);

    send(outStreamString);
    loadVector = parse(PO.GETROOTDIR);
    closeServer(netSocket);
    
    this.name = getField(0, PO.STRING_INDICATOR);
    setPersistent(true);

    return PO.OK;
  }

  /**
   * Sets the vector of (className, stringId, id) information
   * from the network data server
   */
  /*
  public Vector getContext(){

    if (connectServer() == false)
      return null;

    outStreamString = comCons.prepareDirCommandString(PO.GETCONTEXT, userId,
						      objectClassName, dbId);

    send(outStreamString);
    objVector = parse(PO.GETCONTEXT);
    netClient.closeConnection(netSocket);
    
    return contextVector;
  }
  */

  /**
   *
   * Parses GetContext message, extracts each content object's
   * information and stores it in the returned Vector
   *
   */
  /*
  protected Vector parseContext(StreamTokenizer strToke){

    Vector infoVector = new Vector();
    int token;
    int numContents;

    try {
      token = strToke.nextToken();

      if (parseNumber(strToke, "Number (of contents) expected!") != true){
	return null;
      }
      numContents = (int) strToke.nval;

      for (int i=0; i<numContents; i++){
      
	String className;
	String name;
	int id;

	className = parseForWord(strToke, "Class Name expected");
	if (className == null)
	  return null;
	name = parseForWord(strToke, "Content Field expected");
	if (name == null)
	  return null;

	token = strToke.nextToken();
	if (parseNumber(strToke, "Id expected!") != true){
	  return null;
	}
	id = (int) strToke.nval;

DEBUG("The triplet are :" + className + name + id);

	PO_ObjectInfo objInfo = new PO_ObjectInfo(className, name, id);
	infoVector.addElement(objInfo);
      }
    } catch (Exception e){
      System.out.println("Parse problems with get context!");
      return null;
    }

    return infoVector;
  }
  */

  /*-----------------------------------------------------------
   *
   * the code below is for data backend management
   *
   *-----------------------------------------------------------*/

  /**
   * The DirObject construction should be followed by
   * a Load so that the object field(s) will be set
   *
   */
  public DirObject() {
    netObjSetup(numField, numObjField, objectClassName);
  }

  /**
   * Sets up the Vector that that contain the "essential" fields
   * of the object
   */
  protected void setObjFields() {

    setField(0, this.name, PO.STRING);
    //setField(1, this.dbId, PO.UNIQUE_ID);
    //setField(2, this.contents, PO.CHILDREN);
    //setField(3, this.contents, PO.PARENTS);
  }

  /**
   * Loads the object from a network (persistent object storage) database 
   * backend(and sets it's fields)
   */

  public boolean load(String strId) {

    if (loadObject(strId, 0, null) == false) {
      System.out.println("Couldn't load object " + objectClassName + 
                         " with strId " + strId);
      return false;
    }
    
    getObjFields();
    return successfulTransmit;
  }

  protected void getObjFields(){

    this.name = getField(0, PO.STRING_INDICATOR);
  }
}