alloc_exceptions.h

简单的动态内存管理程序源代码

// file: alloc_exception.h
// author: Marc Bumble
// July 11, 2002
// Contains classes related to exceptions
// Copyright (C) 2002 by Marc D. Bumble

//  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.

#ifndef ALLOC_EXCEPTIONS_H
#define ALLOC_EXCEPTIONS_H

// #include <global_defs.h>
#include <iostream>
#include <exception>
#include <string>

namespace Alloc_Exception {

  class alloc_exception : public std::exception {
    std::exception exception_val;
    std::string what_str;
  public:
    alloc_exception(std::string val) : exception_val() {
      what_str = val;
    }
    virtual ~alloc_exception() throw () {}
    virtual const char* what() {
      std::cerr << " Allocator Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class alloc_exception

  
  class shm_page_exception : public alloc_exception {
    std::string what_str;
  public:
    shm_page_exception(std::string val) : alloc_exception(val) {
      what_str = val;
    }
    virtual ~shm_page_exception() throw () {}
    virtual const char* what () {
      std::cerr << " Shared Memory Page Fault Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class shm_page_exception

  class ftok_exception : public alloc_exception {
    std::string what_str;
  public:
    ftok_exception(std::string val) : alloc_exception(val) {
      what_str = val;
    }
    virtual ~ftok_exception() throw () {}
    virtual const char* what () {
      std::cerr << " ftok Key Generation Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class ftok_exception

  class shm_exception : public alloc_exception {
    std::string what_str;
  public:
    shm_exception(std::string val) : alloc_exception(val) {
      what_str = val;
    }
    virtual ~shm_exception() throw () {}
    virtual const char* what () {
      std::cerr << " Shared Memory Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class shm_exception

  class mmap_exception : public alloc_exception {
    std::string what_str;
  public:
    mmap_exception(std::string val) : alloc_exception(val) {
      what_str = val;
    }
    virtual ~mmap_exception() throw () {}
    virtual const char* what () {
      std::cerr << " Memory Map Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class mmap_exception

  class fd_exception : public alloc_exception {
    std::string what_str;
  public:
    fd_exception(std::string val) : alloc_exception(val) {
      what_str = val;
    }
    virtual ~fd_exception() throw () {}
    virtual const char* what () {
      std::cerr << " File Descriptor Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class fd_exception

  class sem_exception : public alloc_exception {
    std::string what_str;
  public:
    sem_exception(std::string val) : alloc_exception(val) {
      what_str = val;
    }
    virtual ~sem_exception() throw () {}
    virtual const char* what () {
      std::cerr << " Semaphore Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class sem_exception

  class mem_exhausted_exception : public alloc_exception {
    std::string what_str;
  public:
    mem_exhausted_exception(std::string val) : alloc_exception(val) {
      what_str = val;
    }
    virtual ~mem_exhausted_exception() throw () {}
    virtual const char* what () {
      std::cerr << " Memory Exhaustion Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class mem_exhausted_exception

  class lock_creation_exception : public sem_exception {
    std::string what_str;
  public:
    lock_creation_exception(std::string val) : sem_exception(val) {
      what_str = val;
    }
    virtual ~lock_creation_exception() throw () {}
    virtual const char* what () {
      std::cerr << "Lock Creation Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class lock_creation_exception

  class locking_exception : public sem_exception {
    std::string what_str;
  public:
    locking_exception(std::string val) : sem_exception(val) {
      what_str = val;
    }
    virtual ~locking_exception() throw () {}
    virtual const char* what () {
      std::cerr << "Lock Creation Exception thrown" << std::endl;
      return what_str.data();
    }
  };  // class locking_exception


};  // namespace Alloc_Exception 

#endif