resourcelists.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.38 $

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

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

// + local headers
#include "accessnumber.h"
#include "e164resource.h"
#include "mutex.h"
#include "ipaddress.h"
#include "osbid.h"
#include "resource.h"
#include "stringutil.h"
#include "trunkresource.h"

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

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

// *********************************************************************
// class definitions

    // *****************************************************************
    // template<typename R> class ResourceList
    template<typename R>
    class ResourceList {
    public:
        typedef std::list<R> List;
        typedef ReadGuard<R*>  Rg;
        typedef WriteGuard<R*> Wg;
        typedef RwGuard ListRg;
        typedef RwGuard ListWg;
        enum GuardStatus {
            success        = 0,
            lockFailed     = 1,         
            objectNotFound = 2          
        };

    public:
        explicit ResourceList(bool useLocks);

    public:
        List resources_;

    public:
        bool useLocks() const;

        R* find(
            const Id<Resource>& id,
                  bool          doThrow
        );

        const R* find(
            const Id<Resource>& id,
                  bool          doThrow
        ) const;



        Rg readLock(
            const Id<Resource>& id,
                  bool          doThrow
        ) const;
        Wg writeLock(
            const Id<Resource>& id,
                  bool          doThrow
        );
        ListRg readLock() const;
        ListWg writeLock();

        bool insert(const R& r);
        bool replace(const R& r);
        bool replace(const ResourceList<R>& src);
        bool erase(const Id<Resource>& id);
        bool clear();

        void sortByResNum(bool desc = false);

    private:                            // data members
        bool useLocks_;
        mutable RwMutex mutex_;

    private:                            // utility functions
        typename List::iterator findIter(const Id<Resource>& id);

        void eraseUnlocked(const Id<Resource>& id);

        void replaceUnlocked(const R& r);

        static bool lessResNum(
            const R& lhs,
            const R& rhs
        );

        static bool greaterResNum(
            const R& lhs,
            const R& rhs
        );
    };                                  // class ResourceList

    // *****************************************************************
    // class ResourceLists
    class ResourceLists {
    public:


        typedef ResourceList<AccessNumber> AnList;
        typedef ResourceList<E164Resource> E164List;
        typedef ResourceList<Ip4Address> Ip4List;
        typedef ResourceList<IpGroup> IpGroupList;
        typedef ResourceList<TrunkResource> TrList;

    public:
        explicit ResourceLists(bool useLocks);

    public:                             // data members
        AnList accessNumbers_;
        E164List e164s_;
        Ip4List ip4s_;
        IpGroupList ipGroups_;
        TrList trunkResources_;



        static bool fetchAn(
            const OSB_DB::Session& session,
                  AnList&          dest,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );
        bool fetchAn(
            const OSB_DB::Session& session,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );



        static bool fetchE164(
            const OSB_DB::Session& session,
                  E164List&        dest,
                  Resource::Status status,
            const std::string&     pattern,
                  size_t           maxAdd
        );
        bool fetchE164(
            const OSB_DB::Session& session,
                  Resource::Status status,
            const std::string&     pattern,
                  size_t           maxAdd
        );



        static bool fetchIp4(
            const OSB_DB::Session& session,
                  Ip4List&         dest,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );
        bool fetchIp4(
            const OSB_DB::Session& session,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );
        void getAssignableIp4s(
            const OSB_DB::Session& session,
                  AssignableIp4s&  dest
        );



        static bool fetchIpg(
            const OSB_DB::Session& session,
                  IpGroupList&     dest,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );
        bool fetchIpg(
            const OSB_DB::Session& session,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );



        static bool fetchTr(
            const OSB_DB::Session& session,
                  TrList&          dest,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );
        bool fetchTr(
            const OSB_DB::Session& session,
                  bool             availOnly = false,
            const Id<Network>&     nwId = Id<Network>()
        );
    };                                  // struct ResourceLists

