Itzam/C++

Main Index

Created by Scott Robert Ladd at Coyote Gulch Productions.

---

itzam_common.h

//---------------------------------------------------------------------
//  Algorithmic Conjurings @ http://www.coyotegulch.com
//
//  Itzam - An Embedded Database Engine
//
//  itzam_common.h
//
//---------------------------------------------------------------------
//
//  Copyright 2004, 2005, 2006 Scott Robert Ladd
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//  
//  This program 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.
//  
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the
//      Free Software Foundation, Inc.
//      59 Temple Place - Suite 330
//      Boston, MA 02111-1307, USA.
//
//-----------------------------------------------------------------------
//
//  For more information on this software package, please visit
//  Scott's web site, Coyote Gulch Productions, at:
//
//      http://www.coyotegulch.com
//  
//-----------------------------------------------------------------------

#if !defined(LIBITZAM_CPP_ITZAM_COMMON_H)
#define LIBITZAM_CPP_ITZAM_COMMON_H

// Standard C
#include <sys/types.h>
#include <sys/stat.h>

#if defined(_MSC_VER)
#include "windows.h"
#else
#include <unistd.h>
#endif

// Standard C++
#include <string>
#include <stdexcept>


namespace itzam
{
    using std::runtime_error;
    using std::string;
    
    // include Itzam/Core within itzam namespace
    #include "itzam_core/itzam.h"


    enum database_state
    {
        ITZAM_DB_BROKEN = -1, 
        ITZAM_DB_UNINIT =  0, 
        ITZAM_DB_OPEN   =  1, 
        ITZAM_DB_CLOSED =  2  
    };


    enum database_error
    {
        DB_ERROR_NONE,             
        DB_ERROR_OPEN_BROKEN,      
        DB_ERROR_OPEN_FAILED,      
        DB_ERROR_CLOSE_BROKEN,     
        DB_ERROR_CLOSE_FAILED,     
        DB_ERROR_WRITE_BROKEN,     
        DB_ERROR_WRITE_CLOSED,     
        DB_ERROR_WRITE_DUPE,       
        DB_ERROR_WRITE_FAILED,     
        DB_ERROR_READ_BROKEN,      
        DB_ERROR_READ_CLOSED,      
        DB_ERROR_READ_NOT_FOUND,   
        DB_ERROR_READ_FAILED,      
        DB_ERROR_EXISTS_BROKEN,    
        DB_ERROR_EXISTS_CLOSED,    
        DB_ERROR_REMOVE_BROKEN,    
        DB_ERROR_REMOVE_CLOSED,    
        DB_ERROR_REMOVE_NOT_FOUND, 
        DB_ERROR_REMOVE_FAILED,    
        DB_ERROR_REFLIST_MISSING,  
        DB_ERROR_COUNT             
    };


    class database_exception : public runtime_error
    {
        private:
            // utility function
            static string build_error_string(const string & message)
            {
                string text("Itzam exception: ");
                text += message;
                return text;
            }

            // strings associated with various codes
            static const string DB_ERRORS [DB_ERROR_COUNT];
            
            // data elements
            database_error    m_error;

        public:

            database_exception(const string & message)
                : runtime_error(build_error_string(message)),
                  m_error(DB_ERROR_NONE)
            {
                // nada
            }


            database_exception(itzam_state state)
                : runtime_error(build_error_string(itzam_get_state_description(state))),
                  m_error(DB_ERROR_NONE)
            {
                // nada
            }


            database_exception(database_error error)
                : runtime_error(build_error_string(DB_ERRORS[error])),
                  m_error(error)
            {
                // nada
            }
            

            database_error get_error() const
            {
                return m_error;
            }
    };
    

    class serial_data
    {
        private:
            void *       m_data;
            size_t       m_size;
            bool         m_cleanup;
            
        public: 
            serial_data()
                : m_data(NULL),
                  m_size(0),
                  m_cleanup(false)
            {
                // nada
            }
            
