invoice.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Andreas Huggel (ahu)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.83 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _INVOICE_H_
#define _INVOICE_H_

// *********************************************************************
// included header files
// + standard includes
#include<vector>

// + local headers
#include "chargetraits.h"
#include "amount.h"
#include "section.h"
#include "contract.h"
#include "product.h"
#include "balancesheet.h"
#include "billingxml.h"
#include "osbunit.h"

// *********************************************************************
// namespace extensions
namespace OSB_LIB {

    // forward declarations
    class Invoice;
    class UsageItemBase;
    class UsageDetailBase;
    class SubsItem;
    class TotalItem;
    class AssociateInfo;
    class SummaryChargesInfo;
    class InvoiceInfoItem;
    class OnetimeChargeItem;
    class BillingXmlBase;
    class BillingXml;

// *********************************************************************
// class definitions
    enum ContributesTo
    {
        ct_nothing    =   0,
        ct_invAmounts =   1,
        ct_invTotal   =   2,
        ct_usgTotal   =   4,
        ct_otcTotal   =   8,
        ct_subsTotal  =  16
    };

    enum TotalContributesTo
    {
        ct_subTotalOnly = 0,
        ct_volumeTotal  = 1
    };

    class InvoiceItem {
        InvoiceItem(const InvoiceItem& rhs);
        InvoiceItem& operator=(const InvoiceItem& rhs);
    public:
        InvoiceItem(const Section& section)
            : section_(section), number_(0) {}
        virtual ~InvoiceItem() {}
        virtual void writeXml(BillingXmlBase& bXml) const=0;
        void setNumber(int n) { number_ = n; }
        const Section& section() { return section_; }

    protected:
        Section section_;

    private:
        int number_;
    };
    class ItemMap {
        ItemMap(const ItemMap&);
        ItemMap& operator=(const ItemMap&);
    public:
        ItemMap() {}
        ~ItemMap();

        struct Node {
            Node() {}
            virtual ~Node() {}
            struct Iterator {
                Iterator() {}
                virtual ~Iterator() {}
                virtual void increment() =0;
                virtual Iterator* clone() const =0;
                virtual InvoiceItem* operator*() const =0;
                bool operator==(const Iterator& i) const
                {
                    return this->operator*() == *i;
                }
            };
            virtual Iterator* newIterator() const =0;
            virtual void mrproper() =0;
            virtual void pbegin(Iterator*) =0;
            virtual void pend(Iterator*) =0;
        };
        // -------------------------------------------------------------
        struct Node1 : public Node {
            Node1(InvoiceItem* ii) : Node(), invoiceItem_(ii) {}
            ~Node1() {}

            struct Iterator : public Node::Iterator {
                Iterator() {}
                explicit Iterator(InvoiceItem* ii) : current_(ii) {}
                void increment() { ++current_; }
                Iterator* clone() const { return new Iterator(*this); };
                InvoiceItem* operator*() const { return current_; }
                InvoiceItem* current_;
            };
            Iterator* newIterator() const { return new Iterator(); }
            void mrproper() { delete invoiceItem_; invoiceItem_ = 0; }
            void pbegin(Node::Iterator* ip)
            {
                *static_cast<Node1::Iterator*>(ip)
                    = Iterator(invoiceItem_);
            }
            void pend(Node::Iterator* ip)
            {
                *static_cast<Node1::Iterator*>(ip)
                    = Iterator(invoiceItem_+1);
            }
            InvoiceItem* invoiceItem_;
        };
        // -------------------------------------------------------------
        template <typename T>
          struct NodeM : public Node {
            NodeM() {}
            NodeM(const T& t, InvoiceItem* ii) { items_[t] = ii; }
            ~NodeM() {}
            // ---------------------------------------------------------
            typedef std::multimap<T, InvoiceItem*> Items;
            // ---------------------------------------------------------
            struct Iterator : public Node::Iterator {
                Iterator() {}
                explicit Iterator(const typename Items::iterator& ii)
                    : current_(ii) {}
                void increment() { ++current_; }
                Iterator* clone() const { return new Iterator(*this); }
                InvoiceItem* operator*() const
                {
                    return current_->second;
                }
                typename Items::iterator current_;
            };
            Iterator* newIterator() const { return new Iterator(); }
            void mrproper()
            {
                for (typename Items::iterator i = items_.begin();
                     i != items_.end(); ++i) {
                    delete i->second;
                    i->second = 0;
                }
            }
            void pbegin(Node::Iterator* ip)
            {
                *static_cast<typename NodeM<T>::Iterator*>(ip)
                      = Iterator(items_.begin());
            }
            void pend(Node::Iterator* ip)
            {
                *static_cast<typename NodeM<T>::Iterator*>(ip)
                      = Iterator(items_.end());
            }

