2005-02-08 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
* oln/core/value_box.hh: Unbox image attribute.
* oln/core/abstract/image_with_data.hh: Clean up in ctors.
* oln/core/abstract/data_storage.hh: Fix bug in size().
* oln/core/2d/array2d.hh: Fix name of size impl.
Index: olena/oln/core/value_box.hh
===================================================================
--- olena/oln/core/value_box.hh (revision 29)
+++ olena/oln/core/value_box.hh (working copy)
@@ -30,10 +30,6 @@
# include <ostream>
-// for mlc::box<T>:
-
-# include <mlc/box.hh>
-
# include <oln/core/macros.hh>
// the proper macro:
@@ -91,7 +87,7 @@
template <typename V>
value_box& operator=(const V& value)
{
- ima_->set(p_, value);
+ ima_.set(p_, value);
return *this;
}
@@ -107,7 +103,7 @@
template <typename II>
value_box& operator=(const value_box<II>& rhs)
{
- ima_->set(p_, rhs); // automatic conversion from rhs to oln_value_type(I)
+ ima_.set(p_, rhs); // automatic conversion from rhs to oln_value_type(I)
return *this;
}
@@ -122,7 +118,7 @@
template <typename A, typename V>
value_box& set(void (I::*method)(A), const V& value)
{
- ima_->set(p_, method, value);
+ ima_.set(p_, method, value);
return *this;
}
@@ -137,13 +133,13 @@
template <typename V>
operator const V() const
{
- const V value = ima_->get(p_);
+ const V value = ima_.get(p_);
return value;
}
operator const oln_value_type(I)() const
{
- return ima_->get(p_);
+ return ima_.get(p_);
}
@@ -160,7 +156,7 @@
const oln_value_type(I) value() const
{
- return ima_->get(p_);
+ return ima_.get(p_);
}
@@ -174,8 +170,8 @@
/// Ctor (restricted access).
- value_box(I& ima, const oln_point_type(I)& p) :
- ima_(ima),
+ value_box(abstract::image<I>& ima, const oln_point_type(I)& p) :
+ ima_(ima.exact()),
p_(p)
{
}
@@ -192,7 +188,7 @@
! attributes !
*------------*/
- mlc::box<I> ima_;
+ I& ima_;
oln_point_type(I) p_;
};
@@ -216,10 +212,9 @@
public:
+ /*! \brief Assignment (op=) is declared but undefined.
+ */
- // FIXME: no operator= was provided here so 'self = self' was possible...
- // FIXME: below, a single decl has been added; to be tested...
-
template <typename V>
void operator=(const V&) const;
@@ -232,13 +227,13 @@
template <typename V>
operator const V() const
{
- const V value = ima_->get(p_);
+ const V value = ima_.get(p_);
return value;
}
operator const oln_value_type(I)() const
{
- return ima_->get(p_);
+ return ima_.get(p_);
}
@@ -255,7 +250,7 @@
const oln_value_type(I) value() const
{
- return ima_->get(p_);
+ return ima_.get(p_);
}
// IDEA: provide op->
@@ -270,8 +265,8 @@
/// Ctor (restricted access).
- value_box(const I& ima, const oln_point_type(I)& p) :
- ima_(ima),
+ value_box(const abstract::image<I>& ima, const oln_point_type(I)& p) :
+ ima_(ima.exact()),
p_(p)
{
}
@@ -288,7 +283,7 @@
! attributes !
*------------*/
- mlc::box<const I> ima_;
+ const I& ima_;
oln_point_type(I) p_;
};
Index: olena/oln/core/abstract/image_with_data.hh
===================================================================
--- olena/oln/core/abstract/image_with_data.hh (revision 29)
+++ olena/oln/core/abstract/image_with_data.hh (working copy)
@@ -137,18 +137,18 @@
/*! \brief Constructor (protected) with no memory allocation for
** data.
*/
- image_with_data()
+ image_with_data() :
+ data_(0)
{
- data_ = 0;
}
/*! \brief Constructor (protected) with memory allocation for
** data.
*/
- image_with_data(const oln_size_type(E)& size)
+ image_with_data(const oln_size_type(E)& size) :
+ data_(new oln_value_container_type(E)(size))
{
- data_ = new oln_value_container_type(E)(size);
}
Index: olena/oln/core/abstract/data_storage.hh
===================================================================
--- olena/oln/core/abstract/data_storage.hh (revision 29)
+++ olena/oln/core/abstract/data_storage.hh (working copy)
@@ -54,7 +54,7 @@
const oln_size_type(E)& size() const
{
- return this->exact().impl_size(this->s);
+ return this->exact().impl_size();
}
void resize(const oln_size_type(E)& s)
Index: olena/oln/core/2d/array2d.hh
===================================================================
--- olena/oln/core/2d/array2d.hh (revision 29)
+++ olena/oln/core/2d/array2d.hh (working copy)
@@ -108,7 +108,7 @@
invariant_();
}
- const size2d& size() const
+ const size2d& impl_size() const
{
return size_;
}
Index: metalic/mlc/tracked_ptr.hh
===================================================================
--- metalic/mlc/tracked_ptr.hh (revision 29)
+++ metalic/mlc/tracked_ptr.hh (working copy)
@@ -28,10 +28,11 @@
#ifndef METALIC_TRACKED_PTR_HH
# define METALIC_TRACKED_PTR_HH
-# include <ostream>
+# include <iostream>
# include <set>
# include <map>
+# include <mlc/contract.hh>
namespace mlc {
@@ -42,93 +43,148 @@
namespace internal {
+ /*! \class tracked_ptr_proxy<T>
+ **
+ ** Class that effectively holds a pointer. For use in class
+ ** tracked_ptr.
+ **
+ ** Parameter T is the type of pointed data.
+ */
+
template <class T>
- class tracked_ptr_proxy
+ struct /* HERE: class */ tracked_ptr_proxy
{
friend class tracked_ptr<T>;
- // attributes
+ /// Attributes.
+
T* ptr_;
std::set<const tracked_ptr<T>*> holders_;
- // w/o impl
+ /// Cpy ctor is not impled.
tracked_ptr_proxy(const tracked_ptr_proxy&);
+
+ /// Assignmt op is not impled.
void operator=(const tracked_ptr_proxy&);
- // methods
- tracked_ptr_proxy() :
- ptr_(0)
- {
- }
-
+ /*! \brief Ctor.
+ **
+ ** We have a new proxy so we have to make sure that the pointer,
+ ** if not null, was not already proxified, meaning that this new
+ ** proxy handles 'new' data.
+ */
tracked_ptr_proxy(T* ptr) :
- ptr_(0)
+ ptr_(0),
+ holders_()
{
- set_ptr(ptr);
+ if (ptr != 0)
+ {
+ invariant(proxy_of()[ptr] == 0);
+ this->ptr_ = ptr;
+ proxy_of()[this->ptr_] = this;
+ }
+ else
+ this->ptr_ = 0;
}
- void set_ptr(T* new_ptr)
+
+ /*! \brief Change data pointer.
+ **
+ ** If the change is effective, former data are deleted.
+ */
+ void set_ptr(T* ptr)
{
- if (new_ptr == this->ptr_)
- return;
- T* old_ptr = this->ptr_;
- if (old_ptr != 0)
+ if (ptr == this->ptr_)
{
- assert(proxy_of()[old_ptr] == this);
- proxy_of().erase(old_ptr);
+ // nothing to be done
+ return;
+ }
+
+ if (this->ptr_ != 0)
+ {
+ invariant(proxy_of()[this->ptr_] == this);
+ proxy_of().erase(this->ptr_);
+ delete this->ptr_;
+ this->ptr_ = 0; // safety
};
- this->ptr_ = new_ptr;
- if (new_ptr != 0)
+
+ // same code as ctor:
+ if (ptr != 0)
{
- assert(proxy_of()[new_ptr] == 0);
- proxy_of()[new_ptr] = this;
- };
+ invariant(proxy_of()[ptr] == 0);
+ this->ptr_ = ptr;
+ proxy_of()[this->ptr_] = this;
+ }
+ else
+ this->ptr_ = 0;
}
+
+ /*! \brief Register a new holder.
+ **
+ ** \precondition Test that it is effectively a new holder.
+ */
void register_holder(const tracked_ptr<T>* holder)
{
- assert(holder != 0);
- assert(holders_.find(holder) == holders_.end());
+ precondition(holder != 0);
+ precondition(holders_.find(holder) == holders_.end());
holders_.insert(holder);
}
+
+ /*! \brief Unregister a holder.
+ **
+ ** If it is the last holder and if data is not null, data are
+ ** deleted. In that case, the return value (true) allows the
+ ** tracked_pointer to know that the proxy has to be deleted.
+ **
+ ** \precondition Test that it is effectively a holder.
+ ** \return True if data is deleted, false otherwise
+ */
+
bool unregister_holder(const tracked_ptr<T>* holder)
{
- assert(holder != 0);
- assert(holders_.size() > 0);
+ // "simple" tests:
+ precondition(holder != 0);
+ precondition(holders_.size() > 0);
- typename std::set<const tracked_ptr<T>*>::iterator e = holders_.find(holder);
- assert(e != holders_.end());
- holders_.erase(e);
+ // "main" test:
+ // note that the couple of "simple" tests above are subtests of the following one
+ typename std::set<const tracked_ptr<T>*>::iterator h = holders_.find(holder);
+ precondition(h != holders_.end());
- if (holders_.size() == 0)
+ holders_.erase(h);
+
+ if (holders_.size() == 0 && this->ptr_ != 0)
{
- proxy_of()[ptr_] = 0;
- delete ptr_;
- ptr_ = 0;
+ proxy_of()[this->ptr_] = 0;
+ delete this->ptr_;
+ this->ptr_ = 0; // safety
return true;
}
+
return false;
}
+
// procedures
typedef std::map<const T*, const tracked_ptr_proxy*> map_type;
static map_type& proxy_of()
{
- static map_type proxy_of_;
- return proxy_of_;
+ static map_type* proxy_of_ = new map_type;
+ return *proxy_of_;
}
friend
std::ostream& operator<<(std::ostream& ostr, const tracked_ptr_proxy& proxy)
{
- ostr << "[ptr=" << proxy.ptr_ << " holders=(";
+ ostr << "proxy " << &proxy << " [ptr=" << proxy.ptr_ << " holders=(";
typename std::set<const tracked_ptr<T>*>::const_iterator i = proxy.holders_.begin();
bool ok = i != proxy.holders_.end();
while (ok)
@@ -143,7 +199,7 @@
};
- } // end of namspace internal
+ } // end of namespace internal
@@ -154,155 +210,185 @@
{
public:
+ /*! \brief Mimics the behavior of op* for a pointer in the const case.
+ **
+ ** \invariant Pointer proxy exists.
+ ** \precondition Data exists (is not null).
+ */
const T& operator*() const
{
- assert(proxy_ != 0 and proxy_->ptr_ != 0);
+ invariant(proxy_ != 0);
+ precondition(proxy_->ptr_ != 0);
return *(proxy_->ptr_);
}
+ /*! \brief Mimics the behavior of op* for a pointer in the mutable case.
+ **
+ ** \invariant Pointer proxy exists.
+ ** \precondition Data exists (is not null).
+ */
T& operator*()
{
- assert(proxy_ != 0 and proxy_->ptr_ != 0);
+ invariant(proxy_ != 0);
+ precondition(proxy_->ptr_ != 0);
return *(proxy_->ptr_);
}
+ /*! \brief Mimics the behavior of op-> for a pointer in the const case.
+ **
+ ** \invariant Pointer proxy exists.
+ */
const T*const operator->() const
{
- assert(proxy_ != 0);
+ invariant(proxy_ != 0);
return proxy_->ptr_;
}
+ /*! \brief Mimics the behavior of op-> for a pointer in the mutable case.
+ **
+ ** \invariant Pointer proxy exists.
+ */
T*const operator->()
{
- assert(proxy_ != 0);
+ invariant(proxy_ != 0);
return proxy_->ptr_;
}
+ /// Coercion towards Boolean (for arithmetical tests).
operator bool() const
{
- return proxy_ != 0 and proxy_->ptr_ != 0;
+ invariant(proxy_ != 0);
+ return proxy_->ptr_ != 0;
}
- bool operator not() const
+ /// Negation (for arithmetical tests).
+ bool operator !() const
{
- return not bool(*this);
+ invariant(proxy_ != 0);
+ return ! bool(*this);
}
+ /// Comparison 'equal to' (for arithmetical tests).
bool operator==(int b) const
{
+ invariant(proxy_ != 0);
return bool(*this) == bool(b);
}
+ /// Comparison 'not equal to' (for arithmetical tests).
bool operator!=(int b) const
{
+ invariant(proxy_ != 0);
return bool(*this) != bool(b);
}
- // hook:
- const internal::tracked_ptr_proxy<T>* proxy() const { return proxy_; }
+ /// Hook that gives access to the data proxy.
+ const internal::tracked_ptr_proxy<T>* proxy() const { return this->proxy_; }
+ internal::tracked_ptr_proxy<T>* proxy() { return this->proxy_; }
- // ctors
- tracked_ptr() :
- proxy_(0)
- {
- invariant_();
- }
-
- tracked_ptr(T* ptr) :
+ /*! \brief Ctor.
+ **
+ ** Creates a proxy that knows the target data pointer. This
+ ** pointer can be null (0).
+ */
+ tracked_ptr(T* ptr = 0) :
proxy_(new internal::tracked_ptr_proxy<T>(ptr))
{
- proxy_->register_holder(this);
+ this->proxy_->register_holder(this);
invariant_();
}
- // shallow copy
+ /*! \brief Cpy ctor performs a shallow copy.
+ **
+ ** The data proxy of \a rhs is shared with the constructed
+ ** tracked_ptr.
+ */
tracked_ptr(const tracked_ptr& rhs) :
proxy_(rhs.proxy_)
{
- if (proxy_ != 0)
- proxy_->register_holder(this);
+ precondition(rhs.proxy_ != 0);
+ this->proxy_->register_holder(this);
invariant_();
}
- // assignment
+ /*! \brief Assignment operator with rhs being a tracked pointer.
+ **
+ ** The lhs proxy unregisters its data and registers the rhs data.
+ ** In the case of both pointers have the same value, no action is
+ ** performed and a warning is produced. The unregistration
+ ** process may desallocate data if the target pointer was the only
+ ** access to those data.
+ */
tracked_ptr& operator=(const tracked_ptr& rhs)
{
- invariant_();
- if (rhs == 0)
- return *this;
+ invariant(this->proxy_ != 0);
+ precondition(rhs.proxy_ != 0);
+
+ invariant_(); // safety
+
if (rhs.proxy_ == this->proxy_)
- return *this;
- if (this->release_proxy_())
- delete this->proxy_;
+ {
+ std::cerr << "warning: nothing done cause both objects share the same data!" << std::endl;
+ // FIXME: say more
+ // e.g.: ima1 = ima2; ima2 = ima1;
+ return *this;
+ }
+
+ if (this->proxy_->unregister_holder(this))
+ {
+ // the current 'tracked pointer' was the only access to
+ // some data (this->proxy_->ptr_); data has been
+ // desallocated, so it goes the same for the proxy:
+ delete this->proxy_;
+ }
+
this->proxy_ = rhs.proxy_;
this->proxy_->register_holder(this);
+
invariant_();
return *this;
}
+
+ /*! \brief Assignment operator with rhs being a data pointer.
+ **
+ ** This assignment just changes the pointed data.
+ */
tracked_ptr& operator=(T* ptr)
{
- if (proxy_ != 0)
- {
- assert(proxy_->holders_.size() <= 1);
- this->release_proxy_();
- }
- else
- proxy_ = new internal::tracked_ptr_proxy<T>(ptr);
- this->proxy_->register_holder(this);
+ invariant(this->proxy_ != 0);
+ this->proxy_->set_ptr(ptr);
return *this;
}
- // dtor
+ // Dtor.
+
~tracked_ptr()
{
- invariant_();
- if (release_proxy_())
- delete proxy_;
- proxy_ = 0;
- }
-
- // dangerous! (?)
-
- void reset_()
- {
- invariant_();
- if (proxy_ == 0 or proxy_->ptr_ == 0)
- return;
- T* ptr = proxy_->ptr_;
- std::set<const tracked_ptr<T>*>& holders = proxy_->holders_;
- typename std::set<const tracked_ptr<T>*>::iterator i;
- for (i = holders.begin(); i != holders.end(); ++i)
+ invariant(this->proxy_ != 0);
+ if (this->proxy_->unregister_holder(this))
{
- if (*i == this)
- continue;
- tracked_ptr<T>* holder = const_cast<tracked_ptr<T>*>(*i);
- holder->proxy_ = 0;
+ // the current 'tracked pointer' was the only access to
+ // some data (this->proxy_->ptr_); data has been
+ // desallocated, so it goes the same for the proxy:
+ delete this->proxy_;
}
- delete this->proxy_->ptr_;
- delete this->proxy_;
- this->proxy_ = 0;
+ this->proxy_ = 0; // safety
}
private:
+ /// Only attribute.
+
internal::tracked_ptr_proxy<T>* proxy_;
- bool release_proxy_()
- {
- invariant_();
- if (proxy_ == 0)
- return false;
- return proxy_->unregister_holder(this);
- }
-
void invariant_() const
{
if (proxy_ == 0)
@@ -313,9 +399,15 @@
assert((*i)->proxy_ == this->proxy_);
}
+ friend
+ std::ostream& operator<<(std::ostream& ostr, const tracked_ptr& ptr)
+ {
+ invariant(ptr.proxy_ != 0);
+ return ostr << "tracked_ptr " << &ptr << " --> " << *(ptr.proxy_);
+ }
};
+
-
} // end of namespace mlc
Index: metalic/mlc/any.hh
===================================================================
--- metalic/mlc/any.hh (revision 29)
+++ metalic/mlc/any.hh (working copy)
@@ -32,7 +32,7 @@
-// abrev
+// abbrev
#define any_mem(E) any <E, dispatch_policy::best_memory>
@@ -46,14 +46,13 @@
{
struct best_speed;
struct best_memory;
- struct compromise;
+ struct simple;
};
// any
- template <typename E,
- typename Dispatch_Policy = dispatch_policy::best_memory>
+ template <typename E, typename Dispatch_Policy = dispatch_policy::simple>
struct any;
@@ -71,12 +70,34 @@
precondition(exact_ptr != 0);
return *exact_ptr;
}
+
+ /// Assignment (op=).
+
+ any& operator=(const any& rhs)
+ {
+ // do nothing
+ // so that "this->exact_ptr" is unchanged
+ return *this;
+ }
+
+ /// Copy Ctor.
+
+ any(const any& rhs) :
+ exact_ptr(0) // safety
+ {
+ // this->exact_ptr is *not* copied
+ // its value has to be set in subclasses copy ctors.
+ }
+
protected:
any(E* exact_ptr) : exact_ptr(exact_ptr) {}
virtual ~any() {}
+
+ /// Only attribute.
E* exact_ptr;
};
+
template <typename E>
struct any__best_speed : public any<E, dispatch_policy::best_speed>
{
@@ -104,8 +125,8 @@
protected:
any() {}
- any(E* exact_ptr); // safety: w/o impl
- virtual ~any() {}
+ any(E* exact_ptr_does_not_exist_in_this_version); // safety
+ virtual ~any() {} // FIXME: virtual for a "best memory" version!?
};
template <typename E>
@@ -123,11 +144,22 @@
- (const char*)(void*)(&any_mem(E)::exact_obj);
- // "compromise" version of 'any'
+ // "simple" version of 'any'
template <typename E>
struct any <E,
- dispatch_policy::compromise>; // FIXME: not yet impled
+ dispatch_policy::simple>
+ {
+ E& exact() {
+ return *(E*)(void*)this;
+ }
+ const E& exact() const {
+ return *(const E*)(const void*)this;
+ }
+ protected:
+ any() {}
+ any(E* exact_ptr_does_not_exist_in_this_version); // safety
+ };
} // end of namespace mlc
