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:
    using Table = SimpleTable;
    using ColumnView = ColumnViewT<SimpleRecord>;
    using Catalog = SortedCatalogT<SimpleRecord>;
    using ConstCatalog = SortedCatalogT<const SimpleRecord>;
 
    SimpleRecord(ConstructionToken const & token, detail::RecordData && data) :
        BaseRecord(token, std::move(data))
    {}
    SimpleRecord(ConstructionToken const & token, detail::RecordData && data) : {…}
 
    std::shared_ptr<SimpleTable const> getTable() const {
        return std::static_pointer_cast<SimpleTable const>(BaseRecord::getTable());
    }
    std::shared_ptr<SimpleTable const> getTable() const  {…}
 
 
    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 SimpleRecord : public BaseRecord {…};
 
class SimpleTable : public BaseTable {
public:
    using Record = SimpleRecord;
    using ColumnView = ColumnViewT<SimpleRecord>;
    using Catalog = SortedCatalogT<Record>;
    using ConstCatalog = SortedCatalogT<const Record>;
 
    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 std::shared_ptr<SimpleTable> make(Schema const& schema) {…}
 
    static Schema makeMinimalSchema() {
        Schema r = getMinimalSchema().schema;
        r.disconnectAliases();
        return r;
    }
    static Schema makeMinimalSchema() {…}
 
    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> 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) {…}
 
    std::shared_ptr<SimpleRecord> copyRecord(BaseRecord const& other, SchemaMapper const& mapper) {
        return std::static_pointer_cast<SimpleRecord>(BaseTable::copyRecord(other, mapper));
    }
    std::shared_ptr<SimpleRecord> copyRecord(BaseRecord const& other, SchemaMapper const& 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);
 
    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
};
class SimpleTable : public BaseTable {…};
 
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 void SimpleRecord::setCoord(lsst::geom::SpherePoint const& 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