Labels.h

 
#pragma once
 
#if defined(Labels_RECURSES)
#error Recursive header files inclusion detected in Labels.h
#else // defined(Labels_RECURSES)
 
#define Labels_RECURSES
 
#if !defined Labels_h
 
#define Labels_h
 
// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CUnsignedNumber.h"
#include "DGtal/kernel/CIntegralNumber.h"
 
namespace DGtal
{
 
  // template class Labels
  template <unsigned int L, typename TWord = DGtal::uint8_t>
  class Labels
  {
    BOOST_STATIC_ASSERT(( L >= 1 ));
    BOOST_CONCEPT_ASSERT(( concepts::CUnsignedNumber<TWord> ));
    BOOST_CONCEPT_ASSERT(( concepts::CIntegralNumber<TWord> ));
 
  public:
    typedef TWord Word;
    typedef Labels<L, Word> Self;
    typedef unsigned int Label;
    typedef Label SizeType;
 
#define __DGTAL_WORD_NBDIGITS ( sizeof( Word ) * 8 )
#define __DGTAL_LABELS_NBWORDS ( (L-1) / __DGTAL_WORD_NBDIGITS + 1 )
#define __DGTAL_LABEL_WORD_INDEX( label ) ( label / __DGTAL_WORD_NBDIGITS )
#define __DGTAL_LABEL_DIGIT_INDEX( label ) ( label % __DGTAL_WORD_NBDIGITS )
 
  protected:
 
    Word myLabels[ __DGTAL_LABELS_NBWORDS ];
 
    static SizeType _word( Label l );
    static SizeType _digit( Label l );
    static Word _mask( Label l );
 
  public:
    class ConstEnumerator {
    public:
      typedef ConstEnumerator Self;
      typedef Label Value;
      typedef const Value* Pointer;
      typedef const Value& Reference;
      typedef std::ptrdiff_t DifferenceType; 
 
      // ----------------------- std types ----------------------------------
      typedef Value value_type;
      typedef std::size_t size_type;
      typedef DifferenceType difference_type;
      typedef Pointer pointer;
      typedef Reference reference;
      typedef std::forward_iterator_tag iterator_category;
 
    private:
      const Word* myWordAddress;  
      Label myWordLabel;
      Label myLabel;    
      Word myWord;      
      
    public:
      ~ConstEnumerator();
 
      ConstEnumerator();
 
      ConstEnumerator( const Word* address, SizeType firstWord );
 
      ConstEnumerator( const ConstEnumerator & other );
 
      Self & operator= ( const Self & other );
      
      Reference operator*() const;
     
      Pointer operator->() const;
      
      Self& operator++();      
      Self operator++( int );
    
      bool operator==( const Self & other ) const;
      
      bool operator!=( const Self & other ) const;
 
    };
 
    typedef ConstEnumerator ConstIterator;
    typedef ConstIterator const_iterator;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~Labels();
 
    Labels();
 
    Labels ( const Self & other );
 
    Self & operator= ( const Self & other );
 
    bool test( Label l ) const;
 
    // bitset<N>& set ( );
    // bitset<N>& reset ( );
 
    Self& set ( Label l, bool val = true );
 
    Self& reset( Label l );
 
    Self& flip( Label l );
 
    Self& reset();
 
    SizeType count() const;
 
    static SizeType size();
 
    void getLabels( std::vector<Label> & labels ) const;
 
    SizeType index( Label l ) const;
 
    ConstIterator begin() const;
 
    ConstIterator end() const;
    
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class Labels
 
 
  template <unsigned int L, typename TWord>
  std::ostream&
  operator<< ( std::ostream & out, const Labels<L, TWord> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/base/Labels.ih"
 
//                                                                           //
 
#endif // !defined Labels_h
 
#undef Labels_RECURSES
#endif // else defined(Labels_RECURSES)