Categorical_event.h

Go to the documentation of this file.

#ifndef CATEGORICAL_EVENT_H_
#define CATEGORICAL_EVENT_H_

#include "l_cpp/l_exception.h"
#include <boost/functional/hash.hpp>
#include <vector>
#include <iostream>

namespace semantics
{
    
class Categorical_event_base;

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N> class Categorical_event;

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N>
Categorical_event<N-1> smooth(
    const Categorical_event<N>& event,
    const size_t                steps = 1);

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N>
Categorical_event<N> get_context(
    const Categorical_event<N>& event,
    const size_t                steps = 1);

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

std::ostream& operator<<(std::ostream&, const Categorical_event_base&);


/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

class Categorical_event_base
{
public:
    typedef Categorical_event_base Self_type;
    typedef size_t Val_type;
    typedef std::vector<Val_type> Data_type;
    typedef size_t Hash_type;
    virtual std::ostream& print_to(std::ostream& os) const {return os;}
    virtual bool operator==(const Self_type&) const {return false;}
};

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N>
class Categorical_event : public Categorical_event_base
{
public:

/*------------------------------------------------------------
 * TYPEDEFS
 *------------------------------------------------------------*/

    typedef Categorical_event<N> Self_type;

/*------------------------------------------------------------
 * CONSTRUCTORS & DESTRUCTOR
 *------------------------------------------------------------*/
    
    Categorical_event() : size_(0), data_(), hash_val_(0) {}
    
    Categorical_event(Data_type data, size_t size);
    
    Categorical_event(
        Data_type::const_iterator first,
        Data_type::const_iterator last,
        size_t                    size
        );

    Categorical_event(const Self_type& other)
    : Categorical_event_base(),
      size_(other.size_),
      data_(other.data_),
      hash_val_(other.hash_val_)
    {}

/*------------------------------------------------------------
 * ACCESSORS
 *------------------------------------------------------------*/
    
    const size_t& size() const {return size_;}

    const size_t& front() const {return data_.front();}

    const size_t& back() const {return data_.back();}

/*------------------------------------------------------------
 * OPERATORS
 *------------------------------------------------------------*/
    
    bool operator==(const Self_type& other) const;

/*------------------------------------------------------------
 * DISPLAY FUNCTIONS
 *------------------------------------------------------------*/
    
    std::ostream& print_to(std::ostream& os) const;

/*------------------------------------------------------------
 * FRIEND FUNCTIONS
 *------------------------------------------------------------*/
    
    friend Categorical_event<N-1> smooth<N>(
        const Self_type& event,
        const size_t     steps);

    friend Categorical_event<N> get_context<N>(
        const Self_type& event,
        const size_t     steps);

    friend size_t hash_value(Self_type const& e) {return e.hash_val_;}
    
private:
    size_t size_; 
    Data_type data_; 
    Hash_type hash_val_; 
    void check_size() const
    {
        if(data_.size() != size_)
        {
            std::cerr << "Data has size: " << data_.size() << ","
                      << "Size required is " << size_ << std::endl;
            KJB_THROW_2(
                kjb::Illegal_argument,
                "Categorical_event constructed with incorrect length.");
        }
    }
};

/*------------------------------------------------------------
 * TEMPLATE MEMBER FUNCTION DEFINITIONS
 *------------------------------------------------------------*/

template<size_t N> inline
Categorical_event<N>::Categorical_event(Data_type data, size_t size)
    : size_(size),
      data_(data),
      hash_val_(boost::hash_range(data.begin(), data.end()))
{
    try
    {
        check_size();
    }
    catch(kjb::Illegal_argument& e)
    {
        std::cout << e.get_msg() << std::endl;
    }
}

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N> inline
Categorical_event<N>::Categorical_event(
        Data_type::const_iterator first,
        Data_type::const_iterator last,
        size_t                    size
        ) : size_(size),
            data_(first, last),
            hash_val_(boost::hash_range(first, last))
{
    try
    {
        check_size();
    }
    catch(kjb::Illegal_argument& e)
    {
        std::cout << e.get_msg() << std::endl;
    }
}

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N> inline
bool Categorical_event<N>::operator==(const Categorical_event<N>& other) const
{
    return hash_val_ == other.hash_val_;
}

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N>
std::ostream& Categorical_event<N>::print_to(std::ostream& os) const
{
    if(data_.size() == 0)
    {
        os << "NULL";
    } else {
        os << "(";
        for(Data_type::const_iterator it = data_.begin();
            it != data_.end(); it++)
        {
            os << *it << ",";
        }
        os << ")";
    }
    return os;
}


/*------------------------------------------------------------
 * TEMPLATE FREE FUNCTION DEFINITIONS
 *------------------------------------------------------------*/

template<size_t N>
Categorical_event<N-1> smooth(
    const Categorical_event<N>& event,
    const size_t steps
    )
{
    if(steps > event.size())
    {
        KJB_THROW_2(
            kjb::Illegal_argument,
            "steps argument of smooth() too large for event");
    }
    return Categorical_event<N-1>(
        event.data_.begin(), event.data_.end() - steps,
        event.size() - steps);
}

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

template<size_t N>
Categorical_event<N> get_context(
    const Categorical_event<N>& event,
    const size_t steps)
{
    return Categorical_event<N>(
        event.data_.begin() + steps, event.data_.end(),
        event.size() - steps);
}

}; //namespace semantics

#endif