#pragma once
#ifndef x12C0DF50_B9FE_11d2_A864_00105A0D0235
#define x12C0DF50_B9FE_11d2_A864_00105A0D0235

/*
 * Copyright (c) 1998 - 1999  Spokane Software Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software and
 * its documentation for any purpose is hereby granted without fee, provided
 * that the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in any supporting
 * documentation.  Spokane Software Systems makes no representations about
 * the suitability of this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 *
 */

// Compile time ASSERT, generates compilation error for false argument
#define CASSERT(x) \
typedef int x2543F841_A0B2_11d2_AFDF_00105A0D0235[(x) ? 1 : -1];

// Determine the number of elements in an array.
#define countof(a) \
(sizeof(::sss::i::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)

#define SSS_TRY try
#define SSS_UNWIND(action) catch ( ... ) { action; throw; }

// According to the standard, wchar_t is a keyword, but for now we
// have to do it the Microsoft way
#if _MSC_VER <= 1200
#ifndef _WCHAR_T_DEFINED
typedef unsigned short wchar_t;
#define _WCHAR_T_DEFINED
#endif
#endif   // _MSC_VER

namespace sss {

namespace i {

template<typename T>
void countof_validate(T* const, T* const*)
{
}

template<typename T>
int countof_validate(const void*, T)
{
}

}  // namespace i

namespace rel_ops {

template<typename T>
inline bool operator!=(const T& x, const T& y)
{
   return !(x == y);
}

template<typename T>
inline bool operator>(const T& x, const T& y)
{
   return y < x;
}

template<typename T>
inline bool operator<=(const T& x, const T& y)
{
   return !(y < x);
}

template<typename T>
inline bool operator>=(const T& x, const T& y)
{
   return !(x < y);
}

}  // namespace rel_ops

template<typename X, typename Y>
class pair {
   typedef pair<X, Y> self;
public:
   typedef X first_type;
   typedef Y second_type;

   pair() : first(X()), second(Y())
   {
   }

   template<typename U, typename V>
   pair(const U& first, const V& second) : first(first), second(second)
   {
   }

   template<typename U, typename V>
   pair(const pair<U, V>& p) : first(p.first), second(p.second)
   {
   }

   template<>
   pair(const pair<X, Y>& p) : first(p.first), second(p.second)
   {
   }

   template<typename U, typename V>
   self& operator=(const pair<U, V>& p)
   {
      first = p.first;
      second = p.second;
      return *this;
   }

   template<>
   self& operator=(const pair<X, Y>& p)
   {
      first = p.first;
      second = p.second;
      return *this;
   }

   X first;
   Y second;
};

template<typename X, typename Y>
inline bool operator==(const pair<X, Y>& x, const pair<X, Y>& y)
{
   return x.first == y.first && x.second == y.second;
}

template<typename X, typename Y>
inline bool operator!=(const pair<X, Y>& x, const pair<X, Y>& y)
{
   return !(x == y);
}

template<typename X, typename Y>
inline bool operator<(const pair<X, Y>& x, const pair<X, Y>& y)
{
   return x.first < y.first || !(y.first < x.first) && x.second < y.second;
}

template<typename X, typename Y>
inline bool operator>(const pair<X, Y>& x, const pair<X, Y>& y)
{
   return y < x;
}

template<typename X, typename Y>
inline bool operator<=(const pair<X, Y>& x, const pair<X, Y>& y)
{
   return !(y < x);
}

template<typename X, typename Y>
inline bool operator>=(const pair<X, Y>& x, const pair<X, Y>& y)
{
   return !(x < y);
}

template<typename X, typename Y>
inline pair<X, Y> make_pair(const X& x, const Y& y)
{
   return pair<X, Y>(x, y);
}

// I thought pair was obnoxious, until I actually had need for a triple.
// You could continue this indefinately, but it would get rediculous.
template<typename X, typename Y, typename Z>
class triple : public pair<X, Y> {
   typedef pair<X, Y> base;
public:
   typedef Z third_type;

   triple() : base(X(), Y()), third(Z())
   {
   }

   template<typename U, typename V, typename W>
   triple(const U& first, const V& second, const W& third)
      : base(first, second), third(third)
   {
   }

   template<typename U, typename V, typename W>
   triple(const triple<U, V, W>& t)
      : base(t), third(t.third)
   {
   }

   template<typename U, typename V, typename W>
   triple& operator=(const triple<U, V, W>& t)
   {
      first = t.first;
      second = t.second;
      third = t.third;
      return *this;
   }

   friend inline bool operator<(const triple& x, const triple& y)
   {
      return static_cast<const base&>(x) < static_cast<const base&>(y) ||
          !(static_cast<const base&>(x) < static_cast<const base&>(y)) &&
          x.third < y.third;
   }

   Z third;
};

template<typename X, typename Y, typename Z>
inline bool operator==(const triple<X, Y, Z>& x, const triple<X, Y, Z>& y)
{
   return x.first == y.first && x.second == y.second && x.third == y.third;
}

template<typename X, typename Y, typename Z>
inline bool operator!=(const triple<X, Y, Z>& x, const triple<X, Y, Z>& y)
{
   !(x == y);
}

template<typename X, typename Y, typename Z>
inline bool operator>(const triple<X, Y, Z>& x, const triple<X, Y, Z>& y)
{
   return y < x;
}

template<typename X, typename Y, typename Z>
inline bool operator<=(const triple<X, Y, Z>& x, const triple<X, Y, Z>& y)
{
   return !(y < x);
}

template<typename X, typename Y, typename Z>
inline bool operator>=(const triple<X, Y, Z>& x, const triple<X, Y, Z>& y)
{
   return !(x < y);
}

template<typename X, typename Y, typename Z>
inline triple<X, Y, Z> make_triple(const X& x, const Y& y, const Z& z)
{
   return triple<X, Y, Z>(x, y, z);
}

template<typename T, int w, int x, int y, int z>
class static_object {
public:
   static_object();
   ~static_object();

   operator T&() const throw();

private:
   static unsigned space[(sizeof(T) + sizeof(unsigned) - 1) / 
                                                            sizeof(unsigned)];
   static unsigned nRefs;
};

template<typename T, int w, int x, int y, int z>
inline static_object<T, w, x, y, z>::static_object()
{
   if ( !nRefs++ ) {
      new(space) T();
   }
}

template<typename T, int w, int x, int y, int z>
inline static_object<T, w, x, y, z>::~static_object()
{
   if ( !--nRefs ) {
      reinterpret_cast<T*>(space)->~T();
   }
}

template<typename T, int w, int x, int y, int z>
inline static_object<T, w, x, y, z>::operator T&() const throw()
{
   return *reinterpret_cast<T*>(space);
}

template<typename T, int w, int x, int y, int z>
unsigned static_object<T, w,x,y,z>::space[(sizeof(T) + sizeof(unsigned) - 1) /
                                                            sizeof(unsigned)];

template<typename T, int w, int x, int y, int z>
unsigned static_object<T, w, x, y, z>::nRefs;

struct static_init_t {
};

}  // namespace sss

/*
 * Copyright (c) 1996,1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

#endif   // x12C0DF50_B9FE_11d2_A864_00105A0D0235