软件架构设计之Utility模块——Any

YKAny类用于保存任意类型的变量类似于variant_t。这里采用的是boost库中的Any实现原理，增加了两个Any之间比较的功能。看代码吧：

 

class UTIL_API YKAny
{
  class PlaceHolder
  {
  public:
    PlaceHolder() {}
    virtual ~PlaceHolder() {}

    virtual const std::type_info& type() const = 0;
    virtual PlaceHolder* Clone() const = 0;
    virtual YK_BOOL operator== (PlaceHolder* pHolder) = 0;
    virtual YK_BOOL operator!= (PlaceHolder* pHolder) = 0;
    virtual YK_BOOL operator< (PlaceHolder* pHolder) = 0;
    virtual YK_BOOL operator> (PlaceHolder* pHolder) = 0;
    virtual YK_BOOL operator<= (PlaceHolder* pHolder) = 0;
    virtual YK_BOOL operator>= (PlaceHolder* pHolder) = 0;
  };

  template <typename T>
  class Holder : public PlaceHolder
  {
    typedef T value_type;
  public:
    Holder(value_type value)
      : m_value(value)
    {}

    virtual const std::type_info& type() const {
      return typeid(value_type);
    }

    virtual PlaceHolder* Clone() const {
      return new Holder(m_value);
    }

    virtual YK_BOOL operator== (PlaceHolder* pHolder) {
      Holder* pRhs = dynamic_cast<Holder*>(pHolder);
      assert(pRhs);
      return m_value == pRhs->m_value;
    }
    virtual YK_BOOL operator!= (PlaceHolder* pHolder)
    { return !(*this == pHolder); }
    virtual YK_BOOL operator< (PlaceHolder* pHolder) {
      Holder* pRhs = dynamic_cast<Holder*>(pHolder);
      assert(pRhs);
      return m_value < pRhs->m_value;
    }
    virtual YK_BOOL operator> (PlaceHolder* pHolder) {
      Holder* pRhs = dynamic_cast<Holder*>(pHolder);
      assert(pRhs);
      return m_value > pRhs->m_value;
    }
    virtual YK_BOOL operator<= (PlaceHolder* pHolder)
    { return !(*this > pHolder); }
    virtual YK_BOOL operator>= (PlaceHolder* pHolder)
    { return !(*this < pHolder); }

    value_type m_value;
  };

public:
  YKAny(void) : m_pValue(YK_NULL) {}

  template <typename T>
  YKAny(T value)
    : m_pValue(new Holder<T>(value))
  {}

  YKAny(const YKAny& rhs)
    : m_pValue(rhs.m_pValue ? rhs.m_pValue->Clone() : YK_NULL)
  {}

  ~YKAny(void) { delete m_pValue; }

  template <typename T>
  YKAny& operator=(typename YKTypeTraits<T>::ParmType value) {
    YKAny(value).Swap(*this);
    return *this;
  }
  YKAny& operator=(const YKAny& rhs)
  { YKAny(rhs).Swap(*this); return *this; }

  YKAny& Swap(YKAny& rhs) 
  { std::swap(m_pValue, rhs.m_pValue); return *this; }
  YK_BOOL Empty() const { return m_pValue == YK_NULL; }
  const std::type_info& type() const 
  { return m_pValue ? m_pValue->type() : typeid(void); }

  // 提取所存值前必须提供值类型
  template <typename T>
  T& Cast() {
    if (type() != typeid(T))
    {
      std::string str = "Failed to convert the value of YKAny to ";
      str += typeid(T).name();
      throw YKException(str, YKException::Exc_BadCast);
    }

    return static_cast<Holder<T>*>(m_pValue)->m_value;
  }

  YK_BOOL operator== (const YKAny& rhs) {
    assert(m_pValue && type() == rhs.type()); 
    return m_pValue->operator==(rhs.m_pValue); 
  }
  YK_BOOL operator!= (const YKAny& rhs) { 
    assert(m_pValue && type() == rhs.type()); 
    return m_pValue->operator!=(rhs.m_pValue); 
  }
  YK_BOOL operator< (const YKAny& rhs) {
    assert(m_pValue && type() == rhs.type()); 
    return m_pValue->operator<(rhs.m_pValue); 
  }
  YK_BOOL operator> (const YKAny& rhs) {
    assert(m_pValue && type() == rhs.type()); 
    return m_pValue->operator>(rhs.m_pValue); 
  }
  YK_BOOL operator<= (const YKAny& rhs) {
    assert(m_pValue && type() == rhs.type()); 
    return m_pValue->operator<=(rhs.m_pValue); 
  }
  YK_BOOL operator>= (const YKAny& rhs) {
    assert(m_pValue && type() == rhs.type()); 
    return m_pValue->operator>=(rhs.m_pValue); 
  }

private:
  PlaceHolder*  m_pValue;
};