Teuchos_Array.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library 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
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef TEUCHOS_ARRAY_H
#define TEUCHOS_ARRAY_H

#include "Teuchos_ConfigDefs.hpp"
#include "Teuchos_TestForException.hpp"
#include "Teuchos_Utils.hpp"
#include "Teuchos_TypeNameTraits.hpp"

namespace Teuchos
{

  class InvalidArrayStringRepresentation : public std::logic_error
  {public:InvalidArrayStringRepresentation(const std::string& what_arg) : std::logic_error(what_arg) {}};

  template<class T>
  class Array : public std::vector<T>
  {
  public:
    Array();

    Array(int n);

    Array(int n, const T& t);

    inline Array<T>& append(const T& entry) {this->push_back(entry); return *this;}

    void remove(int i);

    int length() const {return this->size();}

    inline T& operator[](int i);

    inline const T& operator[](int i) const;

    std::string toString() const ;

    static bool hasBoundsChecking();

  private:

    void indexCheckCrash(int i) const;
  };

  template<class T> std::ostream& operator<<(std::ostream& os, 
                                             const Array<T>& array);

  template<class T> int hashCode(const Array<T>& array);

  template<class T> std::string toString(const Array<T>& array);

  template<class T> inline Array<T>::Array()
    : std::vector<T>()
  {}

  template<class T> inline Array<T>::Array(int n)
    : std::vector<T>(n)
  {}

  template<class T> inline Array<T>::Array(int n, const T& t)
    : std::vector<T>(n, t)
  {}

  template<class T>
  void Array<T>::remove(int i) {
#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
    indexCheckCrash(i);
#endif
    // Erase the i-th element of this array.
    this->erase( this->begin() + i );
  }

  template<class T> inline
  T& Array<T>::operator[](int i) {
#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
    indexCheckCrash(i);
#endif
    return std::vector<T>::operator[](i);
  }

  template<class T> inline
  const T& Array<T>::operator[](int i) const {
#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
    indexCheckCrash(i);
#endif
    return std::vector<T>::operator[](i);
  }

  template<class T> inline
  bool Array<T>::hasBoundsChecking()
  {
#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK  
    return true;
#else
    return false;
#endif
  }

  template<class T> inline
  void Array<T>::indexCheckCrash(int i) const
  {
    TEST_FOR_EXCEPTION(
      !( 0 <= i && i < length() ), std::range_error,
      "Array<"<<TypeNameTraits<T>::name()<<">::indexCheckCrash: "
      "index " << i << " out of range [0, "<< length() << ")"
      );
  }

  // print in form (), (1), or (1,2)
  template<class T> inline std::ostream& operator<<(std::ostream& os, const Array<T>& array)
  {
    return os << Teuchos::toString(array);
  }

  template<class T> inline int hashCode(const Array<T>& array)
  {
    int rtn = hashCode(array.length());
    for (int i=0; i<array.length(); i++)
      {
        rtn += hashCode(array[i]);
      }
    return rtn;
  }

  template<class T> inline std::string Array<T>::toString() const
  {
    std::ostringstream ss;
    ss << "{";

    for (int i=0; i<length(); i++)
      {
        ss << operator[](i);
        if (i<length()-1) ss << ", ";
      }
    ss << "}";

    return ss.str();
  }

  template<class T> inline
  std::string toString(const Array<T>& array)
  {
    return array.toString();
  }

  template<class T>
  Array<T> fromStringToArray(const std::string& arrayStr)
  {
    const std::string str = Utils::trimWhiteSpace(arrayStr);
    std::istringstream iss(str);
    TEST_FOR_EXCEPTION(
      ( str[0]!='{' || str[str.length()-1] != '}' )
      ,InvalidArrayStringRepresentation
      ,"Error, the std::string:\n"
      "----------\n"
      <<str<<
      "\n----------\n"
      "is not a valid array represntation!"
      );
    char c;
    c = iss.get(); // Read initial '{'
    TEST_FOR_EXCEPT(c!='{'); // Should not throw!
    // Now we are ready to begin reading the entries of the array!
    Array<T> a;
    while( !iss.eof() ) {
      // Get the basic entry std::string
      std::string entryStr;
      std::getline(iss,entryStr,','); // Get next entry up to ,!
      // ToDo: Above, we might have to be careful to look for the opening and
      // closing of parentheses in order not to pick up an internal ',' in the
      // middle of an entry (for a std::complex number for instance).  The above
      // implementation assumes that there will be no commas in the middle of
      // the std::string representation of an entry.  This is certainly true for
      // the types bool, int, float, and double.
      //
      // Trim whitespace from beginning and end
      entryStr = Utils::trimWhiteSpace(entryStr);
      // Remove the final '}' if this is the last entry and we did not
      // actually terminate the above getline(...) on ','
      bool found_end = false;
      if(entryStr[entryStr.length()-1]=='}') {
        entryStr = entryStr.substr(0,entryStr.length()-1);
        found_end = true;
        if( entryStr.length()==0 && a.size()==0 )
          return a; // This is the empty array "{}" (with any spaces in it!)
      }
      TEST_FOR_EXCEPTION(
        0 == entryStr.length()
        ,InvalidArrayStringRepresentation
        ,"Error, the std::string:\n"
        "----------\n"
        <<str<<
        "\n----------\n"
        "is not a valid array represntation!"
        );
      // Finally we can convert the entry and add it to the array!
      std::istringstream entryiss(entryStr);
      T entry;
      entryiss >> entry; // Assumes type has operator>>(...) defined!
      // ToDo: We may need to define a traits class to allow us to specialized
      // how conversion from a std::string to a object is done!
      a.push_back(entry);
      // At the end of the loop body here, if we have reached the last '}'
      // then the input stream iss should be empty and iss.eof() should be
      // true, so the loop should terminate.  We put an std::exception test here
      // just in case something has gone wrong.
      TEST_FOR_EXCEPTION(
        found_end && !iss.eof()
        ,InvalidArrayStringRepresentation
        ,"Error, the std::string:\n"
        "----------\n"
        <<str<<
        "\n----------\n"
        "is not a valid array represntation!"
        );
    }
    return a;
  }
                      
  template<class T> inline
  Array<T> tuple(const T& a)
  {
    Array<T> rtn(1, a);
    return rtn;
  }

  template<class T> inline
  Array<T> tuple(const T& a, const T& b)
  {
    Array<T> rtn(2);
    rtn[0] = a;
    rtn[1] = b;
    return rtn;
  }

  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c)
  {
    Array<T> rtn(3);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    return rtn;
  }

  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c, const T& d)
  {
    Array<T> rtn(4);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    rtn[3] = d;
    return rtn;
  }

  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c, const T& d, const T& e)
  {
    Array<T> rtn(5);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    rtn[3] = d;
    rtn[4] = e;
    return rtn;
  }


  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c, const T& d, const T& e,
                 const T& f)
  {
    Array<T> rtn(6);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    rtn[3] = d;
    rtn[4] = e;
    rtn[5] = f;
    return rtn;
  }

  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c, const T& d, const T& e,
                 const T& f, const T& g)
  {
    Array<T> rtn(7);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    rtn[3] = d;
    rtn[4] = e;
    rtn[5] = f;
    rtn[6] = g;
    return rtn;
  }

  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c, const T& d, const T& e,
                 const T& f, const T& g, const T& h)
  {
    Array<T> rtn(8);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    rtn[3] = d;
    rtn[4] = e;
    rtn[5] = f;
    rtn[6] = g;
    rtn[7] = h;
    return rtn;
  }

  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c, const T& d, const T& e,
                 const T& f, const T& g, const T& h, const T& i)
  {
    Array<T> rtn(9);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    rtn[3] = d;
    rtn[4] = e;
    rtn[5] = f;
    rtn[6] = g;
    rtn[7] = h;
    rtn[8] = i;
    return rtn;
  }


  template<class T> inline
  Array<T> tuple(const T& a, const T& b, const T& c, const T& d, const T& e,
                 const T& f, const T& g, const T& h, const T& i, const T& j)
  {
    Array<T> rtn(10);
    rtn[0] = a;
    rtn[1] = b;
    rtn[2] = c;
    rtn[3] = d;
    rtn[4] = e;
    rtn[5] = f;
    rtn[6] = g;
    rtn[7] = h;
    rtn[8] = i;
    rtn[9] = j;
    return rtn;
  }
}

#endif // TEUCHOS_ARRAY_H

---