collection.h

Go to the documentation of this file.

/*
  -------------------------------------------------------------------
  
  Copyright (C) 2006, 2007, 2008, Andrew W. Steiner
  
  This file is part of O2scl.
  
  O2scl is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 3 of the License, or
  (at your option) any later version.
  
  O2scl is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with O2scl. If not, see <http://www.gnu.org/licenses/>.

  -------------------------------------------------------------------
*/
#ifndef O2SCL_COLLECTION_H
#define O2SCL_COLLECTION_H

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <sstream>
#include <o2scl/misc.h>
#include <o2scl/err_hnd.h>
#include <o2scl/test_mgr.h>
#include <o2scl/text_file.h>
#include <o2scl/file_format.h>
#include <o2scl/file_detect.h>
#include <o2scl/ovector_tlate.h>
#include <o2scl/omatrix_tlate.h>
#include <o2scl/ovector_cx_tlate.h>
#include <o2scl/omatrix_cx_tlate.h>

/** \file collection.h
    \brief File containing I/O types and the collection class
    
    New update todos:
    - There are a lot of blank functions in the io_base class, 
    so this class should be made abstract. This can actually be done
    by separating io_base into two classes, so that the parents of
    the collection class and the io_tlate class are different.
    - Construct new templated add() function
    - Fix test_type()
    - Fix error handling in get() functions and make a lookup() method
    which doesn't necessarily call the error handler
    - Fix documentation?
    - Columnify summary output
    - Ensure all parameters are matched by parameter and name if possible

    \future Figure out what to do with templated matrix and vector output.
    What might be ideal is a "vector_io" type which will input or output
    a generic vector of any type.
*/

#ifndef DOXYGENP
namespace o2scl {
#endif

  /** An entry in a collection
      
      Experimental.
  */
  typedef struct {
    /// The pointer to the object
    void *data;
    /// The first size parameter
    int size;
    /// The second size parameter
    int size2;
    /// True if the collection owns this object
    bool owner;
    /// A pointer to the corresponding \ref io_base object
    class io_base *iop;
  } collection_entry;

  /** \brief A pointer output structure
      
      Experimental.
  */
  typedef struct {
    /// The name of the pointer
    std::string name;
    /// Pointer to the collection entry
    collection_entry *ep;
    /// True if the pointer has been written to the file
    bool output;
  } pointer_output;
  
  /** \brief A pointer input structure

      Experimental.
   */
  typedef struct {
    /// The name of the pointer
    std::string name;
    /// The pointer
    void **ptr;
    /// The type of the object pointed to
    std::string stype;
  } pointer_input;

  // Forward declaration of class cinput
  class cinput;
  // Forward declaration of class coutput
  class coutput;

  /** 
      \brief I/O base class

      This class is experimental.

      This class is necessary so that the collection method source code
      and the io_base method source code doesn't have to go in header files.
      
      \todo Should the remove() functions be moved to class collection?
  */
  class io_base {
   
#ifndef DOXYGEN_INTERNAL

  protected:

    /// for io_type_info.add_type().
    friend class io_type_info;
   
    /// for stat_in and stat_out
    friend class collection;

    friend class cinput;
    friend class coutput;
    friend class io_manager;

    /// A pointer to the type manager
    static class io_manager *iom;
    
    /// A count of the number of objects
    static int objs_count;

    /// Automatically create an object for stat_in
    virtual int stat_in_noobj(cinput *co, in_file_format *ins);
  
    /// Automatically create an object for stat_out
    virtual int stat_out_noobj(coutput *co, out_file_format *outs);
  
    /** \brief Allocate memory and input an object
     */
    virtual int in_wrapper(cinput *co, in_file_format *ins, void *&vp);
    
    /** \brief Allocate memory and input an array of objects
     */
    virtual int in_wrapper(cinput *co, in_file_format *ins, void *&vp, 
                           int &sz);

    /** \brief Allocate memory and input a 2-d array of objects 
     */
    virtual int in_wrapper(cinput *co, in_file_format *ins, void *&vp, 
                           int &sz, int &sz2);
    
