home *** CD-ROM | disk | FTP | other *** search
/ ftptest.leeds.ac.uk / 2015.02.ftptest.leeds.ac.uk.tar / ftptest.leeds.ac.uk / bionet / CAE-GROUP / SCL-WIN3x / SCLTEST.EXE / TIO / TIO.CC < prev    next >
C/C++ Source or Header  |  1994-12-13  |  4KB  |  116 lines
  1. /*
  2.  * tio.cc
  3.  *
  4.  * Ian Soboroff, NIST
  5.  * June, 1994
  6.  *
  7.  * Usage: tio infile [outfile]
  8.  *
  9.  * tio tests reading, writing, and appending of STEPfiles.  It must be given
  10.  * a STEPfile for input, and will write output to stdout.  It reads the input
  11.  * file, writes it to stdout, appends another copy of the input file to the
  12.  * instances already in memory, prints all the instances out via the registry,
  13.  * and then writes the final STEPfile to stdout and to the optional output
  14.  * file.
  15.  */
  16.  
  17. /* A switch for tests.h, because we don't need to schema header file */
  18. #define DONT_NEED_HEADER
  19. #include "tests.h"
  20.  
  21. void main(int argc, char *argv[])
  22. {
  23.     int using_outfile = 0;
  24.  
  25.     if (argc > 3 || argc < 2)
  26.     {
  27.         cout << "Syntax:   tio infile [outfile]" << endl;
  28.     exit(1);
  29.     }
  30.     else if (argc > 2)
  31.         using_outfile = 1;  // output filename is in argv[2]
  32.  
  33.     // if the comments below look canned, it's because they're taken
  34.     // straight from the treg source... ;-)
  35.  
  36.     // This has to be done before anything else.  This initializes
  37.     // all of the registry information for the schema you are using.
  38.     // The SchemaInit() function is generated by fedex_plus... see
  39.     // extern statement above.
  40.  
  41.     Registry *registry = new Registry(SchemaInit);
  42.     
  43.     // The nifty thing about the Registry is that it basically keeps a list
  44.     // of everything in your schema.  What this means is that we can go
  45.     // through the Registry and instantiate, say, one of everything, without
  46.     // knowing at coding-time what entities there are to instantiate.  So,
  47.     // this test could be linked with other class libraries produced from
  48.     // other schema, rather than the example, and run happily.
  49.  
  50.     InstMgr instance_list;
  51.     STEPfile *sfile = new STEPfile(*registry, instance_list);
  52.         
  53.     // The STEPfile is actually an object that manages the relationship
  54.     // between what's instantiated in the instance manager, and how that
  55.     // information gets passed to the outside, e.g., a file on disk.
  56.  
  57.     // First we're going to read in the data from the input STEPfile,
  58.     // and print it to stdout
  59.  
  60.     // Reading the STEPfile instantiates all the objects in it.
  61.     // The instances get pointers into the InstMgr, and each type
  62.     // and entity gets a pointer into the registry.
  63.     cout << "\n### Reading exchange file from " << argv[1] << endl;
  64.     sfile->ReadExchangeFile(argv[1]);
  65.  
  66.     // Just checking... ;-)
  67.     cout << "\n### The InstMgr says there are ";
  68.     cout << instance_list.InstanceCount() << " instantiated objects" << endl;
  69.  
  70.     cout << "\n### Here is the exchange file:" << endl << endl;
  71.     sfile->WriteExchangeFile(cout);
  72.  
  73.     // If you append in another exchange file, it creates new instances
  74.     // starting at a 1000-block of numbers.  Just 'Read'ing again
  75.     // would clobber the instances already there.
  76.     cout << "\n### Now appending in another copy" << endl;
  77.     sfile->AppendExchangeFile(argv[1]);
  78.  
  79.     // Browsing the registry...
  80.     cout << "\n### Here is a list of entities now in the registry:" << endl;
  81.     registry->ResetEntities();
  82.     const EntityDescriptor *ent = registry->NextEntity();
  83.     SCLstring tmpstr;
  84.     while (ent)
  85.     {
  86.     cout << ent->Name() << ": " << ent->TypeString(tmpstr) << endl;
  87.     ent = registry->NextEntity();
  88.     }
  89.  
  90.     // Browsing through the instance manager.  This shows how to get
  91.     // at those instances it points to.
  92.     cout << "\n### And here are all the instantiated objects..." << endl;
  93.     int numInstances = instance_list.InstanceCount();
  94.     cout << "### The InstMgr says we have " << numInstances;
  95.     cout << " things instantiated.\n";
  96.     for (int i=0; i<numInstances; i++)
  97.     {
  98.         cout << i << ": " << instance_list[i]->GetSTEPentity()->EntityName();
  99.     cout << " (" << 
  100.       instance_list[i]->GetSTEPentity()->EntityDescriptor->Description();
  101.     cout << ")" << endl;
  102.     }
  103.  
  104.     // Dump everything to STEPfiles...
  105.     cout << "\n### Here it is in STEPfile format:" << endl << endl;
  106.     sfile->WriteExchangeFile(cout);
  107.  
  108.     if (using_outfile)
  109.     {
  110.     ofstream stepout(argv[2]);
  111.     cout << "\n### Writing that to outfile " << argv[2] << endl;
  112.     sfile->WriteExchangeFile(stepout);
  113.     }
  114. }
  115.  
  116.