            Items items_;
        };
        // -------------------------------------------------------------
        typedef std::map<Section, Node*> NodeList;
        // -------------------------------------------------------------

        struct Iterator {
            Iterator() : sub_(0), end_(0) {}
            explicit Iterator(const NodeList::iterator& nli)
                : current_(nli), sub_(0), end_(0) {}
            ~Iterator() { if(sub_) delete sub_; if(end_) delete end_; }
            Iterator(const Iterator& rhs);
            Iterator& operator=(const Iterator& rhs);
            bool operator==(const Iterator& rhs) const;
            bool operator!=(const Iterator& rhs) const;
            Iterator operator++();
            Iterator operator++(int);
            InvoiceItem* operator*() const;

            NodeList::iterator current_;
            mutable Node::Iterator* sub_;
            Node::Iterator* end_;
        };

        Iterator begin() { return Iterator(nodeList_.begin()); }
        Iterator end() { return Iterator(nodeList_.end()); }

        int insert(const Section& s, InvoiceItem* ii);
        template<typename T>
          int insert(const Section& s, const T& t, InvoiceItem* ii);
        Iterator find(const Section& s)
        {
            return Iterator(nodeList_.find(s));
        }

    private:
        NodeList nodeList_;
    };

    // *****************************************************************
    class Invoice {
        Invoice(const Invoice&);
        Invoice& operator=(const Invoice&);
    public:
        Invoice() : count_(0) {}
        ~Invoice() {}

        void addAmount(BaseAmount& a, ContributesTo flags);

        void setNumber(InvoiceItem& ii) { ii.setNumber(++count_); }


        const Subtotal& invoiceTotal() const { return invoiceTotal_; }
        const Subtotal& usageTotal() const { return usageTotal_; }
        const Subtotal& subsTotal() const { return subsTotal_; }
        const Subtotal& onetimeChargesTotal() const
            { return onetimeChargesTotal_; }
        // -------------------------------------------------------------

        template <typename U>
         U* newUsageItem(
            const Section& section,
            ContributesTo flag
         );

        // This function is provided to avoid errors in Forte Compiler.
        template <typename U>
         U* newUsageItem(
            const Section& section
         );

        template <typename U, typename T>
          U* newUsageItem(
            const Section& section,
            const T& t,
            ContributesTo flag
          );

        // This function is provided to avoid errors in Forte Compiler.
        template <typename U, typename T>
          U* newUsageItem(
            const Section& section,
            const T& t
          );
        // -------------------------------------------------------------
        SubsItem *newSubsItem(
            const Section&,
            const SubsCharge*,
                  ContributesTo =
                    ContributesTo(ct_invAmounts|ct_invTotal|
                                  ct_subsTotal)
        );

        template <typename T>
          SubsItem *newSubsItem(
            const Section&,
            const T&,
            const SubsCharge*,
                  ContributesTo
          );

        // This function is provided to avoid errors in Forte Compiler.
        template <typename T>
          SubsItem *newSubsItem(
            const Section&,
            const T&,
            const SubsCharge*
          );
        // -------------------------------------------------------------
        OnetimeChargeItem *newOnetimeChargeItem(
            const Section&,
            const OnetimeCharge*,
                  ContributesTo =
                        ContributesTo(ct_invAmounts|ct_invTotal|
                                      ct_otcTotal)
        );

        template <typename T>
          OnetimeChargeItem *newOnetimeChargeItem(
            const Section&,
            const T&,
            const OnetimeCharge*,
                  ContributesTo
          );

