IterationPack_IterQuantityAccessContiguousDecl.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) 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 Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER
//
// Change Log:
//  11/18/99:
//    * last_updated() Added
//    * set_not_updated(k) Added
//    * resize(n) Added
//    * Lazy initialization implemented.
//  12/20/01:
//      * AbstractFactory added to handle memory management

#ifndef ITER_QUANITY_ACCESS_CONTIGUOUS_DECL_H
#define ITER_QUANITY_ACCESS_CONTIGUOUS_DECL_H

#include <vector>
#include <limits>

#include "IterationPack_IterQuantityAccess.hpp"
#include "Teuchos_AbstractFactoryStd.hpp"

namespace IterationPack {

// ToDo: Use an implementation subclass for the operations to avoid code blot.

template<class T_info>
class IterQuantityAccessContiguous : public IterQuantityAccess<T_info> {
public:

  typedef IterQuantityAccess<T_info> base_t;

  typedef Teuchos::RCP<
    const Teuchos::AbstractFactory<T_info> >          abstract_factory_ptr_t;
  typedef Teuchos::AbstractFactoryStd<T_info,T_info>    abstract_factory_std_t;


  IterQuantityAccessContiguous(
    int                              num_quantities
    ,const std::string&              name
#ifdef _MIPS_CXX // MipsPro 7.3.1.1 tries to instantiate the default type even when one is specified?
    ,const abstract_factory_ptr_t&   abstract_factory
#else
    ,const abstract_factory_ptr_t&   abstract_factory  = Teuchos::rcp(new abstract_factory_std_t())
#endif
    );

  void set_factory( const abstract_factory_ptr_t& abstract_factory );

  void resize( int num_quantities );

  ~IterQuantityAccessContiguous();



  int num_quantities() const;



  IterQuantity* clone() const;
  const char* name() const; 
  bool has_storage_k(int offset) const;
  bool updated_k(int offset) const;
  int last_updated() const;
  void set_not_updated_k(int offset);
  void set_all_not_updated();
  bool will_loose_mem(int offset, int set_offset) const;
  void next_iteration();
  void print_concrete_type( std::ostream& out ) const;



  T_info& get_k(int offset);
  const T_info& get_k(int offset) const;
  T_info& set_k(int offset);
  T_info& set_k(int set_offset, int get_offset);


private:

  // ///////////////////////////////////////////////
  // Private types

  //
  typedef std::vector<bool>                                                       updated_t;
  //
  typedef std::vector<typename abstract_factory_ptr_t::element_type::obj_ptr_t>   store_t;
  //
  typedef std::vector<T_info*>                                                    quantities_t;

  // ///////////////////////////////////////////////
  // Private data members

  // number of contigous iterations memory is reserved for.
  int num_quantities_;
  // The name of the quantity (useful for debugging)
  std::string name_;
  // The abstract factory used to create the objects themselves
  abstract_factory_ptr_t   abstract_factory_;
  // The highest offset for iteration we are providing storage for.  We are providing
  // storage for iterations:
  //   [ k + max_offset_, k + max_offset_ - 1, ..., k + max_offset_ - num_quanities_ + 1 ].
  // For max_offset_ == 1 and num_quantities_  == 3:  [ k+1, k, k-1 ].
  int max_offset_;  
  // Flags for if the iteration quanity was updated.
  //    updated_[max_offset - offset]
  //        for offset = max_offset, max_offset - 1, ..., max_offset_ - num_quanities_ + 1
  // returns true if and only if the quantity (k + offset) has been updated.
  updated_t     updated_;
  // Storage vector for the iteration quantities
  store_t       store_;
  // The vector of pointers to the storage quantities
  quantities_t  quantities_;

  // ///////////////////////////////////////////////
  // Private member functions

  // Returns true if storage is initialized and false otherwise.
  bool is_initialized() const;

  // Called to make sure that we are initialized before a
  // nonconst operation is performed.
  void lazy_initialization();

  // Called to release current memory
  void release_mem();

  // Not defined and not to be called
  IterQuantityAccessContiguous();
  IterQuantityAccessContiguous(const IterQuantityAccessContiguous&);
  IterQuantityAccessContiguous& operator=(const IterQuantityAccessContiguous&);

};  // end class IterQuantityAccessContiguous

// /////////////////////////////////////////////////////////////
// Inline members

template <class T_info>
inline
int IterQuantityAccessContiguous<T_info>::num_quantities() const
{ 
  return num_quantities_; 
}

} // end namespace IterationPack

#endif  // ITER_QUANITY_ACCESS_CONTIGUOUS_DECL_H