---

Array.h

Go to the documentation of this file.

//
//    Title     :  Array.h
//    Project     :  OSCAR Version 2.0
//    Created     :
//    Author      :  Chetan Kapoor
//    Platforms   :  All
//    Copyright   :  Copyright) The University of Texas at Austin, 2002. All rights reserved.
//
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//
//    Purpose     :  Class Definition for parametrized array class.
//
//-----------------------------------------------------------------------------
//
//    $Revisions$
//    Added a copy method that works like operator equal but returns a bool so errors
//      can be passed.   Mark Tisius 3/14/03
//
//    $Log: Array.h,v $
//    Revision 1.10  2005/03/14 22:04:12  pmarch
//    Added to namespace OSCAR and removed "RR" from front of class names.
//
//    Revision 1.9  2004/07/29 20:16:45  chetan
//    Minor changes to compile under g++ with -Wall and -pedantic warning flags enabled
//
//    Revision 1.8  2004/07/26 22:25:16  chetan
//    Made changes to compile with Warning Level 4 and also under the latest C++ standard. Also made compilable with VC extensions turned off
//
//    Revision 1.7  2004/06/04 21:58:35  chetan
//    using namespace std in CommIncludes.h was removed. std:: was added anywhere STL components such as iostream and vector were being used
//
//    Revision 1.6  2004/05/26 20:02:03  pmarch
//    Added /defgroup and /ingroup tags.
//
//    Revision 1.5  2003/09/09 17:13:15  eswint
//    - Changed #include "Math/..." to #include "..."
//
//    Revision 1.4  2003/09/04 22:46:31  eswint
//    - Added non-const GetArray method for speedy data read/write access
//
//    Revision 1.3  2003/08/25 16:54:47  eswint
//    - Made construction from Type[] explicit
//
//    Revision 1.2  2003/08/18 15:49:02  eswint
//    Changed the .at method for array to maintain const-ness: one version for non-const array object, another for const object.  Compiler determines which method to use.
//
//    Revision 1.1  2003/08/18 15:23:44  eswint
//    Initial Commit
//
//
//    Notes
//      Source Code adapted from 'C++ Primer by Lippman, Second Edition'
//
#ifndef Array_hpp
#define Array_hpp

#include "Base/Base.h"

namespace OSCAR {

  template <class Type>
  class Array
  {
    public:

    explicit Array(unsigned int sz, const Type* array = 0);

    Array(const Array<Type>& rhs);

    virtual ~Array(void);

    Array<Type>& operator=(const Array<Type>& rhs);


    bool Copy(const Array<Type>& arrayToCopy);


    unsigned int GetSize() const;

    bool Grow(unsigned int growth);


    bool Output(std::ostream& out) const;

    bool Input(std::istream& in);

    Type& at(unsigned int index);

    const Type& at(unsigned int index) const;

    Type& operator[](unsigned int index);

    const Type& operator[](unsigned int index) const;

    const Type* GetArray() const;

    Type* GetArray();

    protected:

    unsigned int size;  //size of the array

    Type *element;  //pointer to a Type object

    void init(unsigned int size, const Type* array = 0);

    Array();

  };  //End of Array definition

  template <class Type>
  extern std::ostream& operator<<(std::ostream& os, const Array<Type>& a);

  template <class Type>
  extern std::istream& operator>>(std::istream& is, Array<Type>& a);

  std::istream& operator>>(std::istream& is, bool& b);

  #include "Array.ipp"
}

#endif  // #ifndef Array_hpp

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations