Property.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_PROPERTY_HPP
#define OMF_PROPERTY_HPP

// std includes
#include <string>

// OMF includes
#include <OMF/Exception.hpp>
#include <OMF/Primitive.hpp>

namespace OMF
{
  // forward declarations
  class Object;
  class Association;

  struct GetMethod
  {
    virtual Object *get() = 0;
  };

  struct SetMethod
  {
    virtual void set(Object *value) = 0;
  };

  struct ClearMethod
  {
    virtual void clear() = 0;
  };

  template <class Self, class Type>
  struct GetByValConst : public GetMethod
  {
    typedef const Type &(Self::*Function)() const;

    GetByValConst(Self *self, Function method) :
      _self(self),
      _method(method)
    {}

    virtual Object *get()
    {
      const Object *ret = &((_self->*_method)());
      return const_cast<Object *>(ret);
    }

    Self       *_self;
    Function  _method;
  };

  template <class Self, class Type>
  struct GetByValNonConst : public GetMethod
  {
    typedef const Type &(Self::*Function)();

    GetByValNonConst(Self *self, Function method) :
      _self(self),
      _method(method)
    {}

    virtual Object *get()
    {
      const Object *ret = &((_self->*_method)());
      return const_cast<Object *>(ret);
    }

    Self       *_self;
    Function  _method;
  };

  template <class Self, class Type>
  struct GetByRef : public GetMethod
  {
    typedef Type *(Self::*Function)();

    GetByRef(Self *self, Function method) :
      _self(self),
      _method(method)
    {}

    virtual Object *get()
    {
      return (_self->*_method)();
    }

    Self       *_self;
    Function  _method;
  };

  template <class Self, class Type>
  struct SetByVal : public SetMethod
  {
    typedef void (Self::*Function)(const Type &);

    SetByVal(Self *self, Function method) :
      _self(self),
      _method(method)
    {}

    virtual void set(Object *value)
    {
      // used for type coersion
      Type coerce;

      Type *newValue = dynamic_cast<Type *>(value);
      if(!newValue) {
  Primitive *prim = dynamic_cast<Primitive *>(value);
  if(prim) {
    coerce = prim->str();
    newValue = &coerce;
  }
  else {
    throw TypeMismatchError();
  }
      }
      (_self->*_method)(*newValue);
    }

    Self       *_self;
    Function  _method;
  };

  template <class Self, class Type>
  struct SetByRef : public SetMethod
  {
    typedef void(Self::*Function)(Type *);

    SetByRef(Self *self, Function method) :
      _self(self),
      _method(method)
    {}

    virtual void set(Object *value)
    {
      Type *newValue = dynamic_cast<Type *>(value);
      if(!newValue) {
  throw TypeMismatchError();
      }
      else {
  (_self->*_method)(newValue);
      }
    }

    Self       *_self;
    Function  _method;
  };

  template <class Self>
  struct ClearAll : public ClearMethod
  {
    typedef void (Self::*Function)();

    ClearAll(Self *self, Function method) :
      _self(self),
      _method(method)
    {}

    virtual void clear()
    {
      (_self->*_method)();
    }

    Self       *_self;
    Function  _method;
  };

  
  class Property
  {
  public:
    enum AssocPos {
      NoAssoc,
      First,
      Second
    };

    enum AssocLevel {
      None,
      Weak,
      Strong
    };

    Property(const std::string &name);
    virtual ~Property();

    template <class Self, class Type>
    Property &getMethod(Self *self, const Type &(Self::*method)() const)
    {
      _get = new GetByValConst<Self, Type>(self, method);
      return *this;
    }

    template<class Self, class Type>
    Property &getMethod(Self *self, const Type &(Self::*method)())
    {
      _get = new GetByValNonConst<Self, Type>(self, method);
      return *this;
    }

    template <class Self, class Type>
    Property &getMethod(Self *self, Type *(Self::*method)())
    {
      _get = new GetByRef<Self, Type>(self, method);
      return *this;
    }

    template <class Self, class Type>
    Property &setMethod(Self *self, void (Self::*method)(const Type &))
    {
      _set = new SetByVal<Self, Type>(self, method);
      return *this;
    }

    template <class Self, class Type>
    Property &setMethod(Self *self, void (Self::*method)(Type *))
    {
      _set = new SetByRef<Self, Type>(self, method);
      return *this;
    }

    template <class Self, class Type>
    Property &addMethod(Self *self, void (Self::*method)(const Type &))
    {
      _add = new SetByVal<Self, Type>(self, method);
      return *this;
    }

    template <class Self, class Type>
    Property &addMethod(Self *self, void (Self::*method)(Type *))
    {
      _add = new SetByRef<Self, Type>(self, method);
      return *this;
    }

    template <class Self, class Type>
    Property &removeMethod(Self *self, void (Self::*method)(const Type &))
    {
      _remove = new SetByVal<Self, Type>(self, method);
      return *this;
    }

    template <class Self, class Type>
    Property &removeMethod(Self *self, void (Self::*method)(Type *))
    {
      _remove = new SetByRef<Self, Type>(self, method);
      return *this;
    }

    template <class Self>
    Property &clearMethod(Self *self, void (Self::*method)())
    {
      _clear = new ClearAll<Self>(self, method);
      return *this;
    }

    Property &assoc(Association *assoc, AssocPos pos, AssocLevel level)
    {
      _assoc = assoc;
      _pos = pos;
      _level = level;
      return *this;
    }

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

    virtual bool canGet() const
    { return _get != 0; }

    virtual bool canSet() const
    { return _set != 0; }

    virtual bool canAdd() const
    { return _add != 0; }

    virtual bool canRemove() const
    { return _remove != 0; }

    virtual bool canClear() const
    { return _clear != 0; }

    virtual Object *get();
    virtual void set(Object *value);
    virtual void add(Object *value);
    virtual void remove(Object *value);
    virtual void clear();

    Association *association()
    { return _assoc; }

    AssocPos position() const
    { return _pos; }

    AssocLevel level() const
    { return _level; }

  private:
    std::string   _name;
    GetMethod        *_get;
    SetMethod        *_set;
    SetMethod        *_add;
    SetMethod        *_remove;
    ClearMethod        *_clear;
    Association        *_assoc;
    AssocPos    _pos;
    AssocLevel    _level;
  };
}

#endif

---