//
//  PersistentObject.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.io.*;
import java.util.*;
import java.net.*;

/**
 *
 * Persistent Object Class
 * (derived from BackendUtil.java)
 *
 * This is a class which other objects that need network
 * access extends.
 * There are several abstract methods that the application developer
 * must overload in order to use this class.
 *
 * @version 1.5 Feb 1997
 * @author  Francis Chan
 */

abstract public class PersistentObject{

  private Vector objFieldVector = null;
  protected Vector loadVector = null;

  /**
   * Vector which holds the context information after a getContext
   */
  protected Vector contextVector = null;

  static protected PO_CommandConstructor comCons;
  static private boolean firstObj = true;

  // should be "static" for optimal memory management
  // cannot be static if different servers and/or ports are used for
  // for network operations
  static protected PO_NetClient netClient;  
  static private String server = "yoyodyne.eecs.berkeley.edu";
  static private int port = 7010;
  protected Socket netSocket = null;

  //-------------------------------------------
  // variable for testing with and without the network
  static public boolean testNoNet = false;  // with network
  // static private boolean testNoNet = true;   // NO network
  //------------------------------------------

  protected String outStreamString = null;
  protected boolean successfulTransmit = false;

  // for the type-casting of arguments from Input Stream

  protected int numField = 0;   // used for the allocation of the array

  /**
   * The number of object fields the object has
   */
  protected int numObjField = 0;

  /**
   * The array whose contents indicate the type of the field in the
   * corresponding field position of the object
   */
  private int[] fieldTypeArray;

   // internal data structures

  /**
   * The class name of the object which inherits the Persistent Object
   * class.
   */
  protected String objectClassName;

  // for db backend identification purposes

  /**
   * User Id of the Persistent Object (for network transactions)
   */
  // protected String userId;
  protected String userId = "fchan"; // hard-coded right now

  /**
   * Unique identifier returned by the data server after a Save()
   */
  protected int dbId = 0;

  /**
   * String indicating the version of the object (release_name.number)
   */
  protected String version;

  /**
   * Access permission of the object (READ_ONLY, READ_WRITE)
   * usage to be determined
   */
  protected int permission = PO.READ_WRITE;

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

  /**
   * Vector that contains the object's parent node
   */
  public Vector containers;

  /**
   * The number of parents (objects that it attaches to) that the object has
   */
  int numParents;

  /**
   * The number of children (objects that attaches to it) that the object has
   */
  protected int numChildren;

  /**
   * Indicates whether the object's containers are in memory
   */
  protected boolean containersInMem = false;

  /**
   * Indicates whether the object's contents are in memory
   */
  protected boolean contentsInMem = false;

  /**
   * The name of the current class returned during parsing
   */
  protected String currentRelativeClass;

  /**
   * The Id of the object that is being loaded from the data server
   */
  protected int attachObjId;

  /**
   * Variable indicating whether the object has been saved before
   */
  public boolean isPersistent = false;

  /**
   * Flag which may be used to determine whether the object requires updating
   */
  public boolean dirty = true;

  /**
   * Flag to print out debugging statements
   */
  //protected boolean debugFlag = true;
  static public boolean debugFlag = true; 

  /**
   * Constructor of PersistentObject
   * Should never be called explicitly
   */
  public PersistentObject(){

    netClient = new PO_NetClient(server, port);
    containers = new Vector();
    contents = new Vector();

    if (firstObj == true){
      comCons = new PO_CommandConstructor();
    }
    firstObj = false;
    
  }


  /* ------------------------------------------------
   *
   * Methods used to manipulate internal data structures
   *
   * ------------------------------------------------ */

  /**
   *
   * Returns the Object Class Name
   *
   */
  public String getClassName()
  {
    return this.objectClassName;
  }

  /**
   *
   * Sets the isPersistent flag which indicates that this object
   * has persistence (has a copy at the data backend)
   *
   * Future operations will then make use of the object's unique id.
   *
   */

  protected void setPersistent(boolean flag) {

    this.isPersistent = flag;
  }

  /**
   * Sets the server name for network operations
   *
   * @param server       Server name
   */
  protected void setServer(String server) {

    this.server = server;
    netClient = new PO_NetClient(server, port);
  }

  /**
   * Sets the port for network operations
   *
   * @param port         Port Number
   */
  static public void setPort(int portNum) {

    port = portNum;
    netClient = new PO_NetClient(server, portNum);
  }

  /**
   * Sets the flag for debug statement
   *
   * @param flag         true to turn on debugging
   *                     false otherwise
   */
  static public void setDebug(boolean flag) {

    debugFlag = flag;
  }

  /**
   * Sets the flag for network operation
   *
   * @param flag         true if there are no network operations
   *                     false otherwise
   */
  static public void setTestNoNet(boolean flag) {

    testNoNet = flag;
  }


  /* ------------------------------------------------
   *
   * Methods used to set up internal data structures
   *
   * ------------------------------------------------ */

  /**
   *
   * Network Object setup
   *   method that needs to be run before the object can operate
   *   as a persistent object over the network
   *
   * @param port            Port number of the server
   * @param numFields       Number of fields the object has
   * @param objectClassName Name of the class
   */

  protected void netObjSetup(int numFields, int numObjs,
			     String objectClassName) {

    // number of fields must be pre-determined by object developer
    this.numField = numFields + 3;  // +3 for contents, parents and uniqueId
    //this.numField = numFields + 2;  // +2 for contents and uniqueId
    this.numObjField = numObjs;
    this.objectClassName = objectClassName;
    fieldTypeArray = new int[this.numField];
    objFieldVector = new Vector(this.numField);
    setObjFields();
    setField(numFields, 0, PO.UNIQUE_ID);
    setField(numFields+1, this.contents, PO.CHILDREN);
    setField(numFields+2, this.containers, PO.PARENTS);
  }

  private void netSetObj(){

    System.out.println("objectClassName, numField, numObjField: " +
		       objectClassName + numField + numObjField);
  }

