HcalItemCollById.h

Go to the documentation of this file.

#ifndef CondFormats_HcalObjects_HcalItemCollById_h
#define CondFormats_HcalObjects_HcalItemCollById_h

#include <cstdint>

#include "FWCore/Utilities/interface/Exception.h"

#include "CondFormats/HcalObjects/interface/HcalItemColl.h"
#include "CondFormats/HcalObjects/interface/HcalIndexLookup.h"
#include "DataFormats/HcalDetId/interface/HcalDetId.h"
#include "CondFormats/HcalObjects/interface/HcalDetIdTransform.h"
#include "CondFormats/HcalObjects/interface/AbsHcalAlgoData.h"

//
// This collection allows lookup of items by HcalDetId.
// If the given HcalDetId is not explicitly listed in the
// lookup table, default item is returned.
//
// Just like HcalItemColl, this collection works with pointers
// and references only, so it can be used with the inheritance
// scenarios. Note that the ownership of objects is shared with
// the collection provided in the constructor. The default item
// is owned by this collection. Its ownership will also become
// shared if a copy of this collection is made.
//
template<typename Item>
class HcalItemCollById : public AbsHcalAlgoData
{
public:
    typedef Item value_type;

    // Dummy default constructor. To be used only for deserialization.
    inline HcalItemCollById()
        : transformCode_(HcalDetIdTransform::N_TRANSFORMS) {}

    // Normal constructor
    HcalItemCollById(const HcalItemColl<Item>& coll,
                     const HcalIndexLookup& indexLookupTable,
                     const unsigned detIdTransformCode,
                     std::unique_ptr<Item> defaultItem)
        : coll_(coll),
          lookup_(indexLookupTable),
          default_(defaultItem.release()),
          transformCode_(detIdTransformCode)
    {
        // Check that the lookup table is valid for this application
        if (lookup_.hasDuplicateIds())
            throw cms::Exception("In HcalItemCollById constructor:"
                                 " invalid lookup table");

        // Check that the lookup table is consistent with the size
        // of the collection
        const unsigned maxIndex = lookup_.largestIndex();
        if (maxIndex != HcalIndexLookup::InvalidIndex &&
            maxIndex >= coll_.size())
            throw cms::Exception("In HcalItemCollById constructor:"
                    " collection and lookup table are inconsistent");

        HcalDetIdTransform::validateCode(transformCode_);
    }

    inline ~HcalItemCollById() override {}

    // Modifier for the default item
    inline void setDefault(std::unique_ptr<Item> f)
        {default_ = boost::shared_ptr<Item>(f.release());}

    // Size of the internal collection, not counting the default
    inline std::size_t size() const {return coll_.size();}

    // The following method will return nullptr if there is no default
    inline const Item* getDefault() const {return default_.get();}

    // Look up the index into the collection by detector id
    inline unsigned getIndex(const HcalDetId& id) const
        {return lookup_.find(HcalDetIdTransform::transform(id, transformCode_));}

    // Get an item by its index in the collection. If the index
    // is out of range, the default item is returned. If the
    // index is out of range and there is no default, nullptr
    // is returned.
    inline const Item* getByIndex(const unsigned index) const
    {
        if (index < coll_.size()) return coll_.get(index);
        else return default_.get();
    }

    // Convenience function for getting what we need by id.
    // This method can return nullptr.
    inline const Item* get(const HcalDetId& id) const
        {return getByIndex(getIndex(id));}

    // The following method will throw an exception if the id is not
    // in the lookup table and, in addition, there is no default
    inline const Item& at(const HcalDetId& id) const
    {
        const Item* ptr = getByIndex(getIndex(id));
        if (ptr == nullptr) throw cms::Exception(
            "In HcalItemCollById::at: invalid detector id");
        return *ptr;
    }

protected:
    bool isEqual(const AbsHcalAlgoData& other) const override
    {
        const HcalItemCollById& r =
            static_cast<const HcalItemCollById&>(other);
        if (coll_ != r.coll_)
            return false;
        if (lookup_ != r.lookup_)
            return false;
        if (transformCode_ != r.transformCode_)
            return false;
        // The default may or may not be there
        const bool ld = default_.get();
        const bool rd = r.default_.get();
        if (ld != rd)
            return false;
        if (ld)
            if (!(*default_ == *r.default_))
                return false;
        return true;
    }

private:
    HcalItemColl<Item> coll_;
    HcalIndexLookup lookup_;
    boost::shared_ptr<Item> default_;
    uint32_t transformCode_;

    friend class boost::serialization::access;

    template<class Archive>
    inline void serialize(Archive & ar, unsigned /* version */)
    {
        ar & coll_ & lookup_ & default_ & transformCode_;
    }
};

// boost serialization version number for this template
namespace boost {
    namespace serialization {
        template<typename Item>
        struct version<HcalItemCollById<Item> >
        {
            BOOST_STATIC_CONSTANT(int, value = 1);
        };
    }
}

#endif // CondFormats_HcalObjects_HcalItemCollById_h