/home/cypheon/dev/limiro/trunk/src/Question.h

// -*- C++ -*-
/* Copyright (C) 2007-2008 Johann Rudloff
 * License: GNU GPLv2 or later, see file "COPYING". No warranty of any kind! */

#ifndef _QUESTION_H_
#define _QUESTION_H_

#include <config.h>

#include <iostream>
#include <string>
#include <vector>

#include <libxml/parser.h>
#include <libxml/xmlwriter.h>
#include "lua/lua.hpp"

#include "utils.h"

namespace Limiro
{

class Result
{
public:
  Result(bool c, std::string ans="") {correct=c; correctAnswer=ans;};
  operator bool() {return correct;};

  bool correct;

  std::string correctAnswer;
};

class DynamicString
{
public:
  DynamicString();
  DynamicString(const std::string& source, bool parse=true);

  std::string bake(lua_State *L);
  bool isDynamic() const;

#ifdef DEBUG
  void print();
#endif

private:
  class DPart
  {
  public:
    enum PartType
    {
      TypeString,
      TypeScript,
      TypeExpression
    };

    DPart(const DPart& other);
    DPart(PartType type, const std::string& data);
    DPart operator+(const DPart& other);

    std::string toString(lua_State *L);
    PartType type() const {return m_type;};

#ifdef DEBUG
    void print() const;
#endif

  private:
    PartType m_type;
    std::string m_data;
  };
  void parse(const std::string& source);
  std::vector<DPart> m_parts;

};


class Question
{
public:
  enum Type
  {
    TypeUndefined = 0, 
    TypeSimple, 
    TypeMultipleChoice, 
    TypeFloat, 
    TypeYear, 
    TypeDate, 
  };
  Type getType() const {return m_type;};

  operator bool() const {return m_type != TypeUndefined;};
  bool isSimple() const {return m_type == TypeSimple;};
  bool isMultipleChoice() const {return m_type == TypeMultipleChoice;};
  bool isFloat() const {return m_type == TypeFloat;};
  bool isYear() const {return m_type == TypeYear;};
  bool isDate() const {return m_type == TypeDate;};

  virtual const std::string qText() const {return "";};
  virtual const std::string aText() const {return "";};
  virtual const std::vector<std::string> aList() const {return std::vector<std::string>();};

  virtual const Result checkAnswer(const std::string& answer) const = 0;

  virtual void writeXml(xmlTextWriterPtr writer) const = 0;

  virtual ~Question(){};

protected:
  Type m_type; 
};


class QuestionPattern
{
public:
  static QuestionPattern *fromXml(xmlNodePtr qNode);


  bool exhausted() const {return (m_num < 1);};

  virtual bool isDynamic() const = 0;


  virtual Question *bake() = 0;

  virtual ~QuestionPattern(){};

protected:
  static QuestionPattern *newQuestion(std::string type);
  void commonBuild(xmlNodePtr qNode);

  virtual bool build(xmlNodePtr qNode) = 0;

  std::string m_code; 
  int m_num; 
};



class SimpleQuestion : public Question
{
  friend class SimpleQuestionPattern;

public:
  SimpleQuestion() {m_type = TypeSimple;};
  virtual const std::string qText() const {return m_qText;};
  virtual const std::string aText() const {return m_aText;};

  virtual const Result checkAnswer(const std::string& answer) const;

  virtual void writeXml(xmlTextWriterPtr writer) const;

protected:
  std::string m_qText; 
  std::string m_aText; 
};

class SimpleQuestionPattern : public QuestionPattern
{
public:
  virtual bool isDynamic() const;
  virtual Question *bake();

  SimpleQuestionPattern() {};
  virtual ~SimpleQuestionPattern(){};

protected:
  virtual bool build(xmlNodePtr qNode);

  DynamicString m_qText; 
  DynamicString m_aText; 
};

class MultipleChoiceQuestion : public Question
{
  friend class MultipleChoiceQuestionPattern;

public:
  MultipleChoiceQuestion() {m_type = TypeMultipleChoice;};
  virtual const std::string qText() const {return m_qText;};
  virtual const std::string aText() const {return m_aList[m_answer];};
  virtual const std::vector<std::string> aList() const {return m_aList;};

  virtual const Result checkAnswer(const std::string& answer) const;

  virtual void writeXml(xmlTextWriterPtr writer) const;

protected:
  std::string m_qText; 
  std::vector<std::string> m_aList; 
  int m_answer; 
};

class MultipleChoiceQuestionPattern : public QuestionPattern
{
public:
  virtual bool isDynamic() const;
  virtual Question *bake();

  MultipleChoiceQuestionPattern() {};
  virtual ~MultipleChoiceQuestionPattern(){};

protected:
  virtual bool build(xmlNodePtr qNode);

  DynamicString m_qText; 
  std::vector<DynamicString> m_aList; 
  int m_answer; 
};


class YearQuestion : public SimpleQuestion
{
  friend class YearQuestionPattern;

public:
  YearQuestion() {m_type = TypeYear;};

  virtual const std::string aText() const {return utils::toString(m_aYear);};

  virtual const Result checkAnswer(const std::string& answer) const;

  virtual void writeXml(xmlTextWriterPtr writer) const;

protected:
  //std::string m_qText; ///< Fragetext
  int m_aYear; 
};

class YearQuestionPattern : public SimpleQuestionPattern
{
public:
  virtual Question *bake();

  YearQuestionPattern() {};
  virtual ~YearQuestionPattern(){};
};


class FloatQuestion : public Question
{
  friend class FloatQuestionPattern;

public:
  FloatQuestion() {m_type = TypeFloat;};
  virtual const std::string qText() const {return m_qText;};
  virtual const std::string aText() const {return (m_aMag + "," + m_aFrac);};

  virtual const Result checkAnswer(const std::string& answer) const;

  virtual void writeXml(xmlTextWriterPtr writer) const;

protected:
  std::string m_qText; 
  std::string m_aMag; 
  std::string m_aFrac; 
};

class FloatQuestionPattern : public QuestionPattern
{
public:
  virtual bool isDynamic() const;
  virtual Question *bake();

  FloatQuestionPattern() {};
  virtual ~FloatQuestionPattern(){};

protected:
  virtual bool build(xmlNodePtr qNode);

  DynamicString m_qText; 
  DynamicString m_aText; 
};


class DateQuestion : public SimpleQuestion
{
  friend class DateQuestionPattern;

public:
  DateQuestion() {m_type = TypeDate;};
  virtual const std::string aText() const {return m_aTextUser;};

  virtual const Result checkAnswer(const std::string& answer) const;

protected:
  std::string m_aTextUser; 
  std::string m_aText; 
};

class DateQuestionPattern : public SimpleQuestionPattern
{
public:
  virtual bool isDynamic() const;
  virtual Question *bake();

  DateQuestionPattern() {};
  virtual ~DateQuestionPattern(){};

protected:
  virtual bool build(xmlNodePtr qNode);

  DynamicString m_qText; 
  std::string m_aText; 
};

}

#endif // _QUESTION_H_

---