/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

using System;
using System.Collections.Generic;

namespace Apache.Geode.Client.UnitTests
{
  using NUnit.Framework;
  using Apache.Geode.DUnitFramework;
  using Apache.Geode.Client;

  #region Helper class

  public class CacheableHelper
  {
    #region Constants and statics

    private static uint[] CRC32Table = {
      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
      0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
      0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
      0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
      0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
      0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
      0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
      0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
      0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
      0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
      0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
      0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
      0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
      0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
      0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
      0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
      0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
      0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
      0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
      0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
      0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
      0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
      0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
      0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
      0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
      0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
      0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
      0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
      0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
      0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
      0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
      0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
      0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
      0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
      0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
    };

    #endregion

    /// <summary>
    /// Generate a random <c>CData</c> structure.
    /// </summary>
    public static CData RandCData()
    {
      long rnd = (long)Util.Rand(int.MaxValue);
      rnd = (rnd << 32) + (long)Util.Rand(int.MaxValue);
      return new CData(Util.Rand(int.MaxValue), rnd);
    }

    public static PdxCData RandPdxCData()
    {
      long rnd = (long)Util.Rand(int.MaxValue);
      rnd = (rnd << 32) + (long)Util.Rand(int.MaxValue);
      return new PdxCData(Util.Rand(int.MaxValue), rnd);
    }

    public static uint CRC32(byte[] buffer)
    {
      if (buffer == null || buffer.Length == 0)
      {
        return 0;
      }

      uint crc32 = 0xffffffff;

      for (int i = 0; i < buffer.Length; i++)
      {
        crc32 = ((crc32 >> 8) & 0x00ffffff) ^
          CRC32Table[(crc32 ^ buffer[i]) & 0xff];
      }
      return ~crc32;
    }

#pragma warning disable 618

    public static bool IsContainerTypeId(uint typeId)
    {
      return (typeId == GeodeClassIds.CacheableObjectArray) ||
        (typeId == GeodeClassIds.CacheableVector) ||
        (typeId == GeodeClassIds.CacheableArrayList) ||
        (typeId == GeodeClassIds.CacheableStack) ||
        (typeId == GeodeClassIds.CacheableHashMap) ||
        (typeId == GeodeClassIds.CacheableIdentityHashMap) ||
        (typeId == GeodeClassIds.CacheableHashTable) ||
        (typeId == GeodeClassIds.CacheableLinkedHashSet) ||
        (typeId == GeodeClassIds.CacheableHashSet);
    }

