CacheableEnum.hpp

/*=========================================================================
 * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * one or more patents listed at http://www.pivotal.io/patents.
 *=========================================================================
 */
#ifndef CACHEABLE_ENUM_HPP
#define CACHEABLE_ENUM_HPP

#include "CacheableKey.hpp"
#include "CacheableString.hpp"

namespace gemfire {

  class CPPCACHE_EXPORT CacheableEnum : public CacheableKey {
  private:
    CacheableStringPtr m_enumClassName;
    CacheableStringPtr m_enumName;
    int32_t            m_ordinal;
    mutable int32_t    m_hashcode;

  public:

    ~CacheableEnum();

    static Serializable* createDeserializable(){
      return new CacheableEnum();
    }
    virtual void toData(DataOutput& output) const;

    virtual Serializable* fromData(DataInput& input);

    virtual uint32_t objectSize() const {
      uint32_t size = sizeof( CacheableEnum );
      size += (uint32_t)sizeof(int32_t);
      size += m_enumClassName->objectSize();
      size += m_enumName->objectSize();
      return size;
    }

    virtual int32_t classId() const {
      return 0;
    }

    virtual int8_t typeId() const {      
      //return 0;
      return (int8_t) GemfireTypeIds::CacheableEnum;
    }

    virtual CacheableStringPtr toString() const {
      return CacheableString::create("CacheableEnum");
    }

    static CacheableEnumPtr create(const char* enumClassName, const char* enumName, int32_t ordinal) {         
      CacheableEnumPtr str( new CacheableEnum(enumClassName, enumName, ordinal));
      return str;
    }

    const char* getEnumClassName() const {         
      return m_enumClassName->asChar();      
    }

    const char* getEnumName() const {         
      return m_enumName->asChar();      
    }

    int32_t getEnumOrdinal() const {         
      return m_ordinal;      
    } 

    virtual uint32_t hashcode( ) const;

    virtual bool operator==(const CacheableKey& other) const;
  protected:
    CacheableEnum();
    CacheableEnum(const char* enumClassName, const char* enumName, int32_t ordinal);
  private:
    // never implemented.
    void operator =(const CacheableEnum& other);
    CacheableEnum(const CacheableEnum& other);

  };  
}

#endif //CACHEABLE_ENUM_HPP