PP.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 1998 Pascal Vincent
// Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org


 

/* *******************************************************      
   * $Id: PP.h,v 1.7 2004/07/27 16:35:32 tihocan Exp $
   * AUTHORS: Pascal Vincent & Yoshua Bengio
   * This file is part of the PLearn library.
   ******************************************************* */


#ifndef SMART_POINTER_INC
#define SMART_POINTER_INC

#include <typeinfo>
#include "TypeTraits.h"
#include "CopiesMap.h"
#include "plerror.h"

namespace PLearn {
using namespace std;

class PPointable
{
 private:
  int refcount;

 public:
  inline PPointable()
    :refcount(0)
    {}

  inline PPointable(const PPointable& other)
    :refcount(0)
    {}    

  inline void ref() const
    { const_cast<PPointable*>(this)->refcount++; }

  inline void unref() const
    {
      const_cast<PPointable*>(this)->refcount--;
      if(refcount==0)
        delete this;
    }

  inline int usage() const
    { return refcount; }

  virtual ~PPointable() {}
};

template<class T>
class PP
{
 protected:
  T* ptr;

 public:

  inline PP<T>()
    :ptr(0)
    {}

  inline PP<T>(const T* the_ptr)
    {
      ptr = const_cast<T*>(the_ptr);
      if(ptr)
        ptr->ref();
    }

  inline PP<T>(const PP<T>& other)
    { 
      ptr = const_cast<T*>((T*)other);
      if(ptr)
        ptr->ref();
    }

  template <class U>
  explicit PP<T>(const PP<U>& other)
    {
      if(other.isNull())
        ptr = 0;
      else
        {
          ptr = static_cast<T*>((U*)other);

          ptr = dynamic_cast<T*>((U*)other);

          if (!ptr)
            PLERROR("In PP constructor from smart pointer "
                    "of other class (constructing %s from %s)",
                    typeid(T).name(),typeid(U).name());
          ptr->ref();
        }
    }
  
  inline bool isNull() const 
    { return ptr==0; }

  inline bool isNotNull() const 
    { return ptr!=0; }

  inline operator T*() const
    { return ptr; }

  inline T* operator->() const
    { return ptr; }
  
  inline T& operator*() const
    { return *ptr; }
  
  inline PP<T>& operator=(const T* otherptr)
    {
      if(otherptr!=ptr)
        {
          if(ptr)
            ptr->unref();
          ptr = const_cast<T*>(otherptr);
          if(ptr)
            ptr->ref();
        }
      return *this;
    }

  inline PP<T>& operator=(const PP<T>& other)
    { return operator=((T*)other); }

  inline ~PP()
    { 
      if(ptr)
        ptr->unref();
    }

};

  // deepCopyField //
  template <class T>
  inline void deepCopyField(PP<T>& field, CopiesMap& copies)
  {
    if (field) {
      // Check the usage of the object pointed by 'field': it should be > 1,
      // because 'field' is a shallow copy. However, it *could* happen that it
      // is only 1, if the object that pointed to the same object has been deleted.
      // Since this is usually not wanted, we display a warning if this happens.
      // Indeed, there is a risk of this causing trouble, because the 'copies' map
      // may contain invalid mappings refering to now deleted objects.
      if (field->usage() == 1)
        PLWARNING("In deepCopyField(PP<T>& field, ...) - The usage() of the underlying object is only 1, this is unusual");
      field = field->deepCopy(copies);
    }
  }

  template<class T>
  T* deepCopy(PP<T> source, CopiesMap& copies)
  { return deepCopy((T*)source, copies); }


  template<class T>
  inline T* deepCopy(PP<T> source)
  { 
    CopiesMap copies; 
    return deepCopy(source, copies);
  }


template<class T>
class TypeTraits< PP<T> >
{
public:
  static string name()
  { return string("PP< ") + TypeTraits<T>::name()+" >"; }

  static inline unsigned char little_endian_typecode()
  { return 0xFF; }

  static inline unsigned char big_endian_typecode()
  { return 0xFF; }
};

template <class A, class B>
class MultiMap : public PPointable
{
public:
  multimap<A,B> map;
};


} // end of namespace PLearn

#endif

---