view.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

/* -*- tab-width: 4 -*-
 *
 * Electric(tm) VLSI Design System
 *
 * File: View.java
 *
 * Copyright (c) 2003 Sun Microsystems and Static Free Software
 *
 * Electric(tm) is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Electric(tm) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Electric(tm); see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, Mass 02111-1307, USA.
 */
package com.sun.electric.database.hierarchy;

import com.sun.electric.database.text.TextUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

/**
 * A View is an object that represents a style of design, for example schematic, layout, etc.
 * Each Cell has a View associated with it.
 * Views have full names (such as "layout") and abbreviations which are used in cell names
 * (for example "gate{lay}").
 * <P>
 * Electric has a set of Views at the start, and users can define their own.
 */
public class View implements Comparable<View>
{
	// -------------------------- private data -----------------------------

	/** view contains only text */							private final static int TEXTVIEW       = 01;	
	/** view is statically defined and cannot be deleted */ private final static int PERMANENTVIEW  = 04;	

	/** the full name of the view */						private final String fullName;
	/** the abbreviation of the view */						private final String abbreviation;
	/** ordering for this view */							private final int order;
	/** flag bits for the view */							private final int type;

	/** a set of all views in existence */					private static TreeSet<View> views = new TreeSet<View>();
	/** unmodifiable set of all views in existence */		private static Set<View> unmodifiableViews = Collections.unmodifiableSet(views);
	/** a list of views by short and long names */			private static HashMap<String,View> viewNames = new HashMap<String,View>();
	/** the index for new Views. */							private static int overallOrder = 16;

	// -------------------------- public data -----------------------------

	/**
	 * Defines the Schematic view.
	 */
	public static final View SCHEMATIC = makeInstance("schematic", "sch", PERMANENTVIEW, 0);

	/**
	 * Defines the Icon view.
	 * This is used in schematics to represent instances.
	 * Cells with this view typically use primitives from the Artwork Technology.
	 */
	public static final View ICON = makeInstance("icon", "ic", PERMANENTVIEW, 1);

	/**
	 * Defines the Layout view.
	 */
	public static final View LAYOUT = makeInstance("layout", "lay", PERMANENTVIEW, 2);

	/**
	 * Defines the Skeleton view.
	 * Cells with this view contains only a protection frame or other dummy version of true layout.
	 */
	public static final View LAYOUTSKEL = makeInstance("layout.skeleton", "lay.sk", PERMANENTVIEW, 3);

	/**
	 * Defines the Compensated view.
	 * Cells with this view contains compensated layout (adjusted for fabrication).
	 */
	public static final View LAYOUTCOMP = makeInstance("layout.compensated", "lay.comp", PERMANENTVIEW, 4);

	/**
	 * Defines the VHDL view (a text view).
	 * Cells with this view contains a textual description in the VHDL hardware-description language.
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View VHDL = makeInstance("VHDL", "vhdl", PERMANENTVIEW|TEXTVIEW, 5);

	/**
	 * Defines the Verilog view (a text view).
	 * Cells with this view contains a textual description in the Verilog hardware-description language.
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View VERILOG = makeInstance("Verilog", "ver", PERMANENTVIEW|TEXTVIEW, 6);

	/**
	 * Defines the Documentation view (a text view).
	 * Cells with this view contain documentation for other cells in the cell group.
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View DOC = makeInstance("documentation", "doc", PERMANENTVIEW|TEXTVIEW, 7);

	/**
	 * Defines the simulation snapshot view.
	 * Cells with this view contain snapshots of the simulation waveform window.
	 */
	public static final View DOCWAVE = makeInstance("documentation.waveform", "doc.wave", PERMANENTVIEW, 8);