        // This function is provided to avoid errors in Forte Compiler.
        template <typename T>
          OnetimeChargeItem *newOnetimeChargeItem(
            const Section&,
            const T&,
            const OnetimeCharge*
          );

        // -------------------------------------------------------------
        TotalItem* newTotalItem(
            const Section&   section,
                  Decimal&   volume,
            const Unit::Oid& uId,
                  ContributesTo flags = ContributesTo(ct_nothing)
        );

        template <typename T>
          TotalItem* newTotalItem(
            const Section& section,
            const T&            t,
                  Decimal&      volume,
            const Unit::Oid&    uId,
                  ContributesTo flags
        );

        template <typename T>
          TotalItem* newTotalItem(
            const Section&   section,
            const T&         t,
                  Decimal&   volume,
            const Unit::Oid& uId
        );

        // -------------------------------------------------------------
        AssociateInfo* newAssociateInfo(
            const Section& section,
            const Associate* associate
        );

        template <typename T>
          AssociateInfo* newAssociateInfo(
            const Section& section,
            const T& t,
            const Associate* associate
        );

        SummaryChargesInfo* newSummaryChargesInfo(
            const Section& section,
            const SummaryCharges* sumCharges
        );

        template <typename T>
        SummaryChargesInfo* newSummaryChargesInfo(
            const Section& section,
            const T& t,
            const SummaryCharges* sumCharges
        );

        InvoiceInfoItem* newInvoiceInfoItem(
            const Section& section,
            const InvoiceInfo* invInfo
        );

        template <typename T>
        InvoiceInfoItem* newInvoiceInfoItem(
            const Section& section,
            const T& t,
            const InvoiceInfo* invInfo
        );

        // -------------------------------------------------------------
        typedef ItemMap::Iterator ItemListI;
        ItemListI  itemListBegin()       { return items_.begin(); }
        ItemListI  itemListEnd()         { return items_.end(); }
        ItemMap::Iterator findItem(const Section& s)
        {
            return items_.find(s);
        }


        typedef std::vector<SubsItem*> SubsItemList;
        typedef SubsItemList::const_iterator SubsItemListCI;
        typedef SubsItemList::iterator SubsItemListI;
        SubsItemListCI SubsItemListBegin() const
            { return subsItems_.begin(); }
        SubsItemListI SubsItemListBegin()
            { return subsItems_.begin(); }
        SubsItemListCI SubsItemListEnd() const
            { return subsItems_.end(); }
        SubsItemListI SubsItemListEnd()
            { return subsItems_.end(); }


        typedef std::vector<OnetimeChargeItem*> OnetimeChargeItemList;
        typedef OnetimeChargeItemList::const_iterator
                                       OnetimeChargeItemListCI;
        typedef OnetimeChargeItemList::iterator OnetimeChargeItemListI;
        OnetimeChargeItemListCI onetimeChargeItemListBegin() const
            { return onetimeChargeItems_.begin(); }
        OnetimeChargeItemListI onetimeChargeItemListBegin()
            { return onetimeChargeItems_.begin(); }
        OnetimeChargeItemListCI onetimeChargeItemListEnd() const
            { return onetimeChargeItems_.end(); }
        OnetimeChargeItemListI onetimeChargeItemListEnd()
            { return onetimeChargeItems_.end(); }


        typedef std::vector<BaseAmount*> AmountList;
        typedef AmountList::const_iterator AmountListCI;
        typedef AmountList::iterator AmountListI;

        AmountListCI amountListBegin() const
            { return invoiceAmounts_.begin(); }
        AmountListI amountListBegin()
            { return invoiceAmounts_.begin(); }
        AmountListCI amountListEnd() const
            { return invoiceAmounts_.end(); }
        AmountListI amountListEnd()
            { return invoiceAmounts_.end(); }
    private:
        int count_;
        ItemMap items_;
        SubsItemList subsItems_;
        OnetimeChargeItemList onetimeChargeItems_;
        AmountList invoiceAmounts_;
        Subtotal invoiceTotal_;
        Subtotal usageTotal_;
        Subtotal subsTotal_;
        Subtotal totalTotal_;
        Subtotal onetimeChargesTotal_;
    };

