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