anclist.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.16 $

  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 _ANCLIST_H_
#define _ANCLIST_H_

// ************************************************************************
// included header files
// + standard includes
#include <map>
#include <memory>
#include <set>

// + libraries

// + local headers
#include "associate.h"
#include "contract.h"
#include "osbid.h"

// + class declarations
namespace OSB_DB {
    class Session;
}

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

// ************************************************************************
// forward declarations
    struct AnCFilter;

// ************************************************************************
// type definitions

// ************************************************************************
// class definitions
    class AssociateList {
    public:
        typedef std::auto_ptr<Associate> AssociateAutoPtr;



        typedef std::map<Id<Associate>, Associate*> List;
        typedef List::iterator Iterator;
        typedef List::const_iterator ConstIterator;
        typedef List::size_type SizeType;
        typedef List::key_type KeyType;

        AssociateList() {};

        AssociateList(const AssociateList& rhs);

        AssociateList& operator=(const AssociateList& rhs);

        ~AssociateList();


        Iterator begin() { return list_.begin(); }
        Iterator end() { return list_.end(); }
        Iterator find(const KeyType& k) { return list_.find(k); }
        ConstIterator begin() const { return list_.begin(); }
        ConstIterator end() const { return list_.end(); }
        ConstIterator find(const KeyType& k) const
        { return list_.find(k); }
        SizeType size() const { return list_.size(); }
        void swap(AssociateList& rhs);

        Associate* insert(const Associate& assoc);

        Associate* insert(AssociateAutoPtr ap);

        void erase(Iterator pos);

        void erase(const KeyType& k);

        void clear();

        const List& list() const { return list_; }

        Associate* findAssociate(const Id<Associate>& asId);

        const Associate* findAssociate(const Id<Associate>& asId) const;

        const Associate& getAssociate(const Id<Associate>& asId) const;

        Associate& getAssociate(const Id<Associate>& asId);

    private:
        List list_;
    };

    // *****************************************************************
    // AnCList
    class AnCList {
        friend class Associate;
    private:
        typedef std::set<Associate::Oid> AssociateIds;

    public:
        class AssocReadFailed : public OsbException {
        public:
            AssocReadFailed(
                      ErrorNo         errNo,
                const Associate::Oid& asId
            );
        };                              // class AssocReadFailed

        class ContractReadFailed : public OsbException {
        public:
            ContractReadFailed(
                      ErrorNo        errNo,
                const Contract::Oid& coId
            );
        };                              // class ContractReadFailed

        class PpReadFailed : public OsbException {
        public:
            PpReadFailed(
                      ErrorNo          errNo,
                const Id<PersProduct>& ppId
            );
        };                              // class PpReadFailed

    public:
        typedef std::map< Id<Contract>,    Contract>      ContractMap;
        typedef std::map< Id<PersProduct>, Id<Contract> > PersProductMap;

    public:
        AnCList() {}
        AnCList(const AnCList& rhs);
        AnCList& operator=(const AnCList& rhs);
        ~AnCList();

    public:
        const AssociateList& associateList() const
        {
            return aList_;
        }

        const ContractMap& contractMap() const
        {
            return cMap_;
        }



        long search(
            const OSB_DB::Session& session,
                  AnCFilter&       filter
        );



        Associate* associate(const Associate::Oid& asId);

        Associate& getAssociate(const Associate::Oid& asId);

        Associate* read(
            const OSB_DB::Session& session,
            const Associate::Oid   asId
        );

        bool create(
            OSB_DB::Session& session,
            Associate&       assoc
        );

        bool replace(
            const Associate& assoc
        );

        bool remove(
                  OSB_DB::Session& session,
            const Associate::Oid   asId
        );



        const Contract* findContract(const Contract::Oid& coId) const;

        Contract* contract(const Contract::Oid& coId);

        const Contract& getContract(const Contract::Oid& coId) const;

        Contract& getContract(const Contract::Oid& coId);

        Contract* read(
            const OSB_DB::Session& session,
            const Contract::Oid    coId
        );

        bool create(
                  OSB_DB::Session& session,
            const Associate::Oid&  owner,
                  Contract&        contract
        );

        void remove(
                  OSB_DB::Session& session,
            const Contract::Oid    coId
        );

        bool replace(
            const Contract& contract
        );



        PersProduct* persProduct(
            const Id<PersProduct>& ppId
        );

        PersProduct* read(
            const OSB_DB::Session& session,
            const Id<PersProduct>  ppId
        );

        void refresh(const OSB_DB::Session& session);

    private:
        void read(
            const OSB_DB::Session& session,
            const AssociateIds&    idList
        );

        void swap(AnCList& rhs);

        void insert(
            const Contract& co
        );

        void erase(
            const Contract::Oid coId
        );

        bool delAssoc(
            const OSB_DB::Session& session,
            const Associate::Oid   asId
        );

    private:
        AssociateList aList_;
        ContractMap  cMap_;
        PersProductMap ppMap_;
    };                                  // class AnCList

    struct AnCFilter {
        Associate::Oid asId_;
        std::string    asName_;
        Contract::Oid  coId_;

        size_t         maxRows_;
        bool           moreRows_;

        AnCFilter();
    };                                  // struct AnCList::Filter
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _ANCLIST_H_

---