/***
   mockcpp is a C/C++ mock framework.
   Copyright [2008] [Darwin Yuan <darwin.yuan@gmail.com>]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
***/

#include <limits>
#include <mockcpp/types/AnyCast.h>

MOCKCPP_NS_START

///////////////////////////////////////////////////////
template <typename ValueType>
ValueType* type_any_cast(AnyBase* op)
{
   return 0;
}

///////////////////////////////////////////////////////
template <typename Unsigned, typename Signed, typename BaseType>
Unsigned* unsigned_type_any_cast(AnyBase* op)
{
   Unsigned *p = 0;
   if((p = __any_cast<Unsigned>(op)) ||
      (p = (Unsigned*)type_any_cast<BaseType>(op))
   )
   {
      return p;
   }

   Signed* ps = 0;
   if((ps = __any_cast<Signed>(op)) && (*ps) > 0)
   {
      return (Unsigned*)ps;
   }

   return 0;
}

///////////////////////////////////////////////////////
template <typename Signed, typename BaseType >
Signed* signed_type_any_cast(AnyBase* op)
{
   Signed *p = 0;

   (p = __any_cast<Signed>(op)) ||
   (p = (Signed*)type_any_cast<BaseType>(op));

   return p;
}

///////////////////////////////////////////////////////
template <>
char* type_any_cast<char>(AnyBase* op)
{
   return signed_type_any_cast<char, void>(op);
}

///////////////////////////////////////////////////////
template <>
short* type_any_cast<short>(AnyBase* op)
{
   return signed_type_any_cast<short, char>(op);
}

///////////////////////////////////////////////////////
template <>
int* type_any_cast<int>(AnyBase* op)
{
   return signed_type_any_cast<int, short>(op);
}

///////////////////////////////////////////////////////
template <>
long* type_any_cast<long>(AnyBase* op)
{
   return signed_type_any_cast<long, int>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned char* type_any_cast<unsigned char>(AnyBase* op)
{
   return unsigned_type_any_cast<unsigned char, char, void>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned short* type_any_cast<unsigned short>(AnyBase* op)
{
   return unsigned_type_any_cast<unsigned short, short, unsigned char>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned int* type_any_cast<unsigned int>(AnyBase* op)
{
   return unsigned_type_any_cast<unsigned int, int, unsigned short>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned long* type_any_cast<unsigned long>(AnyBase* op)
{
   return unsigned_type_any_cast<unsigned long, long, unsigned int>(op);
}

///////////////////////////////////////////////////////
template <typename ValueType>
ValueType* scope_check_any_cast(AnyBase* op)
{
   ValueType* v = type_any_cast<ValueType>(op);
   if(v != 0)
   {
      return v;
   }

   unsigned long* ul = type_any_cast<unsigned long>(op);
   if(ul  && ((*ul) <= (unsigned long)std::numeric_limits<ValueType>::max()))
   {
      return (ValueType*)ul;
   }

   long* l = type_any_cast<long>(op);
   if(l  && (((*l) <= (long)std::numeric_limits<ValueType>::max()) && 
              (*l) >= (long)std::numeric_limits<ValueType>::min()))
   {
      return (ValueType*)l;
   }

   return 0;
}

///////////////////////////////////////////////////////
template <>
char* any_cast<char>(AnyBase* op)
{
   return scope_check_any_cast<char>(op);
}

///////////////////////////////////////////////////////
template <>
short* any_cast<short>(AnyBase* op)
{
   return scope_check_any_cast<short>(op);
}

///////////////////////////////////////////////////////
template <>
int* any_cast<int>(AnyBase* op)
{
   return scope_check_any_cast<int>(op);
}

///////////////////////////////////////////////////////
template <>
long* any_cast<long>(AnyBase* op)
{
   return scope_check_any_cast<long>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned char* any_cast<unsigned char>(AnyBase* op)
{
   return scope_check_any_cast<unsigned char>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned short* any_cast<unsigned short>(AnyBase* op)
{
   return scope_check_any_cast<unsigned short>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned int* any_cast<unsigned int>(AnyBase* op)
{
   return scope_check_any_cast<unsigned int>(op);
}

///////////////////////////////////////////////////////
template <>
unsigned long* any_cast<unsigned long>(AnyBase* op)
{
   return scope_check_any_cast<unsigned long>(op);
}

MOCKCPP_NS_END