Class.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2004  Andrew Sutton
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to:
 *
 * The Free Software Foundation, Inc.
 * 59 Temple Place, Suite 330
 * Boston, MA  02111-1307  USA
 *
 * Contact:
 *   Andrew Sutton  asutton@cs.kent.edu
 */

#ifndef OMF_CLASS_HPP
#define OMF_CLASS_HPP

// std includes
#include <iostream>
#include <string>
#include <set>

// OMF includes
#include <OMF/Set.hpp>

namespace OMF
{
  // forward declarations
  class Object;

  class Class
  {
  protected:
    Class() : 
      _ofClass(),
      _ofType(),
      _name()
    {}

    Class &init(const std::string &name)
    {
      if(_name.empty()) {
  _name = name;
      }
      return *this;
    }

  public:
    virtual ~Class()
    {
      // we could clean up remaining instances, but the process
      // is going away
    }

    const std::string &name() const
    { return _name; }

    virtual Object *createInstance()
    { return 0; }

    virtual void destroyInstance(Object *)
    {}

    const OMF::Set &allOfClass() const
    { return _ofClass; }

    const OMF::Set &allOfType() const
    { return _ofType; }

    void addType(Object *type)
    { _ofType.insert(type); }

    void removeType(Object *type)
    { _ofType.erase(type); }

  protected:
    OMF::Set  _ofClass;
    OMF::Set  _ofType;

  private:
    std::string   _name;
  };

  struct Concrete
  {
    static const bool abstract = false;
  };

  struct Abstract
  {
    static const bool abstract = true;
  };


  template <class Type, class Factory = Concrete>
  class BasicClass : public Class
  {
    typedef BasicClass<Type, Factory> Self;

  protected:
     BasicClass() :
       Class()
    {}

  public:
    virtual ~BasicClass()
    {}

    static Self &instance(const std::string &name = "")
    {
      static Self _instance;
      return static_cast<Self &>(_instance.init(name));
    }

    Type *create()
    {
      Type *ret = 0;
      if(!Factory::abstract) {
  // create the object
  ret = new Type;

  // add to the instance set
  _ofClass.add(ret);
      }
      return ret;
    }

    void destroy(Object *instance)
    {
      _ofClass.remove(instance);
    }

    virtual Object *createInstance()
    {
      return create();
    }

    virtual void destroyInstance(Object *instance)
    {
      destroy(instance);
    }
  };
}

#endif

---