	/**
	 * Defines the general Netlist view (a text view).
	 * Cells with this view contain an unknown format netlist.
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View NETLIST = makeInstance("netlist", "net", PERMANENTVIEW|TEXTVIEW, 9);

	/**
	 * Defines the NetLisp (netlist) view (a text view).
	 * Cells with this view contain a "netlisp" format netlist (for simulation).
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View NETLISTNETLISP = makeInstance("netlist.netlisp", "net.netlisp", PERMANENTVIEW|TEXTVIEW, 10);

	/**
	 * Defines the RSIM (netlist) view (a text view).
	 * Cells with this view contain an "RSIM" format netlist (for simulation).
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View NETLISTRSIM = makeInstance("netlist.rsim", "net.rsim", PERMANENTVIEW|TEXTVIEW, 11);

	/**
	 * Defines the SILOS (netlist) view (a text view).
	 * Cells with this view contain a "SILOS" format netlist (for simulation).
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View NETLISTSILOS = makeInstance("netlist.silos", "net.silos", PERMANENTVIEW|TEXTVIEW, 12);

	/**
	 * Defines the QUISC (netlist) view (a text view).
	 * Cells with this view contain an "QUISC" format netlist (for place-and-route by the QUISC Silicon Compiler).
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View NETLISTQUISC = makeInstance("netlist.quisc", "net.quisc", PERMANENTVIEW|TEXTVIEW, 13);

	/**
	 * Defines the ALS (netlist) view (a text view).
	 * Cells with this view contain an "ALS" format netlist (for simulation).
	 * The text is located in the "FACET_message" variable on the cell.
	 */
	public static final View NETLISTALS = makeInstance("netlist.als", "net.als", PERMANENTVIEW|TEXTVIEW, 14);

	/**
	 * Defines the unknown view.
	 * This view has an empty abbreviation.
	 */
	public static final View UNKNOWN = makeInstance("unknown", "", PERMANENTVIEW, 15);

	/****************************** CREATE, DELETE ******************************/

	/**
	 * Method to create a View with the given name.
	 * @param fullName the full name of the View, for example "layout".
	 * @param abbreviation the short name of the View, for example "lay".
	 * The short name is used inside of braces when naming a cell (for example "gate{lay}").
	 * @return the newly created View.
	 */
	public static View newInstance(String fullName, String abbreviation)
	{
		// make sure this can be done now
		EDatabase.serverDatabase().checkChanging();

		View view = makeInstance(fullName, abbreviation, 0, getNextOrder());

		// handle change control, constraint, and broadcast
//		Undo.newObject(view);
		return view;
	}

	/**
	 * Method to create a Text-only View with the given name.
	 * Cells with text-only views have no nodes or arcs, just text.
	 * @param fullName the full name of the View, for example "documentation".
	 * @param abbreviation the short name of the View, for example "doc".
	 * The short name is used inside of braces when naming a cell (for example "gate{doc}").
	 * @return the newly created Text-only View.
	 */
	public static View newTextInstance(String fullName, String abbreviation)
	{
		// make sure this can be done now
		EDatabase.serverDatabase().checkChanging();

		View view = makeInstance(fullName, abbreviation, TEXTVIEW, getNextOrder());

		// handle change control, constraint, and broadcast
//		Undo.newObject(view);
		return view;
	}

	/**
	 * Method to delete this View.
	 */
	public void kill()
	{
		System.out.println("Cannot delete views");
// 		// cannot delete the permanent views (created at initialization)
// 		if (isPermanentView()) return;
// 
// 		// cannot delete views that are in use
// 		for(Iterator it = Library.getLibraries(); it.hasNext(); )
// 		{
// 			Library lib = it.next();
// 			for(Iterator cIt = lib.getCells(); cIt.hasNext(); )
// 			{
// 				Cell cell = cIt.next();
// 				if (cell.getView() == this)
// 				{
// 					System.out.println("Cannot delete view " + this.getFullName() +
// 						" because it is in use (for example, cell " + cell.describe() + ")");
// 					return;
// 				}
// 			}
// 		}
// 
// 		// make sure this can be done now
// 		Job.checkChanging();
// 
// 		// handle change control, constraint, and broadcast
// 		Undo.killObject(this);
// 
// 		// delete this view
//         synchronized(View.class) {
//             viewNames.remove(fullName);
//             viewNames.remove(abbreviation);
//             views.remove(this);
//         }
	}