  /**
   * Sets up the object's fields into internal data structure.
   *
   * Calls setField with the respective parameters for different types
   * Needs to be overloaded by the object developer
   */

  abstract protected void setObjFields();

  /**
   *
   * sets the type of each field.
   * This is a method the Object designer has to overload.
   *
   * @param nthField The position of the field
   * @param type     The type of the field
   */

  protected void setType(int nthField, int type) {

    fieldTypeArray[nthField] = type;
  }

  /**
   *
   * Sets the fields in the Vector holding the fields of the
   * object
   *
   * Non-object types are stored in object that matches mostly closely
   * its type.
   *
   * @param nthField        The position of the field
   * @param Second_Argument Different data types may be used
   * @param type            The type of the field
   */

  protected void setField(int nthField, String stringField, int type) {

    objFieldVector.insertElementAt(stringField, nthField);
    setType(nthField, PO.STRING);
  }

  protected void setField(int nthField, int intField, int type) {

    Integer intObj = new Integer(intField);
    objFieldVector.insertElementAt(intObj, nthField);

    if (type != PO.UNIQUE_ID) {
      setType(nthField, PO.INT);
    } else {
      setType(nthField, PO.UNIQUE_ID);
    }
  }

  protected void setField(int nthField, double doubleField, int type) {

    Double doubleObj = new Double(doubleField);
    objFieldVector.insertElementAt(doubleObj, nthField);
    setType(nthField, PO.DOUBLE);
  }

  protected void setField(int nthField, char charField, int type) {

    String charString = new String();
    charString = charString.valueOf(charField);

    objFieldVector.insertElementAt(charString, nthField);
    setType(nthField, PO.CHAR);
  }

  protected void setField(int nthField, boolean boolField, int type) {

    if (boolField == true) {
      objFieldVector.insertElementAt("1", nthField);
    } else objFieldVector.insertElementAt("0", nthField);
    setType(nthField, PO.BOOLEAN);
  }

  protected void setField(int nthField, float floatField, int type) {

    Float floatObj = new Float(floatField);

    objFieldVector.insertElementAt(floatObj, nthField);
    setType(nthField, PO.FLOAT);
  }

  protected void setField(int nthField, Vector vectorField, int type) {

    objFieldVector.insertElementAt(vectorField, nthField);
    setType(nthField, type);
  }

  protected void setField(int nthField, Object objField, int type) {

    objFieldVector.insertElementAt(objField, nthField);
    setType(nthField, type);
  }

  protected void setField(int nthField, double[] arrayField, int type) {

    objFieldVector.insertElementAt(arrayField, nthField);
    setType(nthField, type);
  }

  /* ------------------------------------------------
   *
   * Methods for network operations
   *
   * ------------------------------------------------ */


  /**
   *
   * Calls openConnection to connect to remote server
   *
   * If testNoNet flag is set, then the connection is ignored and
   * operations (load, save, etc.) will be done locally
   *
   */
  protected boolean connectServer(){

    if (testNoNet == true)
      return true;
    
    netSocket = netClient.openConnection();
    if (netSocket == null) {
      DEBUG("Can't open connection, abort, I repeat, ABORT NOW!");
      return false;
    }
    return true;
  }


  /**
   *
   * Calls closeConnection to close a remote server connection
   *
   * If testNoNet flag is set, then the close is ignored and
   * operations (load, save, etc.) will be done locally
   *
   */
  protected boolean closeServer(Socket socket){

    if (testNoNet == true)
      return true;
    
    if (netSocket == null) {
      DEBUG("Socket is null, can't close connection.");
      return false;
    }
    netClient.closeConnection(socket);

    return true;
  }

  
  /**
   *
   * Sends the specified string to the remote server
   *
   * If testNoNet flag is set, then the message will be outputed
   * to the screen
   *
   * @param msg     The message/string to be sent
   */
  protected void send(String msg){

    if (testNoNet == true)
      System.out.println(msg);
    else netClient.sendString(msg);
  }


  /* ------------------------------------------------
   *
   * Methods for Save
   *
   * ------------------------------------------------ */

  /**
   *
   * Save (Object)
   *
   * Encapsulation of the actual call to SaveObject
   * (returns either OK, ERROR  or the Object's UniqueID)
   *
   */

  public int save() {

    DEBUG("PerObj: Saving... " + this.objectClassName);
    return saveObject(this.objectClassName, PO.NO_VERSION);
  }

  /**
   * Saves the object as a new version of the "basic object"
   *
   * @param versionFlag  Indicator of whether a "point" (single object)
   *                     is to be saved or the whole "tree", rooted
   *                     at this point
   */
  public int versionSave(int versionFlag) {

    if ((versionFlag < PO.NO_VERSION) || (versionFlag > PO.TREE_VERSION)){
      System.out.println("Invalid version save option, save not completed");
      return PO.ERROR;
    }

    DEBUG("Saving Version... " + this.objectClassName);
    return saveObject(this.objectClassName, versionFlag);
  }

  /**
   *
   * Save Object
   *
   *   returns Unique DbId    if save is completed
   *           ERROR          if not
   *
   * @param objectClassName Name of the class
   */

