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 Data ------------------------------
  private:
    // ------------------------- Private Data --------------------------------
  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)