Odometer.h

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2015 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#ifndef ODOMETER_H_
#define ODOMETER_H_
 
#include <vector>
 
namespace functions {
 
class Odometer
{
public:
    typedef std::vector<unsigned int> shape;
 
private:
    // The state set by the ctor
    shape d_shape;
    size_t d_highest_offset;
    size_t d_rank;
 
    // The varying state of the Odometer
    shape d_indices;
    size_t d_offset{0};
 
public:
    explicit Odometer(shape shape) : d_shape(std::move(shape))
    {
        d_rank = d_shape.size();
 
        // compute the highest offset value based on the array shape
        d_highest_offset = 1;
        for (unsigned int i = 0; i < d_rank; ++i) {
            d_highest_offset *= d_shape.at(i);
        }
 
        d_indices.resize(d_rank, 0);
    }
 
    void reset()
    {
        for (unsigned int i = 0; i < d_rank; ++i)
            d_indices.at(i) = 0;
        d_offset = 0;
    }
 
    inline unsigned int next()
    {
        // About 2.4 seconds for 10^9 elements
        auto si = d_shape.rbegin();
        for (auto i = d_indices.rbegin(), e = d_indices.rend(); i != e; ++i, ++si) {
            if (++(*i) == *si) {
                *i = 0;
            }
            else {
                break;
            }
        }
 
        return ++d_offset;
    }
 
    // This version throws Error if offset() == end()
    unsigned int next_safe();
 
    inline unsigned int set_indices(const shape &indices)
    {
        d_indices = indices;
 
        // I copied this algorithm from Nathan's code in NDimenensionalArray in the
        // ugrid function module. jhrg 5/22/15
 
        auto shape_index = d_shape.rbegin();
        auto index = d_indices.rbegin(), index_end = d_indices.rend();
        d_offset = *index++;
        unsigned int chunk_size = *shape_index++;
        while (index != index_end) {
            d_offset += chunk_size * *index++;
            chunk_size *= *shape_index++;
        }
 
        return d_offset;
    }
 
    unsigned int set_indices(const std::vector<int> &indices)
    {
        shape temp;
        std::copy(indices.begin(), indices.end(), std::back_inserter(temp));
 
        return set_indices(temp);
    }
 
    inline void indices(shape &indices)
    {
        indices = d_indices;
    }
 
    inline unsigned int offset()
    {
        return d_offset;
    }
 
    inline unsigned int end()
    {
        return d_highest_offset;
    }
 
};
 
}       // namespace libdap
 
#endif /* ODOMETER_H_ */