Alphabet.h

Go to the documentation of this file.

// Contents: Definitions of Alphabet related  classes
//
// Principal Author:   Alexei Miasnikov
// Copyright (C) 2005
//
// Status: in progress
//
// Revision History:
//

#ifndef _ALPHABET_H_
#define _ALPHABET_H_

#include <iostream>
#include <vector>
#include <string>
//#include "Word.h"
#include "Parser.h"
#include <stdlib.h>
#include <sstream>

using namespace std;

class Word;

/**********************************************************
 *
 *   ALPHABET INTERFACE
 *
 ***********************************************************/

class Alphabet
{
 public:
  virtual int getNum( const string& letter )const = 0;
  
  virtual string getLetter( int index )const = 0;
  
  void printWord( ostream& out, const Word& w )const;
  
  Word readWord( istream& in )const;
  
  void printVector( ostream& out, const vector<Word>& v )const;
  
  vector<Word> readVector( istream& in )const;
};

/**********************************************************
 *
 *  FINITE ALPHABET
 *
 ***********************************************************/


class FiniteAlphabet : public Alphabet
{
 public:
  FiniteAlphabet(): theLetters( 0 ) { }

  FiniteAlphabet(int r): theLetters( r ) 
    {
      for (int i=0;i<r;i++){
        stringstream ss;
        ss << "x" << i+1 << flush;
        theLetters[i] = ss.str();
      }
    }

  FiniteAlphabet(const vector<string>& letters): theLetters( letters ) { }
  
  int size()const { return theLetters.size(); }
  

  int getNum( const string& letter ) const;
  

  string getLetter( int index ) const;


  const vector<string>& getLetters(  ) const;

  friend ostream& operator << ( ostream& out, const FiniteAlphabet& a ){
    if (a.theLetters.size() == 0)
      out << "{ }" << flush;
    else {
      out << "{ ";
      for ( int i=0;i<a.theLetters.size()-1;i++)
        out << a.theLetters[i] << ", ";
      out << a.theLetters[a.theLetters.size()-1] << " }" << flush;
    }
    return out;
  }
  
  friend istream& operator >> ( istream& in,  FiniteAlphabet& a ){
    AParser ap( in );
    ap.parse();
    
    a = ap.getAlphabet();
    return in;
  }

 private:

  friend class AlphabetFlexLexer;

  void addGenerator( const string& g) { theLetters.push_back( g ); }
  vector<string> theLetters; 
};


/**********************************************************
 *
 *  INFINITE ALPHABET
 *
 ***********************************************************/
class InfiniteAlphabet : public Alphabet
{
 public:

  InfiniteAlphabet(string pref  = string("x")): thePrefix( pref ) { }
  

  int getNum( const string& letter ) const;
  
  

  string getLetter( int index ) const;

  static InfiniteAlphabet defaultAlphabet;
  
  friend ostream& operator << ( ostream& out, const InfiniteAlphabet& a ){
    out << "{ ";
    for ( int i=1;i<4;i++)
      out << a.thePrefix << i <<  ", ";
    out << "... }" << flush;
    
    return out;
  }
  
 private:
  string thePrefix; 
};


void readFPPresentation( istream& in );


#endif