// *********************************************************************
// template definitions

    // *****************************************************************
    // class ResourceList<R>
    template<typename R>
    ResourceList<R>::ResourceList(bool useLocks)
      : useLocks_(useLocks)
    {
        // empty body
    }

    template<typename R>
    bool ResourceList<R>::useLocks() const
    {
        return useLocks_;
    }

    template<typename R>
    typename ResourceList<R>::List::iterator
    ResourceList<R>::findIter(const Id<Resource>& id)
    {
        typedef typename List::iterator Iter;
        bool found = false;
        Iter rc = resources_.begin();
        Iter e  = resources_.end();
        while (!found && rc != e) {
            if (id == rc->oid()) found = true;
            else                 ++rc;
        }
        return rc;
    }

    template<typename R>
    R* ResourceList<R>::find(
        const Id<Resource>& id,
              bool          doThrow
    )
    {
        R* rc = 0;
        typename List::iterator i = findIter(id);
        if (i != resources_.end()) {
            rc = &(*i);
        }
        else if (doThrow) {
            throw DefException(712) << id;
        }
        return rc;
    }

    template<typename R>
    const R* ResourceList<R>::find(
        const Id<Resource>& id,
              bool          doThrow
    ) const
    {
        return const_cast<ResourceList*>(this)->find(id, doThrow);
    }

    template<typename R>
    typename ResourceList<R>::Rg
    ResourceList<R>::readLock(
        const Id<Resource>& id,
              bool          doThrow
    ) const
    {
        // get the lock if needed, return in case of failure.
        RwMutex* mutex = 0;
        if (useLocks_) {
            if (0 != mutex_.readLock()) return Rg(lockFailed);
            mutex = &mutex_;
        }

        // make sure the lock is released
        Rg rc(0, true, mutex);

        // get the resource, set the return value
        const R* ptr = find(id, doThrow);

        if (0 != ptr) { // found: set the guard pointer
            rc = Rg(ptr, rc.release(), mutex);
        }
        else {         // not found: no need to keep lock
            rc.status_ = objectNotFound;
            rc.unlock();
        }

        return rc;
    }

    template<typename R>
    typename ResourceList<R>::Wg
    ResourceList<R>::writeLock(
        const Id<Resource>& id,
              bool          doThrow
    )
    {
        // Get the lock if needed, return in case of failure.
        RwMutex* mutex = 0;
        if (useLocks_) {
            if (0 != mutex_.writeLock()) return Wg(lockFailed);
            mutex = &mutex_;
        }

        // make sure the lock is released
        Wg rc(0, true, mutex);

        // get the resource, set the return value
        R* ptr = find(id, doThrow);

        if (0 != ptr) { // found: set the guard pointer
            rc = Wg(ptr, rc.release(), mutex);
        }
        else {         // not found: no need to keep lock
            rc.status_ = objectNotFound;
            rc.unlock();
        }

        return rc;
    }

    template<typename R>
    typename ResourceList<R>::ListRg
    ResourceList<R>::readLock() const
    {
        // Return immediately if no locking is applied:
        if (!useLocks_) return ListRg();

        // If needed: get the lock, return in case of failure.
        if (useLocks_) {
           if (0 != mutex_.readLock()) return ListRg(false);
        }

        // Return a loaded guard:
        return ListRg(true, &mutex_, &RwMutex::readUnlock);
    }

    template<typename R>
    typename ResourceList<R>::ListWg
    ResourceList<R>::writeLock()
    {
        // Return immediately if no locking is applied:
        if (!useLocks_) return ListWg();

        // If needed: get the lock, return in case of failure.
        if (useLocks_) {
            if (0 != mutex_.writeLock()) return ListWg(false);
        }

        // Return a loaded guard:
        return ListWg(true, &mutex_, &RwMutex::writeUnlock);
    }

    template<typename R>
    bool ResourceList<R>::insert(const R& r)
    {
        ListWg guard = writeLock();
        if (!guard.locked()) return false;
        bool rc = false;                // return value
        if (0 == find(r.oid(), false)) {
            resources_.push_back(r);
            rc = true;
        }
        return rc;
    }

    template<typename R>
    bool ResourceList<R>::replace(const ResourceList<R>& src)
    {
        typedef typename List::const_iterator Iter;

        ListWg guard = writeLock();
        if (!guard.locked()) return false;
        Iter i = src.resources_.begin();
        Iter e = src.resources_.end();
        for (; i != e; ++i) replaceUnlocked(*i);
        return true;
    }

    template<typename R>
    bool ResourceList<R>::replace(const R& r)
    {
        ListWg guard = writeLock();
        if (!guard.locked()) return false;
        replaceUnlocked(r);
        return true;
    }

    template<typename R>
    void ResourceList<R>::replaceUnlocked(const R& r)
    {
        R* ptr = find(r.oid(), false);
        if (ptr != &r) { // prevent replacing a list member
            if (0 != ptr) eraseUnlocked(r.oid());
            resources_.push_back(r);
        }
    }

    template<typename R>
    bool ResourceList<R>::erase(const Id<Resource>& id)
    {
        ListWg guard = writeLock();
        if (!guard.locked()) return false;
        eraseUnlocked(id);
        return true;
    }

    template<typename R>
    void ResourceList<R>::eraseUnlocked(const Id<Resource>& id)
    {
        typename List::iterator i = findIter(id);
        if (i != resources_.end()) resources_.erase(i);
    }

    template<typename R>
    bool ResourceList<R>::clear()
    {
        ListWg guard = writeLock();
        if (!guard.locked()) return false;
        resources_.clear();
        return true;
    }

    template<typename R>
    bool ResourceList<R>::lessResNum(const R& lhs, const R& rhs)
    {
        const std::string& lname = lhs.resourceNumber();
        const std::string& rname = rhs.resourceNumber();
        return LessStr<>(true)(lname, rname);
    }

    template<typename R>
    bool ResourceList<R>::greaterResNum(const R& lhs, const R& rhs)
    {
        const std::string& lname = lhs.resourceNumber();
        const std::string& rname = rhs.resourceNumber();
        return GreaterStr<>(true)(lname, rname);
    }

    template<typename R>
    void ResourceList<R>::sortByResNum(bool desc)
    {
        if (desc) resources_.sort(greaterResNum);
        else      resources_.sort(lessResNum);
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _RESOURCELISTS_H_

---