
/*

  KLayout Layout Viewer
  Copyright (C) 2006-2016 Matthias Koefferlein

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/


#ifndef _HDR_tlVariantUserClasses
#define _HDR_tlVariantUserClasses

#include "tlVariant.h"
#include "tlTypeTraits.h"
#include "tlString.h"
#include "tlAssert.h"

namespace tl
{

class EvalClass;

/**
 *  @brief A helper function to implement equal as efficiently as possible
 */
template<class T, class I>
bool _var_user_equal_impl (const T *a, const T *b, I);

template<class T>
bool _var_user_equal_impl (const T *a, const T *b, tl::true_tag)
{
  return *a == *b;
}

template<class T>
bool _var_user_equal_impl (const T *a, const T *b, tl::false_tag)
{
  tl_assert (false);
}

/**
 *  @brief A helper function to implement clone as efficiently as possible
 */
template<class T, class I>
T *_var_user_clone_impl (const T *a, I);

template<class T>
T *_var_user_clone_impl (const T *a, tl::true_tag)
{
  return new T (*a);
}

template<class T>
T *_var_user_clone_impl (const T *a, tl::false_tag)
{
  tl_assert (false);
}

/**
 *  @brief A helper function to implement less as efficiently as possible
 */
template<class T, class I>
bool _var_user_less_impl (const T *a, const T *b, I);

template<class T>
bool _var_user_less_impl (const T *a, const T *b, tl::true_tag)
{
  return *a < *b;
}

template<class T>
bool _var_user_less_impl (const T *a, const T *b, tl::false_tag)
{
  tl_assert (false);
}

/**
 *  @brief A helper function to implement to_string as efficiently as possible
 */
template<class T, class I>
std::string _var_user_to_string_impl (const T *a, I);

template<class T>
std::string _var_user_to_string_impl (const T *a, tl::true_tag)
{
  return a->to_string ();
}

template<class T>
std::string _var_user_to_string_impl (const T *a, tl::false_tag)
{
  tl_assert (false);
}

/**
 *  @brief A helper function to implement read as efficiently as possible
 */
template<class T, class I>
void _var_user_read_impl (T *a, tl::Extractor &ex, I);

template<class T>
void _var_user_read_impl (T *a, tl::Extractor &ex, tl::true_tag)
{
  ex.read (*a);
}

template<class T>
void _var_user_read_impl (T *a, tl::Extractor &ex, tl::false_tag)
{
  tl_assert (false);
}

/**
 *  @brief A utility implementation of tl::VariantUserClass using type traits for the implementation
 */
template <class T>
class VariantUserClassImpl 
  : public tl::VariantUserClass<T>
{
public:
  virtual void *create () const 
  { 
    return new T (); 
  }

  virtual void destroy (void *a) const 
  {
    delete (T *)a; 
  }

  virtual bool equal (void *a, void *b) const 
  { 
    typename tl::type_traits<T>::has_equal_operator f;
    return _var_user_equal_impl ((T *) a, (T *) b, f);
  }

  virtual bool less (void *a, void *b) const 
  { 
    typename tl::type_traits<T>::has_less_operator f;
    return _var_user_less_impl ((T *) a, (T *) b, f);
  }

  virtual void *clone (void *a) const
  { 
    typename tl::type_traits<T>::has_copy_constructor f;
    return _var_user_clone_impl ((T *) a, f);
  }

  virtual std::string to_string (void *a) const
  { 
    typename tl::type_traits<T>::supports_to_string f;
    return _var_user_to_string_impl ((T *) a, f);
  }

  virtual void read (void *a, tl::Extractor &ex) const 
  { 
    typename tl::type_traits<T>::supports_extractor f;
    _var_user_read_impl ((T *) a, ex, f);
  }

  virtual const char *name () const 
  { 
    return ""; 
  }

  virtual bool is_const () const 
  { 
    return false; 
  }

  virtual const gsi::ClassBase *gsi_cls () const 
  { 
    return 0; 
  }

  virtual const tl::EvalClass *eval_cls () const 
  { 
    return 0; 
  }
};

}

#endif




