Make output more clear

The output and code is now better structured. Layers, classes and types are alphabetically ordered for semantical comparison
```
name: open-streets
tile: z/y/x
features: [features.length]
layers: [layers.length]
classes: [classes.length]
types: [types.length]
[layer]
    [class]
        [type]
```

compare-vector-tiles/index.js

@@ -2,44 +2,155 @@ var fs = require('fs');
 var VectorTile = require('vector-tile').VectorTile;
 var Protobuf = require('pbf');
 
-var tile = new VectorTile(new Protobuf(fs.readFileSync('./vector.pbf')));
-
-// Contains a map of all layers
-tile.layers;
-
-for(var k in tile.layers) {
-	var layer = tile.layers[k];
-	// place_label: 61 Features
-	console.log(k+": "+tile.layers[k].length+" Features");
-
+function getTileInfo(layers) {
+	var layerCount = 0;
+	var featureCount = 0;
 	var classSet = new Set();
 	var typeSet = new Set();
-	for(var i=0; i < layer.length; ++i) {
-		if(layer.feature(i).properties.class) {
-			classSet.add(layer.feature(i).properties.class);
+
+	for(var i in layers) {
+		++layerCount;
+		var layer = layers[i];
+		featureCount += layer.length;
+		for(var j = 0; j < layer.length; ++j) {
+			var feature = layer.feature(j);
+			if(feature.properties.class) {
+				classSet.add(feature.properties.class);
+			}
+			if(feature.properties.type) {
+				typeSet.add(feature.properties.class);
+			}
 		}
-		if(layer.feature(i).properties.type) {
-			typeSet.add("class: "+layer.feature(i).properties.class+" type: "+layer.feature(i).properties.type);
+	}
+	return { "layers": layerCount, "features": featureCount, "classes": classSet.size, "types": typeSet.size };
+}
+
+function containsClass(classSet, className) {
+	var containsClass = false;
+	for(var item of classSet) {
+		if(item.name === className) {
+			containsClass = true;
+			return containsClass;
 		} else {
-			//typeSet.add(layer.feature(i).properties);
+			containsClass = false;
 		}
 	}
-	// prints all classes available in this layer
-	console.log("Has classes: ");
+	return containsClass;
+}
+
+function addType(classSet, className, type) {
+	for(var item of classSet) {
+		if(item.name === className) {
+			if(type) {
+				item.types.add(type);
+			} else {
+				item.types.add("no type");
+			}
+		}
+	}
+	return classSet;
+}
+
+function addClass(classSet, className, type) {
+	var layerClass = {
+		"name": className,
+		"types": new Set()
+	};
+
+	if(type) {
+		layerClass.types.add(type);
+	} else {
+		layerClass.types.add("no type");
+		//layerClass.types.add(layer.feature(i).properties);
+	}
+	classSet.add(layerClass);
+	return classSet;
+}
+
+function getSortedItems(unsortedItems, sortByName) {
+	var sortedItems = [];
+	for(var unsortedItem of unsortedItems) {
+		sortedItems.push(unsortedItem);
+	}
+	if(sortByName) {
+		sortedItems.sort(function(a, b) { 
+		    if(a.name > b.name) {
+		      return 1;
+		    }
+		    if (a.name < b.name) {
+		      return -1;
+		    }
+			return 0;
+		});
+	} else {
+		sortedItems.sort();
+	}
+	return sortedItems;
+}
+
+function getSortedLayers(layers) {
+	var sortedLayerNames = [];
+	for(var i in layers) {
+		sortedLayerNames.push(i);
+	}
+	sortedLayerNames.sort();
+	var sortedLayers = [];
+	for(var layerName of sortedLayerNames) {
+		sortedLayers.push({"name": layerName, "layer": layers[layerName]});
+	}
+	return sortedLayers;
+}
+
+function getLayerResult(layerObject, amountOfFeatures) {
+	console.log("\n" + layerObject.name + " (features: " + amountOfFeatures + ")");
+
+	var classSet = new Set();
+	for(var j=0; j < layerObject.layer.length; ++j) {
+		var properties = layerObject.layer.feature(j).properties;
+		var className = properties.class;
+		var type = properties.type;
+		if(className) {
+			if(containsClass(classSet, className)){
+				classSet = addType(classSet, className, type);
+			} else {
+				classSet = addClass(classSet, className, type);
+			}
+		}
+	}
+	return classSet;
+}
+
+function printLayerResult(classSet) {
 	if(classSet.size === 0) {
-		console.log("no classes")
+		console.log("\t"+" no class")
 	} else {
-		for(var item of classSet ) {
-			console.log(item);
-		}
-	}
-	// prints all types available in this class with classname
-	console.log("Has types: ");
-	if(typeSet.size === 0) {
-		console.log("no types")
-	} else {
-		for(var item of typeSet ) {
-			console.log(item);
+		for(var item of getSortedItems(classSet, true)) {
+			console.log("\t"+item.name);
+			for(var sortedType of getSortedItems(item.types)) {
+				console.log("\t" + "\t" + sortedType);
+			}
 		}
 	}
 }
+
+function printProlog(layers) {
+	var tileInfo = getTileInfo(layers);
+	console.log("name: open-streets");
+	console.log("tile: 10/4141/5356");
+	console.log("features: " + tileInfo.features);
+	console.log("layers: " + tileInfo.layers);
+	console.log("classes: " + tileInfo.classes);
+	console.log("types: " + tileInfo.types);
+}
+
+function printResult(layers) {
+	var layerArray = getSortedLayers(layers);
+	for(var i in layerArray) {
+		var layerObject = layerArray[i];
+		printLayerResult(getLayerResult(layerObject, layers[layerObject.name].length));
+	}
+}
+
+var tile = new VectorTile(new Protobuf(fs.readFileSync('./vector.pbf')));
+printProlog(tile.layers);
+printResult(tile.layers);