OrderedAlphabet.h

#pragma once

#if defined(OrderedAlphabet_RECURSES)
#error Recursive header files inclusion detected in OrderedAlphabet.h
#else // defined(OrderedAlphabet_RECURSES)

#define OrderedAlphabet_RECURSES

#if !defined OrderedAlphabet_h

#define OrderedAlphabet_h

// Inclusions
#include <iostream>
#include <string>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/NumberTraits.h"

namespace DGtal
{

  // class OrderedAlphabet
  class OrderedAlphabet
  {
    // ----------------------- Standard types ------------------------------
  public:

    typedef int Integer;
     
    typedef unsigned int index_t;

    typedef unsigned int size_t;

    // ----------------------- Standard services ------------------------------
  public:

    ~OrderedAlphabet();

    OrderedAlphabet( char first, unsigned int nb );

    std::string orderedAlphabet() const;

    void shiftLeft();

    void shiftRight();

    void reverse();

    void reverseAround12();
    
    unsigned int order( char c ) const;

    char letter( unsigned int i ) const;

    bool less( char c1, char c2 ) const;

    bool lessOrEqual( char c1, char c2 ) const;

    bool equal( char c1, char c2 ) const;

    // ----------------------- word services ------------------------------
  public:

    void firstLyndonFactor( size_t & len, size_t & nb,
          const std::string & w, 
          index_t s, index_t e ) const;


    void firstLyndonFactorMod( size_t & len, size_t & nb,
             const std::string & w, 
             index_t s, index_t e ) const;


    bool duvalPP( size_t & len, size_t & nb,
      const std::string & w, 
      index_t s, index_t e
      ) const;

    bool duvalPPMod( size_t & len, size_t & nb,
        const std::string & w, 
        index_t s, index_t e ) const;
    bool duvalPPtoDSS( size_t & len, size_t & nb,
      unsigned int & n1,  unsigned int & n2,
      unsigned int & Lf1, unsigned int & Lf2,
      const std::string & w, 
      index_t s, index_t e
      ) const;



    // ----------------------- MLP services -----------------------------------
  public:

    size_t nextEdge( size_t & nb_a1, size_t & nb_a2,
         std::string & w, index_t & s, bool & cvx );


    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
    char myFirst;

    unsigned int myNb;

    unsigned int* myOrder;

    // ------------------------- Hidden services ------------------------------
  protected:

    OrderedAlphabet();

  private:

    OrderedAlphabet ( const OrderedAlphabet & other );

    OrderedAlphabet & operator= ( const OrderedAlphabet & other );

    // ------------------------- Internals ------------------------------------
  private:

  }; // end of class OrderedAlphabet


  std::ostream&
  operator<< ( std::ostream & out, const OrderedAlphabet & object );


} // namespace DGtal


// Includes inline functions/methods if necessary.
#include "DGtal/base/OrderedAlphabet.ih"

//                                                                           //

#endif // !defined OrderedAlphabet_h

#undef OrderedAlphabet_RECURSES
#endif // else defined(OrderedAlphabet_RECURSES)