Simple.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010, 2011 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_Simple_h_INCLUDED
#define AFW_TABLE_Simple_h_INCLUDED

#include "lsst/afw/table/BaseRecord.h"
#include "lsst/afw/table/BaseTable.h"
#include "lsst/afw/table/IdFactory.h"
#include "lsst/afw/table/Catalog.h"
#include "lsst/afw/table/BaseColumnView.h"
#include "lsst/afw/table/SortedCatalog.h"
#include "lsst/afw/table/aggregates.h"

namespace lsst {
namespace afw {
namespace table {

class SimpleRecord;
class SimpleTable;

class SimpleRecord : public BaseRecord {
public:
    typedef SimpleTable Table;
    typedef ColumnViewT<SimpleRecord> ColumnView;
    typedef SortedCatalogT<SimpleRecord> Catalog;
    typedef SortedCatalogT<SimpleRecord const> ConstCatalog;

    SimpleRecord(ConstructionToken const & token, detail::RecordData && data) :
        BaseRecord(token, std::move(data))
    {}

    std::shared_ptr<SimpleTable const> getTable() const {
        return std::static_pointer_cast<SimpleTable const>(BaseRecord::getTable());
    }

    RecordId getId() const;
    void setId(RecordId id);

    lsst::geom::SpherePoint getCoord() const;
    void setCoord(lsst::geom::SpherePoint const& coord);

    lsst::geom::Angle getRa() const;
    void setRa(lsst::geom::Angle ra);

    lsst::geom::Angle getDec() const;
    void setDec(lsst::geom::Angle dec);

    SimpleRecord(const SimpleRecord&) = delete;
    SimpleRecord& operator=(const SimpleRecord&) = delete;
    SimpleRecord(SimpleRecord&&) = delete;
    SimpleRecord& operator=(SimpleRecord&&) = delete;
    ~SimpleRecord() override;

private:
    friend class SimpleTable;
};

class SimpleTable : public BaseTable {
public:
    typedef SimpleRecord Record;
    typedef ColumnViewT<SimpleRecord> ColumnView;
    typedef SortedCatalogT<Record> Catalog;
    typedef SortedCatalogT<Record const> ConstCatalog;

    static std::shared_ptr<SimpleTable> make(Schema const& schema,
                                             std::shared_ptr<IdFactory> const& idFactory);

    static std::shared_ptr<SimpleTable> make(Schema const& schema) {
        return make(schema, IdFactory::makeSimple());
    }

    static Schema makeMinimalSchema() {
        Schema r = getMinimalSchema().schema;
        r.disconnectAliases();
        return r;
    }

    static bool checkSchema(Schema const& other) { return other.contains(getMinimalSchema().schema); }

    std::shared_ptr<IdFactory> getIdFactory() { return _idFactory; }

    std::shared_ptr<IdFactory const> getIdFactory() const { return _idFactory; }

    void setIdFactory(std::shared_ptr<IdFactory> f) { _idFactory = f; }


    static Key<RecordId> getIdKey() { return getMinimalSchema().id; }
    static CoordKey getCoordKey() { return getMinimalSchema().coord; }

    std::shared_ptr<SimpleTable> clone() const { return std::static_pointer_cast<SimpleTable>(_clone()); }

    std::shared_ptr<SimpleRecord> makeRecord() {
        return std::static_pointer_cast<SimpleRecord>(_makeRecord());
    }

    std::shared_ptr<SimpleRecord> copyRecord(BaseRecord const& other) {
        return std::static_pointer_cast<SimpleRecord>(BaseTable::copyRecord(other));
    }

    std::shared_ptr<SimpleRecord> copyRecord(BaseRecord const& other, SchemaMapper const& mapper) {
        return std::static_pointer_cast<SimpleRecord>(BaseTable::copyRecord(other, mapper));
    }

    SimpleTable& operator=(SimpleTable const&) = delete;
    SimpleTable& operator=(SimpleTable&&) = delete;
    ~SimpleTable() override;

protected:
    SimpleTable(Schema const& schema, std::shared_ptr<IdFactory> const& idFactory);

    explicit SimpleTable(SimpleTable const& other);
    explicit SimpleTable(SimpleTable&& other);

    std::shared_ptr<BaseTable> _clone() const override;

    std::shared_ptr<BaseRecord> _makeRecord() override;

private:
    // Struct that holds the minimal schema and the special keys we've added to it.
    struct MinimalSchema {
        Schema schema;
        Key<RecordId> id;
        CoordKey coord;

        MinimalSchema();
    };

    // Return the singleton minimal schema.
    static MinimalSchema& getMinimalSchema();

    friend class io::FitsWriter;

    // Return a writer object that knows how to save in FITS format.  See also FitsWriter.
    std::shared_ptr<io::FitsWriter> makeFitsWriter(fits::Fits* fitsfile, int flags) const override;

    std::shared_ptr<IdFactory> _idFactory;  // generates IDs for new records
};

inline RecordId SimpleRecord::getId() const { return get(SimpleTable::getIdKey()); }
inline void SimpleRecord::setId(RecordId id) { set(SimpleTable::getIdKey(), id); }

inline lsst::geom::SpherePoint SimpleRecord::getCoord() const { return get(SimpleTable::getCoordKey()); }
inline void SimpleRecord::setCoord(lsst::geom::SpherePoint const& coord) {
    set(SimpleTable::getCoordKey(), coord);
}

inline lsst::geom::Angle SimpleRecord::getRa() const { return get(SimpleTable::getCoordKey().getRa()); }
inline void SimpleRecord::setRa(lsst::geom::Angle ra) { set(SimpleTable::getCoordKey().getRa(), ra); }

inline lsst::geom::Angle SimpleRecord::getDec() const { return get(SimpleTable::getCoordKey().getDec()); }
inline void SimpleRecord::setDec(lsst::geom::Angle dec) { set(SimpleTable::getCoordKey().getDec(), dec); }
}  // namespace table
}  // namespace afw
}  // namespace lsst

#endif  // !AFW_TABLE_Simple_h_INCLUDED