persproductcache.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Ramlan Rusdijanto (rr)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.31 $

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

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

// + local headers
#include "mutex.h"
#include "chrono.h"
#include "period.h"
#include "persproduct.h"
#include "resourcefwd.h"

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

    class PersProductCache {
    public:
        explicit PersProductCache(bool useLocks);
        ~PersProductCache();
    private:
        PersProductCache(const PersProductCache&);
        PersProductCache& operator=(PersProductCache&);

    public:
        void setMaxSize(long maxSize);
        void setCacheTime(long cacheTime);

        ReadGuard<PersProduct*> find(
            const OSB_DB::Session& session,
            const ResourceKey&     resourceKey,
            const DateTime&        timestamp
        );

        void logStats() const;

    // cache implementation
    private:
        // forward declaration of Entry
        class Entry;
        typedef std::map<PersProduct::Oid, Entry*> PersProducts;

        enum GuardStatus {
            ppFound = 0,
            ppNotFound
        };

        struct Key {
            inline Key(
                const ResourceKey& resourceKey
            );

            inline Key(
                const ResourceKey& resourceKey,
                const Period&      assigned
            );

            inline bool operator<(const Key& rhs) const;

            inline void mkAssignPeriod();

            ResourceKey resourceKey_;
            Period assigned_;
        };

        struct Stats {
            unsigned long hits_;
            unsigned long unchanged_;
            unsigned long reloads_;
            unsigned long loads_;
            unsigned long keysAdded_;
            unsigned long notFound_;
            unsigned long evicted_;

            Stats();
        };                              // struct Stats

        typedef std::map<Key, PersProduct::Oid> Keys;

        typedef std::list<PersProduct::Oid> Queue;

    private:
        Entry* find(
            const Key& key
        );

        Entry* load(
            const OSB_DB::Session& session,
                  Key&             key,
            const DateTime&        timestamp,
                  bool             isReload
        );

        Entry* add(
                  Key&         key,
            const PersProduct& persProduct
        );

        Entry* addMiss(
            const OSB_DB::Session& session,
                  Key&             key,
            const DateTime&        timestamp
        );

        void addKey(
            Entry* entry,
            Key&   key
        );

        void remove(
            const PersProduct::Oid& ppId,
            bool   force
        );

        void adjustSize();

    private:
        PersProducts persProducts_;
        Keys resources_;
        Queue queue_;

        bool useLocks_;
        unsigned long maxSize_;
        long cacheTime_;

        long nextMiss_;

        Mutex mutex_;
        MutexUnlock unlock_;

        Stats stats_;
    };

    class PersProductCache::Entry {
        friend class PersProductCache;
        static bool useLocks_;
    public:
        Entry(
            const PersProduct& pp,
                  long         cacheTime
        );

    private:
        Entry(const Entry&);
        Entry& operator=(const Entry&);

    public:
        ReadGuard<PersProduct*> readLock();
        RwGuard writeLock(bool wait);

    public:
        PersProduct persProduct_;
        DateTime expires_;
        std::vector<Keys::iterator> keys_;
        Queue::iterator queuePos_;
    private:
        RwMutex mutex_;
    };                                  // class PersProductCache::Entry
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
    // ********************************************************************
    // struct PersProductCache::Key::Key
    inline PersProductCache::Key::Key(
        const ResourceKey& resourceKey
    ) : resourceKey_(resourceKey)
    {
        // empty
    }

    inline PersProductCache::Key::Key(
        const ResourceKey& resourceKey,
        const Period&      assigned
    ) : resourceKey_(resourceKey), assigned_(assigned)
    {
        // empty
    }

    inline bool PersProductCache::Key::operator<(
        const PersProductCache::Key& rhs
    ) const
    {
        if (resourceKey_ < rhs.resourceKey_) return true;
        if (rhs.resourceKey_ < resourceKey_) return false;
        return assigned_.less(rhs.assigned_);
    }

    inline void PersProductCache::Key::mkAssignPeriod()
    {
        if (assigned_.isTimestamp() &&
            assigned_.to() != DateTime::max()) {
            assigned_ = Period(assigned_.from(),
                               assigned_.to().addSeconds(1));
        }
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _PERSPRODUCTCACHE_H_

---