    /** \brief Internal function to output an object (or an array
        or 2-d array) 
    */
    virtual int out_wrapper(coutput *co, out_file_format *outs, 
                            void *vp, int sz, int sz2);

    /// Input an object (no memory allocation)
    virtual int object_in_void(cinput *cin, in_file_format *ins, void *op,
                               std::string &name);
    
    /// Input an array of objects (no memory allocation)
    virtual int object_in_void(cinput *cin, in_file_format *ins, void *op, 
                               int sz, std::string &name);
    
    /// Input a 2-d array of objects (no memory allocation)
    virtual int object_in_void(cinput *cin, in_file_format *ins, void *op, 
                               int sz, int sz2, std::string &name);
    
    /// Input an object (no memory allocation)
    virtual int object_in_mem_void(cinput *cin, in_file_format *ins, 
                                   void *&op, std::string &name);
    
    /// Input an array of objects (no memory allocation)
    virtual int object_in_mem_void(cinput *cin, in_file_format *ins, 
                                   void *&op, int &sz, std::string &name);
    
    /// Input a 2-d array of objects (no memory allocation)
    virtual int object_in_mem_void(cinput *cin, in_file_format *ins, 
                                   void *&op, int &sz, int &sz2,
                                   std::string &name);
    
    /// Output an object, an array of objects, or a 2-d array of objects
    virtual int object_out_void(coutput *cout, out_file_format *outs, 
                                void *op, int sz, int sz2, 
                                std::string name="");

    /** \brief Store the value of \c sw given in the constructor so
        that we know if we need to remove the type in the destructor
    */
    int sw_store;

    /** \name Functions to remove the memory that was allocated for an object
     */
    //@{
    /// Remove the memory for an object
    virtual int remove(void *vp) { return 0; }
    
    /// Remove the memory for an array of objects
    virtual int remove_arr(void *vp) { 
      return 0; 
    }

    /// Remove the memory for a 2-dimensional array of objects
    virtual int remove_2darr(void *vp, int sz) { return 0; }
    //@}

#endif
  
  public:

    /** 
        \brief Create a new I/O object 
        
        If \c sw is different from zero, then the type will not
        be added to the io_manager. This is useful if you want
        an object to be its own I/O class, in which case you
        may want to make sure that the io_manager only tries
        to add the type once. There is no need to have an I/O 
        object for every instance of a particular type.
    */
    io_base(int sw=0);

    /** \brief Create a new object only if an I/O object for type \c t
        is not yet present
    */
    io_base(const char *t);

    virtual ~io_base();
    
    /// \name Functions to be overloaded in descendants of io_base
    //@{
    /// Return the type of an object
    virtual const char *type() { return "io_base"; }
    
    /// If true, then the object contains static data
    virtual bool has_static_data() { return false; }
    //@}
    
    /** \name Functions useful for in in() and out()
     */
    //@{
    /// Input a pointer
    virtual int pointer_in(cinput *co, in_file_format *ins, void **pp, 
                           std::string &stype);

    /** 
        \brief Output an object to \c outs of type \c stype 

        This is useful for to output a pointer to an object in the
        out() or stat_out() functions for a class. The data for
        the object which is pointed to is separate from the object
        and is only referred to once if more than one objects
        point to it.
    */
    virtual int pointer_out(coutput *co, out_file_format *outs, void *ptr, 
                            std::string stype);
    //@}
    
  };
 
  /** 
      \brief Manage I/O type information

      This class is experimental.

      This class is automatically created, utilized, and destroyed by
      \ref io_base. It's sole constructor is protected, so it cannot
      be created by a generic end-user. 
  */
  class io_manager {

  public:

    /** 
        \brief Add a type to the list

        Unfortunately, add_type() cannot ensure that no type is added
        more than once, since the type is not specified until the 
        entire constructor hierarchy has been executed and add_type()
        is called at the top of this hierarchy.
    */
    int add_type(io_base *iop);

    /// Return 0 if \c iop points to a valid type
    int is_type(io_base *iop);

    /// Add type \c iop to the manager assuming the type name \c t
    int add_type(io_base *iop, const char *t);

