/**
 * PANDA 3D SOFTWARE
 * Copyright (c) Carnegie Mellon University.  All rights reserved.
 *
 * All use of this software is subject to the terms of the revised BSD
 * license.  You should have received a copy of this license along
 * with this source code in a file named "LICENSE."
 *
 * @file functional
 * @author tobspr
 * @date 2016-11-01
 */

// This file, and all the other files in this directory, aren't
// intended to be compiled--they're just parsed by CPPParser (and
// interrogate) in lieu of the actual system headers, to generate the
// interrogate database.

#ifndef FUNCTIONAL_H
#define FUNCTIONAL_H

#include <stddef.h>

namespace std {

  // base (deprecated):
  template <class Arg, class Result> struct unary_function;
  template <class Arg1, class Arg2, class Result> struct binary_function;
 
  // reference_wrapper:
  template <class T> class reference_wrapper;

  // arithmetic operations:
  template <class T> struct plus;
  template <class T> struct minus;
  template <class T> struct multiplies;
  template <class T> struct divides;
  template <class T> struct modulus;
  template <class T> struct negate;
 
  // comparisons:
  template <class T> struct equal_to;
  template <class T> struct not_equal_to;
  template <class T> struct greater;
  template <class T> struct less;
  template <class T> struct greater_equal;
  template <class T> struct less_equal;
 
  // logical operations:
  template <class T> struct logical_and;
  template <class T> struct logical_or;
  template <class T> struct logical_not;
 
  // bitwise operations:
  template <class T> struct bit_and;
  template <class T> struct bit_or;
  template <class T> struct bit_xor;
 
  // negators:
  template <class Predicate> class unary_negate;
  template <class Predicate>  class binary_negate;
 
  // bind:
  template<class T> struct is_bind_expression;
  template<class T> struct is_placeholder;

  namespace placeholders {
    // M is the implementation-defined number of placeholders
    // (8 should be enough for interrogate)
    extern char _1;
    extern char _2;
    extern char _3;
    extern char _4;
    extern char _5;
    extern char _6;
    extern char _7;
    extern char _8;
  }
 
  // binders (deprecated):
  template <class Fn> class binder1st;
  template <class Fn> class binder2nd;

  // adaptors (deprecated):
  template <class Arg, class Result> class pointer_to_unary_function;
  template <class Arg1, class Arg2, class Result>
    class pointer_to_binary_function;
 
  // adaptors (deprecated):
  template<class S, class T> class mem_fun_t;
  template<class S, class T, class A> class mem_fun1_t;
  template<class S, class T> class mem_fun_ref_t;
  template<class S, class T, class A> class mem_fun1_ref_t;
  template <class S, class T> class const_mem_fun_t;
  template <class S, class T, class A> class const_mem_fun1_t;
  template <class S, class T> class const_mem_fun_ref_t;
  template <class S, class T, class A> class const_mem_fun1_ref_t;
 

  // polymorphic function wrappers:
  class bad_function_call;

  // hash function base template:
  template <class T> struct hash;
 
  // Hash function specializations
  template <> struct hash<bool>;
  template <> struct hash<char>;
  template <> struct hash<signed char>;
  template <> struct hash<unsigned char>;
  template <> struct hash<char16_t>;
  template <> struct hash<char32_t>;
  template <> struct hash<wchar_t>;
  template <> struct hash<short>;
  template <> struct hash<unsigned short>;
  template <> struct hash<int>;
  template <> struct hash<unsigned int>;
  template <> struct hash<long>;
  template <> struct hash<long long>;
  template <> struct hash<unsigned long>;
  template <> struct hash<unsigned long long>;
  template <> struct hash<float>;
  template <> struct hash<double>;
  template <> struct hash<long double>;
  template<class T> struct hash<T*>;
   
  template <class T> class reference_wrapper {
  public :
    // types
    typedef T type;
    typedef void   result_type;      // not always defined
    typedef void argument_type;    // not always defined
    typedef void  first_argument_type;  // not always defined
    typedef void  second_argument_type; // not always defined
  };

  template<class T> struct is_bind_expression {};
  // : integral_constant<bool, true> {};

  class bad_function_call : public std::exception {};

  // template<class> class function; // undefined
   
  template< class R, class... ArgTypes >
  class function {
  public:
    typedef R result_type;
  };

}


#endif