  protected synchronized int saveObject(String objectClassName, 
					int versionFlag)
  {

    // immediately don't save if SavePolicy indicates the
    // object has not been modified

    Vector objVector;

    if (savePolicy(this) == PO.OK) {

      //DEBUG(objectClassName + " SavePolicy passed! ");

    if (connectServer() == false)
      return PO.ERROR;

    // clear obj field vector for new fields
    objFieldVector = new Vector();
    setObjFields();
    setField(numField-3, 0, PO.UNIQUE_ID);
    setField(numField-2, this.contents, PO.CHILDREN);

    if (versionFlag == PO.NO_VERSION){
      if (isPersistent == false) {     // save/modify plain object
	outStreamString = comCons.prepareSaveString(PO.PUT, userId,
						    objectClassName,
						    dbId, null,
						    objFieldVector,
						    fieldTypeArray,
						    PO.NO_VERSION);
      } else {
	outStreamString = comCons.prepareSaveString(PO.MODIFY, userId,
						    objectClassName,
						    dbId, null,
						    objFieldVector,
						    fieldTypeArray,
						    PO.NO_VERSION);
      }
    } else {   // version save
      outStreamString = comCons.prepareSaveString(PO.PUTVER, userId,
						  objectClassName,
						  dbId, null,
						  objFieldVector,
						  fieldTypeArray,
						  versionFlag);
    }

    send(outStreamString);

    // parse and verify the OK message

    if (isPersistent == false) {
      objVector = parse(PO.PUT);
    } else {
      objVector = parse(PO.MODIFY);
    }
    closeServer(netSocket);

    if (objVector == null) {   // something went wrong, return
      System.out.println("Saving of " + objectClassName +
			 " cannot be completed");
      return PO.ERROR;
    }

    // dbId should be set
    DEBUG("DbID after save: " + this.dbId);

    // traverse all fields and look for vector fields

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

//System.out.println("Sizeof objfieldvector: " + objFieldVector.size());

      if (fieldTypeArray[i] == PO.OBJECT) {
        if (saveObjField(objFieldVector.elementAt(i), dbId) != PO.OK)
	  return PO.ERROR;
      }

      if ((fieldTypeArray[i] == PO.CHILDREN) ||
	  (fieldTypeArray[i] == PO.VECTOR)){
//System.out.println("got children or vector");

	// traverse all elements of the vector
	// prepare a string for each and explicity attach at db backend

	Vector vecField = (Vector) objFieldVector.elementAt(i);

	DEBUG("# of children: " + vecField.size());

	for (int j =0; j<vecField.size(); j++) {

	  Object obj = (Object) vecField.elementAt(j);

	  if(obj instanceof PersistentObject) {
	    PersistentObject po = (PersistentObject) obj;

	    if (savePolicy(po) == PO.OK) {

	      // first save current object
	      // get back a unique id from data backend

	      attachObjId = po.save();

	      postSavePolicy(po);
	      int ok = connect(dbId, attachObjId);
	      
	    } else {
	      DEBUG(objectClassName +
		    " object has not been updated, no need to Save&Connect");
	    }
	  } else {
	    System.out.println("Non-instances of Persistent Object");
	    System.out.println("cannot be saved.");
	  }
	}
      }     
    }

    if (objVector != null) {
      postSavePolicy(this);
      DEBUG("Returning this as DbID: " + this.dbId);
      return dbId;
    } else return PO.ERROR;
   }

