/home/ug/devel/kombilo-py-dev/kombilo/libkombilo/sgfparser.h

Go to the documentation of this file.

#ifndef _SGFPARSER_H_
#define _SGFPARSER_H_

#include <string>
#include <vector>
#include <utility>
#include <stack>
#include <map>
using namespace std;


class SGFError {
  public:
    SGFError();
};

class ExtendedMoveNumber {
  public:
    int length;
    int* data; // "even" entries: go right, "odd" entries: go down in game tree.

    ExtendedMoveNumber();
    ExtendedMoveNumber(int LENGTH, int* DATA);
    ExtendedMoveNumber(int D);
    ExtendedMoveNumber(const ExtendedMoveNumber& emn);
    ~ExtendedMoveNumber();

    ExtendedMoveNumber& operator=(const ExtendedMoveNumber& emn);
    void next();
    void down() throw(SGFError);
    int total_move_num();
    // void down();
};


char* SGFescape(const char* s);

class Cursor;

class PropValue {
  public:
    PropValue(std::string IDC, std::vector<std::string>* PV);
    PropValue(const PropValue& pval);
    ~PropValue();
    std::string IDcomplete;
    std::vector<std::string>* pv;
};

class Node {
  public:
    Node* previous;
    Node* next;
    Node* up;
    Node* down;
    int numChildren;
    std::string SGFstring;
    int parsed;
    std::vector<std::string> gpv(const string& prop);
    std::vector<std::string>* get_property_value(const string& prop);
    void set_property_value(const string& IDcomplete, vector<string> propValue) throw(SGFError);  
    void add_property_value(const string& IDcomplete, vector<string> propValue) throw(SGFError);  
    void del_property_value(const string& IDcomplete) throw(SGFError);  // delete data[ID]
    vector<string> keys();

    int posyD; // used when displaying SGF structure graphically as a tree

    Node(Node* prev, char* SGFst) throw(SGFError);
    ~Node();
    ExtendedMoveNumber get_move_number();
    void parseNode() throw(SGFError);
    static int sloppy;
    int level;
  private:
    std::map<std::string, PropValue> data; // use get_property_value to access this

  friend class Cursor;
};

typedef char* char_p;

std::vector<std::string>* parseRootNode(Node* n, std::vector<std::string>* tags) throw(SGFError);

class Cursor {
  public:
    Cursor(const char* sgf, int sloppy) throw(SGFError);
    ~Cursor();

    int atStart;
    int atEnd;
    int height;
    int width;
    Node* root;
    Node* currentN;
    int posx;
    int posy;

    void parse(const char* s) throw(SGFError);
    void game(int n) throw(SGFError); 
    Node* next(int n=0) throw(SGFError); 
    Node* previous() throw(SGFError);
    Node* getRootNode(int n) throw(SGFError);
    char* outputVar(Node* node);
    char* output();
    void add(char* st);
    void delVariation(Node* node);
    void setFlags();  

  protected:
    void delVar(Node* node);
    void deltree(Node* node);

};

std::string nodeToString(std::map<std::string, PropValue >& data) throw(SGFError);
// char* rootNodeToString(PyObject* data);

#endif