            serial_data(const void * data, size_t size, bool cleanup = false)
                : m_data(const_cast<void *>(data)),
                  m_size(size),
                  m_cleanup(cleanup)
            {
                // nada
            }
            
            serial_data(const serial_data & source)
              : m_data(NULL),
                m_size(source.m_size),
                m_cleanup(source.m_cleanup)
            {
                if (m_cleanup)
                {
                    m_data = malloc(m_size);
                    memcpy(m_data,source.m_data,m_size);
                }
                else
                    m_data = source.m_data;
            }
            
            serial_data & operator = (const serial_data & source)
            {
                if (m_cleanup)
                    free(m_data);
                
                m_size    = source.m_size;
                m_cleanup = source.m_cleanup;
                
                if (m_cleanup)
                {
                    m_data = malloc(m_size);
                    memcpy(m_data,source.m_data,m_size);
                }
                else
                    m_data = source.m_data;
                
                return *this;
            }
            
            virtual ~serial_data()
            {
                if (m_cleanup)
                    free(m_data);
            }
            
            const void * get_data() const
            {
                return m_data;
            }
            
            size_t get_size() const
            {
                return m_size;
            }
    };
    

    template < typename base_t >
         class atomic_record
         {
             public:

                 atomic_record(const base_t & value = 0)
                   : m_value(value)
                 {
                     // nada
                 }


                 atomic_record(const serial_data & source)
                   : m_value(*((base_t *)source.get_data()))
                 {
                     // nada
                 }


                 atomic_record(const atomic_record & source)
                   : m_value(source.m_value)
                 {
                     // nada
                 }


                 atomic_record & operator = (const atomic_record<base_t> & source)
                 {
                     m_value = source.m_value;
                     return *this;
                 }


                 atomic_record & operator = (const base_t & source)
                 {
                     m_value = source;
                     return *this;
                 }


                 atomic_record & operator = (const serial_data & source)
                 {
                     m_value = *((base_t *)source.get_data());
                     return *this;
                 }


                 virtual ~atomic_record()
                 {
                     // nada, just for any derived classes
                 }
                 

                 operator base_t() const
                 {
                     return m_value;
                 }


                 operator serial_data() const
                 {
                     return serial_data(&m_value,sizeof(base_t),false);
                 }
                 
            protected:
                base_t m_value;
         };
         

    template <typename base_t>
        class numeric_key
          : public atomic_record<base_t>
        {
             public:

                 numeric_key(const base_t & value = 0)
                   : atomic_record<base_t>(value)
                 {
                     // nada
                 }


                 numeric_key(const serial_data & source)
                   : atomic_record<base_t>(source)
                 {
                     // nada
                 }


                 numeric_key(const numeric_key & source)
                   : atomic_record<base_t>(source)
                 {
                     // nada
                 }


                 numeric_key & operator = (const numeric_key<base_t> & source)
                 {
                     atomic_record<base_t>::operator = (source);
                     return *this;
                 }


                 numeric_key & operator = (const base_t & source)
                 {
                     atomic_record<base_t>::operator = (source);
                     return *this;
                 }


                 numeric_key & operator = (const serial_data & source)
                 {
                     atomic_record<base_t>::operator = (source);
                     return *this;
                 }


                 virtual ~numeric_key()
                 {
                     // nada, just for any derived classes
                 }


                 static int compare_keys(const void * key1, const void * key2)
                 {
                     int result = 0;

                     // I can't simply cast this value to int, since if base_t is real,
                     //      abs(diff) might be  close enough to zero that nearby keys
                     //      would be cast to 0 (equal). Although real keys are unlikely,
                     //      it's still a good idea to account for them.
                     base_t diff = (*((const base_t *)key1)) - (*((const base_t *)key2));

                     if (diff < 0)
                         result = -1;
                     else if (diff > 0)
                         result = 1;

                     return result;
                 }
        };


    class string_key
    {
         public:

             string_key(const string & value = 0)
               : m_value(value)
             {
                 // nada
             }


