BonTypes.hpp

Go to the documentation of this file.

#ifndef __BonTypes_H_
#define __BonTypes_H_
#include<vector>
#include "CoinSmartPtr.hpp"
 
namespace Bonmin {
template<typename T>
class vector : public std::vector<T>{
public:
  vector(): std::vector<T>(){}
  vector(size_t n, const T& v): std::vector<T>(n,v){}
  vector(const vector<T>& other): std::vector<T>(other){}
  vector(const std::vector<T>& other): std::vector<T>(other){}
  vector(size_t n): std::vector<T>(n){}
  vector<T>& operator=(const vector<T>& other){
     std::vector<T>::operator=(other);
     return (*this);}

  vector<T>& operator=(const std::vector<T>& other){
     return std::vector<T>::operator=(other);
     return (*this);}

inline T* operator()(){
  return &(*std::vector<T>::begin());
}

inline const T* operator()() const {
  return &(*std::vector<T>::begin());
}
};
 
//structure to store an object of class X in a Coin::ReferencedObject
template<class X>
struct SimpleReferenced : public Coin::ReferencedObject {
 X object;
 
 const X& operator()() const{
   return object;}
 
 X& operator()() {
   return object;}
 
};
//structure to store a pointer to an object of class X in a 
// Coin::ReferencedObject
template<class X>
struct SimpleReferencedPtr : public Coin::ReferencedObject {
 X * object;
 
 SimpleReferencedPtr():
   object(NULL){}
 
 ~SimpleReferencedPtr(){
   delete object;}
 
 const X& operator()() const{
   return *object;}
 
 X& operator()() {
   return *object;}
 
 const X* ptr() const{
    return object;}
 
 X* ptr(){
    return object;}
};
 
template <class X>
SimpleReferenced<X> * make_referenced(X other){
  SimpleReferenced<X> * ret_val = new SimpleReferenced<X>;
  ret_val->object = other;
  return ret_val;
}
template <class X>
SimpleReferencedPtr<X> * make_referenced(X* other){
  SimpleReferencedPtr <X> * ret_val = new SimpleReferencedPtr<X>;
  ret_val->object = other;
  return ret_val;
}
 
 
}
#endif