    /// Remove a type from the list
    int remove_type(io_base *iop);

#ifndef DOXYGEN_INTERNAL

  protected:

    /// So that io_base can access add_type().
    friend class io_base;

    /// So that collections can access get_ptr
    friend class collection;

    /// So that cinputs can access get_ptr()
    friend class cinput;

    /// So that coutputs can access get_ptr()
    friend class coutput;

    // So that io_type_info can access tlist
    friend class io_type_info;

    /// Get a pointer to type \c stype 
    io_base *get_ptr(std::string stype);
  
    /// The list of types in the form of io_base pointers
    std::vector<io_base *> tlist;
  
    /// A useful definition for iterating through types
    typedef std::vector<io_base *>::iterator titer;

    /// Empty constructor
    io_manager() {};
  
#endif

  };

  // ----------------------------------------------------------------
  // Start of class io_type_info
  // ----------------------------------------------------------------

  /** 
      \brief User interface to provide I/O type information

      This class is experimental.
  */
  class io_type_info : public io_base {

#ifndef DOXYGEN_INTERNAL

  protected:

    /// So that collection::fout() can access static_fout().
    friend class collection;
    
    /// Output the static information for the I/O types
    int static_fout(coutput *co, out_file_format *out);
    
    /// Output the static information for the I/O types not in the list
    int static_fout_restricted(coutput *co, out_file_format *out,
                               std::set<std::string,string_comp> list);
  
    /// A useful definition for iterating through types
    typedef std::vector<io_base *>::iterator titer;

#endif
  
  public:

    io_type_info();

    virtual ~io_type_info();

    /** \name Type manipulation 
     */
    //@{

    /// Return 0 if \c stype is a valid I/O type
    int is_type(std::string stype);

    /** 
        \brief Remove \c stype from the list of valid I/O types

        This method is dangerous, as it can't check to ensure that
        no collection has remaining objects of the type to be
        removed.
    */
    int remove_type(std::string stype);

    /** 
        \brief Remove all types in the list of valid I/O types

        This method is dangerous as it doesn't ensure that
        all collections are empty.
    */
    virtual int clear_types();

    /// Print a summary of valid types to the \c outs stream
    void type_summary(std::ostream *outs, bool pointers=false);

    /// Add an I/O type to the list
    int add_type(io_base *iop) { return iom->add_type(iop); }
    //@}

  };
  
  // ----------------------------------------------------------------
  // End of class io_type_info
  // ----------------------------------------------------------------

  // ----------------------------------------------------------------
  // Start of class collection
  // ----------------------------------------------------------------

  /** 
      \brief Collection of objects 

      This class is experimental.

      By default, the fout() functions alphabetize the objects by name,
      but this is not a requirement for files read using fin().
    
      Important issues:
      1. Pointers are not set until after an entire file is read so that
      objects that are pointed to may occur anywhere in a file. This
      means that the information that is pointed to cannot be used in
      the io_tlate_d::input() function.
      
      \todo
      - If pointer_in gets a null pointer it does nothing. Should we
      replace this behaviour by two pointer_in() functions. One which
      does nothing if it gets a null pointer, and one which will
      go ahead and set the pointer to null. This is useful for 
      output object which have default values to be used if
      they are given a null pointer.
      - More testing on rewrite() function.
      - Think more about adding arrays of pointers? pointers to arrays?
      - Modify static data output so that if no objects of a type
      are included, then no static data is output for that type?
      (No, it's too hard to go through all objects looking for
      an object of a particular type).
      
      \bug
      - Ensure that the user cannot add a object with a name of ptrXXX.
      - Test_type does not test handle static data or pointers.
      - Check strings and words for characters that we can't handle
      - The present version of a text-file requires
      strings to contain at least one printable character.
      - Ensure that all matching is done by both type and name if 
      possible.

      Structure:
      collection::fout() does the following:
      - create an object of type coutput
      - Add all objects in the list to the pointer map \c ptr_map 
      (with \c output=true ) so that they can be referred to by
      pointers later
      - Output all static data using io_type_info::static_fout()
      - Output all of the items in the list \c plist  (see
      below). Any pointers which are not already in \c ptr_map  are
      added at this point (with \c output=false 
      - Call coutput::pointer_map_fout() to output all objects that
      were referred to but not in the list

      To output individual items, collection::fout() does the following:
      - Call either io_base::out_wrapper() or io_base::out_hc_wrapper()
      - In turn, these functions call io_base::output(), which the user
      has overloaded
      - If the function io_base::output() calls io_tlate::object_out() then the
      io_base::output() function appropriate for that object is called.
      No type or name information is included, but size integers are
      included if the object is a 1- or 2-d array.
      - If the function io_base::output() calls io_base::pointer_out(), then 
      the object is searched for in the \c ptr_map . If it is 
      not there, then the object is added and assigned a name. The
      type and name are then output. If the pointer is NULL, then
      both the type and the name are set to \c null .

  */
  class collection : public io_base {

#ifndef DOXYGEN_INTERNAL
  
