/*
* Copyright 2008 Google Inc.
*
* Licensed 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.
*/
package com.google.gwt.soyc;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* Compile Report information about a compiled module.
*/
public class GlobalInformation {
private static final SizeBreakdown[] EMPTY_SIZE_BREAKDOWN = new SizeBreakdown[0];
public Map<String, Map<String, String>> dependencies = null;
private Map<String, String> classToPackage = new TreeMap<String, String>();
private HashMap<String, HashSet<String>> classToWhatItDependsOn = new HashMap<String, HashSet<String>>();
private Map<Integer, SizeBreakdown> exclusiveCodeBreakdowns = new HashMap<Integer, SizeBreakdown>();
private SizeBreakdown initialCodeBreakdown = new SizeBreakdown(
"Initially downloaded code", "initial");
private SizeBreakdown leftoversBreakdown = new SizeBreakdown(
"Leftovers code, code not in any other fragment", "leftovers");
private Map<String, TreeSet<String>> packageToClasses = new TreeMap<String, TreeSet<String>>();
private final String permutationId;
private ArrayList<Integer> initialFragmentLoadSequence = new ArrayList<Integer>();
private HashMap<Integer, List<String>> fragmentDescriptors =
new HashMap<Integer, List<String>>();
private SizeBreakdown totalCodeBreakdown = new SizeBreakdown("Total program",
"total");
public GlobalInformation(String permutationId) {
this.permutationId = permutationId;
}
public SizeBreakdown[] allSizeBreakdowns() {
List<SizeBreakdown> breakdowns = new ArrayList<SizeBreakdown>();
breakdowns.add(totalCodeBreakdown);
breakdowns.add(initialCodeBreakdown);
if (getNumFragments() > 0) {
breakdowns.add(leftoversBreakdown);
for (int fragment = 1; fragment <= getNumFragments(); fragment++) {
breakdowns.add(fragmentCodeBreakdown(fragment));
}
}
return breakdowns.toArray(EMPTY_SIZE_BREAKDOWN);
}
/**
* Computes all package sizes.
*/
public void computePackageSizes() {
for (SizeBreakdown breakdown : allSizeBreakdowns()) {
computePackageSizes(breakdown.packageToSize, breakdown.classToSize);
}
}
/**
* Gets the mapping from each class to its package.
*
* @return classToPackage
*/
public final Map<String, String> getClassToPackage() {
return classToPackage;
}
/**
* Gets the mapping from a class to what it depends on.
*
* @return classToWhatItDependsOn
*/
public final HashMap<String, HashSet<String>> getClassToWhatItDependsOn() {
return classToWhatItDependsOn;
}
/**
* Gets the exclusive code breakdown.
*
* @return exclusiveCodeBreakdown
*/
public final Map<Integer, SizeBreakdown> getExclusiveCodeBreakdowns() {
return exclusiveCodeBreakdowns;
}
/**
* Gets the initial fragment size breakdown.
*
* @return initialCodeBreakdown
*/
public final SizeBreakdown getInitialCodeBreakdown() {
return initialCodeBreakdown;
}
/**
* Gets the leftovers fragment size breakdown.
*
* @return leftoversCodeBreakdown
*/
public final SizeBreakdown getLeftoversBreakdown() {
return leftoversBreakdown;
}
/**
* Gets the number of fragments..
*
* @return the number of fragments.
*/
public final int getNumFragments() {
return fragmentDescriptors.size();
}
/**
* Gets the mapping from packages to classes.
*
* @return packageToClasses
*/
public final Map<String, TreeSet<String>> getPackageToClasses() {
return packageToClasses;
}
public String getPermutationId() {
return permutationId;
}
/**
* Gets the initial load sequence.
*
* @return initialFragmentLoadSequence
*/
public final ArrayList<Integer> getInitialFragmentLoadSequence() {
return initialFragmentLoadSequence;
}
/**
* Adds a descriptor (a split point) to a fragment.
*
* @param fragment the fragment number.
* @param desc a string describing a split point for fragment <code>fragment</code>
*
*/
public final void addFragmentDescriptor(int fragment, String desc) {
List<String> descriptions = fragmentDescriptors.get(fragment);
if (descriptions == null) {
descriptions = new ArrayList<String>();
fragmentDescriptors.put(fragment, descriptions);
}
descriptions.add(desc);
}
/**
* Gets the descriptors associated with a
* fragment.
*
* @param fragment the fragment number
* @return a list of descriptors (each representing a single split point.
*/
public final List<String> getFragmentDescriptors(int fragment) {
return fragmentDescriptors.get(fragment);
}
/**
* Gets the total code breakdown.
*
* @return totalCodeBreakdown
*/
public final SizeBreakdown getTotalCodeBreakdown() {
return totalCodeBreakdown;
}
/**
* Gets an exclusive code breakdown for a fragment.
*
* @param fragment the fragment id
* @return exlusive code breakdown for fragment
*/
public SizeBreakdown fragmentCodeBreakdown(int fragment) {
assert fragment >= 1 && fragment <= getNumFragments();
if (!exclusiveCodeBreakdowns.containsKey(fragment)) {
exclusiveCodeBreakdowns.put(fragment, new SizeBreakdown("split point " + fragment
+ ": " + fragmentDescriptors.get(fragment), "fragment" + fragment));
}
return exclusiveCodeBreakdowns.get(fragment);
}
/**
* Computes package sizes from class sizes. TODO(spoon) move this to the
* SizeBreakdown class.
*
* @param packageToSize mapping from packages to their sizes
* @param classToSize mapping from classes to their sizes
*/
private void computePackageSizes(Map<String, Integer> packageToSize,
Map<String, Integer> classToSize) {
packageToSize.clear();
for (String packageName : packageToClasses.keySet()) {
packageToSize.put(packageName, 0);
for (String className : packageToClasses.get(packageName)) {
if (classToSize.containsKey(className)) {
int curSize = classToSize.get(className);
int newSize = curSize + packageToSize.get(packageName);
packageToSize.put(packageName, newSize);
}
}
}
}
}