    public static bool IsUnhandledType(uint typeId)
    {
      // TODO: [sumedh] skipping CacheableFileName for now since it will
      // not work on Windows without significant workarounds; also see
      // the corresponding comment in C++ testThinClientCacheables.
      // Also skipping C# specific classes.
      return (typeId == GeodeClassIds.CacheableFileName) ||
        (typeId == GeodeClassIds.CacheableManagedObject) ||
        (typeId == GeodeClassIds.CacheableManagedObjectXml);
    }
    public static long ConstantDateTime = 0;
    public static void RegisterBuiltins(long dateTime)
    {
      ConstantDateTime = dateTime;
      CacheableWrapperFactory.ClearStaticVaraiables();
      #region Cacheable keys

      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableBoolean,
        typeof(CacheableBooleanWrapper), CacheableBooleanWrapper.Create, typeof(bool));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableByte,
        typeof(CacheableByteWrapper), CacheableByteWrapper.Create, typeof(sbyte));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableCharacter,
        typeof(CacheableCharacterWrapper), CacheableCharacterWrapper.Create, typeof(Char));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableDate,
        typeof(CacheableDateWrapper), CacheableDateWrapper.Create, typeof(DateTime));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableDouble,
        typeof(CacheableDoubleWrapper), CacheableDoubleWrapper.Create, typeof(Double));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableFileName,
        typeof(CacheableFileNameWrapper), CacheableFileNameWrapper.Create, typeof(CacheableFileName));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableFloat,
        typeof(CacheableFloatWrapper), CacheableFloatWrapper.Create, typeof(float));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt16,
        typeof(CacheableInt16Wrapper), CacheableInt16Wrapper.Create, typeof(Int16));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt32,
        typeof(CacheableInt32Wrapper), CacheableInt32Wrapper.Create, typeof(Int32));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt64,
        typeof(CacheableInt64Wrapper), CacheableInt64Wrapper.Create, typeof(Int64));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableASCIIString,
        typeof(CacheableStringWrapper), CacheableStringWrapper.Create, typeof(string));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableString,
        typeof(CacheableUnicodeStringWrapper), CacheableUnicodeStringWrapper.Create);
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableASCIIStringHuge,
        typeof(CacheableHugeStringWrapper), CacheableHugeStringWrapper.Create);
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableStringHuge,
        typeof(CacheableHugeUnicodeStringWrapper), CacheableHugeUnicodeStringWrapper.Create);
      CacheableWrapperFactory.RegisterKeyType(10001,
      typeof(PdxCDataWrapper), PdxCDataWrapper.Create, typeof(PdxCData));

      //need to register pdx type
      Assert.NotNull(CacheHelper.DCache);
      CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxCData.CreateDeserializable);

      #endregion

      #region Other cacheables

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableBytes,
        typeof(CacheableBytesWrapper), CacheableBytesWrapper.Create, typeof(byte[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableDoubleArray,
        typeof(CacheableDoubleArrayWrapper), CacheableDoubleArrayWrapper.Create, typeof(Double[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableFloatArray,
        typeof(CacheableFloatArrayWrapper), CacheableFloatArrayWrapper.Create, typeof(float[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashMap,
        typeof(CacheableHashMapWrapper), CacheableHashMapWrapper.Create, typeof(Dictionary<object, object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashTable,
        typeof(CacheableHashTableWrapper), CacheableHashTableWrapper.Create, typeof(System.Collections.Hashtable));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableIdentityHashMap,
        typeof(CacheableIdentityHashMapWrapper), CacheableIdentityHashMapWrapper.Create, typeof(Dictionary<object, object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashSet,
        typeof(CacheableHashSetWrapper), CacheableHashSetWrapper.Create, typeof(CacheableHashSet));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableLinkedHashSet,
        typeof(CacheableLinkedHashSetWrapper), CacheableLinkedHashSetWrapper.Create, typeof(CacheableLinkedHashSet));

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt16Array,
        typeof(CacheableInt16ArrayWrapper), CacheableInt16ArrayWrapper.Create, typeof(Int16[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt32Array,
        typeof(CacheableInt32ArrayWrapper), CacheableInt32ArrayWrapper.Create, typeof(Int32[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt64Array,
        typeof(CacheableInt64ArrayWrapper), CacheableInt64ArrayWrapper.Create, typeof(Int64[]));
      {//old one
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableNullString,
        //  typeof(CacheableNullStringWrapper), CacheableNullStringWrapper.Create);
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableASCIIString,
        //  typeof(CacheableEmptyStringWrapper), CacheableEmptyStringWrapper.Create);
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableString,
        //  typeof(CacheableEmptyUnicodeStringWrapper), CacheableEmptyUnicodeStringWrapper.Create);
      }
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableStringArray,
        typeof(CacheableStringArrayWrapper), CacheableStringArrayWrapper.Create, typeof(string[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableUndefined,
        typeof(CacheableUndefinedWrapper), CacheableUndefinedWrapper.Create, typeof(CacheableUndefined));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableVector,
        typeof(CacheableVectorWrapper), CacheableVectorWrapper.Create, typeof(System.Collections.ArrayList));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableObjectArray,
        typeof(CacheableObjectArrayWrapper), CacheableObjectArrayWrapper.Create, typeof(CacheableObjectArray));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableArrayList,
        typeof(CacheableArrayListWrapper), CacheableArrayListWrapper.Create, typeof(List<object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableStack,
        typeof(CacheableStackWrapper), CacheableStackWrapper.Create, typeof(Stack<object>));

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableManagedObject,
        typeof(CacheableObjectWrapper), CacheableObjectWrapper.Create, typeof(CacheableObject));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableManagedObjectXml,
        typeof(CacheableObjectXmlWrapper), CacheableObjectXmlWrapper.Create, typeof(CacheableObjectXml));


      #endregion
    }

    public static void RegisterBuiltinsJavaHashCode(long dateTime)
    {
      ConstantDateTime = dateTime;
      CacheableWrapperFactory.ClearStaticVaraiables();
      #region Cacheable keys

      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableBoolean,
        typeof(CacheableBooleanWrapper), CacheableBooleanWrapper.Create, typeof(bool));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableByte,
        typeof(CacheableByteWrapper), CacheableByteWrapper.Create, typeof(sbyte));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableCharacter,
        typeof(CacheableCharacterWrapper), CacheableCharacterWrapper.Create, typeof(Char));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableDate,
        typeof(CacheableDateWrapper), CacheableDateWrapper.Create, typeof(DateTime));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableDouble,
        typeof(CacheableDoubleWrapper), CacheableDoubleWrapper.Create, typeof(Double));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableFileName,
        typeof(CacheableFileNameWrapper), CacheableFileNameWrapper.Create, typeof(CacheableFileName));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableFloat,
        typeof(CacheableFloatWrapper), CacheableFloatWrapper.Create, typeof(float));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt16,
        typeof(CacheableInt16Wrapper), CacheableInt16Wrapper.Create, typeof(Int16));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt32,
        typeof(CacheableInt32Wrapper), CacheableInt32Wrapper.Create, typeof(Int32));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt64,
        typeof(CacheableInt64Wrapper), CacheableInt64Wrapper.Create, typeof(Int64));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableASCIIString,
        typeof(CacheableStringWrapper), CacheableStringWrapper.Create, typeof(string));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableString,
        typeof(CacheableUnicodeStringWrapper), CacheableUnicodeStringWrapper.Create);
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableASCIIStringHuge,
        typeof(CacheableHugeStringWrapper), CacheableHugeStringWrapper.Create);
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableStringHuge,
        typeof(CacheableHugeUnicodeStringWrapper), CacheableHugeUnicodeStringWrapper.Create);

      //need to register pdx type
      Assert.NotNull(CacheHelper.DCache);
      CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxCData.CreateDeserializable);

      #endregion

      #region Other cacheables

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableBytes,
        typeof(CacheableBytesWrapper), CacheableBytesWrapper.Create, typeof(byte[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableDoubleArray,
        typeof(CacheableDoubleArrayWrapper), CacheableDoubleArrayWrapper.Create, typeof(Double[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableFloatArray,
        typeof(CacheableFloatArrayWrapper), CacheableFloatArrayWrapper.Create, typeof(float[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashMap,
        typeof(CacheableHashMapWrapper), CacheableHashMapWrapper.Create, typeof(Dictionary<object, object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashTable,
        typeof(CacheableHashTableWrapper), CacheableHashTableWrapper.Create, typeof(System.Collections.Hashtable));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableIdentityHashMap,
        typeof(CacheableIdentityHashMapWrapper), CacheableIdentityHashMapWrapper.Create, typeof(Dictionary<object, object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashSet,
        typeof(CacheableHashSetWrapper), CacheableHashSetWrapper.Create, typeof(CacheableHashSet));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableLinkedHashSet,
        typeof(CacheableLinkedHashSetWrapper), CacheableLinkedHashSetWrapper.Create, typeof(CacheableLinkedHashSet));

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt16Array,
        typeof(CacheableInt16ArrayWrapper), CacheableInt16ArrayWrapper.Create, typeof(Int16[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt32Array,
        typeof(CacheableInt32ArrayWrapper), CacheableInt32ArrayWrapper.Create, typeof(Int32[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt64Array,
        typeof(CacheableInt64ArrayWrapper), CacheableInt64ArrayWrapper.Create, typeof(Int64[]));
      {//old one
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableNullString,
        //  typeof(CacheableNullStringWrapper), CacheableNullStringWrapper.Create);
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableASCIIString,
        //  typeof(CacheableEmptyStringWrapper), CacheableEmptyStringWrapper.Create);
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableString,
        //  typeof(CacheableEmptyUnicodeStringWrapper), CacheableEmptyUnicodeStringWrapper.Create);
      }
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableStringArray,
        typeof(CacheableStringArrayWrapper), CacheableStringArrayWrapper.Create, typeof(string[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableUndefined,
        typeof(CacheableUndefinedWrapper), CacheableUndefinedWrapper.Create, typeof(CacheableUndefined));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableVector,
        typeof(CacheableVectorWrapper), CacheableVectorWrapper.Create, typeof(System.Collections.ArrayList));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableObjectArray,
        typeof(CacheableObjectArrayWrapper), CacheableObjectArrayWrapper.Create, typeof(CacheableObjectArray));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableArrayList,
        typeof(CacheableArrayListWrapper), CacheableArrayListWrapper.Create, typeof(List<object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableStack,
        typeof(CacheableStackWrapper), CacheableStackWrapper.Create, typeof(Stack<object>));

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableManagedObject,
        typeof(CacheableObjectWrapper), CacheableObjectWrapper.Create, typeof(CacheableObject));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableManagedObjectXml,
        typeof(CacheableObjectXmlWrapper), CacheableObjectXmlWrapper.Create, typeof(CacheableObjectXml));


      #endregion
    }

    public static void RegisterBuiltinsAD(long dateTime)
    {
      ConstantDateTime = dateTime;
      CacheableWrapperFactory.ClearStaticVaraiables();
      #region Cacheable keys

      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableBoolean,
        typeof(CacheableBooleanWrapper), CacheableBooleanWrapper.Create, typeof(bool));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableByte,
        typeof(CacheableByteWrapper), CacheableByteWrapper.Create, typeof(sbyte));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableCharacter,
        typeof(CacheableCharacterWrapper), CacheableCharacterWrapper.Create, typeof(Char));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableDate,
        typeof(CacheableDateWrapper), CacheableDateWrapper.Create, typeof(DateTime));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableDouble,
        typeof(CacheableDoubleWrapper), CacheableDoubleWrapper.Create, typeof(Double));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableFileName,
        typeof(CacheableFileNameWrapper), CacheableFileNameWrapper.Create, typeof(CacheableFileName));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableFloat,
        typeof(CacheableFloatWrapper), CacheableFloatWrapper.Create, typeof(float));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt16,
        typeof(CacheableInt16Wrapper), CacheableInt16Wrapper.Create, typeof(Int16));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt32,
        typeof(CacheableInt32Wrapper), CacheableInt32Wrapper.Create, typeof(Int32));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableInt64,
        typeof(CacheableInt64Wrapper), CacheableInt64Wrapper.Create, typeof(Int64));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableASCIIString,
        typeof(CacheableStringWrapper), CacheableStringWrapper.Create, typeof(string));
      CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableString,
        typeof(CacheableUnicodeStringWrapper), CacheableUnicodeStringWrapper.Create);
      {
        //CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableASCIIStringHuge,
        //  typeof(CacheableHugeStringWrapper), CacheableHugeStringWrapper.Create);
        //CacheableWrapperFactory.RegisterKeyType(GeodeClassIds.CacheableStringHuge,
        //  typeof(CacheableHugeUnicodeStringWrapper), CacheableHugeUnicodeStringWrapper.Create);
      }
      CacheableWrapperFactory.RegisterKeyType(10001,
     typeof(PdxCDataWrapper), PdxCDataWrapper.Create, typeof(PdxCData));

      //need to register pdx type
      CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxCData.CreateDeserializable);


      #endregion

      #region Other cacheables

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableBytes,
        typeof(CacheableBytesWrapper), CacheableBytesWrapper.Create, typeof(byte[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableDoubleArray,
        typeof(CacheableDoubleArrayWrapper), CacheableDoubleArrayWrapper.Create, typeof(Double[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableFloatArray,
        typeof(CacheableFloatArrayWrapper), CacheableFloatArrayWrapper.Create, typeof(float[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashMap,
        typeof(CacheableHashMapWrapper), CacheableHashMapWrapper.Create, typeof(Dictionary<object, object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashTable,
        typeof(CacheableHashTableWrapper), CacheableHashTableWrapper.Create, typeof(System.Collections.Hashtable));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableIdentityHashMap,
        typeof(CacheableIdentityHashMapWrapper), CacheableIdentityHashMapWrapper.Create, typeof(Dictionary<object, object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableHashSet,
        typeof(CacheableHashSetWrapper), CacheableHashSetWrapper.Create, typeof(CacheableHashSet));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableLinkedHashSet,
        typeof(CacheableLinkedHashSetWrapper), CacheableLinkedHashSetWrapper.Create, typeof(CacheableLinkedHashSet));

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt16Array,
        typeof(CacheableInt16ArrayWrapper), CacheableInt16ArrayWrapper.Create, typeof(Int16[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt32Array,
        typeof(CacheableInt32ArrayWrapper), CacheableInt32ArrayWrapper.Create, typeof(Int32[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableInt64Array,
        typeof(CacheableInt64ArrayWrapper), CacheableInt64ArrayWrapper.Create, typeof(Int64[]));
      {//old one
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableNullString,
        //  typeof(CacheableNullStringWrapper), CacheableNullStringWrapper.Create);
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableASCIIString,
        //  typeof(CacheableEmptyStringWrapper), CacheableEmptyStringWrapper.Create);
        //CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableString,
        //  typeof(CacheableEmptyUnicodeStringWrapper), CacheableEmptyUnicodeStringWrapper.Create);
      }
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableStringArray,
        typeof(CacheableStringArrayWrapper), CacheableStringArrayWrapper.Create, typeof(string[]));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableUndefined,
        typeof(CacheableUndefinedWrapper), CacheableUndefinedWrapper.Create, typeof(CacheableUndefined));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableVector,
        typeof(CacheableVectorWrapper), CacheableVectorWrapper.Create, typeof(System.Collections.ArrayList));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableObjectArray,
        typeof(CacheableObjectArrayWrapper), CacheableObjectArrayWrapper.Create, typeof(CacheableObjectArray));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableArrayList,
        typeof(CacheableArrayListWrapper), CacheableArrayListWrapper.Create, typeof(List<object>));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableStack,
        typeof(CacheableStackWrapper), CacheableStackWrapper.Create, typeof(Stack<object>));

      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableManagedObject,
        typeof(CacheableObjectWrapper), CacheableObjectWrapper.Create, typeof(CacheableObject));
      CacheableWrapperFactory.RegisterType(GeodeClassIds.CacheableManagedObjectXml,
        typeof(CacheableObjectXmlWrapper), CacheableObjectXmlWrapper.Create, typeof(CacheableObjectXml));


      #endregion
    }
  }

  #endregion

  #region Builtin cacheable keys

  public class CacheableBooleanWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableBooleanWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return 2;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      bool value = (keyIndex % 2 == 1 ? true : false);
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      bool value = (Util.Rand(byte.MaxValue) % 2 == 1 ? true : false);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      //Util.Log("cacheableObject Type = {0}", cacheableObject.GetType());
      bool value = (bool)cacheableObject;
      Assert.IsNotNull(value, "GetChecksum: Null object.");
      return (uint)(value ? 1 : 0);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      bool val = (bool)cacheableObject;
      if (val) return 1231;
      else return 1237;
    }

    #endregion
  }

  public class CacheableByteWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableByteWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return byte.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      sbyte value = (sbyte)keyIndex;
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      sbyte value = (sbyte)Util.Rand(byte.MaxValue);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      sbyte value = (sbyte)cacheableObject;
      Assert.IsNotNull(value, "GetChecksum: Null object.");
      byte[] buffer = new byte[1];
      buffer[0] = (byte)value;
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      sbyte val = (sbyte)cacheableObject;
      return val;
    }

    #endregion
  }

  public class CacheableCharacterWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableCharacterWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return char.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      char value = (char)keyIndex;
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      char value = (char)Util.Rand(char.MaxValue);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      char obj = (char)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");
      char value = obj;
      int numBytes = sizeof(char);
      byte[] buffer = new byte[numBytes];
      for (int i = 0; i < numBytes; i++)
      {
        buffer[i] = (byte)(value & 0xff);
        value = (char)(value >> 8);
      }
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      char val = (char)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableDateWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableDateWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      //m_cacheableObject = DateTime.Today.AddMinutes(keyIndex % 0xFFFF);
      DateTime dt = new DateTime(CacheableHelper.ConstantDateTime + keyIndex * TimeSpan.TicksPerMinute);
      m_cacheableObject = dt;
      Util.Log(" datevalue initkey " + dt.ToString());
    }

    private DateTime createRoundOffDTVal(DateTime dt)
    {
      long ticksToAdd = dt.Ticks % TimeSpan.TicksPerMillisecond;
      ticksToAdd = (ticksToAdd >= (TimeSpan.TicksPerMillisecond / 2) ?
        (TimeSpan.TicksPerMillisecond - ticksToAdd) : -ticksToAdd);
      dt = dt.AddTicks(ticksToAdd);
      return dt;
    }

    public override void InitRandomValue(int maxSize)
    {
      int rnd = Util.Rand(int.MaxValue);
      //DateTime value = DateTime.Now.AddMilliseconds(rnd % 2 == 0 ? rnd : -rnd);
      DateTime value = new DateTime(CacheableHelper.ConstantDateTime);
      m_cacheableObject = value;
      Util.Log(" datevalue InitRandomValue " + value.ToString());
    }

    public override uint GetChecksum(object cacheableObject)
    {
      //CacheableDate obj = cacheableObject as CacheableDate;
      DateTime obj = (DateTime)cacheableObject;
      Util.Log(" datevalue getchecksum " + obj.ToString());
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      obj = createRoundOffDTVal(obj);
      long value = obj.Ticks;
      int numBytes = sizeof(long);
      byte[] buffer = new byte[numBytes];
      for (int i = 0; i < numBytes; i++)
      {
        buffer[i] = (byte)(value & 0xff);
        value = value >> 8;
      }
      uint cks = CacheableHelper.CRC32(buffer);
      Util.Log(" datevalue getchecksum  " + cks);
      return cks;
    }

    #endregion
  }

  public class CacheableDoubleWrapper : CacheableKeyWrapper
  {
    #region Private constants

    private const double MaxError = 1E-20;

    #endregion

    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableDoubleWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      double value = (double)keyIndex;
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      double value = Util.Rand() * double.MaxValue;
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      double value = (double)cacheableObject;
      Assert.IsNotNull(value, "GetChecksum: Null object.");
      return CacheableHelper.CRC32(BitConverter.GetBytes(value));
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      double val = (double)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableFileNameWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableFileNameWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of key should be greater than zero.");
      if (maxSize < 11)
      {
        maxSize = 11;
      }
      string value = "C:\\" + new string('\x0905', maxSize - 13) +
        keyIndex.ToString("D10");
      m_cacheableObject = CacheableFileName.Create(value);
    }

    public override void InitRandomValue(int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of value should be greater than zero.");
      byte[] buffer = Util.RandBytes(maxSize / 2);
      char[] value = new char[maxSize / 2];
      for (int i = 0; i < maxSize / 2; i++)
      {
        value[i] = (char)((int)buffer[i] + 0x0901);
      }
      m_cacheableObject = CacheableFileName.Create(value);
    }

    public override uint GetChecksum(object cacheableObject)
    {
      CacheableFileName obj = cacheableObject as CacheableFileName;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      string value = obj.Value;
      byte[] buffer = new byte[value.Length * 2];
      for (int i = 0; i < value.Length; i++)
      {
        char c = value[i];
        buffer[i * 2] = (byte)(c & 0xff);
        buffer[i * 2 + 1] = (byte)((c >> 8) & 0xff);
      }
      return CacheableHelper.CRC32(buffer);
    }

    #endregion
  }

  public class CacheableFloatWrapper : CacheableKeyWrapper
  {
    #region Private constants

    private const float MaxError = 1E-10F;

    #endregion

    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableFloatWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      float value = (float)keyIndex;
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      float value = (float)Util.Rand() * float.MaxValue;
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      float value = (float)cacheableObject;
      Assert.IsNotNull(value, "GetChecksum: Null object.");
      return CacheableHelper.CRC32(BitConverter.GetBytes(value));
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      float val = (float)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableInt16Wrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableInt16Wrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return short.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      short value = (short)keyIndex;
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      short value = (short)Util.Rand(short.MaxValue);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Int16 obj = (Int16)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");
      short value = obj;
      int numBytes = sizeof(short);
      byte[] buffer = new byte[numBytes];
      for (int i = 0; i < numBytes; i++)
      {
        buffer[i] = (byte)(value & 0xff);
        value = (short)(value >> 8);
      }
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      Int16 val = (Int16)cacheableObject;
      return val;
    }
    #endregion
  }

  public class CacheableInt32Wrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableInt32Wrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      int value = keyIndex;
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      int value = Util.Rand(int.MaxValue);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Int32 obj = (Int32)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      int value = obj;
      int numBytes = sizeof(int);
      byte[] buffer = new byte[numBytes];
      for (int i = 0; i < numBytes; i++)
      {
        buffer[i] = (byte)(value & 0xff);
        value = value >> 8;
      }
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      Int32 val = (Int32)cacheableObject;
      return val;
    }
    #endregion
  }

  public class CacheableInt64Wrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableInt64Wrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      long value = (long)keyIndex;
      m_cacheableObject = value;
    }

    public override void InitRandomValue(int maxSize)
    {
      long value = Util.Rand(int.MaxValue);
      value = (value << 32) + Util.Rand(int.MaxValue);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Int64 obj = (Int64)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");
      long value = obj;
      int numBytes = sizeof(long);
      byte[] buffer = new byte[numBytes];
      for (int i = 0; i < numBytes; i++)
      {
        buffer[i] = (byte)(value & 0xff);
        value = value >> 8;
      }
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      Int64 val = (Int64)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableStringWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableStringWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of key should be greater than zero.");
      if (maxSize < 11)
      {
        maxSize = 11;
      }
      if (keyIndex == 0)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        string value = new string('A', maxSize - 10) + keyIndex.ToString("D10");
        m_cacheableObject = value;
      }
    }

    public override void InitRandomValue(int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of value should be greater than zero.");
      maxSize = (maxSize / 2) > 1 ? (maxSize / 2) : 2;
      Util.Log(" in cacheable string wrapper maxsize = " + maxSize);
      if (maxSize == 2)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        byte[] buffer = Util.RandBytes(maxSize);
        string value = BitConverter.ToString(buffer).Replace("-", string.Empty);
        Util.Log("cacheable string wrapper " + value);
        m_cacheableObject = value;
      }
    }

    public override uint GetChecksum(object cacheableObject)
    {
      string obj = (string)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      string value = obj;
      if (value != null)
      {
        byte[] buffer = new byte[value.Length];
        for (int i = 0; i < value.Length; i++)
        {
          buffer[i] = (byte)value[i];
        }
        return CacheableHelper.CRC32(buffer);
      }
      return 0;
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      string val = (string)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableUnicodeStringWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableUnicodeStringWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of key should be greater than zero.");
      if (maxSize < 11)
      {
        maxSize = 11;
      }
      if (keyIndex == 0)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        string value = new string('\x0905', maxSize - 10) + keyIndex.ToString("D10");
        m_cacheableObject = value;
      }
    }

    public override void InitRandomValue(int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of value should be greater than zero.");
      if (maxSize == 2)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        byte[] buffer = Util.RandBytes(maxSize / 2);
        char[] value = new char[maxSize / 2];
        for (int i = 0; i < maxSize / 2; i++)
        {
          value[i] = (char)((int)buffer[i] + 0x0901);
        }
        m_cacheableObject = new string(value);
      }
    }

    public override uint GetChecksum(object cacheableObject)
    {
      string obj = (string)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      string value = obj;
      byte[] buffer = new byte[value.Length * 2];
      for (int i = 0; i < value.Length; i++)
      {
        char c = value[i];
        buffer[i * 2] = (byte)(c & 0xff);
        buffer[i * 2 + 1] = (byte)((c >> 8) & 0xff);
      }
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      string val = (string)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableHugeStringWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableHugeStringWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of key should be greater than zero.");
      if (maxSize < 0xFFFF)
      {
        maxSize += 0xFFFF + 1;
      }
      if (keyIndex == 0)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        string value = new string('A', maxSize - 10) + keyIndex.ToString("D10");
        m_cacheableObject = value;
      }
    }

    public override void InitRandomValue(int maxSize)
    {
      if (maxSize < 0xFFFF)
      {
        maxSize += 0xFFFF + 1;
      }
      Assert.Greater(maxSize, 0, "Size of value should be greater than zero.");
      if (maxSize < 0xFFFF + 10)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        byte[] buffer = Util.RandBytes(maxSize);
        string value = BitConverter.ToString(buffer).Replace("-", string.Empty);
        m_cacheableObject = value;
      }
    }

    public override uint GetChecksum(object cacheableObject)
    {
      string obj = (string)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      string value = obj;
      byte[] buffer = new byte[value.Length];
      for (int i = 0; i < value.Length; i++)
      {
        buffer[i] = (byte)value[i];
      }
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      string val = (string)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableHugeUnicodeStringWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new CacheableHugeUnicodeStringWrapper();
    }

    #endregion

    #region CacheableKeyWrapper Members

    public override int MaxKeys
    {
      get
      {
        return int.MaxValue;
      }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      Assert.Greater(maxSize, 0, "Size of key should be greater than zero.");
      if (maxSize < 0xFFFF)
      {
        maxSize += 0xFFFF + 1;
      }
      if (keyIndex == 0)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        string value = new string('\x0905', maxSize - 10) + keyIndex.ToString("D10");
        m_cacheableObject = value;
      }
    }

    public override void InitRandomValue(int maxSize)
    {
      if (maxSize < 0xFFFF)
      {
        maxSize += 0xFFFF + 1;
      }
      Assert.Greater(maxSize, 0, "Size of value should be greater than zero.");
      if (maxSize < 0xFFFF + 10)
      {
        m_cacheableObject = string.Empty;
      }
      else
      {
        byte[] buffer = Util.RandBytes(maxSize);
        char[] value = new char[maxSize];
        for (int i = 0; i < maxSize; i++)
        {
          value[i] = (char)((int)buffer[i] + 0x0901);
        }
        m_cacheableObject = new string(value);
      }
    }

    public override uint GetChecksum(object cacheableObject)
    {
      string obj = (string)cacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      string value = obj;
      byte[] buffer = new byte[value.Length * 2];
      for (int i = 0; i < value.Length; i++)
      {
        char c = value[i];
        buffer[i * 2] = (byte)(c & 0xff);
        buffer[i * 2 + 1] = (byte)((c >> 8) & 0xff);
      }
      return CacheableHelper.CRC32(buffer);
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      string val = (string)cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  #endregion

  #region Builtin cacheables that are not keys

  public class CacheableBytesWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableBytesWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      byte[] value = Util.RandBytes(maxSize);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      byte[] value = (byte[])cacheableObject;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      return CacheableHelper.CRC32(value);
    }
    public override int GetHashCodeN(object cacheableObject)
    {
      byte[] val = (byte[])cacheableObject;
      return val.GetHashCode();
    }

    #endregion
  }

  public class CacheableDoubleArrayWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableDoubleArrayWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      int arraySize = maxSize / sizeof(double);
      arraySize = arraySize > 1 ? arraySize : 2;
      double[] value = new double[arraySize];
      for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++)
      {
        value[arrayIndex] = Util.Rand() * double.MaxValue;
      }
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Double[] obj = cacheableObject as Double[];
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      double[] value = obj;
      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      foreach (double v in value)
      {
        byte[] buffer = BitConverter.GetBytes(v);
        ms.Write(buffer, 0, buffer.Length);
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      double[] val = (double[])cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableFloatArrayWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableFloatArrayWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      int arraySize = maxSize / sizeof(float);
      arraySize = arraySize > 1 ? arraySize : 2;
      float[] value = new float[arraySize];
      for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++)
      {
        value[arrayIndex] = (float)Util.Rand() * float.MaxValue;
      }
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      float[] obj = cacheableObject as float[];
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      float[] value = obj;
      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      foreach (float v in value)
      {
        byte[] buffer = BitConverter.GetBytes(v);
        ms.Write(buffer, 0, buffer.Length);
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      float[] val = (float[])cacheableObject;
      return val.GetHashCode();
    }
    #endregion
  }

  public class CacheableHashMapWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableHashMapWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //CacheableHashMap map = new CacheableHashMap();
      Dictionary<object, object> map = new Dictionary<object, object>();
      ICollection<UInt32> keyTypeIds =
        CacheableWrapperFactory.GetRegisteredKeyTypeIds();
      ICollection<UInt32> valueTypeIds =
        CacheableWrapperFactory.GetRegisteredValueTypeIds();
      int keySize = 16;
      maxSize = maxSize / (keyTypeIds.Count * valueTypeIds.Count) + 1;
      CacheableKeyWrapper keyWrapper;
      CacheableWrapper valueWrapper;
      foreach (UInt32 keyTypeId in keyTypeIds)
      {
        int index = 0;
        foreach (UInt32 valueTypeId in valueTypeIds)
        {
          if ((valueTypeId == GeodeClassIds.CacheableASCIIStringHuge ||
            valueTypeId == GeodeClassIds.CacheableStringHuge)
              && !(keyTypeId == GeodeClassIds.CacheableBoolean))
          {
            continue;
          }
          if ((keyTypeId == GeodeClassIds.CacheableASCIIStringHuge ||
            keyTypeId == GeodeClassIds.CacheableStringHuge)
              && !(valueTypeId == GeodeClassIds.CacheableBoolean))
          {
            continue;
          }
          // null object does not work on server side during deserialization
          if (valueTypeId == GeodeClassIds.CacheableNullString)
          {
            continue;
          }

          keyWrapper = CacheableWrapperFactory.CreateKeyInstance(keyTypeId);
          Assert.IsNotNull(keyWrapper, "CacheableHashMapWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", keyTypeId);
          if (keyWrapper.MaxKeys <= index)
          {
            break;
          }
          keyWrapper.InitKey((int)(keyTypeId << 8) + index, keySize);
          if (!CacheableHelper.IsContainerTypeId(valueTypeId) &&
            !CacheableHelper.IsUnhandledType(valueTypeId))
          {
            valueWrapper = CacheableWrapperFactory.CreateInstance(valueTypeId);
            Assert.IsNotNull(valueWrapper, "CacheableHashMapWrapper.InitRandomValue:" +
              " Could not create an instance of typeId [{0}].", valueTypeId);
            valueWrapper.InitRandomValue(maxSize);
            Util.Log(" updating map " + keyWrapper.CacheableKey + " : " + valueWrapper.Cacheable);
            map.Add(keyWrapper.CacheableKey, valueWrapper.Cacheable);
          }
          index++;
        }
      }
      m_cacheableObject = map;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      //CacheableHashMap value = cacheableObject as CacheableHashMap;
      Dictionary<object, object> value = cacheableObject as Dictionary<object, object>;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableKeyWrapper keyWrapper;
      CacheableWrapper valueWrapper;
      foreach (KeyValuePair<object, object> pair in value)
      {
        Util.Log(" pair " + pair.Key.GetType() + " : " + pair.Value.GetType());
        keyWrapper = CacheableWrapperFactory.CreateKeyInstance((pair.Key));
        Assert.IsNotNull(keyWrapper, "CacheableHashMap.GetChecksum:" +
          " Could not create an instance of typeId [{0}].",
          keyWrapper.TypeId);
        valueWrapper = CacheableWrapperFactory.CreateInstance(
          pair.Value);
        Assert.IsNotNull(valueWrapper, "CacheableHashMap.GetChecksum:" +
          " Could not create an instance of typeId [{0}].",
          valueWrapper.TypeId);

        ckSum ^= (keyWrapper.GetChecksum(pair.Key) ^
          valueWrapper.GetChecksum(pair.Value));
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableHashTableWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableHashTableWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //CacheableHashTable table = new CacheableHashTable();
      System.Collections.Hashtable table = new System.Collections.Hashtable();
      ICollection<UInt32> keyTypeIds =
        CacheableWrapperFactory.GetRegisteredKeyTypeIds();
      ICollection<UInt32> valueTypeIds =
        CacheableWrapperFactory.GetRegisteredValueTypeIds();
      int keySize = 16;
      maxSize = maxSize / (keyTypeIds.Count * valueTypeIds.Count) + 1;
      CacheableKeyWrapper keyWrapper;
      CacheableWrapper valueWrapper;
      foreach (UInt32 keyTypeId in keyTypeIds)
      {
        int index = 0;
        foreach (UInt32 valueTypeId in valueTypeIds)
        {
          if ((valueTypeId == GeodeClassIds.CacheableASCIIStringHuge ||
            valueTypeId == GeodeClassIds.CacheableStringHuge)
            && !(keyTypeId == GeodeClassIds.CacheableBoolean))
          {
            continue;
          }
          if ((keyTypeId == GeodeClassIds.CacheableASCIIStringHuge ||
            keyTypeId == GeodeClassIds.CacheableStringHuge)
            && !(valueTypeId == GeodeClassIds.CacheableBoolean))
          {
            continue;
          }
          if (valueTypeId == GeodeClassIds.CacheableNullString)
          {
            continue;
          }

          keyWrapper = CacheableWrapperFactory.CreateKeyInstance(keyTypeId);
          Assert.IsNotNull(keyWrapper, "CacheableHashTableWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", keyTypeId);
          if (keyWrapper.MaxKeys <= index)
          {
            break;
          }
          keyWrapper.InitKey((int)(keyTypeId << 8) + index, keySize);

          if (!CacheableHelper.IsContainerTypeId(valueTypeId) &&
              !CacheableHelper.IsUnhandledType(valueTypeId))
          {
            valueWrapper = CacheableWrapperFactory.CreateInstance(valueTypeId);
            Assert.IsNotNull(valueWrapper, "CacheableHashTableWrapper.InitRandomValue:" +
              " Could not create an instance of typeId [{0}].", valueTypeId);
            valueWrapper.InitRandomValue(maxSize);
            if (valueWrapper.Cacheable == null)
            {
              Util.Log(" adding null value " + valueWrapper.GetType() + " : " + valueTypeId);
            }
            else
              Util.Log(" adding value " + valueWrapper.GetType() + " : " + valueTypeId);
            table.Add(keyWrapper.CacheableKey, valueWrapper.Cacheable);
          }
          index++;
        }
      }
      m_cacheableObject = table;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      //Dictionary<object, object> value = new Dictionary<object, object>();
      System.Collections.Hashtable value = cacheableObject as System.Collections.Hashtable;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableKeyWrapper keyWrapper;
      CacheableWrapper valueWrapper;
      foreach (System.Collections.DictionaryEntry pair in value)
      {
        keyWrapper = CacheableWrapperFactory.CreateKeyInstance(
          pair.Key);
        Assert.IsNotNull(keyWrapper, "CacheableHashTable.GetChecksum:" +
          " Could not create an instance of typeId [{0}].",
          keyWrapper.TypeId);
        valueWrapper = CacheableWrapperFactory.CreateInstance(
          pair.Value);
        Assert.IsNotNull(valueWrapper, "CacheableHashTable.GetChecksum:" +
          " Could not create an instance of typeId [{0}].",
          valueWrapper.TypeId);

        ckSum ^= (keyWrapper.GetChecksum(pair.Key) ^
          valueWrapper.GetChecksum(pair.Value));
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableIdentityHashMapWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableIdentityHashMapWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //CacheableIdentityHashMap map = new CacheableIdentityHashMap();
      Dictionary<object, object> map = new Dictionary<object, object>();
      ICollection<UInt32> keyTypeIds =
        CacheableWrapperFactory.GetRegisteredKeyTypeIds();
      ICollection<UInt32> valueTypeIds =
        CacheableWrapperFactory.GetRegisteredValueTypeIds();
      int keySize = 16;
      maxSize = maxSize / (keyTypeIds.Count * valueTypeIds.Count) + 1;
      CacheableKeyWrapper keyWrapper;
      CacheableWrapper valueWrapper;
      foreach (UInt32 keyTypeId in keyTypeIds)
      {
        int index = 0;
        foreach (UInt32 valueTypeId in valueTypeIds)
        {
          if ((valueTypeId == GeodeClassIds.CacheableASCIIStringHuge ||
            valueTypeId == GeodeClassIds.CacheableStringHuge)
            && !(keyTypeId == GeodeClassIds.CacheableBoolean))
          {
            continue;
          }
          if ((keyTypeId == GeodeClassIds.CacheableASCIIStringHuge ||
            keyTypeId == GeodeClassIds.CacheableStringHuge)
            && !(valueTypeId == GeodeClassIds.CacheableBoolean))
          {
            continue;
          }
          // null object does not work on server side during deserialization
          if (valueTypeId == GeodeClassIds.CacheableNullString)
          {
            continue;
          }

          keyWrapper = CacheableWrapperFactory.CreateKeyInstance(keyTypeId);
          Assert.IsNotNull(keyWrapper, "CacheableIdentityHashMapWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", keyTypeId);
          if (keyWrapper.MaxKeys <= index)
          {
            break;
          }
          keyWrapper.InitKey((int)(keyTypeId << 8) + index, keySize);

          if (!CacheableHelper.IsContainerTypeId(valueTypeId) &&
              !CacheableHelper.IsUnhandledType(valueTypeId))
          {
            valueWrapper = CacheableWrapperFactory.CreateInstance(valueTypeId);
            Assert.IsNotNull(valueWrapper, "CacheableIdentityHashMapWrapper.InitRandomValue:" +
              " Could not create an instance of typeId [{0}].", valueTypeId);
            valueWrapper.InitRandomValue(maxSize);
            map.Add(keyWrapper.CacheableKey, valueWrapper.Cacheable);
          }
          index++;
        }
      }
      m_cacheableObject = map;
    }

    public override uint GetChecksum(object cacheableObject)
    {

      //CacheableHashMap value = cacheableObject as CacheableHashMap;
      Dictionary<object, object> value = new Dictionary<object, object>();
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableKeyWrapper keyWrapper;
      CacheableWrapper valueWrapper;
      foreach (KeyValuePair<object, object> pair in value)
      {
        keyWrapper = CacheableWrapperFactory.CreateKeyInstance(
          pair.Key);
        Assert.IsNotNull(keyWrapper, "CacheableIdentityHashMap.GetChecksum:" +
          " Could not create an instance of typeId [{0}].",
          keyWrapper.TypeId);
        valueWrapper = CacheableWrapperFactory.CreateInstance(
          pair.Value);
        Assert.IsNotNull(valueWrapper, "CacheableIdentityHashMap.GetChecksum:" +
          " Could not create an instance of typeId [{0}].",
          valueWrapper.TypeId);

        ckSum ^= (keyWrapper.GetChecksum(pair.Key) ^
          valueWrapper.GetChecksum(pair.Value));
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableHashSetWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableHashSetWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      CacheableHashSet set = new CacheableHashSet();
      //List<object> set = new List<object>();

      //Dictionary set = new Dictionary();
      ICollection<UInt32> keyTypeIds =
        CacheableWrapperFactory.GetRegisteredKeyTypeIds();
      maxSize = maxSize / keyTypeIds.Count + 1;
      CacheableKeyWrapper wrapper;
      int keyIndex = 0;
      foreach (UInt32 typeId in keyTypeIds)
      {
        if (!CacheableHelper.IsContainerTypeId(typeId) &&
          !CacheableHelper.IsUnhandledType(typeId))
        {
          wrapper = CacheableWrapperFactory.CreateKeyInstance(typeId);
          Assert.IsNotNull(wrapper, "CacheableHashSetWrapper.InitRandomValue:" +
              " Could not create an instance of typeId [{0}].", typeId);
          wrapper.InitKey(keyIndex++, maxSize);


          set.Add(wrapper.CacheableKey);
        }
      }
      m_cacheableObject = set;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      CacheableHashSet value = cacheableObject as CacheableHashSet;
      //List<object> value = cacheableObject as List<object>;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableKeyWrapper wrapper;
      foreach (object key in value)
      {
        wrapper = CacheableWrapperFactory.CreateKeyInstance(key);
        Assert.IsNotNull(wrapper, "CacheableHashSet.GetChecksum:" +
          " Could not create an instance of typeId [{0}].", wrapper.TypeId);
        ckSum ^= wrapper.GetChecksum(key);
      }
      return ckSum;
    }

    public override int GetHashCodeN(object cacheableObject)
    {
      CacheableHashSet value = cacheableObject as CacheableHashSet;

      return value.GetHashCode();
    }
    #endregion
  }

  public class CacheableLinkedHashSetWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableLinkedHashSetWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      CacheableLinkedHashSet set = new CacheableLinkedHashSet();
      //Dictionary<object, object> set = new Dictionary<object, object>();
      //List<object> set = new List<object>();
      ICollection<UInt32> keyTypeIds =
        CacheableWrapperFactory.GetRegisteredKeyTypeIds();
      maxSize = maxSize / keyTypeIds.Count + 1;
      CacheableKeyWrapper wrapper;
      int keyIndex = 0;
      foreach (UInt32 typeId in keyTypeIds)
      {
        if (!CacheableHelper.IsContainerTypeId(typeId) &&
          !CacheableHelper.IsUnhandledType(typeId))
        {
          wrapper = CacheableWrapperFactory.CreateKeyInstance(typeId);
          Assert.IsNotNull(wrapper, "CacheableLinkedHashSetWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", typeId);
          wrapper.InitKey(keyIndex++, maxSize);
          set.Add(wrapper.CacheableKey);
        }
      }
      m_cacheableObject = set;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      //List<object> value = new List<object>();
      CacheableLinkedHashSet value = cacheableObject as CacheableLinkedHashSet;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableKeyWrapper wrapper;
      foreach (object key in value)
      {
        wrapper = CacheableWrapperFactory.CreateKeyInstance(key);
        Assert.IsNotNull(wrapper, "CacheableLinkedHashSet.GetChecksum:" +
          " Could not create an instance of typeId [{0}].", wrapper.TypeId);
        ckSum ^= wrapper.GetChecksum(key);
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableInt16ArrayWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableInt16ArrayWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      int arraySize = maxSize / sizeof(short);
      arraySize = arraySize > 1 ? arraySize : 2;
      short[] value = new short[arraySize];
      for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++)
      {
        value[arrayIndex] = (short)Util.Rand(short.MaxValue);
      }
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Int16[] obj = cacheableObject as Int16[];
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      short[] value = obj;
      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      foreach (short v in value)
      {
        short conv = v;
        int numBytes = sizeof(short);
        for (int i = 0; i < numBytes; i++)
        {
          ms.WriteByte((byte)(conv & 0xff));
          conv = (short)(conv >> 8);
        }
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    #endregion
  }

  public class CacheableInt32ArrayWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableInt32ArrayWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      int arraySize = maxSize / sizeof(int);
      arraySize = arraySize > 1 ? arraySize : 2;
      int[] value = new int[arraySize];
      for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++)
      {
        value[arrayIndex] = Util.Rand(int.MaxValue);
      }
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Int32[] obj = cacheableObject as Int32[];
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      int[] value = obj;
      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      foreach (int v in value)
      {
        int conv = v;
        int numBytes = sizeof(int);
        for (int i = 0; i < numBytes; i++)
        {
          ms.WriteByte((byte)(conv & 0xff));
          conv = conv >> 8;
        }
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    #endregion
  }

  public class CacheableInt64ArrayWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableInt64ArrayWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      int arraySize = maxSize / sizeof(long);
      arraySize = arraySize > 1 ? arraySize : 2;
      long[] value = new long[arraySize];
      long rnd;
      for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++)
      {
        rnd = (long)Util.Rand(int.MaxValue);
        rnd = (rnd << 32) + (long)Util.Rand(int.MaxValue);
        value[arrayIndex] = rnd;
      }
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Int64[] obj = cacheableObject as Int64[];
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      long[] value = obj;
      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      foreach (long v in value)
      {
        long conv = v;
        int numBytes = sizeof(long);
        for (int i = 0; i < numBytes; i++)
        {
          ms.WriteByte((byte)(conv & 0xff));
          conv = conv >> 8;
        }
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    #endregion
  }

  public class CacheableNullStringWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableNullStringWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //m_cacheableObject = CacheableString.Create((string)null);
      m_cacheableObject = null;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      //CacheableString value = cacheableObject as CacheableString;
      Assert.IsNull(cacheableObject, "GetChecksum: expected null object.");
      return (uint)0;
    }

    #endregion
  }

  public class CacheableEmptyStringWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableEmptyStringWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //m_cacheableObject = CacheableString.Create(string.Empty);
      m_cacheableObject = string.Empty;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      string value = cacheableObject as string;
      Assert.IsNotNull(value, "GetChecksum: expected non null object.");
      Assert.IsTrue(value == string.Empty || value.Length == 0, "Expected IsNullOrEmpty " + value.Length);
      return (uint)0;
    }

    #endregion
  }

  public class CacheableEmptyUnicodeStringWrapper : CacheableWrapper
  {
    // TODO : VJR : Is this a real UNICODE empty string?
    // See bugs #324 and #356 to add this wrapper when tracking them.

    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableEmptyUnicodeStringWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //m_cacheableObject = CacheableString.Create(string.Empty);
      m_cacheableObject = string.Empty;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      string value = cacheableObject as string;
      Assert.IsNotNull(value, "GetChecksum: expected non null object.");
      Assert.IsTrue(value == string.Empty || value.Length == 0, "Expected IsNullOrEmpty");
      return (uint)0;
    }

    #endregion
  }

  public class CacheableStringArrayWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableStringArrayWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      int arraySize = 16;
      maxSize = maxSize / arraySize;
      if (maxSize < 2)
      {
        maxSize = 2;
      }
      String[] value = new String[arraySize];
      for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++)
      {
        if (arrayIndex % 2 == 0)
        {
          byte[] buffer = Util.RandBytes(maxSize / 2);
          value[arrayIndex] = BitConverter.ToString(buffer).Replace("-", string.Empty);
        }
        else
        {
          byte[] buffer = Util.RandBytes(maxSize / 2);
          char[] charArray = new char[maxSize / 2];
          for (int i = 0; i < maxSize / 2; i++)
          {
            charArray[i] = (char)((int)buffer[i] + 0x0901);
          }
          value[arrayIndex] = new String(charArray);
        }
      }
      //m_cacheableObject = CacheableStringArray.Create(value);
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      String[] value = cacheableObject as String[];
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      foreach (String str in value)
      {
        foreach (char c in str)
        {
          ms.WriteByte((byte)(c & 0xff));
          byte uByte = (byte)((c >> 8) & 0xff);
          if (uByte != 0x00)
            ms.WriteByte(uByte);
        }
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    #endregion
  }

  public class CacheableUndefinedWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableUndefinedWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      m_cacheableObject = new CacheableUndefined();
    }

    public override uint GetChecksum(object cacheableObject)
    {
      CacheableUndefined value = cacheableObject as CacheableUndefined;
      // TODO: [sumedh] server sends back null; check this
      //Assert.IsNotNull(value, "GetChecksum: Null object.");

      return 0;
    }

    #endregion
  }

  public class CacheableVectorWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableVectorWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //CacheableVector vec = new CacheableVector();
      System.Collections.ArrayList vec = new System.Collections.ArrayList();

      ICollection<UInt32> valueTypeIds =
        CacheableWrapperFactory.GetRegisteredValueTypeIds();
      maxSize = maxSize / valueTypeIds.Count + 1;
      CacheableWrapper wrapper;
      foreach (UInt32 typeId in valueTypeIds)
      {
        if (!CacheableHelper.IsContainerTypeId(typeId) &&
          !CacheableHelper.IsUnhandledType(typeId))
        {
          wrapper = CacheableWrapperFactory.CreateInstance(typeId);
          Assert.IsNotNull(wrapper, "CacheableVectorWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", typeId);
          wrapper.InitRandomValue(maxSize);
          vec.Add(wrapper.Cacheable);
        }
      }
      m_cacheableObject = vec;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      System.Collections.ArrayList value = cacheableObject as System.Collections.ArrayList;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableWrapper wrapper;
      foreach (object obj in value)
      {
        if (obj == null)
        {
          continue;
        }
        wrapper = CacheableWrapperFactory.CreateInstance(obj);
        Assert.IsNotNull(wrapper, "CacheableVectorWrapper.GetChecksum:" +
          " Could not create an instance of typeId [{0}].", wrapper.TypeId);
        ckSum ^= wrapper.GetChecksum(obj);
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableObjectArrayWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableObjectArrayWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      CacheableObjectArray arr = new CacheableObjectArray();
      ICollection<UInt32> valueTypeIds =
        CacheableWrapperFactory.GetRegisteredValueTypeIds();
      maxSize = maxSize / valueTypeIds.Count + 1;
      CacheableWrapper wrapper;
      foreach (UInt32 typeId in valueTypeIds)
      {
        if (!CacheableHelper.IsContainerTypeId(typeId) &&
          !CacheableHelper.IsUnhandledType(typeId))
        {
          wrapper = CacheableWrapperFactory.CreateInstance(typeId);
          Assert.IsNotNull(wrapper, "CacheableObjectArrayWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", typeId);
          wrapper.InitRandomValue(maxSize);

          arr.Add(wrapper.Cacheable);
        }
      }
      m_cacheableObject = arr;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      CacheableObjectArray value = cacheableObject as CacheableObjectArray;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableWrapper wrapper;
      foreach (object obj in value)
      {
        if (obj == null)
        {
          continue;
        }
        wrapper = CacheableWrapperFactory.CreateInstance(obj);
        Assert.IsNotNull(wrapper, "CacheableObjectArrayWrapper.GetChecksum:" +
          " Could not create an instance of typeId [{0}].", wrapper.TypeId);
        ckSum ^= wrapper.GetChecksum(obj);
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableArrayListWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableArrayListWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //CacheableArrayList arrayList = new CacheableArrayList();
      List<object> arrayList = new List<object>();

      ICollection<UInt32> valueTypeIds =
        CacheableWrapperFactory.GetRegisteredValueTypeIds();
      maxSize = maxSize / valueTypeIds.Count + 1;
      CacheableWrapper wrapper;
      Util.Log(" arrayList size InitRandomValue ");
      foreach (UInt32 typeId in valueTypeIds)
      {
        if (!CacheableHelper.IsContainerTypeId(typeId) &&
          !CacheableHelper.IsUnhandledType(typeId))
        {
          wrapper = CacheableWrapperFactory.CreateInstance(typeId);
          Assert.IsNotNull(wrapper, "CacheableArrayListWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", typeId);
          wrapper.InitRandomValue(maxSize);
          arrayList.Add(wrapper.Cacheable);
        }
      }
      m_cacheableObject = arrayList;
      Util.Log(" arrayList size InitRandomValue " + arrayList.Count);
    }

    public override uint GetChecksum(object cacheableObject)
    {
      List<object> value = cacheableObject as List<object>;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableWrapper wrapper;
      foreach (object obj in value)
      {
        if (obj == null)
        {
          continue;
        }
        wrapper = CacheableWrapperFactory.CreateInstance(obj);
        Assert.IsNotNull(wrapper, "CacheableArrayListWrapper.GetChecksum:" +
          " Could not create an instance of typeId [{0}].", wrapper.TypeId);
        ckSum ^= wrapper.GetChecksum(obj);
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableStackWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableStackWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      //CacheableStack vec = new CacheableStack();
      Stack<object> vec = new Stack<object>();

      ICollection<UInt32> valueTypeIds =
        CacheableWrapperFactory.GetRegisteredValueTypeIds();
      maxSize = maxSize / valueTypeIds.Count + 1;
      CacheableWrapper wrapper;
      foreach (UInt32 typeId in valueTypeIds)
      {
        if (!CacheableHelper.IsContainerTypeId(typeId) &&
            !CacheableHelper.IsUnhandledType(typeId))
        {
          wrapper = CacheableWrapperFactory.CreateInstance(typeId);
          Assert.IsNotNull(wrapper, "CacheableStackWrapper.InitRandomValue:" +
            " Could not create an instance of typeId [{0}].", typeId);
          wrapper.InitRandomValue(maxSize);
          vec.Push(wrapper.Cacheable);
        }
      }
      m_cacheableObject = vec;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      Stack<object> value = cacheableObject as Stack<object>;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      uint ckSum = 0;
      CacheableWrapper wrapper;
      foreach (Object obj in value)
      {
        if (obj == null)
        {
          continue;
        }
        wrapper = CacheableWrapperFactory.CreateInstance(obj);
        Assert.IsNotNull(wrapper, "CacheableStackWrapper.GetChecksum:" +
          " Could not create an instance of typeId [{0}].", wrapper.TypeId);
        ckSum ^= wrapper.GetChecksum(obj);
      }
      return ckSum;
    }

    #endregion
  }

  public class CacheableObjectWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableObjectWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      CData value = CacheableHelper.RandCData();
      m_cacheableObject = CacheableObject.Create(value);
    }

    public override uint GetChecksum(object cacheableObject)
    {
      CacheableObject obj = cacheableObject as CacheableObject;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      CData value = (CData)obj.Value;
      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      int first = value.First;
      int numBytes = sizeof(int);
      for (int i = 0; i < numBytes; i++)
      {
        ms.WriteByte((byte)(first & 0xff));
        first = first >> 8;
      }
      long second = value.Second;
      numBytes = sizeof(long);
      for (int i = 0; i < numBytes; i++)
      {
        ms.WriteByte((byte)(second & 0xff));
        second = second >> 8;
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }


    #endregion
  }

  public class CacheableObjectXmlWrapper : CacheableWrapper
  {
    #region Static factory creation function

    public static CacheableWrapper Create()
    {
      return new CacheableObjectXmlWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      CData value = CacheableHelper.RandCData();
      m_cacheableObject = CacheableObjectXml.Create(value);
    }

    public override uint GetChecksum(object cacheableObject)
    {
      CacheableObjectXml obj = cacheableObject as CacheableObjectXml;
      Assert.IsNotNull(obj, "GetChecksum: Null object.");

      CData value = (CData)obj.Value;
      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      int first = value.First;
      int numBytes = sizeof(int);
      for (int i = 0; i < numBytes; i++)
      {
        ms.WriteByte((byte)(first & 0xff));
        first = first >> 8;
      }
      long second = value.Second;
      numBytes = sizeof(long);
      for (int i = 0; i < numBytes; i++)
      {
        ms.WriteByte((byte)(second & 0xff));
        second = second >> 8;
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    #endregion
  }

  public class PdxCDataWrapper : CacheableKeyWrapper
  {
    #region Static factory creation function

    public static CacheableKeyWrapper Create()
    {
      return new PdxCDataWrapper();
    }

    #endregion

    #region CacheableWrapper Members

    public override void InitRandomValue(int maxSize)
    {
      PdxCData value = CacheableHelper.RandPdxCData();
      m_cacheableObject = value;
    }

    public override uint GetChecksum(object cacheableObject)
    {
      PdxCData value = cacheableObject as PdxCData;
      Assert.IsNotNull(value, "GetChecksum: Null object.");

      System.IO.MemoryStream ms = new System.IO.MemoryStream();
      int first = value.First;
      int numBytes = sizeof(int);
      for (int i = 0; i < numBytes; i++)
      {
        ms.WriteByte((byte)(first & 0xff));
        first = first >> 8;
      }
      long second = value.Second;
      numBytes = sizeof(long);
      for (int i = 0; i < numBytes; i++)
      {
        ms.WriteByte((byte)(second & 0xff));
        second = second >> 8;
      }
      return CacheableHelper.CRC32(ms.ToArray());
    }

    #endregion

    public override int MaxKeys
    {
      get { return 10; }
    }

    public override void InitKey(int keyIndex, int maxSize)
    {
      //PdxCData value = CacheableHelper.RandPdxCData();
      PdxCData value = new PdxCData(keyIndex, keyIndex * 2999);
      m_cacheableObject = value;
    }
  }

  public class TypesClass
  {
    private Object[,] typesArray;
    private Object NullItem = null;
    public TypesClass()
    {
      typesArray = new Object[,] {
      { /*TypeIds.BoolId ,*/ false, false, false, false, false, false, false, false },
      { /*TypeIds.ByteId , */(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7 },
      { /*TypeIds.CharId ,*/ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' },
      { /*TypeIds.DecimalId , */(decimal)0.0m, (decimal)1.0m, (decimal)2.0m, (decimal)3.0m , (decimal)4.0m, (decimal)5.0m, (decimal)6.0m, (decimal)7.0m },
      { /*TypeIds.DoubleId , */(double)0.0, (double)1.0, (double)2.0, (double)3.0 , (double)4.0, (double)5.0, (double)6.0, (double)7.0 },
      { /*TypeIds.FloatId , */(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f , (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f },
      { /*TypeIds.IntId , */0, 1, 2, 3 ,4 , 5, 6, 7},
      { /*TypeIds.LongId , */(long)0L, (long)1L, (long)2L, (long)3L ,(long)4L , (long)5L, (long)6L, (long)7L},
      { /*TypeIds.SbyteId , */(sbyte)0, (sbyte)1, (sbyte)2, (sbyte)3 ,(sbyte)4 , (sbyte)5, (sbyte)6, (sbyte)7 },
      { /*TypeIds.ShortId , */(short)0, (short)1, (short)2, (short)3 ,(short)4 , (short)5, (short)6, (short)7},
      { /*TypeIds.StructId ,*/ 0, 1, 2, 3 ,4 , 5, 6, 7},
      { /*TypeIds.UintId ,*/ (uint)0u, (uint)1u, (uint)2u, (uint)3u ,(uint)4u , (uint)5u, (uint)6u, (uint)7u},
      { /*TypeIds.UlongId ,*/ (ulong)0UL, (ulong)1UL, (ulong)2UL, (ulong)3UL ,(ulong)4UL , (ulong)5UL, (ulong)6UL, (ulong)7UL},
      { /*TypeIds.UshortId ,*/ (ushort)0, (ushort)1, (ushort)2, (ushort)3 ,(ushort)4 , (ushort)5, (ushort)6, (ushort)7 },
      { /*TypeIds.StringId ,*/ "Zero", "One", "Two", "Three" , "Four", "Five", "Six", "Seven" },
      { /*TypeIds.ObjectId ,*/ (object)"Zero", (object)"One", (object)"Two", (object)"Three" , (object)"Four", (object)"Five", (object)"Six", (object)"Seven" },
      { /*TypeIds.BoolArrayId ,*/ new bool[]{false, false, false, false, false, false, false, false}, new bool[]{false, false, false, false, false, false, false, false}, 
        new bool[]{false, false, false, false, false, false, false, false}, new bool[]{false, false, false, false, false, false, false, false}, 
        new bool[]{false, false, false, false, false, false, false, false}, new bool[]{false, false, false, false, false, false, false, false}, 
        new bool[]{false, false, false, false, false, false, false, false}, new bool[]{false, false, false, false, false, false, false, false} },
      { /*TypeIds.ByteArrayId ,*/ new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7}, new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7}, new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7}, 
        new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7}, new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7}, new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7}, new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7},
        new byte[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7} },
      { /*TypeIds.CharArrayId ,*/ new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}, new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}, new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}, 
        new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}, new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}, new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}, new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'},
        new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'} },
      { /*TypeIds.DecimalArrayId ,*/ new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7}, new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7}, new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7}, 
        new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7}, new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7}, new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7}, new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7},
        new decimal[]{(decimal)0, (decimal)1, (decimal)2, (decimal)3, (decimal)4, (decimal)5, (decimal)6, (decimal)7} },      
      { /*TypeIds.doubleArrayId ,*/ new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D}, new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D}, new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D}, 
        new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D}, new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D}, new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D}, new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D},
        new Double[]{(Double)1.7E+0D, (Double)1.7E+1D, (Double)1.7E+2D, (Double)1.7E+3D, (Double)1.7E+4D, (Double)1.7E+5D, (Double)1.7E+6D, (Double)1.7E+7D} },
      { /*TypeIds.floatArrayId ,*/ new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f}, new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f}, new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f}, 
        new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f}, new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f}, new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f}, new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f},
        new float[]{(float)0.0f, (float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)6.0f, (float)7.0f} },
      { /*TypeIds.intArrayId ,*/ new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7}, new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7}, new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7}, 
        new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7}, new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7}, new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7}, new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7},
        new int[]{(int)0, (int)1, (int)2, (int)3, (int)4, (int)5, (int)6, (int)7} },
      { /*TypeIds.longArrayId ,*/ new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}, new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}, new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}, 
        new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}, new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}, new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}, new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L},
        new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L} },
      { /*TypeIds.sbyteArrayId ,*/ new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 }, new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 }, new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 }, 
        new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 }, new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 }, new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 }, new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 },
        new sbyte[]{(sbyte)0 , (sbyte)1 , (sbyte)2 , (sbyte)3 , (sbyte)4 , (sbyte)5 , (sbyte)6 , (sbyte)7 } },
      { /*TypeIds.shortArrayId ,*/ new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 }, new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 }, new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 }, 
        new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 }, new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 }, new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 }, new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 },
        new short[]{(short)0 , (short)1 , (short)2 , (short)3 , (short)4 , (short)5 , (short)6 , (short)7 } },
      { /*TypeIds.StructArrayId ,*/ new int[]{0, 1, 2, 3 ,4 , 5, 6, 7},new int[]{0, 1, 2, 3 ,4 , 5, 6, 7},new int[]{0, 1, 2, 3 ,4 , 5, 6, 7},new int[]{0, 1, 2, 3 ,4 , 5, 6, 7},new int[]{0, 1, 2, 3 ,4 , 5, 6, 7},new int[]{0, 1, 2, 3 ,4 , 5, 6, 7},new int[]{0, 1, 2, 3 ,4 , 5, 6, 7},new int[]{0, 1, 2, 3 ,4 , 5, 6, 7}},
      { /*TypeIds.uintArrayId ,*/ new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 }, new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 }, new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 }, 
        new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 }, new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 }, new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 }, new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 },
        new uint[]{(uint)0 , (uint)1 , (uint)2 , (uint)3 , (uint)4 , (uint)5 , (uint)6 , (uint)7 } },
      { /*TypeIds.ulongArrayId ,*/ new ulong[]{(uint)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 }, new ulong[]{(ulong)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 }, new ulong[]{(ulong)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 }, 
        new ulong[]{(ulong)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 }, new ulong[]{(ulong)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 }, new ulong[]{(ulong)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 }, new ulong[]{(ulong)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 },
        new ulong[]{(ulong)0 , (ulong)1 , (ulong)2 , (ulong)3 , (ulong)4 , (ulong)5 , (ulong)6 , (ulong)7 } },
      { /*TypeIds.ushortArrayId ,*/ new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 }, new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 }, new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 }, 
        new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 }, new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 }, new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 }, new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 },
        new ushort[]{(ushort)0 , (ushort)1 , (ushort)2 , (ushort)3 , (ushort)4 , (ushort)5 , (ushort)6 , (ushort)7 } },      
      { /*TypeIds.stringArrayId ,*/ new string[]{"0" ,  "1" ,  "2" ,  "3" ,  "4" ,  "5" ,  "6" ,  "7" }, new string[]{ "0" ,  "1" ,  "2" ,  "3" ,  "4" ,  "5" ,  "6" ,  "7" }, new string[]{ "0" ,  "1" ,  "2" ,  "3" ,  "4" ,  "5" ,  "6" ,  "7" }, 
        new string[]{ "0" ,  "1" ,  "2" ,  "3" ,  "4" ,  "5" ,  "6" ,  "7" }, new string[]{ "0" ,  "1" ,  "2" ,  "3" ,  "4" ,  "5" ,  "6" ,  "7" }, new string[]{ "0" ,  "1" ,  "2" ,  "3" ,  "4" ,  "5" ,  "6" ,  "7" }, new string[]{ "0" ,  "1" ,  "2" ,  "3" ,  "4" ,  "5" ,  "6" ,  "7" },
        new string[]{ "0" ,  "1" ,  "2" ,  "3" ,  "4",  "5" ,  "6" ,  "7" } },
      { /*TypeIds.ObjectArrayId ,*/ new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 }, new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 }, new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 }, 
        new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 }, new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 }, new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 }, new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 },
        new object[]{(object)0 , (object)1 , (object)2 , (object)3 , (object)4 , (object)5 , (object)6 , (object)7 } }      
      };
    }

    public enum TypeIds
    {
      BoolId = 0,
      ByteId,
      CharId,
      DecimalId,
      DoubleId,
      FloatId,
      IntId,
      LongId,
      SbyteId,
      ShortId,
      StructId,
      UintId,
      UlongId,
      UshortId,
      StringId,
      ObjectId,
      //These all array types will be values only.
      BoolArrayId,
      ByteArrayId,
      CharArrayId,
      DecimalArrayId,
      DoubleArrayId,
      FloatArrayId,
      IntArrayId,
      LongArrayId,
      SbyteArrayId,
      ShortArrayId,
      StructArrayId,
      UintArrayId,
      UlongArrayId,
      UshortArrayId,
      StringArrayId,
      ObjectArrayId
    };

    public TItem GetTypeItem<TItem>(int KeyId, int index)
    {
      //Util.Log("TItem type is {0} ", typeof(TItem));
      return (TItem)typesArray[KeyId, index];
    }

    public TItem GetArrayTypeItem<TItem>(int KeyId, int index)
    {
      //Util.Log("TItem type is {0} keyid = {1} index = {2}", typeof(TItem), KeyId, index);
      TItem temp = (TItem)typesArray[KeyId, index];
      return temp;
    }

    public Object[,] GetTypesArray()
    {
      return typesArray;
    }

    public Object GetNullItem()
    {
      return NullItem;
    }

  };
  #endregion
}