   else DEBUG(objectClassName + " has not been updated, no need to Save");
   return PO.OK;
  }

  /*
   *
   * saveObjField
   *
   * Handle the cases where the field of the PersistentObject is
   * itself an object
   *
   * @param pObj (Persistent) Object to be saved
   * @param dbId Unique id of the object
   */

  private int saveObjField(Object pObj, int dbId) {
    
    int attachObjId;
    
    if (pObj instanceof PersistentObject) {
      PersistentObject obj = (PersistentObject) pObj;
      
      if (savePolicy(obj) == PO.OK) {
	
	// first save current object
	// get back a unique id from data backend
	attachObjId = obj.save();
	
	postSavePolicy(obj);
	
	int ok = connect(dbId, attachObjId);

      } else {
	DEBUG(objectClassName +
	      " object has not been updated, no need to Save&Connect");
      }
    } else {
      System.out.println("Non-instances of Persistent Object");
      System.out.println("cannot be saved.   :(");
    }
    return PO.OK;
  }


  /* ------------------------------------------------
   *
   * Methods for Load
   *
   * ------------------------------------------------ */

  /**
   *
   * Load (from Persistent Storage over the network).
   *
   * Return PO.OK if Load is successful, PO.ERROR otherwise.
   *
   * @param strId String type of id
   * @param intId Integer type of id
   */

  public boolean load(int intId){
    if (loadObject(null, intId, null) == false) {
      System.out.println("Couldn't load object " + objectClassName + 
			 " with intId " + intId);
      return false;
    }

    getObjFields();

    return successfulTransmit;
  }

  /**
   * Load by a (database backend location) string has to be overloaded
   * by the object developer if such a feature is desired
   */
  public boolean load(String strId){

    return true;
  }

  /**
   *
   * Load a specific version of the object
   *
   * Return PO.OK if Load is successful, PO.ERROR otherwise.
   *
   * @param strId    String type of id
   * @param intId    Integer type of id
   * @param version  Version of the object
   */

  public boolean loadVersion(String strId, int intId, String version){
    if (loadObject(null, intId, version) == false) {
      System.out.println("Couldn't load object " + objectClassName + 
			 " with intId " + intId);
      return false;
    }

    getObjFields();

    return successfulTransmit;
  }

  /**
   *
   * Determines how the fields of the objects should be filled after
   * a (network) load
   * To be declared by object developer
   *
   */
  abstract protected void getObjFields();

  /**
   * The actual method call thats being made when a load() is called.
   *
   * @param objectClassName (String) Name of the class
   * @param strId           String type of Id of the object
   * @param intId           Integer type of Id of the object
   * @param version         Version of the object
   *
   */

  protected boolean loadObject(String strId,
                               int intId, String version)
  {
    int loadType;

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

    if (version == null){
      if (strId != null) {
	outStreamString = comCons.prepareCommandString(PO.GETSTR, userId,
						       objectClassName,
						       intId, strId,
						       0, 0, null);
	loadType = PO.GETSTR;
      } else {
	outStreamString = comCons.prepareCommandString(PO.GETID, userId,
						       objectClassName,
						       intId, strId,
						       0, 0, null);
	loadType = PO.GETID;
      }
    } else {   // get versioned object
      outStreamString = comCons.prepareCommandString(PO.GETVERID, userId,
						     objectClassName,
						     intId, strId,
						     0, 0, version);
      loadType = PO.GETVERID;      
      this.version = version; 
    }

    send(outStreamString);

    loadVector = parse(loadType);
    closeServer(netSocket);
    if (loadVector == null)
      return false;

    postLoadPolicy(this);
    setPersistent(true);

    return true;
  }

  /**
   * Loads and instantiates a "copy" of the object from
   * the data back-end.
   */

  protected PersistentObject makeInstance() {

    loadObject(null, dbId, null);

    contentsInMem = false;
    containersInMem = false;

    // isPersistent flag is set to false so the object can be saved
    // and not "modified"

    setPersistent(false);
    instancePolicy(this);
    return this;
  }

  /**
   * Policy that must be followed after instantiating an object
   */

  //abstract public void instancePolicy(PersistentObject pObj);
  public void instancePolicy(PersistentObject pObj){
  }

 /**
   *
   * get the corresponding contents from an internal vector
   * that parsed and stored the values of a network Load
   *
   * @param nthField Position of the field
   * @param Indictor Different types according to the type expected
   *
   */

  protected String getField(int nthField, String indicator) {

    return (String) loadVector.elementAt(nthField);
  }

  protected int getField(int nthField, int indicator) {

    return ((Integer) loadVector.elementAt(nthField)).intValue();
  }

  protected double getField(int nthField, double indicator) {

    return ((Double) loadVector.elementAt(nthField)).doubleValue();
  }

  protected boolean getField(int nthField, boolean indicator) {

    if (((String) loadVector.elementAt(nthField)).compareTo("1") == 0)
      return true;
    return false;

  }

  protected char getField(int nthField, char indicator) {

    return ((String) loadVector.elementAt(nthField)).charAt(0);

  }

  protected float getField(int nthField, float indicator) {

    return ((Float) loadVector.elementAt(nthField)).floatValue();

  }

  protected double[] getField(int nthField, double[] indicator) {

    return (double[]) loadVector.elementAt(nthField);
  }

  protected Vector getField(int nthField, Vector indicator) {

    return initGenRelative(PO.CONTENTS);
  }

  protected PersistentObject getField(int nthField, Object indicator) {

    PersistentObject po;

    po = getMemberInfo(PO.CONTENTS, numObjField - (numField - nthField - 3));
    // -1 for ocntents vector
    //po = memInfo.getObj();

    return po;
  }    


  /* ------------------------------------------------
   *
   * Methods for Parse
   *
   * ------------------------------------------------ */

  /**
   *
   * parse
   *
   * This method is responsible for parsing responses from
   * remote network server(s)
   *
   * (see
   *    http://www-cad.eecs.berkeley.edu/~mds/oct/protocol.html
   *  for details)
   *
   * (called after PO_NetClient.openConnection)
   */

  // Do we really need length, how do make constructive use
  // of the length of the stream?
  // Will there be type compatibility problems (between types)
  //
  // using StreamTokenizer loses the adherence to the protocol
  // due to multiple white spaces count as one
  // (trivial but time-consuming check/parse strategy for total
  //  adherence)

  protected Vector parse(int preceedingOp){

    Vector inputVector = new Vector(); 
    StreamTokenizer strToke;
    FileInputStream testStream;
    InputStream inputStream;
    int length = 0;
    int token = 0;
    int status = 0;

    // tests by using local file to produce streams
    // as well as through a remote host
    
    try {
      if (testNoNet == true) {
	
	// emulating the processing of a stream by opening a local file
	// and parsing/retrieving the parameters required for
	// object creation
	
	if (preceedingOp == PO.PUT)
	  testStream = new FileInputStream("put");	
	else if (preceedingOp == PO.GETATTINFO)
	  testStream = new FileInputStream("getattinfo");
	else if (preceedingOp == PO.GETROOTDIR)
	  testStream = new FileInputStream("getrootdir");
	else if (objectClassName.compareTo("Member") == 0)
	  testStream = new FileInputStream("get_Member");
	else if ((objectClassName.compareTo("DataObject") == 0) &&
		 (preceedingOp == PO.GETSTR))
	  testStream = new FileInputStream("get_dataObj");
	else testStream = new FileInputStream("get_Fields");

	strToke = new StreamTokenizer(testStream);

	inputStream = netSocket.getInputStream();
	/*
	try{
	  inputStream = netSocket.getInputStream();
	} catch (Exception e){
	  System.out.println("Dummy socket statement for compilation.");
	}
	*/
      }
      else {
	inputStream = netSocket.getInputStream();
	strToke = new StreamTokenizer(inputStream);
      }
      
      // may need a little more work
      // should change to look for end of stream to end
      // parsing
      
      strToke.wordChars(32, 126); // normalize most characters

      // should also get the length of the string to confirm that
      // that correct string was received
      
      int num = 2 + numField;  // 2 for the overhead
      
      for (int i=0; i < num; i++){
	try {
	  token = strToke.nextToken();
	  
	  // parse overhead
	  switch (i) {
	    
	  case 0:
	    if (parseNumber(strToke, "1st Para not Number!") != true){
	      return null;
	    }
	    else {
	      status = (int) strToke.nval;
	      
	      switch(status) {
		
	      case PO.OK_VAL:
		
		DEBUG("Got OK_VAL!");
		
		// different processes needed according to the
		// preceeding operation
		
		switch(preceedingOp) {
		  
		case PO.PUT:
		  
		  // parse forward and look for UniqueObjectId
		  
		  try {
		    token = strToke.nextToken();
		    
		    if (parseNumber(strToke,
				    "No Db ID returned") != true){
		      return null;
		    }
		  } catch (Exception e) {
		    System.out.println("DbId parse problem!");
		    return null;
		  }
		  dbId = (int) strToke.nval;
		  
DEBUG("PUT " + objectClassName + " returned " + "dbId: " + strToke.nval);
		  
		  successfulTransmit = true;
		  closeServer(netSocket);
		  return inputVector;
		  
		case PO.GETSTR:
		case PO.GETID:
		case PO.GETVERID:
		case PO.GETROOTDIR:
		  break;
		  
		case PO.GETATTINFO:
		  
		  currentRelativeClass =
		    parseForWord(strToke, "ClassName expected (GI)");
		  
		  if (currentRelativeClass == null) {
		    return null;
		  }
		  
		  DEBUG("Cool, (GI) className is: " + currentRelativeClass);
		  
		  try {
		    token = strToke.nextToken();
		    
		    if (parseNumber(strToke, "No Attach ID returned!")
			== false){
		      return null;
		    }
		  } catch (Exception e) {
		    System.out.println("Attach Id parse problem!");
		    return null;
		  }
		  
		  attachObjId = (int) strToke.nval;
		  
DEBUG("GETATTINFO " + currentRelativeClass + " dbId: " + strToke.nval);
		  
		  successfulTransmit = true;
		  closeServer(netSocket);
		  return inputVector;
		  
		case PO.DELETE:
		case PO.MODIFY:
		case PO.PUTVER:
		case PO.CONNECT:
		case PO.DISCONNECT:
		  
		  // don't have to look anymore
		  DEBUG("Connect, Disconnect, ");
		  DEBUG("Modify or Delete is okayed!");
		  successfulTransmit = true;
		  closeServer(netSocket);
		  return inputVector;
		  
		case PO.CONNECTNEW:
		  break;

		case PO.QUERY:
		  token = strToke.nextToken();
		  parseQuery(strToke);
		  return null;
		}
		break;
		
		default:
		  parseErrorResponse(status);
		  closeServer(netSocket);
		  return null;		
		}
	      }
	      break;
	    
	  case 1:
	    
	    if (strToke.ttype != strToke.TT_WORD) {
	      System.out.println("Object ClassName/String expected");
	      return null;
	    } else {
	      if (objectClassName.compareTo(strToke.sval) != 0) {
		DEBUG("Got: " + strToke.sval);
		System.out.println("Received wrong object");
		return null;
	      } else {
		DEBUG("Cool, className is: " + strToke.sval);

		// if GETCONTEXT was called, need to call another 
		// method to parse the results
		if ((preceedingOp == PO.GETCONTEXT) || 
		    (preceedingOp == PO.VERGETCONTEXT)){
		  contextVector = parseContext(strToke);
		  return contextVector;
		}
		break;
	      }
	    }
	    
	    // checking the type array and
	    // casting the tokens from the stream to the right type
	    
	    // here comes the parameters
	    
	  default:
    {
	      switch(fieldTypeArray[i-2]) {
		
	      case PO.STRING:
		if (strToke.ttype != strToke.TT_WORD) {
		  System.out.println("Para " + (i-2) + " not word (String)!");
		  return null;
		  
		} else {
		  
		  String str = strToke.sval;
		  if (str.compareTo("NULL") == 0) {
		    str = null;
		  } else {
		    
		    //String parsedStr;
		    /*
		    if ((testNoNet == false) &&
			(this.objectClassName.compareTo("DataObject")==0)){
			*/
		    if (testNoNet == false){
		      str = str + parseString(strToke, inputStream);
                    }		      
		    else str = strToke.sval;
		  }
		  /*
		  if (str.compareTo("NULL") == 0) {
		    inputVector.addElement(new String());
		  } else {
		    inputVector.addElement(str);
		  }
		  */
                  inputVector.addElement(str);		      
		  DEBUG("Para " + (i-2) + " is " + str);
		  //DEBUG("Para " + (i-2) + " is " + strToke.sval);
		  break;
		}
		
	      case PO.INT:
		if (strToke.ttype != strToke.TT_NUMBER) {
		  System.out.println("Para not num!");
		  return null;
		  
		} else {
		  Integer intObj = new Integer((int) strToke.nval);
		  
		  inputVector.addElement(intObj);
		  DEBUG("Para " + (i-2) + " is " + strToke.nval);
		  break;
		}
		
		// need a type object to store the values
		//   so that the object itself can be added to the vector
		
	      case PO.DOUBLE:
		if (strToke.ttype != strToke.TT_NUMBER) {
		  System.out.println("Para not num!");
		  return null;
		  
		} else {
		  Double doubleObj = new Double(strToke.nval);
		  
		  inputVector.addElement(doubleObj);
		  DEBUG("Para " + (i-2) + " is " + strToke.nval);
		  break;
		}
		
	      case PO.FLOAT:
		
		// need to deal with special cases for float
		// (infinity(ies)
		
		if (strToke.ttype != strToke.TT_NUMBER) {
		  System.out.println("Para not number (for float)!");
		  return null;
		  
		} else {
DEBUG("Para " + (i-2) + " is " + strToke.nval);
		  try {
		    Float floatObj = new Float(strToke.nval);
		    
		    // parse again to see if there an exponent part
		    token = strToke.nextToken();
		    
		    if (strToke.ttype == strToke.TT_WORD) {
DEBUG("Token in float, para # " + (i-2) + " is " + strToke.sval);
		      if ((strToke.sval.charAt(0) == 'e') ||
			  (strToke.sval.charAt(0) == 'E')) {
			
			floatObj = floatObj.valueOf(floatObj.toString() +
						    strToke.sval);
		      } else if ((strToke.sval.charAt(0) == 'f') ||
				 (strToke.sval.charAt(0) == 'F')) {
			
			if (floatObj.doubleValue() == 0) {
			  // 0.0f chosen arbitrarily as positive infinity
			  floatObj = new Float(Float.POSITIVE_INFINITY);
			} else if (floatObj.doubleValue() == 1) {
			  floatObj = new Float(Float.POSITIVE_INFINITY);
			} else if (floatObj.doubleValue() == -1) {
			  floatObj = new Float(Float.NEGATIVE_INFINITY);
			} else {
			  System.out.println("Bad float!");
			  return null;
			}
		      } else
			strToke.pushBack(); // no exponent
		    } else {
		      strToke.pushBack(); // no exponent
		    }
		    inputVector.addElement(floatObj);
		  } catch (Exception e) {
		    System.out.println("Can't parse number to float!");
		    return null;
		  }
		  break;
		}
		
		// true to represented by T
		// false               by F
		
	      case PO.BOOLEAN:
		if (strToke.ttype != strToke.TT_NUMBER) {
		  System.out.println("Para not boolean number!");
		  return null;
		  
		} else {
DEBUG("Para " + (i-2) + " is " + strToke.nval);
                  if (strToke.nval == 1) {
		    inputVector.addElement("1");
		  } else if (strToke.nval == 0) {
		    inputVector.addElement("0");
		  } else {
		    //System.out.println("boolean value neither T nor F");
		    System.out.println("boolean value neither 1 nor 0");
		    return null;
		  }
		  break;
		}
		
	      case PO.CHAR:
		if (strToke.ttype != strToke.TT_WORD) {
		  System.out.println("Para not word (char)!");
		  return null;
		  
		} else if (strToke.sval.length() != 1) {
		  System.out.println("Char length > 1!");
		  return null;
		}
		
		inputVector.addElement(strToke.sval);
DEBUG("Para " + (i-2) + " is " + strToke.sval);
		break;
		
		// need to deal with strings that contain
		//   "whitespace"
		
	      case PO.ARRAY:

		double[] dArray = parseArray(strToke);
	      		
		if (dArray == null)
		  return null;
		else inputVector.addElement(dArray);
		  break;
		
	      case PO.OBJECT:
		
		// needs to get and parse string
		// find out what the object type is and look it up
		// correspondingly (can I not hard code it in
		// Persistent Object, and instead write a ObjectLookupTable
		// class to handle the casting, parsing and returns the object
		// to this function)
		
		// also a consideration is
		// just-in-time loading, return the object despite one or more
		// fields may not be set, but will load when the user requests
		// access
		
		// need to add a dummy object so that ordering
		// in the vector is preserved
		
		strToke.pushBack(); // push token back since objects are
		//handled in a different way
		
		
		String dummyStr = new String("dummy String");
		inputVector.addElement(dummyStr);
		
		break;
		
		// should pad the vector in the future althought
		// it doesn't make any difference in the current design
		
	      case PO.UNIQUE_ID:
		
		if (strToke.ttype != strToke.TT_NUMBER) {
		  System.out.println("ID field not num!");
		  return null;
		  
		} else {
		  
		  dbId = (int) strToke.nval;
DEBUG(objectClassName + "'s Id value is: " + dbId);
		  break;
		}
		
	      case PO.PARENTS:
		
		if (strToke.ttype != strToke.TT_NUMBER) {
		  System.out.println("Parent field not num!");
		  return null;
		  
		} else {
		  
		  numParents = (int) strToke.nval;
DEBUG(objectClassName + " has " + numParents + " parents");
		  break;
		}
		
	      case PO.CHILDREN:
		
		if (strToke.ttype != strToke.TT_NUMBER) {
		  System.out.println("Children field not num!");
		  return null;
		  
		} else {
		  
		  numChildren = (int) strToke.nval;
DEBUG(objectClassName + " has " + numChildren + " children");
		  break;
		}
		
	      default:
		
		break;
	      }
	    }
	  }
	} catch (Exception e) {
	  System.out.println("Can't Tokenize Stream");
	  e.printStackTrace();
	}
	
      }
    } catch (Exception e) {
      System.out.println("Input file/stream error!");
    }
    
DEBUG("Message code: " + status + " length: " + length);
    
    successfulTransmit = true;
    closeServer(netSocket);
    return inputVector;
  }


  /**
   *
   * Verifies that the token is a number
   * Prints out the msg if it is not a number, returns false
   *
   * @param strToke  StreamTokenizer to be verified
   * @param msg      Error message to be outputed
   */

  protected boolean parseNumber(StreamTokenizer strToke, String msg){

    if(strToke.ttype != strToke.TT_NUMBER) {
      System.out.println(msg);
      return false;
    }
    return true;
  }

  /**
   * Method that parses and constructs a string given that
   * \n (which acts as delimiters in StreamTokenizer
   * could exist in a string
   */
  private String parseString(StreamTokenizer strToke, InputStream inputStream){

    String str = new String();
    byte[] b = new byte[1];
    int b_int;

    /* 
       Strange logic, but working code is a result of:
       Java java.io limitations
       StreamTokenizer can't parse "\r"s
       InputStream.read() skips a "\n" at first
       */
   
    try {

      if (13 == (int) b[0]){
	System.out.println("Carriage in String");
	return str;
      }
      char pre = '\0';
      char curr = '\n';

      while(b[0] != '\r'){
	b_int = inputStream.read(b);
	pre = curr;
	curr = (char) b[0];
	if ((pre == '\n') && (curr == '\r')){
	  return str;
	} 
	str += pre;
      }
    } catch (Exception e){
      System.out.println("Parse String Error!");
      return str;
    }
    return str;
  }

  /**
   * Parses an array (arrangement)
   */  
  protected double[] parseArray(StreamTokenizer strToke){

    int token;

    if (strToke.ttype != strToke.TT_NUMBER) {
      System.out.println("Array size/NumContents not a number!");
      return null;
		  
    } else {
		  
      int numEle  = (int) strToke.nval;
      double[] dArray = new double[numEle+1];
DEBUG("Size of Array: " + numEle);
		  
      if (numEle == 0){
	System.out.println("Size of contents/array = 0");
      }

      dArray[0] = (double) numEle;
     
      try{
	for (int j=1; j<=numEle; j++) {
	  token = strToke.nextToken();
		    
	  if (strToke.ttype != strToke.TT_NUMBER) {
	    System.out.println("Array element not num!");
	    return null;
	  } else {
	    dArray[j] = (double) strToke.nval;
DEBUG("Array element no. " + j + " is " + dArray[j]);
	  }
	}
      } catch (Exception e){
	System.out.println("Parsing (array) contents error");
      }
      return dArray;
    }
  }

  /**
   *
   * Verifies that the token is a word/String
   * Prints out the msg if it is not a string, return null
   * returns the String parsed otherwise
   *
   * @param strToke  StreamTokenizer to be verified
   * @param msg      Error message to be outputed
   */

  protected String parseForWord(StreamTokenizer strToke, String msg){

    int token = 0;

    try {
      token = strToke.nextToken();

      if (strToke.ttype != strToke.TT_WORD) {
	System.out.println(msg);
	return null;
      }
    } catch (Exception e) {
      System.out.println(msg);
      return null;
    }

    return strToke.sval;
  }

  /**
   *
   * Method that parses stream into (className, str, id) information
   * for DirObjects, stringID = content's 1st identifier
   * for Version Object, stringId = content's version string
   *
   */ 
  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;

      String className;
      String str;
      int id;

      for (int i=0; i<numContents; i++){
      
	className = parseForWord(strToke, "Class Name expected");
	if (className == null)
	  return null;
	str = parseForWord(strToke, "Content Field expected");
	if (str == null)
	  return null;

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

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

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

    return infoVector;
  }

  /**
   *
   * Method that parses the query reult
   * for QueryObjects
   * To be overloaded in QueryObject.java
   */ 
  protected Vector parseQuery(StreamTokenizer strToke) {

    Vector vec = null;
    return vec;
  }


  /**
   *
   * Translates the error response codes from the network server
   *
   */

  private void parseErrorResponse(int response){

    switch(response) {

    case PO.DUPLICATE_VAL:
      System.out.println("Duplicate Value reported!");
      return;

    case PO.BAD_REQUEST_VAL:
      System.out.println("Bad Request reported!");
      return;

    case PO.NOT_FOUND_VAL:
      System.out.println("Object Not Found reported!");
      return;

    case PO.NOT_FOUND_A_VAL:
      System.out.println("Not found A reported!");
      return;

    case PO.NOT_FOUND_B_VAL:
      System.out.println("Not found B reported!");
      return;

    case PO.EMPTY_REQUEST_VAL:
      System.out.println("Empty Request reported!");
      return;

    case PO.NO_ATTACH_VAL:
      System.out.println("No Attachment reported!");
      return;

    case PO.SELF_ATTACH_VAL:
      System.out.println("Self-attachment reported!");
      return;

    case PO.PERM_ERROR_VAL:
      System.out.println("Perm Error reported!");
      return;

    case PO.CONT_ERROR_VAL:
      System.out.println("Container Error reported!");
      return;

    case PO.INTERNAL_ERROR_VAL:
      System.out.println("Internal Error reported!");
      return;

    case PO.NOT_VERSIONOBJ_VAL:
      System.out.println("Not Version Object Error reported!");
      return;

    case PO.ATTACH_NOT_FOUND_VAL:
      System.out.println("Attach not found error reported!");
      return;

    default:
      System.out.println("Unknown Response!");
      return;
    }
  }


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

    int type;

    if (this.objectClassName.equals("DirObject")){
      type = PO.GETCONTEXT;
    } else if (this.objectClassName.equals("VersionObject")){
      type = PO.VERGETCONTEXT;
    } else {
      System.out.print("Only Directory objects and Version Objects can "); 
      System.out.print("perform getContext calls.\n");
      return null;
    }

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

      outStreamString = comCons.prepareDirCommandString(type, userId,
							objectClassName, 
							dbId);
    send(outStreamString);
    contextVector = parse(type);
    closeServer(netSocket);
    
    return contextVector;
  }

  /**
   *
   * Connect (Objects)
   * Sets up the connection at the data back-end
   *
   * @param parentId Id of the parent
   * @param childId  Id of the child
   */

  protected int connect(int parentId, int childId) {

    if (connectServer() == false)
      return PO.ERROR;

    outStreamString = comCons.prepareCommandString(PO.CONNECT, 
						   userId,
						   objectClassName,
						   parentId, null,
						   childId, 0,
						   null);
    send(outStreamString);
    Vector parseVector = parse(PO.CONNECT);
    closeServer(netSocket);
    return PO.OK;
  }

  /**
   *
   * Disconnect (Objects)
   * Voids the connections at the data back-end
   *
   * @param parentId Id of the parent
   * @param childId  Id of the child
   */

  protected int disconnect(int parentId, int childId) {

    if (connectServer() == false)
      return PO.ERROR;

    outStreamString = comCons.prepareCommandString(PO.DISCONNECT, userId,
                                                   objectClassName,
                                                   parentId, null,
                                                   childId, 0, null);
    send(outStreamString);
    Vector objVector = parse(PO.DISCONNECT);
    closeServer(netSocket);
    return PO.OK;    // will have to figure out the not OK situations
  }


  /* --------------------------------------------------------
   *
   * Methods for Manipulating DirObject at the server level
   *
   * -------------------------------------------------------- */

  /**
   * Adds the Persistent Object to the contents Vector,
   * adds this to the pObj's container Vector
   * Returns PO.OK
   * @param pObj        PersistentObject to be added
   */

  public int attach(PersistentObject pObj) {
    /*
    if (policy(this, pObj) != PO.OK) {
      return PO.ERROR;
    }
    */

    // attach obj to current objects contents

    contents.addElement(pObj);
    
    // attach current object to obj's conatiners

    pObj.containers.addElement(this);

    return PO.OK;

  }


  /**
   *
   * Detach 
   *
   * User can/should only Detach OctObjects that are not Persistent
   *
   * For detaching already Persistent OctObjects, disconnect should be called
   * so that the information gets transferred back to the data server.
   *
   * @param obj   object to Detach
   */

  public int detach(PersistentObject pObj) {

    PersistentObject vecPObj;

    if (pObj.isPersistent == true) {
      //System.out.println("Can't detach an object that's persistent");
      //System.out.println("May use detachCommit");
      //return PO.ERROR;
    }

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

      vecPObj = (PersistentObject) contents.elementAt(i);

      if (pObj.equals(vecPObj)) {
	contents.removeElementAt(i);
	
	// have pObj delete "this" from containers Vector

	pObj.detachFrom(this);
	return PO.OK;
      }
    }
 
    System.out.println("Can't find the object, " + 
		       pObj.objectClassName + " to detach!");
    return PO.NOT_ATTACHED;
    
  }

  /**
   *
   * Detach the (DirObject) container's content's instance of this object
   * @param cnt  The container to delete from
   */

  public void detachFrom(PersistentObject cnt) {

    PersistentObject pObj;

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

      pObj = (PersistentObject) containers.elementAt(i);

      if (pObj.equals(cnt))
	containers.removeElementAt(i);
    }
    System.out.println("Can't detach from the container");
  }
  
  /**
   *
   * Delete Object
   * Deletes the object at the data back-end
   *
   */

  protected int deleteMe() {

    // delete links in the dynamic session
    for (int i=0; i<contents.size(); i++){
      PersistentObject pObj = (PersistentObject) contents.elementAt(i);      
      pObj.detachFrom(this);
    }

    for (int i=0; i<containers.size(); i++){
      PersistentObject pObj = (PersistentObject) containers.elementAt(i);      
      pObj.detach(this);
    }

    if (connectServer() == false)
      return PO.ERROR;

    outStreamString = comCons.prepareCommandString(PO.DELETE, userId,
                                                   objectClassName,
                                                   dbId, null,
                                                   0, 0, null);
    send(outStreamString);
    Vector objVector = parse(PO.DELETE);
    closeServer(netSocket);
    return PO.OK;
  }


  /* ------------------------------------------------
   *
   * (Other) Abstract Methods that should be overloaded by the 
   * application programmer to capture full 
   * object management capabilities 
   *
   * ------------------------------------------------ */

  /**
   *
   * Object Saving policy, such as handling of dirty bits, etc., that
   * must/should be done before saving.
   * The object developer has to overload this method.
   *
   * @param obj Object to be saved
   */

  //abstract protected int savePolicy(PersistentObject pObj);
  protected int savePolicy(PersistentObject pObj) {
    return PO.OK;
  }

  /**
   *
   * Post-object-saving policy, such as handling of dirty bits, etc.,
   * that the object developer has to overload
   *
   * @param obj Object that has been saved
   */

  //abstract protected void postSavePolicy(PersistentObject pObj);
  protected void postSavePolicy(PersistentObject pObj){
    isPersistent = true;
  }

  /**
   *
   * Post-object-loading policy, such as handling of dirty bits, etc.,
   * that the object developer has to overload
   *
   * @param Object that has been loaded
   */

  //abstract protected void postLoadPolicy(Object obj);
  protected void postLoadPolicy(Object obj){
  }

  /**
   * Load objects that are attached at the next direct level
   * of the current object to the Vector contents
   *
   * Return PO.OK     if operation is successful
   *        PO.ERROR  if not
   */ 
  public int initGenContents(){

    if (contentsInMem == true) {
      DEBUG("Contents already in memory");
      return PO.OK;
    }

    contents = initGenRelative(PO.CONTENTS);
    if (contents == null)
      return PO.ERROR;
    return PO.OK;
  }

  /**
   * Load objects that are attached at the next upper level
   * of the current object to the Vector contents
   *
   * Return PO.OK     if operation is successful
   *        PO.ERROR  if not
   */ 
  public int initGenContainers(){

    if (containersInMem == true) {
      DEBUG("Contents already in memory");
      return PO.OK;
    }

    containers = initGenRelative(PO.CONTAINERS);
    if (containers == null)
      return PO.ERROR;
    return PO.OK;
  }

  private Vector initGenRelative(int relativeType) {
  
    Vector relativeVector = new Vector();
    int numMembers;
    //int memType;
    int index = 0;
    PersistentObject pObj;
    
    if (isPersistent == false){
      System.out.print("Can't generate relatives for not-yet "); 
      System.out.print("Persistent Objects\n");
      return null;
    }

    if (relativeType == PO.CONTAINERS) {

      if (containersInMem == true)
	return null;
      numMembers = numParents;
      //memType = PARENTS;
    } else {

      if (contentsInMem == true)
	return null;

      numMembers = numChildren;
      //memType = CONTENTS;
      index = numObjField;  // index starts at numObjField as there are
                            // numObjField objects already attached
    }
    
    for (int i=index; i<numMembers; i++) {
      pObj = getMemberInfo(relativeType, i);
      relativeVector.addElement(pObj);
    }

    if (relativeType == PO.CONTAINERS)
      containersInMem = true;
    else contentsInMem = true;

    return relativeVector;
  }


  /**
   * Return a MemberInfo object which contains the object class name
   * and object id pair
   *
   * @param type    Either PARENTS or CHILDREN
   * @param index   The position of the object field
   */
  protected PersistentObject getMemberInfo(int type, int index) {

    PersistentObject pObj = null;
    Object obj;
    Class poClass;

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

    outStreamString = comCons.prepareCommandString(PO.GETATTINFO, userId,
						   objectClassName,
						   dbId, null,
						   index, type, null);
    send(outStreamString);
    Vector objVector = parse(PO.GETATTINFO);
    closeServer(netSocket);
    //memInfo = new PO_MemberInfo(currentRelativeClass, attachObjId);

    try {

      poClass = Class.forName(currentRelativeClass);
DEBUG("relative class: " + currentRelativeClass);

      try {
	obj = poClass.newInstance();

	pObj = (PersistentObject) obj;
	  
	pObj.load(attachObjId);
	return pObj;

      } catch (Exception e){
	System.out.println("Can't create new instance");
      } 
    } catch (Exception e){
      System.out.println(currentRelativeClass + " Class Not Found");
    }
    
    return pObj;
  }


  /**
   *
   * Debug
   * Prints debugging statements if the debug flag is set to true
   *
   * @param debugStmt The debugging statement supplied
   */

  protected void DEBUG(String debugStmt){

    if (debugFlag == true) {
      System.out.println("PersistentObject: " + debugStmt);
    }
  }

}