	/****************************** IMPLEMENTATION ******************************/

	/**
	 * This constructor is never called.  Use the factory "makeInstance" instead.
	 */
	private View(String fullName, String abbr, int type, int order)
	{
        this.fullName = fullName;
        this.abbreviation = abbr;
        this.type = type;
        this.order = order;
	}

	private static View makeInstance(String fullName, String abbreviation, int type, int order)
	{
		// make sure the view doesn't already exist
		if (viewNames.containsKey(abbreviation))
		{
			System.out.println("multiple views with same name: " + abbreviation);
			return null;
		}
		if (viewNames.containsKey(fullName))
		{
			System.out.println("multiple views with same name: " + fullName);
			return null;
		}

		// create the view
		View v = new View(fullName, abbreviation, type, order);

		// enter both the full and short names into the hash table
        synchronized(View.class) {
            viewNames.put(fullName, v);
            viewNames.put(abbreviation, v);
            views.add(v);
        }
		return v;
	}

    private static int getNextOrder() {
        synchronized(View.class) {
            return overallOrder++;
        }
    }

	/****************************** INFORMATION ******************************/

	/**
	 * Method to return a View using its full or short name.
	 * @param name the name of the View.
	 * @return the named View, or null if no such View exists.
	 */
	public static View findView(String name)
	{
		return viewNames.get(name);
	}

	/**
	 * Method to return the full name of this View.
	 * @return the full name of this View.
	 */
	public String getFullName() { return fullName; }

	/**
	 * Method to return the short name of this View.
	 * The short name is used inside of braces when naming a cell (for example "gate{doc}").
	 * @return the short name of this View.
	 */
	public String getAbbreviation() { return abbreviation; }

    /**
     * Method to return the string containing the extension to be used for cell names
     * @return the short name of this View with appropiated parentesis
     */
    public String getAbbreviationExtension() { return "{" + getAbbreviation() + "}"; }

    /**
	 * Method to get the ordering of this View for sorting.
	 * @return the ordering this View.
	 */
	public int getOrder() { return order; }

	/**
	 * Method to return true if this View is Text-only.
	 * Cells with text-only views have no nodes or arcs, just text.
	 * @return true if this View is Text-only.
	 */
	public boolean isTextView() { return (type & TEXTVIEW) != 0; }

	/**
	 * Method to return true if this View is permanent.
	 * Permanent views are those that are created initially, and cannot be deleted.
	 * @return true if this View is permanent.
	 */
	public boolean isPermanentView() { return (type & PERMANENTVIEW) != 0; }

	/**
	 * Method to return an iterator over the views.
	 * @return an iterator over the views.
	 */
	public static Iterator<View> getViews() { return unmodifiableViews.iterator(); }

	/**
	 * Method to return the number of views.
	 * @return the number of views.
	 */
	public static int getNumViews() { return views.size(); }

	/**
	 * Method to return a List of all libraries, sorted by name.
	 * The list excludes hidden libraries (i.e. the clipboard).
	 * @return a List of all libraries, sorted by name.
	 */
	public static List<View> getOrderedViews()
	{
		List<View> sortedList = new ArrayList<View>(views);
		Collections.sort(sortedList, new ViewByOrder());
		return sortedList;
	}

	private static class ViewByOrder implements Comparator<View>
	{
		public int compare(View v1, View v2)
		{
			return v1.getOrder() - v2.getOrder();
		}
	}

    /**
     * Compares two <code>View</code> objects.
     * @param that the View to be compared.
     * @return the result of comparison.
     */
	public int compareTo(View that)
	{
		return TextUtils.STRING_NUMBER_ORDER.compare(getAbbreviation(), that.getAbbreviation());
    }

	/**
	 * Returns a printable version of this View.
	 * @return a printable version of this View.
	 */
	public String toString()
	{
		return "View " + fullName;
	}

}