doi.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */

#ifndef CARTODATA_ROI_DOI_H
#define CARTODATA_ROI_DOI_H

#include <cartobase/object/object_d.h>
#include <cartodata/wip/roi/roi.h>

#define DECLARE_VIRTUAL_GENERIC_OBJECT_TYPE( T ) \
template <> \
struct GenericObjectTypeDeclared< T > \
{ \
    static inline void check() {}; \
}; \
template <> \
void DictionaryInterface::setProperty( const std::string &key, \
                                       T const &value ); \
template <> \
bool DictionaryInterface::getProperty( const std::string &key, T &value ) const; \
extern template class TypedObject< T >; \
extern template class ReferenceObject< T >; \
extern template class PointerObject< T >; \
extern template \
T const &GenericObject::value< T >() const; \
extern template \
T &GenericObject::value< T >(); \
template <> \
bool GenericObject::value( T &dest ) const; \
template <> \
void GenericObject::setValue( T const & x ); \
extern template bool DictionaryInterface:: \
getProperty( const std::string &, T &  ) const; \
extern template void DictionaryInterface:: \
setProperty( const std::string &, T const & ); \


namespace carto {


  //------------------//
 //  RcptrObject<T>  //
//------------------//

// This class has nthing to do here, it should go in object.h.
// It is just for testing without compiling everything.
template <typename T>
class RcptrObject : public TypedObject<T>
{
public:
  inline RcptrObject( T &x );
  virtual ~RcptrObject();
  virtual T &getValue();
  
  virtual Object clone() const;
  
private:

  mutable rc_ptr<T> _pvalue;
};


  //--------------------//
 //  RcptrObject<T>  //
//--------------------//

//-----------------------------------------------------------------------------
template <typename T>
inline RcptrObject<T>::RcptrObject( T &x ) : _pvalue( &x )
{
}


  //----------------//
 //  DiscreteDOI   //
//----------------//

class DiscreteDOI : public virtual RCObject, virtual public IterableInterface
{
public:
  virtual ~DiscreteDOI();

  virtual Object objectIterator() const = 0;
  virtual Object valueAt( const Site &site ) const;

};

// DECLARE_VIRTUAL_GENERIC_OBJECT_TYPE( DiscreteDOI );

#if 0
#define T DiscreteDOI
template <>
struct GenericObjectTypeDeclared< T >
{
    static inline void check() {};
};
template <>
void DictionaryInterface::setProperty( const std::string &key,
                                       T const &value );
template <>
bool DictionaryInterface::getProperty( const std::string &key, T &value ) const;
template <>
bool GenericObject::value( T &dest ) const;
template <>
void GenericObject::setValue( T const & x );
extern template class TypedObject< T >;
extern template class ReferenceObject< T >;
extern template class PointerObject< T >;
extern template
T const &GenericObject::value< T >() const;
extern template
T &GenericObject::value< T >();
extern template
bool GenericObject::value( T &dest ) const;
extern template
void GenericObject::setValue( T const & x );
extern template bool DictionaryInterface::
getProperty( const std::string &, T &  ) const;
extern template void DictionaryInterface::
setProperty( const std::string &, T const & );
#undef T
#endif


  //-------------------//
 //  NumberIterator   //
//-------------------//

class NumberIterator : public virtual RCObject, virtual public IteratorInterface
{
  Object currentValue() const;
  virtual double currentNumber() const = 0;
};

// DECLARE_VIRTUAL_GENERIC_OBJECT_TYPE( NumberIterator );


  //----------------------//
 //  DiscreteNumberDOI   //
//----------------------//

class DiscreteNumberDOI : public DiscreteDOI
{
  virtual Object objectIterator() const;
  virtual Object valueAt( const Site &site ) const;
  virtual NumberIterator *numberIterator() const = 0;
  virtual double numberAt( const Site &site ) const;
};

// DECLARE_VIRTUAL_GENERIC_OBJECT_TYPE( DiscreteNumberDOI );



} // namespace carto

#endif // ifndef CARTODATA_ROI_DOI_H