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"
#include "DGtal/arithmetic/ModuloComputer.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)