    // *****************************************************************
    // UsageItem and UsageDetail Base Class

    class UsageItemBase : public InvoiceItem {
        UsageItemBase(const UsageItemBase& rhs);
        UsageItemBase& operator=(const UsageItemBase& rhs);
    public:
        typedef std::vector<UsageDetailBase*> UsageDetailList;
        typedef UsageDetailList::const_iterator UsageDetailListCI;
        typedef UsageDetailList::iterator UsageDetailListI;

        UsageItemBase(const Section& section) : InvoiceItem(section) {}

        UsageItemBase(
            const Section& section,
            const ChargeTraits& ct
        ) : InvoiceItem(section), amount(ct) {}

        virtual ~UsageItemBase() {}

        virtual void writeXml(BillingXmlBase& bXml) const = 0;

        // -------------------------------------------------------------
        // public data members
        Subtotal amount;
        UsageDetailList details;
    };

    class UsageDetailBase {
    public:
        UsageDetailBase() : amount() {}
        UsageDetailBase(const Amount& a) : amount(a) {}
        virtual ~UsageDetailBase() {}

        virtual void writeXml(BillingXmlBase& bXml) const = 0;
        Amount amount;
    };

    // *****************************************************************
    // UsageItem and UsageDetail to handle Usagerecord

    class UsagerecordItem : public UsageItemBase {
    public:
        UsagerecordItem(const Section& section)
              : UsageItemBase(section) {}

        UsagerecordItem(
            const Section& section,
            const ChargeTraits& ct
        ) : UsageItemBase(section, ct) {}

        ~UsagerecordItem();
        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeUsagerecordItem(*this);
        }

        UsagerecordDetail* newUsagerecordDetail(const Usagerecord* ur);

        UsagerecordDetail* newUsagerecordDetail(
            const Amount& a,
            const Usagerecord* ur
        );
    };

    // *****************************************************************
    // UsageItem and UsageDetail to handle SumCdr01

    class SumCdr01Item : public UsageItemBase {
    public:
        SumCdr01Item(const Section& section)
              : UsageItemBase(section) {}

        SumCdr01Item(
            const Section& section,
            const ChargeTraits& ct
        ) : UsageItemBase(section, ct) {}


        ~SumCdr01Item();
        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<SumCdr01BillingXml&>(bXml).
                writeSumCdr01Item(*this);
        }

        SumCdr01Detail* newSumCdr01Detail(
            const SumCdr01* cdr
        );

        SumCdr01Detail* newSumCdr01Detail(
            const Amount& a,
            const SumCdr01* cdr
        );
    };

    class SumCdr01Detail : public UsageDetailBase {
    public:
        SumCdr01Detail(
            const SumCdr01* cdr =0
        ) : UsageDetailBase(), cmCdr(cdr) {}

        SumCdr01Detail(const Amount& a, const SumCdr01* cdr)
            : UsageDetailBase(a), cmCdr(cdr) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<SumCdr01BillingXml&>(bXml).
                writeSumCdr01Detail(*this);
        }
        const SumCdr01* cmCdr;
    };


    // *****************************************************************
    class UsagerecordDetail : public UsageDetailBase {
    public:
        UsagerecordDetail(
            const Usagerecord* ur =0
        ) : UsageDetailBase(), usagerecord(ur) {}

        UsagerecordDetail(const Amount& a, const Usagerecord* ur)
            : UsageDetailBase(a), usagerecord(ur) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeUsagerecordDetail(*this);
        }
        const Usagerecord* usagerecord;
    };

    class SubsItem : public InvoiceItem {
    public:
        SubsItem(const Section& section, const SubsCharge* sc)
              : InvoiceItem(section), subsCharge(sc) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeSubsItem(*this);
        }

        // -------------------------------------------------------------
        // public data members
        Amount amount;
        const SubsCharge* subsCharge;
    };

    // *****************************************************************
    class OnetimeChargeItem : public InvoiceItem {
    public:
        OnetimeChargeItem(const Section& section,
                          const OnetimeCharge* onetimeCharge):
            InvoiceItem(section), onetimeCharge(onetimeCharge) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeOtcItem(*this);
        }

        // -------------------------------------------------------------
        // public data members
        Amount         amount;
        const OnetimeCharge* onetimeCharge;
    };

    class TotalItem : public InvoiceItem {
    public:
        TotalItem(
            const Section&   section,
            const Decimal&   vol,
            const Unit::Oid& uId
        ) : InvoiceItem(section), volume_(vol), unitId_(uId) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeTotalItem(*this);
        }

        // -------------------------------------------------------------
        // public data members
        Subtotal amount_;
        //TODO: It should be able to handle more than one unit
        Decimal     volume_;
        Unit::Oid   unitId_;
        std::string remark_;
    };

    // *****************************************************************
    class AssociateInfo : public InvoiceItem {
    public:
        AssociateInfo(const Section& section, const Associate* ass)
            : InvoiceItem(section), associate(ass) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeAssociate(*associate);
        }
        // -------------------------------------------------------------
        // public data members
        const Associate* associate;
    };

    class SummaryChargesInfo : public InvoiceItem {
    public:
        SummaryChargesInfo(
            const Section& section,
            const SummaryCharges* sc
        ) : InvoiceItem(section), summaryCharges(sc) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeSummaryCharges(
                *summaryCharges);
        }
        // -------------------------------------------------------------
        // public data members
        const SummaryCharges* summaryCharges;
    };

    class InvoiceInfoItem : public InvoiceItem {
    public:
        InvoiceInfoItem(
            const Section& section,
            const InvoiceInfo* invInfo
        ) : InvoiceItem(section), invoiceInfo(invInfo) {}

        virtual void writeXml(BillingXmlBase& bXml) const
        {
            dynamic_cast<BillingXml&>(bXml).writeInvoiceInfo(
                *invoiceInfo);
        }
        // -------------------------------------------------------------
        // public data members
        const InvoiceInfo* invoiceInfo;
    };

