RelativeLocation.h

/*
 *   Repast for High Performance Computing (Repast HPC)
 *
 *   Copyright (c) 2010 Argonne National Laboratory
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with
 *   or without modification, are permitted provided that the following
 *   conditions are met:
 *
 *       Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *
 *       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.
 *
 *       Neither the name of the Argonne National Laboratory nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   ``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 THE TRUSTEES OR
 *   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.
 *
 *
 *  RelativeLocation.h
 *
 *  Created on: July 28, 2015
 *      Author: jtm
 */
 
#ifndef RELATIVELOCATION_H_
#define RELATIVELOCATION_H_
 
#include <vector>
 
using namespace std;
 
namespace repast {
 
class RelativeLocation{
 
public:
  static int getDirectionIndex(vector<int> dirVec);
 
  static int getReverseDirectionIndex(vector<int> dirVec);
 
private:
  vector<int> currentValue;
  vector<int> minima;
  vector<int> maxima;
  int         countOfDimensions;
  vector<int> places;
  int         maxIndex;           // Memoize
  int         indexOfCenter;      // Memoize
 
  void setPlaces();
 
public:
 
  RelativeLocation(int dimensions);
 
  RelativeLocation(vector<int> minima, vector<int> maxima);
 
  RelativeLocation(const RelativeLocation& original);
 
  void translate(vector<int> displacement);
 
  virtual ~RelativeLocation();
 
  /*
   * Increments this RelativeLocation instance.
   * Returns false if the instance is already at its
   * maximum (but will also roll over to minimum values!)
   */
  bool increment();
 
  bool increment(bool skipZero);
 
 
  bool set(vector<int> newValues);
 
  bool equals(RelativeLocation other);
 
  vector<int> getCurrentValue();
 
  int operator[](int index);
 
  int getCountOfDimensions();
 
  int getMaxIndex();
 
  int getTotalValues();
 
  int getIndex(vector<int> value);
 
  int getIndex();
 
  int getIndexOfCenter();
 
 
  bool validNonCenter();
 
  int getMinimumAt(int index);
 
  int getMaximumAt(int index);
 
  RelativeLocation trim(RelativeLocation toBeTrimmed);
 
  std::string report();
};
 
}
 
#endif /* DIFFUSIONLAYERND_H_ */