private void layers(byte[] data)
        {
            PbfReader tileReader = new PbfReader(data);

            while (tileReader.NextByte())
            {
                if (_Validate)
                {
                    if (!ConstantsAsDictionary.TileType.ContainsKey(tileReader.Tag))
                    {
                        throw new System.Exception(string.Format("Unknown tile tag: {0}", tileReader.Tag));
                    }
                }
                if (tileReader.Tag == (int)TileType.Layers)
                {
                    string    name         = null;
                    byte[]    layerMessage = tileReader.View();
                    PbfReader layerView    = new PbfReader(layerMessage);
                    while (layerView.NextByte())
                    {
                        if (layerView.Tag == (int)LayerType.Name)
                        {
                            ulong strLen = (ulong)layerView.Varint();
                            name = layerView.GetString(strLen);
                        }
                        else
                        {
                            layerView.Skip();
                        }
                    }
                    if (_Validate)
                    {
                        if (string.IsNullOrEmpty(name))
                        {
                            throw new System.Exception("Layer missing name");
                        }
                        if (_Layers.ContainsKey(name))
                        {
                            throw new System.Exception(string.Format("Duplicate layer names: {0}", name));
                        }
                    }
                    _Layers.Add(name, layerMessage);
                }
                else
                {
                    tileReader.Skip();
                }
            }
        }
        private VectorTileLayer getLayer(byte[] data)
        {
            VectorTileLayer layer       = new VectorTileLayer(data);
            PbfReader       layerReader = new PbfReader(layer.Data);

            while (layerReader.NextByte())
            {
                int layerType = layerReader.Tag;
                if (_Validate)
                {
                    if (!ConstantsAsDictionary.LayerType.ContainsKey(layerType))
                    {
                        throw new System.Exception(string.Format("Unknown layer type: {0}", layerType));
                    }
                }
                switch ((LayerType)layerType)
                {
                case LayerType.Version:
                    ulong version = (ulong)layerReader.Varint();
                    layer.Version = version;
                    break;

                case LayerType.Name:
                    ulong strLength = (ulong)layerReader.Varint();
                    layer.Name = layerReader.GetString(strLength);
                    break;

                case LayerType.Extent:
                    layer.Extent = (ulong)layerReader.Varint();
                    break;

                case LayerType.Keys:
                    byte[] keyBuffer = layerReader.View();
                    string key       = Encoding.UTF8.GetString(keyBuffer, 0, keyBuffer.Length);
                    layer.Keys.Add(key);
                    break;

                case LayerType.Values:
                    byte[]    valueBuffer = layerReader.View();
                    PbfReader valReader   = new PbfReader(valueBuffer);
                    while (valReader.NextByte())
                    {
                        switch ((ValueType)valReader.Tag)
                        {
                        case ValueType.String:
                            byte[] stringBuffer = valReader.View();
                            string value        = Encoding.UTF8.GetString(stringBuffer, 0, stringBuffer.Length);
                            layer.Values.Add(value);
                            break;

                        case ValueType.Float:
                            float snglVal = valReader.GetFloat();
                            layer.Values.Add(snglVal);
                            break;

                        case ValueType.Double:
                            double dblVal = valReader.GetDouble();
                            layer.Values.Add(dblVal);
                            break;

                        case ValueType.Int:
                            long i64 = valReader.Varint();
                            layer.Values.Add(i64);
                            break;

                        case ValueType.UInt:
                            long u64 = valReader.Varint();
                            layer.Values.Add(u64);
                            break;

                        case ValueType.SInt:
                            long s64 = valReader.Varint();
                            layer.Values.Add(s64);
                            break;

                        case ValueType.Bool:
                            long b = valReader.Varint();
                            layer.Values.Add(b == 1);
                            break;

                        default:
                            throw new System.Exception(string.Format(
                                                           NumberFormatInfo.InvariantInfo
                                                           , "NOT IMPLEMENTED valueReader.Tag:{0} valueReader.WireType:{1}"
                                                           , valReader.Tag
                                                           , valReader.WireType
                                                           ));
                            //uncomment the following lines when not throwing!!
                            //valReader.Skip();
                            //break;
                        }
                    }
                    break;

                case LayerType.Features:
                    layer.AddFeatureData(layerReader.View());
                    break;

                default:
                    layerReader.Skip();
                    break;
                }
            }

            if (_Validate)
            {
                if (string.IsNullOrEmpty(layer.Name))
                {
                    throw new System.Exception("Layer has no name");
                }
                if (0 == layer.Version)
                {
                    throw new System.Exception(string.Format("Layer [{0}] has invalid version. Only version 2.x of 'Mapbox Vector Tile Specification' (https://github.com/mapbox/vector-tile-spec) is supported.", layer.Name));
                }
                if (2 != layer.Version)
                {
                    throw new System.Exception(string.Format("Layer [{0}] has invalid version: {1}. Only version 2.x of 'Mapbox Vector Tile Specification' (https://github.com/mapbox/vector-tile-spec) is supported.", layer.Name, layer.Version));
                }
                if (0 == layer.Extent)
                {
                    throw new System.Exception(string.Format("Layer [{0}] has no extent.", layer.Name));
                }
                if (0 == layer.FeatureCount())
                {
                    throw new System.Exception(string.Format("Layer [{0}] has no features.", layer.Name));
                }
                //TODO: find equivalent of 'Distinct()' for NET20
#if !NET20
                if (layer.Values.Count != layer.Values.Distinct().Count())
                {
                    throw new System.Exception(string.Format("Layer [{0}]: duplicate attribute values found", layer.Name));
                }
#endif
            }

            return(layer);
        }