dx/src/com/android/dx/dex/file/MixedItemSection.java - platform/dalvik - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * 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.android.dx.dex.file;

 import com.android.dex.util.ExceptionWithContext;
 import com.android.dx.util.AnnotatedOutput;
 import com.android.dx.util.Hex;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.TreeMap;

 /**
  * A section of a {@code .dex} file which consists of a sequence of
  * {@link OffsettedItem} objects, which may each be of a different concrete
  * class and/or size.
  *
  * <b>Note:</b> It is invalid for an item in an instance of this class to
  * have a larger alignment requirement than the alignment of this instance.
  */
 public final class MixedItemSection extends Section {
     static enum SortType {
         /** no sorting */
         NONE,

         /** sort by type only */
         TYPE,

         /** sort in class-major order, with instances sorted per-class */
         INSTANCE;
     };

     /** {@code non-null;} sorter which sorts instances by type */
     private static final Comparator<OffsettedItem> TYPE_SORTER =
         new Comparator<OffsettedItem>() {
         public int compare(OffsettedItem item1, OffsettedItem item2) {
             ItemType type1 = item1.itemType();
             ItemType type2 = item2.itemType();
             return type1.compareTo(type2);
         }
     };

     /** {@code non-null;} the items in this part */
     private final ArrayList<OffsettedItem> items;

     /** {@code non-null;} items that have been explicitly interned */
     private final HashMap<OffsettedItem, OffsettedItem> interns;

     /** {@code non-null;} how to sort the items */
     private final SortType sort;

     /**
      * {@code >= -1;} the current size of this part, in bytes, or {@code -1}
      * if not yet calculated
      */
     private int writeSize;

     /**
      * Constructs an instance. The file offset is initially unknown.
      *
      * @param name {@code null-ok;} the name of this instance, for annotation
      * purposes
      * @param file {@code non-null;} file that this instance is part of
      * @param alignment {@code > 0;} alignment requirement for the final output;
      * must be a power of 2
      * @param sort how the items should be sorted in the final output
      */
     public MixedItemSection(String name, DexFile file, int alignment,
             SortType sort) {
         super(name, file, alignment);

         this.items = new ArrayList<OffsettedItem>(100);
         this.interns = new HashMap<OffsettedItem, OffsettedItem>(100);
         this.sort = sort;
         this.writeSize = -1;
     }

     /** {@inheritDoc} */
     @Override
     public Collection<? extends Item> items() {
         return items;
     }

     /** {@inheritDoc} */
     @Override
     public int writeSize() {
         throwIfNotPrepared();
         return writeSize;
     }

     /** {@inheritDoc} */
     @Override
     public int getAbsoluteItemOffset(Item item) {
         OffsettedItem oi = (OffsettedItem) item;
         return oi.getAbsoluteOffset();
     }

     /**
      * Gets the size of this instance, in items.
      *
      * @return {@code >= 0;} the size
      */
     public int size() {
         return items.size();
     }

     /**
      * Writes the portion of the file header that refers to this instance.
      *
      * @param out {@code non-null;} where to write
      */
     public void writeHeaderPart(AnnotatedOutput out) {
         throwIfNotPrepared();

         if (writeSize == -1) {
             throw new RuntimeException("write size not yet set");
         }

         int sz = writeSize;
         int offset = (sz == 0) ? 0 : getFileOffset();
         String name = getName();

         if (name == null) {
             name = "<unnamed>";
         }

         int spaceCount = 15 - name.length();
         char[] spaceArr = new char[spaceCount];
         Arrays.fill(spaceArr, ' ');
         String spaces = new String(spaceArr);

         if (out.annotates()) {
             out.annotate(4, name + "_size:" + spaces + Hex.u4(sz));
             out.annotate(4, name + "_off: " + spaces + Hex.u4(offset));
         }

         out.writeInt(sz);
         out.writeInt(offset);
     }

     /**
      * Adds an item to this instance. This will in turn tell the given item
      * that it has been added to this instance. It is invalid to add the
      * same item to more than one instance, nor to add the same items
      * multiple times to a single instance.
      *
      * @param item {@code non-null;} the item to add
      */
     public void add(OffsettedItem item) {
         throwIfPrepared();

         try {
             if (item.getAlignment() > getAlignment()) {
                 throw new IllegalArgumentException(
                         "incompatible item alignment");
             }
         } catch (NullPointerException ex) {
             // Elucidate the exception.
             throw new NullPointerException("item == null");
         }

         items.add(item);
     }

     /**
      * Interns an item in this instance, returning the interned instance
      * (which may not be the one passed in). This will add the item if no
      * equal item has been added.
      *
      * @param item {@code non-null;} the item to intern
      * @return {@code non-null;} the equivalent interned instance
      */
     public synchronized <T extends OffsettedItem> T intern(T item) {
         throwIfPrepared();

         OffsettedItem result = interns.get(item);

         if (result != null) {
             return (T) result;
         }

         add(item);
         interns.put(item, item);
         return item;
     }

     /**
      * Gets an item which was previously interned.
      *
      * @param item {@code non-null;} the item to look for
      * @return {@code non-null;} the equivalent already-interned instance
      */
     public <T extends OffsettedItem> T get(T item) {
         throwIfNotPrepared();

         OffsettedItem result = interns.get(item);

         if (result != null) {
             return (T) result;
         }

         throw new NoSuchElementException(item.toString());
     }

     /**
      * Writes an index of contents of the items in this instance of the
      * given type. If there are none, this writes nothing. If there are any,
      * then the index is preceded by the given intro string.
      *
      * @param out {@code non-null;} where to write to
      * @param itemType {@code non-null;} the item type of interest
      * @param intro {@code non-null;} the introductory string for non-empty indices
      */
     public void writeIndexAnnotation(AnnotatedOutput out, ItemType itemType,
             String intro) {
         throwIfNotPrepared();

         TreeMap<String, OffsettedItem> index =
             new TreeMap<String, OffsettedItem>();

         for (OffsettedItem item : items) {
             if (item.itemType() == itemType) {
                 String label = item.toHuman();
                 index.put(label, item);
             }
         }

         if (index.size() == 0) {
             return;
         }

         out.annotate(0, intro);

         for (Map.Entry<String, OffsettedItem> entry : index.entrySet()) {
             String label = entry.getKey();
             OffsettedItem item = entry.getValue();
             out.annotate(0, item.offsetString() + ' ' + label + '\n');
         }
     }

     /** {@inheritDoc} */
     @Override
     protected void prepare0() {
         DexFile file = getFile();

         /*
          * It's okay for new items to be added as a result of an
          * addContents() call; we just have to deal with the possibility.
          */

         int i = 0;
         for (;;) {
             int sz = items.size();
             if (i >= sz) {
                 break;
             }

             for (/*i*/; i < sz; i++) {
                 OffsettedItem one = items.get(i);
                 one.addContents(file);
             }
         }
     }

     /**
      * Places all the items in this instance at particular offsets. This
      * will call {@link OffsettedItem#place} on each item. If an item
      * does not know its write size before the call to {@code place},
      * it is that call which is responsible for setting the write size.
      * This method may only be called once per instance; subsequent calls
      * will throw an exception.
      */
     public void placeItems() {
         throwIfNotPrepared();

         switch (sort) {
             case INSTANCE: {
                 Collections.sort(items);
                 break;
             }
             case TYPE: {
                 Collections.sort(items, TYPE_SORTER);
                 break;
             }
         }

         int sz = items.size();
         int outAt = 0;
         for (int i = 0; i < sz; i++) {
             OffsettedItem one = items.get(i);
             try {
                 int placedAt = one.place(this, outAt);

                 if (placedAt < outAt) {
                     throw new RuntimeException("bogus place() result for " +
                             one);
                 }

                 outAt = placedAt + one.writeSize();
             } catch (RuntimeException ex) {
                 throw ExceptionWithContext.withContext(ex,
                         "...while placing " + one);
             }
         }

         writeSize = outAt;
     }

     /** {@inheritDoc} */
     @Override
     protected void writeTo0(AnnotatedOutput out) {
         boolean annotates = out.annotates();
         boolean first = true;
         DexFile file = getFile();
         int at = 0;

         for (OffsettedItem one : items) {
             if (annotates) {
                 if (first) {
                     first = false;
                 } else {
                     out.annotate(0, "\n");
                 }
             }

             int alignMask = one.getAlignment() - 1;
             int writeAt = (at + alignMask) & ~alignMask;

             if (at != writeAt) {
                 out.writeZeroes(writeAt - at);
                 at = writeAt;
             }

             one.writeTo(file, out);
             at += one.writeSize();
         }

         if (at != writeSize) {
             throw new RuntimeException("output size mismatch");
         }
     }
 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* 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.android.dx.dex.file;

	import com.android.dex.util.ExceptionWithContext;
	import com.android.dx.util.AnnotatedOutput;
	import com.android.dx.util.Hex;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.NoSuchElementException;
	import java.util.TreeMap;

	/**
	* A section of a {@code .dex} file which consists of a sequence of
	* {@link OffsettedItem} objects, which may each be of a different concrete
	* class and/or size.
	*
	* <b>Note:</b> It is invalid for an item in an instance of this class to
	* have a larger alignment requirement than the alignment of this instance.
	*/
	public final class MixedItemSection extends Section {
	static enum SortType {
	/** no sorting */
	NONE,

	/** sort by type only */
	TYPE,

	/** sort in class-major order, with instances sorted per-class */
	INSTANCE;
	};

	/** {@code non-null;} sorter which sorts instances by type */
	private static final Comparator<OffsettedItem> TYPE_SORTER =
	new Comparator<OffsettedItem>() {
	public int compare(OffsettedItem item1, OffsettedItem item2) {
	ItemType type1 = item1.itemType();
	ItemType type2 = item2.itemType();
	return type1.compareTo(type2);
	}
	};

	/** {@code non-null;} the items in this part */
	private final ArrayList<OffsettedItem> items;

	/** {@code non-null;} items that have been explicitly interned */
	private final HashMap<OffsettedItem, OffsettedItem> interns;

	/** {@code non-null;} how to sort the items */
	private final SortType sort;

	/**
	* {@code >= -1;} the current size of this part, in bytes, or {@code -1}
	* if not yet calculated
	*/
	private int writeSize;

	/**
	* Constructs an instance. The file offset is initially unknown.
	*
	* @param name {@code null-ok;} the name of this instance, for annotation
	* purposes
	* @param file {@code non-null;} file that this instance is part of
	* @param alignment {@code > 0;} alignment requirement for the final output;
	* must be a power of 2
	* @param sort how the items should be sorted in the final output
	*/
	public MixedItemSection(String name, DexFile file, int alignment,
	SortType sort) {
	super(name, file, alignment);

	this.items = new ArrayList<OffsettedItem>(100);
	this.interns = new HashMap<OffsettedItem, OffsettedItem>(100);
	this.sort = sort;
	this.writeSize = -1;
	}

	/** {@inheritDoc} */
	@Override
	public Collection<? extends Item> items() {
	return items;
	}

	/** {@inheritDoc} */
	@Override
	public int writeSize() {
	throwIfNotPrepared();
	return writeSize;
	}

	/** {@inheritDoc} */
	@Override
	public int getAbsoluteItemOffset(Item item) {
	OffsettedItem oi = (OffsettedItem) item;
	return oi.getAbsoluteOffset();
	}

	/**
	* Gets the size of this instance, in items.
	*
	* @return {@code >= 0;} the size
	*/
	public int size() {
	return items.size();
	}

	/**
	* Writes the portion of the file header that refers to this instance.
	*
	* @param out {@code non-null;} where to write
	*/
	public void writeHeaderPart(AnnotatedOutput out) {
	throwIfNotPrepared();

	if (writeSize == -1) {
	throw new RuntimeException("write size not yet set");
	}

	int sz = writeSize;
	int offset = (sz == 0) ? 0 : getFileOffset();
	String name = getName();

	if (name == null) {
	name = "<unnamed>";
	}

	int spaceCount = 15 - name.length();
	char[] spaceArr = new char[spaceCount];
	Arrays.fill(spaceArr, ' ');
	String spaces = new String(spaceArr);

	if (out.annotates()) {
	out.annotate(4, name + "_size:" + spaces + Hex.u4(sz));
	out.annotate(4, name + "_off: " + spaces + Hex.u4(offset));
	}

	out.writeInt(sz);
	out.writeInt(offset);
	}

	/**
	* Adds an item to this instance. This will in turn tell the given item
	* that it has been added to this instance. It is invalid to add the
	* same item to more than one instance, nor to add the same items
	* multiple times to a single instance.
	*
	* @param item {@code non-null;} the item to add
	*/
	public void add(OffsettedItem item) {
	throwIfPrepared();

	try {
	if (item.getAlignment() > getAlignment()) {
	throw new IllegalArgumentException(
	"incompatible item alignment");
	}
	} catch (NullPointerException ex) {
	// Elucidate the exception.
	throw new NullPointerException("item == null");
	}

	items.add(item);
	}

	/**
	* Interns an item in this instance, returning the interned instance
	* (which may not be the one passed in). This will add the item if no
	* equal item has been added.
	*
	* @param item {@code non-null;} the item to intern
	* @return {@code non-null;} the equivalent interned instance
	*/
	public synchronized <T extends OffsettedItem> T intern(T item) {
	throwIfPrepared();

	OffsettedItem result = interns.get(item);

	if (result != null) {
	return (T) result;
	}

	add(item);
	interns.put(item, item);
	return item;
	}

	/**
	* Gets an item which was previously interned.
	*
	* @param item {@code non-null;} the item to look for
	* @return {@code non-null;} the equivalent already-interned instance
	*/
	public <T extends OffsettedItem> T get(T item) {
	throwIfNotPrepared();

	OffsettedItem result = interns.get(item);

	if (result != null) {
	return (T) result;
	}

	throw new NoSuchElementException(item.toString());
	}

	/**
	* Writes an index of contents of the items in this instance of the
	* given type. If there are none, this writes nothing. If there are any,
	* then the index is preceded by the given intro string.
	*
	* @param out {@code non-null;} where to write to
	* @param itemType {@code non-null;} the item type of interest
	* @param intro {@code non-null;} the introductory string for non-empty indices
	*/
	public void writeIndexAnnotation(AnnotatedOutput out, ItemType itemType,
	String intro) {
	throwIfNotPrepared();

	TreeMap<String, OffsettedItem> index =
	new TreeMap<String, OffsettedItem>();

	for (OffsettedItem item : items) {
	if (item.itemType() == itemType) {
	String label = item.toHuman();
	index.put(label, item);
	}
	}

	if (index.size() == 0) {
	return;
	}

	out.annotate(0, intro);

	for (Map.Entry<String, OffsettedItem> entry : index.entrySet()) {
	String label = entry.getKey();
	OffsettedItem item = entry.getValue();
	out.annotate(0, item.offsetString() + ' ' + label + '\n');
	}
	}

	/** {@inheritDoc} */
	@Override
	protected void prepare0() {
	DexFile file = getFile();

	/*
	* It's okay for new items to be added as a result of an
	* addContents() call; we just have to deal with the possibility.
	*/

	int i = 0;
	for (;;) {
	int sz = items.size();
	if (i >= sz) {
	break;
	}

	for (/i/; i < sz; i++) {
	OffsettedItem one = items.get(i);
	one.addContents(file);
	}
	}
	}

	/**
	* Places all the items in this instance at particular offsets. This
	* will call {@link OffsettedItem#place} on each item. If an item
	* does not know its write size before the call to {@code place},
	* it is that call which is responsible for setting the write size.
	* This method may only be called once per instance; subsequent calls
	* will throw an exception.
	*/
	public void placeItems() {
	throwIfNotPrepared();

	switch (sort) {
	case INSTANCE: {
	Collections.sort(items);
	break;
	}
	case TYPE: {
	Collections.sort(items, TYPE_SORTER);
	break;
	}
	}

	int sz = items.size();
	int outAt = 0;
	for (int i = 0; i < sz; i++) {
	OffsettedItem one = items.get(i);
	try {
	int placedAt = one.place(this, outAt);

	if (placedAt < outAt) {
	throw new RuntimeException("bogus place() result for " +
	one);
	}

	outAt = placedAt + one.writeSize();
	} catch (RuntimeException ex) {
	throw ExceptionWithContext.withContext(ex,
	"...while placing " + one);
	}
	}

	writeSize = outAt;
	}

	/** {@inheritDoc} */
	@Override
	protected void writeTo0(AnnotatedOutput out) {
	boolean annotates = out.annotates();
	boolean first = true;
	DexFile file = getFile();
	int at = 0;

	for (OffsettedItem one : items) {
	if (annotates) {
	if (first) {
	first = false;
	} else {
	out.annotate(0, "\n");
	}
	}

	int alignMask = one.getAlignment() - 1;
	int writeAt = (at + alignMask) & ~alignMask;

	if (at != writeAt) {
	out.writeZeroes(writeAt - at);
	at = writeAt;
	}

	one.writeTo(file, out);
	at += one.writeSize();
	}

	if (at != writeSize) {
	throw new RuntimeException("output size mismatch");
	}
	}
	}