             string_key(const serial_data & source)
               : m_value(reinterpret_cast<const char *>(source.get_data()))
             {
                 // nada
             }


             string_key(const string_key & source)
               : m_value(source.m_value)
             {
                 // nada
             }


             string_key & operator = (const string_key & source)
             {
                 m_value = source.m_value;
                 return *this;
             }


             string_key & operator = (const string & source)
             {
                 m_value = source;
                 return *this;
             }


             string_key & operator = (const serial_data & source)
             {
                 m_value = string(reinterpret_cast<const char *>(source.get_data()));
                 return *this;
             }


             virtual ~string_key()
             {
                 // nada, just for any derived classes
             }


             operator string() const
             {
                 return m_value;
             }


             operator serial_data() const
             {
                 char * s = strdup(m_value.c_str());
                 return serial_data(s,strlen(s) + 1,true);
             }


             static int compare_keys(const void * key1, const void * key2)
             {
                 return strcmp((const char *)key1, (const char *)key2);
             }
                 
        protected:
            string m_value;
    };


    class mutex
    {
        public:

            virtual ~mutex()
            {
                // nada
            }


            virtual void lock() = 0;


            virtual void unlock() = 0;


            virtual void sleep() = 0;
    };


    class null_mutex : public mutex
    {
        public:

            virtual ~null_mutex()
            {
                // nada
            }


            virtual void lock()
            {
                // nada
            }


            virtual void unlock()
            {
                // nada
            }

        protected:

            virtual void sleep()
            {
                // nada
            }
    };


    class simple_mutex : public mutex
    {
        public:

            simple_mutex()
              : m_locked(false)
            {
                // nada
            }


            virtual ~simple_mutex()
            {
                // nada
            }


            virtual void lock()
            {
                while (m_locked)
                {
                    sleep();
                }

                m_locked = true;
            }


            virtual void unlock()
            {
                m_locked = false;
            }


            virtual void sleep()
            {
#if defined(_MSC_VER)
                Sleep(50000);
#else
                usleep(50000);
#endif
            }

        private:
            bool m_locked;
    };


    template < class key_t >
        class selector
        {
            public:

                virtual ~selector()
                {
                    // nada
                }

                // all derivations of this class must define a static member function of this form
                //     static bool selector(const void * key);
        };


    template < class key_t >
        class select_all
          : public selector<key_t>
        {
            public:

                virtual ~select_all()
                {
                    // nada
                }


                static bool select(const void * key)
                {
                    return true;
                }
        };


    class database_object
    {
        protected:
            database_state m_state;

            itzam_file_lock_mode m_file_lock_mode;
        
            string m_name;
        
        public:

            database_object(const string & name, itzam_file_lock_mode lock_mode)
              : m_state(ITZAM_DB_UNINIT),
                m_name(name),
                m_file_lock_mode(lock_mode)
            {
                // nada
            }


            database_object(const database_object & source)
              : m_state(source.m_state),
                m_name(source.m_name),
                m_file_lock_mode(source.m_file_lock_mode)
            {
                // nada
            }


            database_object & operator = (const database_object & source)
            {
                m_state = source.m_state;
                m_name  = source.m_name;
                m_file_lock_mode = source.m_file_lock_mode;
                return *this;
            }


            database_state get_state() const
            {
                return m_state;
            }


            string get_name() const
            {
                return m_name;
            }


            itzam_file_lock_mode get_lock_mode() const
            {
                return m_file_lock_mode;
            }


            bool is_okay() const
            {
                return (m_state != ITZAM_DB_BROKEN);
            }


            bool is_broken() const
            {
                return (m_state == ITZAM_DB_BROKEN);
            }


            bool is_open() const
            {
                return (m_state == ITZAM_DB_OPEN);
            }


            bool is_closed() const
            {
                return (m_state == ITZAM_DB_CLOSED);
            }
    };
    
} // end namespace itzam

#endif

---

© 1996-2005 Scott Robert Ladd. All rights reserved.
HTML documentation generated by Dimitri van Heesch's excellent Doxygen tool.