CS_ELEMENT.hpp

#include<string>
#include<iostream>
#include<sstream>

#include "CACHE.hpp"

#ifndef _H_CS_ELEMENT
#define _H_CS_ELEMENT

template < typename T > class CS_ELEMENT {
   private:

   protected:

        T* _array;

        unsigned long int FAC;

   public:

        //static stuff first

        //end static stuff

        CS_ELEMENT() {
                _array = new T[ 1 ];
                FAC    = 0;
        }

        CS_ELEMENT( const T initial_caption ) {
                _array = new T[ 1 ];
                FAC    = 0;
                access() = initial_caption;
        }

        ~CS_ELEMENT() {
                delete [] _array;
        }

        const T& const_access() {
                CACHE::getInstance()->access( &( _array[ 0 ] ), sizeof( T ), FAC );
                return _array[ 0 ];
        }

        T& access() {
                CACHE::getInstance()->access( &( _array[ 0 ] ), sizeof( T ), FAC );
                return _array[ 0 ];
        }

        T& unrecorded_access() { return _array[ 0 ]; }

        const T& unrecorded_const_access() const { return _array[ 0 ]; }

        //operator overloading:
        CS_ELEMENT< T >& operator=( const CS_ELEMENT< T >& other ) { access() = other.const_access(); return *this; }
        CS_ELEMENT< T >& operator=( const T& other ) { access() = other; return *this; }
        CS_ELEMENT< T > operator+( const CS_ELEMENT< T >& other ) const { return CS_ELEMENT< T >( const_access() + other.const_access() ); }
        CS_ELEMENT< T > operator-( const CS_ELEMENT< T >& other ) const { return CS_ELEMENT< T >( const_access() - other.const_access() ); }
        CS_ELEMENT< T > operator*( const CS_ELEMENT< T >& other ) const { return CS_ELEMENT< T >( const_access() * other.const_access() ); }
        CS_ELEMENT< T > operator/( const CS_ELEMENT< T >& other ) const { return CS_ELEMENT< T >( const_access() / other.const_access() ); }

        void operator++() { ++( access() ); }

        //comparators:
        bool operator<( const T& other ) const { return const_access() < other; }
        bool operator<( const CS_ELEMENT< T >& other ) const { return const_access() < other.const_access(); }
        bool operator>( const T& other ) const { return const_access() > other; }
        bool operator>( const CS_ELEMENT< T >& other ) const { return const_access() > other.const_access(); }
        bool operator==( const T& other ) const { return const_access() == other; }
        bool operator==( const CS_ELEMENT< T >& other ) const { return const_access() == other.const_access(); }
        
};

#endif

---