IterationPack_IterQuantityAccessContiguousDecl.hpp

Go to the documentation of this file.

// @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.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// 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