  protected:

    friend class io_base;
    friend class cinput;
    friend class coutput;
  
    /// A convenient iterator definition for the collection
    typedef std::map<std::string,collection_entry,string_comp>::iterator 
      piter;
  
    /// The actual collection
    std::map<std::string,collection_entry,string_comp> plist;

#endif

  public:
    
    collection() : io_base(1) {};
      
#ifdef O2SCL_NEVER_DEFINED
      // This is just to assist emacs tabification
  }
  {
#endif
    
    ~collection();
    
    /** \name Output to file methods */
    //@{
    
    /// Output entire list to \c outs 
    int fout(out_file_format *outs);
    
    /// Output entire list to a text file named \c filename
    int fout(std::string filename);
    //@}
    
    /** \name Input from file methods 
        If \c overwrt is true, then any objects which
        already exist with the same name are overwritten
        with the objects in the file. The collection
        owns all the objects read. (Since it created them,
        the collection assumes it ought to be responsible
        to destroy them.)
    */
    //@{
    /// Read a collection from text file named \c file_name
    int fin(std::string file_name, bool overwrt=false, int verbose=0);
    
    /// Read a collection from \c ins
    int fin(in_file_format *ins, bool overwrt=false, int verbose=0);
    //@}
    
    /** \name Miscellaneous methods
     */
    //@{

    /// Test the output for type \c stype.
    int test_type(o2scl::test_mgr &t, std::string stype, void *obj,
                  void *&newobj, bool scrout=false);

    /** 
        \brief Update a file containing a collection
 
        This method loads the file from "fin" and produces a file at
        "fout" containing all of the objects from "fin", updated by
        their new values in the present list if possible. Then, it adds
        to the end of "fout" any objects in the present list that were
        not originally contained in "fin".
    */
    int rewrite(std::string in_name, std::string out_name);

    /** \brief Force the collection to assume that the ownership
        of \c name is external.

        This allows the user to take over ownership of the object
        named \c name. This is particularly useful if the object is
        read from a file (since then object is owned initially by the
        collection), and you want to delete the collection, but retain
        the object.  
    */
    int disown(std::string name);

    /** \brief Summarize contents of collection
     */
    int summary(std::ostream *out, bool show_addresses=false);

    /** 
        \brief Remove an object for the collection

        Free the memory \c name if it is owned by the collection 
        and then remove it from the collection.  
    */
    int remove(std::string name);
    
    /** \brief Remove all objects from the list
     */
    void clear();

    /** 
        \brief Count number of objects */
    int size();

    //@}

    /** \name Generic add methods
        
    If \c overwrt is true, then any objects which already exist
    with the same name as \c name are overwritten. If owner=true,
    then the collection will own the memory allocated for the
    object and will free that memory with delete when the object
    is removed or the collection is deleted.
    */
    //@{
    int add_void(std::string name, io_base *tio, void *vec, int sz=0, 
                 int sz2=0, bool overwrt=true, bool owner=false);
    
    int add_void(std::string name, std::string stype, 
            void *vec, int sz=0, int sz2=0,
            bool overwrt=true, bool owner=false);
    //@}

    /// \name Machine type get methods
    //@{
    /// Get a boolean value named \c name with default value \c def_value
    bool getb_def(std::string name, bool def_value) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="bool") {   
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getc2().",
                    gsl_efailed);
            return 0;
          }
          bool *wp=(bool *)(pit->second.data);                  
          return *wp;
        }                                                       
      }                                                 
      return def_value;
    }
    
    /// Get a char named \c name with default value \c def_value
    char getc_def(std::string name, char def_value) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="char") {   
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getc2().",
                    gsl_efailed);
            return 0;
          }
          char *wp=(char *)(pit->second.data);                  
          return *wp;
        }                                                       
      }                                                 
      return def_value;
    }
    
    /// Get a double named \c name with default value \c def_value
    double getd_def(std::string name, double def_value) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="double") { 
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getd2().",
                    gsl_efailed);
            return 0.0;
          }
          double *wp=(double *)(pit->second.data);                      
          return *wp;
        }                                                       
      }                                                 
      return def_value;
    }
    
    /// Get an integer named \c name with default value \c def_value
    int geti_def(std::string name, int def_value) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="int") {    
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::geti2().",
                    gsl_efailed);
            return 0;
          }
          int *wp=(int *)(pit->second.data);                    
          return *wp;
        }                                                       
      }                                                 
      return def_value;
    }
    
    /// Get a string named \c name with default value \c def_value
    std::string gets_def(std::string name, std::string def_value) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="string") { 
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::gets2().",
                    gsl_efailed);
            return "";
          }
          std::string *wp=(std::string *)(pit->second.data);
          return *wp;
        }                                                       
      }
      return def_value;
    }
    
    /// Get a boolean value named \c name with default value \c def_value
    std::string getw_def(std::string name, std::string def_value) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="word") {   
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getw2().",
                    gsl_efailed);
            return "";
          }
          std::string *wp=(std::string *)(pit->second.data);
          return *wp;
        }                                                       
      }                                                 
      return def_value;
    }
    
    /// Desc
    bool getb(std::string name) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="bool") {   
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getc2().",
                    gsl_efailed);
            return 0;
          }
          bool *wp=(bool *)(pit->second.data);                  
          return *wp;
        }                                                       
      }                                                 
      O2SCL_ERR("Object not found in collection::getc2().",gsl_enotfound);
      return false;
    }
    
    /// Desc
    char getc(std::string name) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="char") {   
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getc2().",
                    gsl_efailed);
            return 0;
          }
          char *wp=(char *)(pit->second.data);                  
          return *wp;
        }                                                       
      }                                                 
      O2SCL_ERR("Object not found in collection::getc2().",gsl_enotfound);
      return 0;
    }
    
    /// Desc
    double getd(std::string name) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="double") { 
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getd2().",
                    gsl_efailed);
            return 0.0;
          }
          double *wp=(double *)(pit->second.data);                      
          return *wp;
        }                                                       
      }                                                 
      O2SCL_ERR("Object not found in collection::getd2().",gsl_enotfound);
      return 0.0;
    }
    
    /// Desc
    int geti(std::string name) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="int") {    
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::geti2().",
                    gsl_efailed);
            return 0;
          }
          int *wp=(int *)(pit->second.data);                    
          return *wp;
        }                                                       
      }                                                 
      O2SCL_ERR("Object not found in collection::geti2().",gsl_enotfound);
      return 0;
    }
    
    /// Desc
    std::string gets(std::string name) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="string") { 
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::gets2().",
                    gsl_efailed);
            return "";
          }
          std::string *wp=(std::string *)(pit->second.data);
          return *wp;
        }                                                       
      }
      O2SCL_ERR("Object not found in collection::gets2().",gsl_enotfound);
      return "";
    }
    
    /// Desc
    std::string getw(std::string name) {
      piter pit=plist.find(name);                       
      if (pit!=plist.end()) {                           
        if (((std::string)pit->second.iop->type())=="word") {   
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR("Size of object incorrect in collection::getw2().",
                    gsl_efailed);
            return "";
          }
          std::string *wp=(std::string *)(pit->second.data);
          return *wp;
        }                                                       
      }                                                 
      O2SCL_ERR("Object not found in collection::getw2().",gsl_enotfound);
      return "";
    }
    

    /// Desc
    int getb(std::string name, bool *&op, size_t &sz) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="bool") {
          if (pit->second.size==0 || pit->second.size2!=0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(bool *)(pit->second.data);
          sz=pit->second.size;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }
    
    /// Desc
    int getb(std::string name, bool **&op, size_t &sz,
             size_t &sz2) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="bool") {
          if (pit->second.size==0 || pit->second.size2==0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(bool **)(pit->second.data);
          sz=pit->second.size;
          sz2=pit->second.size2;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }

    /// Desc
    int getc(std::string name, char *&op, size_t &sz) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="char") {
          if (pit->second.size==0 || pit->second.size2!=0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(char *)(pit->second.data);
          sz=pit->second.size;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }
    
    /// Desc
    int getc(std::string name, char **&op, size_t &sz,
            size_t &sz2) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="char") {
          if (pit->second.size==0 || pit->second.size2==0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(char **)(pit->second.data);
          sz=pit->second.size;
          sz2=pit->second.size2;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }

    /// Desc
    int getd(std::string name, double *&op, size_t &sz) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="double") {
          if (pit->second.size==0 || pit->second.size2!=0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(double *)(pit->second.data);
          sz=pit->second.size;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }
    
    /// Desc
    int getd(std::string name, double **&op, size_t &sz,
             size_t &sz2) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="double") {
          if (pit->second.size==0 || pit->second.size2==0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(double **)(pit->second.data);
          sz=pit->second.size;
          sz2=pit->second.size2;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }

    /// Desc
    int geti(std::string name, int *&op, size_t &sz) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="int") {
          if (pit->second.size==0 || pit->second.size2!=0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(int *)(pit->second.data);
          sz=pit->second.size;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }
    
    /// Desc
    int geti(std::string name, int **&op, size_t &sz,
             size_t &sz2) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="int") {
          if (pit->second.size==0 || pit->second.size2==0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(int **)(pit->second.data);
          sz=pit->second.size;
          sz2=pit->second.size2;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }

    /// Desc
    int gets(std::string name, std::string *&op, size_t &sz) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="string") {
          if (pit->second.size==0 || pit->second.size2!=0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(std::string *)(pit->second.data);
          sz=pit->second.size;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }
    
    /// Desc
    int gets(std::string name, std::string **&op, size_t &sz,
             size_t &sz2) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="string") {
          if (pit->second.size==0 || pit->second.size2==0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(std::string **)(pit->second.data);
          sz=pit->second.size;
          sz2=pit->second.size2;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }

    /// Desc
    int getw(std::string name, std::string *&op, size_t &sz) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="word") {
          if (pit->second.size==0 || pit->second.size2!=0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(std::string *)(pit->second.data);
          sz=pit->second.size;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }
    
    /// Desc
    int getw(std::string name, std::string **&op, size_t &sz,
             size_t &sz2) {
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())=="word") {
          if (pit->second.size==0 || pit->second.size2==0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(std::string **)(pit->second.data);
          sz=pit->second.size;
          sz2=pit->second.size2;
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something 
      // that they don't expect to find.
      //  O2SCL_ERR(tname+" not found in get().",not_found);
      return gsl_enotfound;
    }

    //@}
    
    /// \name Generic type get methods
    //@{

    /// Desc
    template<class obj_t>
      int get(std::string name, obj_t *&op) {
      obj_t od;
      op=0;
      piter pit=plist.find(name);
      if (pit!=plist.end()) {
        if (((std::string)pit->second.iop->type())==od.type()) {
          if (pit->second.size!=0 || pit->second.size2!=0) {
            O2SCL_ERR_RET("Size of object incorrect in collection::get2().",
                        gsl_efailed);
          }
          op=(obj_t *)(pit->second.data);
          return gsl_success;
        }
      }
      // 1/9/05 We choose not to set an error here in case
      // the user is legitimately looking for something