//-----------------------------------------------------------------
// main.C.sample 
// This file is an example for a main.C Demeter main file.
// It provides sample code fragments showing how to use some of the 
// Demeter runtime libraries. To have a quick test of your environment 
// rename this file to main.C and compile the environment. 
//-----------------------------------------------------------------

#include "UNKNOWN.h"


void out_of_store()
{
  cerr << "UNKNOWN: operator new failed, out of store\n";
  exit( 1 );
}

#ifndef __GNUC__
extern PF set_new_handler( PF );
#else
extern "C"  PF set_new_handler( PF );
#endif

/*
 * GEN_DIR is a global variable containing the path of the generation
 * environment. This path is used to find the cd-print and cd-parse
 * class dictionaries.
 * Do NOT delete the following statement.
 */

char* GEN_DIR = getenv( "GEN_DIR" );

int main( int argc, char* argv[], char* envp[] )
{
  // set new handler to catch out of memory exception
  set_new_handler( &out_of_store );

  //----------------------------------------
  // Parsing an object 
  //----------------------------------------
  // specify file to parse in 
  const int MAXPATH = 256;
  char Dem_input[MAXPATH];

  // Input file is first argument
  if( argc >= 2 )
     strcpy( Dem_input, argv[1] );
  else {
     strcpy( Dem_input, "demeter-input" );  // default input 
  }

  // parse it in 
  cout << "Parsing in object in: " << Dem_input << "." << endl;
  Container* iContainer = new Container();
  if ( ( Container* ) iContainer -> g_parse( Dem_input ) == NULL )
  {
     cerr << "Parser error." << endl;
     exit(1);
  }
  cout << endl;

  //----------------------------------------
  // Drawing an object 
  //----------------------------------------
  cout << "Drawing the parsed object:" << endl;
  iContainer -> g_draw();
  cout << "\nEnd of drawing.\n" << endl;

  //----------------------------------------
  // Copying an object 
  //----------------------------------------
  cout << "Copying the object." << endl;
  Container* nContainer = ( Container* ) iContainer -> g_copy();
  cout << endl;

  //----------------------------------------
  // Displaying the copied object as a tree
  //----------------------------------------
  cout << "Displaying the copied object as a tree:" << endl;
  nContainer -> g_displayAsTree();
  cout << "\nEnd of display.\n" << endl;

  //----------------------------------------
  // Comparing two objects 
  //----------------------------------------
  cout << "Comparing the two objects:" << endl;
  if ( iContainer -> g_equal( nContainer ) == 1 )
     cout << "copied and original object are equal\n" << endl;
  else
     cout << "copied and original object are NOT equal\n" << endl;

  //----------------------------------------
  // Printing an object 
  //----------------------------------------
  cout << "Pretty printing the parsed object:" << endl;
  char* tmp_filename = "notmod/tmp/demeter-output";
  ofstream outFile( tmp_filename );
  if ( !outFile ) {
    cerr << "UNKNOWN error: unable to open " << tmp_filename
         << " for output" << endl;
    exit( 1 );
  }
  cout << iContainer << endl;
  iContainer -> g_print( outFile );
  outFile.close();
  cout << "\nEnd of printing.\n" << endl;

  //----------------------------------------
  // Selftest of generic parser/printer 
  //----------------------------------------
  cout << "Selftest of generic parser/printer:" << endl;
  Container* iContainer_printed = new Container();
  iContainer_printed = (Container*)iContainer_printed->g_parse( tmp_filename );
  if( iContainer->g_equal( iContainer_printed ) == 1 ) {
    cout << "g_parse and g_parse( g_print( g_parse ) ) are equal.\n"
         << "Selftest passed.\n";
  } else {
    cout << "g_parse and g_parse( g_print( g_parse ) ) are NOT equal.\n"
         << "Selftest failed.\n";
  }
  cout << endl;

  //----------------------------------------
  // Your own code follows after this 
  //----------------------------------------

  cout << "\n*** FINISHED ***" << endl;

  return ( 0 );
}