//**********************************************************************
// inline and template definitions

    template<typename T>
      int ItemMap::insert(const Section& s, const T& t, InvoiceItem* ii)
    {
        int rc = 0;
        NodeList::iterator nI = nodeList_.find(s);
        if (nI == nodeList_.end()) {
            Node* np = new NodeM<T>;
            nI = nodeList_.insert(std::make_pair(s, np)).first;
        }
        if (NodeM<T>* nmp = dynamic_cast<NodeM<T>*>(nI->second)) {
            nmp->items_.insert(std::make_pair(t, ii));
        }
        else {
            // Section does not have a NodeM<T>. Indicate failure
            rc = 1;
        }
        return rc;
    }

    template <typename U>
     U* Invoice::newUsageItem(
        const Section& section,
              ContributesTo flags
    )
    {
        U* ui = new U(section);
        int rc = items_.insert(section, ui);
        if (rc) {
            delete ui;
            throw DefException(26) << section.str();
        }
        setNumber(*ui);
        addAmount(ui->amount, flags);
        return ui;
    }

    template <typename U>
     U* Invoice::newUsageItem(
        const Section& section
    )
    {
        return newUsageItem<U>(section, ContributesTo(
                        ct_invAmounts|ct_invTotal|ct_usgTotal));
    }

    template <typename U, typename T>
     U* Invoice::newUsageItem(
        const Section& section,
        const T& t,
              ContributesTo flags
    )
    {
        U* ui = new U(section);
        int rc = items_.insert(section, t, ui);
        if (rc) {
            delete ui;
            throw DefException(29) << section.str();
        }
        setNumber(*ui);
        addAmount(ui->amount, flags);
        return ui;
    }

    template <typename U, typename T>
     U* Invoice::newUsageItem(
        const Section& section,
        const T& t
    )
    {
        return newUsageItem<U, T>(section, t, ContributesTo(
                        ct_invAmounts|ct_invTotal|ct_usgTotal));
    }

    template <typename T>
      SubsItem *Invoice::newSubsItem(
        const Section& section, const T& t, const SubsCharge* sc,
        ContributesTo flags)
    {
        SubsItem *si = new SubsItem(section, sc);
        int rc = items_.insert(section, t, si);
        if (rc) {
            delete si;
            throw DefException(29) << section.str();
        }
        subsItems_.push_back(si);
        setNumber(*si);
        addAmount(si->amount, flags);
        return si;
    }

    template <typename T>
      SubsItem *Invoice::newSubsItem(
        const Section& section,
        const T& t,
        const SubsCharge* sc
    )
    {
        return newSubsItem<T>(section, t, sc,
                ContributesTo(ct_invAmounts|ct_invTotal|ct_subsTotal));
    }

    template <typename T>
      OnetimeChargeItem* Invoice::newOnetimeChargeItem(
        const Section& section,
        const T& t,
        const OnetimeCharge* onetimeCharge,
              ContributesTo flags
    )
    {
        OnetimeChargeItem *otc
            = new OnetimeChargeItem(section, onetimeCharge);
        int rc = items_.insert(section, t, otc);
        if (rc) {
            delete otc;
            throw DefException(29) << section.str();
        }
        onetimeChargeItems_.push_back(otc);
        setNumber(*otc);
        addAmount(otc->amount, flags);
        return otc;
    }

    template <typename T>
      OnetimeChargeItem* Invoice::newOnetimeChargeItem(
        const Section& section,
        const T& t,
        const OnetimeCharge* onetimeCharge
    )
    {
        return newOnetimeChargeItem<T>(section, t, onetimeCharge,
                ContributesTo(ct_invAmounts|ct_invTotal|ct_otcTotal));
    }

    // Create a new total item and link it to the invoice as specified
    // Provided are versions with and without additional sort key
    template <typename T>
    TotalItem* Invoice::newTotalItem(
        const Section&   section,
        const T&         t,
              Decimal&   volume,
        const Unit::Oid& unitId,
        ContributesTo    flags
    )
    {
        // Check if unit exists.
        if (unitId.unKnown()) {
            throw DefException(51) << unitId;
        }

        TotalItem* tot = new TotalItem(section, volume, unitId);
        int rc = items_.insert(section, t, tot);
        if (rc) {
            delete tot;
            throw DefException(29) << section.str();
        }
        setNumber(*tot);
        addAmount(tot->amount_, flags);
        return tot;
    }

    template <typename T>
    TotalItem* Invoice::newTotalItem(
        const Section&   section,
        const T&         t,
              Decimal&   volume,
        const Unit::Oid& unitId
    )
    {
        return newTotalItem<T>(section, t, volume, unitId,
                ContributesTo(ct_nothing));
    }

    template <typename T>
      AssociateInfo* Invoice::newAssociateInfo(
        const Section& section,
        const T& t,
        const Associate* associate
    )
    {
        AssociateInfo* ii = new AssociateInfo(section, associate);
        int rc = items_.insert(section, t, ii);
        if (rc) {
            delete ii;
            throw DefException(29) << section.str();
        }
        setNumber(*ii);
        return ii;
    }

    template <typename T>
      SummaryChargesInfo* Invoice::newSummaryChargesInfo(
        const Section& section,
        const T& t,
        const SummaryCharges* sumCharges
    )
    {
        SummaryChargesInfo* ii =
            new SummaryChargesInfo(section, sumCharges);
        int rc = items_.insert(section, t, ii);
        if (rc) {
            delete ii;
            throw DefException(29) << section.str();
        }
        setNumber(*ii);
        return ii;
    }

    template <typename T>
      InvoiceInfoItem* Invoice::newInvoiceInfoItem(
        const Section& section,
        const T& t,
        const InvoiceInfo* invInfo
    )
    {
        InvoiceInfoItem* ii =
            new InvoiceInfoItem(section, invInfo);
        int rc = items_.insert(section, t, ii);
        if (rc) {
            delete ii;
            throw DefException(29) << section.str();
        }
        setNumber(*ii);
        return ii;
    }
}                                   // namespace OSB_LIB
#endif                              // #ifndef _INVOICE_H_

---