/* fifo-policy-prob.h
 *
 * Created: 11-06-2013
 * Copyright (c) 2013 Trinity College fo Dublin, Ireland
 * Author: Andriana Ioannou <ioannoa@scss.tcd.ie>
 *
 * This is the fifo policy implementing the probabilistic cahing. Additions to the original content object packet are the inclusion of the set_probability and get_probability functions, based on the probability_ variable. (search for //(+) )
 */

#ifndef FIFO_POLICY_H_
#define FIFO_POLICY_H_

#include <boost/intrusive/options.hpp>
#include <boost/intrusive/list.hpp>

namespace ns3 {
namespace ndn {
namespace ndnSIM {
            
/**
 * @brief Traits for First In First Out replacement policy
*/
struct fifo_policy_traits
{
    /// @brief Name that can be used to identify the policy (for NS-3 object model and logging)
    static std::string GetName () { return "Fifo"; }
                
    struct policy_hook_type : public boost::intrusive::list_member_hook<> {};
                
    template<class Container>
    struct container_hook
    {
        // could be class/struct implementation
        typedef boost::intrusive::member_hook< Container,
        policy_hook_type,
        &Container::policy_hook_ > type;
    };
                
    template<class Base,
             class Container,
             class Hook>
    struct policy
    {
        typedef typename boost::intrusive::list< Container, Hook > policy_container;
                    
        // could be just typedef
        class type : public policy_container
        {
        public:
            typedef Container parent_trie;
                        
            type (Base &base)
            : base_ (base)
            , max_size_ (100)
            , probability_ (1.0)
            {
            }
                        
            inline void
            update (typename parent_trie::iterator item)
            {
                // do nothing
            }
                        
            inline bool
            insert (typename parent_trie::iterator item)
            {
                if (max_size_ != 0 && policy_container::size () >= max_size_)
                {
                    base_.erase (&(*policy_container::begin ()));
                }
                            
                policy_container::push_back (*item);
                return true;
            }
                        
            inline void
            lookup (typename parent_trie::iterator item)
            {
                // do nothing
            }
                        
            inline void
            erase (typename parent_trie::iterator item)
            {
                policy_container::erase (policy_container::s_iterator_to (*item));
            }
                        
            inline void
            clear ()
            {
                policy_container::clear ();
            }
                        
            inline void
            set_max_size (size_t max_size)
            {
                max_size_ = max_size;
            }
                        
            inline size_t
            get_max_size () const
            {
                return max_size_;
            }

//--------------------------------------------------------------------------
            inline void//(+)
            set_probability (double probability)
            {
                probability_ = probability;
            }
                        
            inline double//(+)
            get_probability () const
            {
                return probability_;
            }
//--------------------------------------------------------------------------
            
        private:
            type () : base_(*((Base*)0)) { };
                        
        private:
            Base &base_;
            size_t max_size_;//--------------------------------------------
            double probability_;//(+)
        };//----------------------------------------------------------------
    };
};
            
} // ndnSIM
} // ndn
} // ns3

#endif //FIFO_POLICY_H_