Domi_Slice.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//     Domi: Multi-dimensional Distributed Linear Algebra Services
//                 Copyright (2014) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia
// Corporation, the U.S. Government retains certain rights in this
// software.
//
// 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 William F. Spotz (wfspotz@sandia.gov)
//
// ***********************************************************************
// @HEADER

#ifndef DOMI_SLICE_HPP
#define DOMI_SLICE_HPP

// Teuchos includes
#include "Teuchos_Assert.hpp"

// Domi includes
#include "Domi_ConfigDefs.hpp"
#include "Domi_Exceptions.hpp"
#include "Domi_Utils.hpp"

namespace Domi
{

struct Slice
{
public:

  typedef Domi::dim_type dim_type;

  static const dim_type Default;


  inline Slice();

  inline Slice(dim_type stopVal);

  inline Slice(dim_type startVal, dim_type stopVal, dim_type stepVal=1);

  inline Slice(const Slice & source);

  virtual ~Slice() { }



  inline const dim_type start() const;

  inline const dim_type stop() const;

  inline const dim_type step() const;



  inline Slice & operator=(const Slice & source);

  inline bool operator==(const Slice & slice) const;

  inline bool operator!=(const Slice & slice) const;


  virtual Slice bounds(dim_type size) const;

  std::string toString() const;

  friend std::ostream & operator<<(std::ostream & os,
                                   const Slice & slice);

private:

  // Start index
  dim_type _start;

  // Stop index
  dim_type _stop;

  // Step interval
  dim_type _step;

  // Boolean flag indicating whether the step is positive and the stop
  // index is concrete (i.e. it is not Default and not negative)
  bool _bounded_pos;

  // Boolean flag indicating whether the step is negative and the
  // start index is concrete (i.e. it is not Default and not negative)
  bool _bounded_neg;

};

struct ConcreteSlice : public Slice
{
public:
  ConcreteSlice(dim_type stopVal);

  ConcreteSlice(dim_type startVal, dim_type stopVal, dim_type stepVal=1);

  virtual ~ConcreteSlice() { }

  inline Slice bounds(dim_type size) const { return *this; }

private:

  // Private and not implemented
  ConcreteSlice();
};

// Inline implementations

Slice::Slice() :
  _start(0),
  _stop(Slice::Default),
  _step(1),
  _bounded_pos(false),
  _bounded_neg(false)
{
}


Slice::Slice(dim_type stopVal) :
  _start(0),
  _stop(stopVal),
  _step(1),
  _bounded_pos((_stop >= 0 && _stop != Slice::Default)),
  _bounded_neg(false)
{
}


Slice::Slice(dim_type startVal, dim_type stopVal, dim_type stepVal) :
  _start(((startVal==Slice::Default) && (stepVal > 0)) ? 0 : startVal),
  _stop( ((stopVal ==Slice::Default) && (stepVal < 0)) ? 0 : stopVal ),
  _step(  (stepVal ==Slice::Default) ? 1 : stepVal),
  _bounded_pos(((_step > 0) && (_stop  >= 0 && _stop  != Slice::Default))),
  _bounded_neg(((_step < 0) && (_start >= 0 && _start != Slice::Default)))
{
  TEUCHOS_TEST_FOR_EXCEPTION(
    (_step == 0),
    InvalidArgument, "Slice step interval cannot be zero"
    );
}


Slice::Slice(const Slice & source) :
  _start(source._start),
  _stop(source._stop),
  _step(source._step),
  _bounded_pos(source._bounded_pos),
  _bounded_neg(source._bounded_neg)
{
}


const dim_type Slice::start() const
{
  return _start;
}


const dim_type Slice::stop() const
{
  return _stop;
}


const dim_type Slice::step() const
{
  return _step;
}


Slice & Slice::operator=(const Slice & slice)
{
  _start       = slice._start      ;
  _stop        = slice._stop       ;
  _step        = slice._step       ;
  _bounded_pos = slice._bounded_pos;
  _bounded_neg = slice._bounded_neg;
  return *this;
}


bool Slice::operator==(const Slice & slice) const
{
  return ((_start == slice._start) &&
          (_stop  == slice._stop ) &&
          (_step  == slice._step )    );
}


bool Slice::operator!=(const Slice & slice) const
{
  return (not operator==(slice));
}

}  // namespace Domi

#endif