/* ---------------------------------------------------- */
/* This is a C-style comment, nothing particular to say */
/* but here we are.                                     */
/*                                                      */
/*                                                      */
/* -----------------------------------------------------*/

#include <iosfwd>
#include <list>
#include <map>
#include <string>

using namespace std;

using std::string;
using std::list;

#define ONE 1
#if defined(ONE)
#define TWO 2
#endif

typedef map<string, string> map_of_strings_t;

// -------------------------------------------------
// This is a C++ style comment.  Once again, nothing 
// particular to say but here we are!
// -------------------------------------------------

// a class declaration, typically found in .H files
class JustABaseClass
{

public: // public members

  int somePublicInt;
  string somePublicString;
  std::string somePublicStringWithScopeResolution;

  list<string> aListOfStrings;

  JustABaseClass(); // a constructor declaration
  virtual JustABaseClass(); // a destructor declaration

protected: // protected members


private: // private members

  // pure virtual declaration
  virtual int somePureVirtualMethod() = 0;

  // virtual declaration (expects implementation)
  virtual int someVirtualMethod(); 

  // const accessor declaration
  int getSomeInt() const; 

  // mutator declaration with value passed by const reference
  int setSomeString(const std::string &value); 

};

// Now for a bit of implementation, typically 
// found in .cpp or .cc or .cxx files.

JustABaseClass::JustABaseClass()
{
  // insert constructor code here...
}

JustABaseClass:~JustABaseClass()
{
  // insert destructor code here...
}

int JustABaseClass::getSomeInt()
{
  return somePublicInt;
}

int JustABaseClass::setSomeString(const std::string &value)
{
  somePublicString = value;
}

// And now for some more odd template stuff...

// a free template method

template <typename C>
int split(C &container, const std::string &data)
{
  // implement some code to parse data and add data 
  // elements to container ...
}

//* comment this line only
int JustABaseClass::setSomeString(const std::string &value)
{
  somePublicString = value;
}
//*/

/* comment everything here
int JustABaseClass::setSomeString(const std::string &value)
{
  somePublicString = value;
}
//*/

///* comment this line only
int JustABaseClass::setSomeString(const std::string &value)
{
  somePublicString = value;
}
//*/

// Hey emacs, this is a -*- C++ -*- file
#ifndef _STACK_H
#define _STACK_H

#include <stdexcept>
using namespace std;

template <typename T, int max> class Stack {
public:
    // C'Tor for empty stacks
    Stack() throw() {
        top = 0;
    }

    // Add t to the top of the stack
    void push(T t) {
        if(isfull())
            throw overflow_error("Stack overflow!");
        contents[top++] = t;
    }

    // Remove and return the top of the stack
    T pop(){
        if(isempty())
            throw underflow_error("Stack underflow!");
        return contents[--top];
    }
    
    // Will push() succeed?
    bool isfull(){
        return top>= max;
    }

    // Will pop() succeed?
    bool isempty(){
        return top==0;
    }
private:
    int top;
    T contents[max];
    
};

#endif