shared_object.hpp

Go to the documentation of this file.

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010 by Joel Andersson, Moritz Diehl, K.U.Leuven. All rights reserved.
 *
 *    CasADi 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 3 of the License, or (at your option) any later version.
 *
 *    CasADi 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 CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifndef SHARED_OBJECT_HPP
#define SHARED_OBJECT_HPP

#include "printable_object.hpp"
#include "casadi_exception.hpp"
#include <map>
#include <vector>

namespace CasADi{

// Forward declaration of internal class
class SharedObjectNode;

class SharedObject : public PrintableObject{
#ifndef SWIG
  template<class B> friend B shared_cast(SharedObject& A);
  template<class B> friend const B shared_cast(const SharedObject& A);
#endif // SWIG
  
  public:
#ifndef SWIG
    SharedObject();
    
    SharedObject(const SharedObject& ref);

    SharedObject clone() const;
    
    ~SharedObject();
    
    SharedObject& operator=(const SharedObject& ref);
    
    void assignNode(SharedObjectNode* node);
    
    void assignNodeNoCount(SharedObjectNode* node);
    
    const SharedObjectNode* get() const;

    SharedObjectNode* get();

    int getCount() const;
    
    void swap(SharedObject& other);

    SharedObjectNode* operator->();

    const SharedObjectNode* operator->() const;

    virtual void repr(std::ostream &stream) const;

    virtual void print(std::ostream &stream=std::cout) const;
    
    #endif // SWIG
    
    void init();

    bool isInit() const;
    
    void assertInit() const;
    
    bool isNull() const;

    virtual bool checkNode() const;
    
    void makeUnique(bool clone_members=true);
#ifndef SWIG
    void makeUnique(std::map<SharedObjectNode*,SharedObject>& already_copied, bool clone_members=true);
    
  private:
    SharedObjectNode *node;
    void count_up(); // increase counter of the node
    void count_down(); // decrease counter of the node
#endif // SWIG
};

#ifndef SWIG

class SharedObjectNode{
  friend class SharedObject;
  public:
  
  SharedObjectNode();

  SharedObjectNode(const SharedObjectNode& node);
  
  SharedObjectNode& operator=(const SharedObjectNode& node);
  
  virtual ~SharedObjectNode() = 0;

  virtual SharedObjectNode* clone() const=0;

  virtual void deepCopyMembers(std::map<SharedObjectNode*,SharedObject>& already_copied);

  int getCount() const;

  virtual void init();
  
  bool isInit() const;
  
  void assertInit() const;

  virtual void repr(std::ostream &stream) const;

  virtual void print(std::ostream &stream) const;

  protected:
    template<class B>
    B shared_from_this();

    template<class B>
    const B shared_from_this() const;

    bool is_init_;

  private:
    unsigned int count;
};

template<class B>
B shared_cast(SharedObject& A){
  
  SharedObjectNode* ptr = A.get();
  
  B ret;
  
  ret.assignNode(ptr);
      
  if(ptr && !ret.checkNode()) 
    ret.assignNode(0);

  return ret;
}

template<class B>
const B shared_cast(const SharedObject& A){
  SharedObject A_copy = A;
  return shared_cast<B>(A_copy);
}

template<class B>
bool is_a(const SharedObject& A){
  casadi_assert(!A.isNull());
  return !shared_cast<B>(A).isNull();
}

template<class A>
A deepcopy(const A& a){
  A ret = a;
  ret.makeUnique();
  return ret;
}

template<class A>
A deepcopy(const A& a, std::map<SharedObjectNode*,SharedObject>& already_copied){
  A ret = a;
  ret.makeUnique(already_copied);
  return ret;
}

template<class A>
std::vector<A> deepcopy(const std::vector<A>& a, std::map<SharedObjectNode*,SharedObject>& already_copied){
  std::vector<A> ret = a;
  for(typename std::vector<A>::iterator it=ret.begin(); it!=ret.end(); ++it){
    it->makeUnique(already_copied);
  }
  return ret;
}

// Template function implementations
template<class B>
B SharedObjectNode::shared_from_this(){
  B ret;
  ret.assignNode(this);
  
  // Assert that the object is valid
  casadi_assert(ret.checkNode());
  
  return ret;
}

template<class B>
const B SharedObjectNode::shared_from_this() const{
  B ret;
  ret.assignNode(const_cast<SharedObjectNode*>(this));
  
  // Assert that the object is valid
  casadi_assert(ret.checkNode());
  
  return ret;
}


#endif // SWIG


} // namespace CasADi


#endif // SHARED_OBJECT_HPP