arrays.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2014 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef AFW_TABLE_arrays_h_INCLUDED
#define AFW_TABLE_arrays_h_INCLUDED
 
#include "lsst/cpputils/hashCombine.h"
 
#include "lsst/afw/table/FunctorKey.h"
#include "lsst/afw/table/Schema.h"
 
namespace lsst {
namespace afw {
namespace table {

template <typename T>
class ArrayKey : public FunctorKey<ndarray::Array<T const, 1, 1> >,
                 public ReferenceFunctorKey<ndarray::ArrayRef<T, 1, 1> >,
                 public ConstReferenceFunctorKey<ndarray::ArrayRef<T const, 1, 1> > {
public:
    static ArrayKey addFields(Schema& schema, std::string const& name, std::string const& doc,
                              std::string const& unit, std::vector<T> const& docData);

    static ArrayKey addFields(Schema& schema, std::string const& name, std::string const& doc,
                              std::string const& unit, size_t size);

    ArrayKey() noexcept : _begin(), _size(0) {}

    explicit ArrayKey(std::vector<Key<T> > const& keys);

    explicit ArrayKey(Key<Array<T> > const& other) noexcept;

    explicit ArrayKey(SubSchema const& s);
 
    ArrayKey(ArrayKey const&) noexcept;
    ArrayKey(ArrayKey&&) noexcept;
    ArrayKey& operator=(ArrayKey const&) noexcept;
    ArrayKey& operator=(ArrayKey&&) noexcept;
    ~ArrayKey() noexcept override;

    std::size_t getSize() const noexcept { return _size; }

    ndarray::Array<T const, 1, 1> get(BaseRecord const& record) const override;

    void set(BaseRecord& record, ndarray::Array<T const, 1, 1> const& value) const override;

    ndarray::ArrayRef<T, 1, 1> getReference(BaseRecord& record) const override;

    ndarray::ArrayRef<T const, 1, 1> getConstReference(BaseRecord const& record) const override;


    bool operator==(ArrayKey<T> const& other) const noexcept {
        return other._begin == _begin && other._size == _size;
    }
    bool operator!=(ArrayKey<T> const& other) const noexcept { return !operator==(other); }

    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return cpputils::hashCombine(17, _begin, _size);
    }

    bool isValid() const noexcept { return _begin.isValid(); }

    Key<T> operator[](std::size_t i) const;

    ArrayKey slice(std::size_t begin, std::size_t end) const;
 
private:
    ArrayKey(Key<T> const& begin, std::size_t size) noexcept : _begin(begin), _size(size) {}
 
    Key<T> _begin;
    std::size_t _size;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
namespace std {
template <typename T>
struct hash<lsst::afw::table::ArrayKey<T>> {
    using argument_type = lsst::afw::table::ArrayKey<T>;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std
 
#endif  // !AFW_TABLE_arrays_h_INCLUDED