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"

namespace DGtal
{

  // template class Labels
  template <unsigned int L, typename TWord = DGtal::uint8_t>
  class Labels
  {
    BOOST_STATIC_ASSERT(( L >= 1 ));
    // BOOST_CONCEPT_ASSERT(( CUnsignedInteger<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; //< only positive offsets allowed.

      // ----------------------- 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;  //< current address of word
      Label myWordLabel;//< index of first label of the current word.
      Label myLabel;    //< current label
      Word myWord;      //< current word (modified until 0).
      
    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)