idwriter.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: IdWriter.java
 * Written by: Dmitry Nadezhin, Sun Microsystems.
 *
 * 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.id;

import com.sun.electric.database.geometry.EPoint;
import com.sun.electric.database.geometry.ERectangle;
import com.sun.electric.database.geometry.Orientation;
import com.sun.electric.database.text.Name;
import com.sun.electric.database.variable.TextDescriptor;
import com.sun.electric.database.variable.Variable;
import com.sun.electric.tool.Tool;

import java.io.DataOutputStream;
import java.io.IOException;
import java.util.HashMap;

/**
 * Class to write trace of Snapshots to DataOutput byte sequence.
 */
public class IdWriter {
    
    public final IdManager idManager;
    private final DataOutputStream out;
    private TechCounts[] techCounts = {}; // One entry is for Generic technology
    private int libCount;
    private int[] exportCounts = {};
    private HashMap<Variable.Key,Integer> varKeys = new HashMap<Variable.Key,Integer>();
    private HashMap<TextDescriptor,Integer> textDescriptors = new HashMap<TextDescriptor,Integer>();
    private HashMap<Tool,Integer> tools = new HashMap<Tool,Integer>();
    private HashMap<Orientation,Integer> orients = new HashMap<Orientation,Integer>();
    
    private static class TechCounts {
        int modCount;
        int arcCount;
        int[] portCounts = {};
    }
   
    /** Creates a new instance of SnapshotWriter */
    public IdWriter(IdManager idManager, DataOutputStream out) {
        this.idManager = idManager;
        this.out = out;
    }

    public void writeDiffs() throws IOException {
        TechId[] techIdsArray;
        LibId[] libIdsArray;
        CellId[] cellIdsArray;
        synchronized (idManager) {
            techIdsArray = idManager.techIds.toArray(TechId.NULL_ARRAY);
            libIdsArray = idManager.libIds.toArray(LibId.NULL_ARRAY);
            cellIdsArray = idManager.cellIds.toArray(CellId.NULL_ARRAY);
        }
        
        writeInt(techIdsArray.length);
        if (techIdsArray.length != techCounts.length) {
            TechCounts[] newTechCounts = new TechCounts[techIdsArray.length];
            System.arraycopy(techCounts, 0, newTechCounts, 0, techCounts.length);
            for (int techIndex = techCounts.length; techIndex < techIdsArray.length; techIndex++) {
                TechId techId = techIdsArray[techIndex];
                writeString(techId.techName);
                newTechCounts[techIndex] = new TechCounts();
            }
            techCounts = newTechCounts;
        }
        
        writeInt(libIdsArray.length);
        for (int libIndex = libCount; libIndex < libIdsArray.length; libIndex++) {
            LibId libId = libIdsArray[libIndex];
            writeString(libId.libName);
        }
        libCount = libIdsArray.length;
        
        writeInt(cellIdsArray.length);
        if (cellIdsArray.length != exportCounts.length) {
            int[] newExportCounts = new int[cellIdsArray.length];
            System.arraycopy(exportCounts, 0, newExportCounts, 0, exportCounts.length);
            for (int cellIndex = exportCounts.length; cellIndex < cellIdsArray.length; cellIndex++) {
                CellId cellId = cellIdsArray[cellIndex];
                writeLibId(cellId.libId);
                writeString(cellId.cellName.toString());
            }
            exportCounts = newExportCounts;
        }
        
        for (int techIndex = 0; techIndex < techIdsArray.length; techIndex++) {
            TechId techId = techIdsArray[techIndex];
            TechCounts techCount = techCounts[techIndex];
            int modCount = techId.modCount;
            if (modCount == techCount.modCount) continue;
            
            writeInt(techIndex);

            int numArcProtoIds = techId.numArcProtoIds();
            int numNewArcProtoIds = numArcProtoIds - techCount.arcCount;
            assert numNewArcProtoIds >= 0;
            writeInt(numNewArcProtoIds);
            for (int i = 0; i < numNewArcProtoIds; i++)
                writeString(techId.getArcProtoId(techCount.arcCount + i).name);
            techCount.arcCount = numArcProtoIds;

            int numPrimitiveNodeIds = techId.numPrimitiveNodeIds();
            int numNewPrimitiveNodeIds = numPrimitiveNodeIds - techCount.portCounts.length;
            assert numNewPrimitiveNodeIds >= 0;
            writeInt(numNewPrimitiveNodeIds);
            if (numNewPrimitiveNodeIds > 0) {
                for (int i = 0; i < numNewPrimitiveNodeIds; i++)
                    writeString(techId.getPrimitiveNodeId(techCount.portCounts.length + i).name);
                int[] newPortCounts = new int[numPrimitiveNodeIds];
                System.arraycopy(techCount.portCounts, 0, newPortCounts, 0, techCount.portCounts.length);
                techCount.portCounts = newPortCounts;
            }

            for (int primIndex = 0; primIndex < numPrimitiveNodeIds; primIndex++) {
                PrimitiveNodeId primitiveNodeId = techId.getPrimitiveNodeId(primIndex);
                int numPrimitivePortIds = primitiveNodeId.numPrimitivePortIds();
                int numNewPrimitivePortIds = numPrimitivePortIds - techCount.portCounts[primIndex];
                assert numNewPrimitivePortIds >= 0;
                if (numNewPrimitivePortIds == 0) continue;
                
                writeInt(primIndex);
                writeInt(numNewPrimitivePortIds);
                for (int i = 0; i < numNewPrimitivePortIds; i++)
                    writeString(primitiveNodeId.getPortId(techCount.portCounts[primIndex] + i).externalId);
                techCount.portCounts[primIndex] = numPrimitivePortIds;
            }
            writeInt(-1);
            
            techCount.modCount = modCount;
        }
        writeInt(-1);
        
        for (int cellIndex = 0; cellIndex < cellIdsArray.length; cellIndex++) {
            CellId cellId = cellIdsArray[cellIndex];
            int numExportIds = cellId.numExportIds();
            int exportCount = exportCounts[cellIndex];
            if (numExportIds != exportCount) {
                writeInt(cellIndex);
                int numNewExportIds = numExportIds - exportCount;
                assert numNewExportIds > 0;
                writeInt(numNewExportIds);
                for (int i = 0; i < numNewExportIds; i++)
                    writeString(cellId.getPortId(exportCount + i).externalId);
                exportCounts[cellIndex] = numExportIds;
            }
        }
        writeInt(-1);
    }
    
    /** Flushes this SnapshotWriter */
    public void flush() throws IOException {
        out.flush();
    }
    
    /**
     * Writes boolean.
     * @param v boolean to write.
     */
    public void writeBoolean(boolean v) throws IOException {
        out.writeBoolean(v);
    }
    
    /**
     * Writes byte.
     * @param v byte to write.
     */
    public void writeByte(byte v) throws IOException {
        out.writeByte(v);
    }
    
    /**
     * Writes short.
     * @param v short to write.
     */
    public void writeShort(short v) throws IOException {
        out.writeShort(v);
    }
    
    /**
     * Writes integer.
     * @param v integer to write.
     */
    public void writeInt(int v) throws IOException {
        out.writeInt(v);
    }
    
    /**
     * Writes long.
     * @param v long to write.
     */
    public void writeLong(long v) throws IOException {
        out.writeLong(v);
    }
    
    /**
     * Writes float.
     * @param v float to write.
     */
    public void writeFloat(float v) throws IOException {
        out.writeFloat(v);
    }

    /**
     * Writes double.
     * @param v double to write.
     */
    public void writeDouble(double v) throws IOException {
        out.writeDouble(v);
    }

    /**
     * Writes bytes.
     * @param v bytes to write.
     */
    public void writeBytes(byte[] v) throws IOException {
        out.writeInt(v.length);
        out.write(v);
    }
    
    /**
     * Writes string.
     * @param s string to write.
     */
    public void writeString(String s) throws IOException {
        out.writeUTF(s);
    }

    /**
     * Writes variable key.
     * @param key variable key to write.
     */
    public void writeVariableKey(Variable.Key key) throws IOException {
        Integer i = varKeys.get(key);
        if (i != null) {
            out.writeInt(i.intValue());
        } else {
            i = new Integer(varKeys.size());
            varKeys.put(key, i);
            out.writeInt(i.intValue());
            
            out.writeUTF((key.toString()));
        }
    }

    /**
     * Writes TextDescriptor.
     * @param td TextDescriptor to write.
     */
    public void writeTextDescriptor(TextDescriptor td) throws IOException {
        if (td == null) {
            out.writeInt(-1);
            return;
        }
        Integer i = textDescriptors.get(td);
        if (i != null) {
            out.writeInt(i.intValue());
        } else {
            i = new Integer(textDescriptors.size());
            textDescriptors.put(td, i);
            out.writeInt(i.intValue());
            
            out.writeLong(td.lowLevelGet());
            out.writeInt(td.getColorIndex());
            out.writeBoolean(td.isDisplay());
            int face = td.getFace();
            String fontName = face != 0 ? TextDescriptor.ActiveFont.findActiveFont(face).getName() : "";
            out.writeUTF(fontName);
        }
    }
    
    /**
     * Writes Tool.
     * @param tool Tool to write.
     */
    public void writeTool(Tool tool) throws IOException {
        Integer i = tools.get(tool);
        if (i != null) {
            out.writeInt(i.intValue());
        } else {
            i = new Integer(tools.size());
            tools.put(tool, i);
            out.writeInt(i.intValue());
            out.writeUTF(tool.getName());
        }
    }
    
    /**
     * Writes TechId.
     * @param techId TechId to write.
     */
    public void writeTechId(TechId techId) throws IOException {
        assert techId.idManager == idManager;
        out.writeInt(techId.techIndex);
    }
    
    /**
     * Writes ArcProtoId.
     * @param arcProtoId ArcProtoId to write.
     */
    public void writeArcProtoId(ArcProtoId arcProtoId) throws IOException {
        writeTechId(arcProtoId.techId);
        writeInt(arcProtoId.chronIndex);
    }

    /**
     * Writes LibId.
     * @param libId LibId to write.
     */
    public void writeLibId(LibId libId) throws IOException {
        out.writeInt(libId.libIndex);
    }
    
    /**
     * Writes NodeProtoId.
     * @param nodeProtoId NodeProtoId to write.
     */
    public void writeNodeProtoId(NodeProtoId nodeProtoId) throws IOException {
        if (nodeProtoId instanceof CellId) {
            CellId cellId = (CellId)nodeProtoId;
            assert cellId.idManager == idManager;
            out.writeInt(cellId.cellIndex);
            return;
        } else {
            PrimitiveNodeId pnId = (PrimitiveNodeId)nodeProtoId;
            out.writeInt(~pnId.chronIndex);
            writeTechId(pnId.techId);
        }
    }
    
    /**
     * Writes PortProtoId.
     * @param portProtoId PortProtoId to write.
     */
    public void writePortProtoId(PortProtoId portProtoId) throws IOException {
        writeNodeProtoId(portProtoId.getParentId());
        out.writeInt(portProtoId.getChronIndex());
    }
    
   /**
     * Writes node id.
     * @param nodeId node id to write.
     */
    public void writeNodeId(int nodeId) throws IOException {
        out.writeInt(nodeId);
    }

   /**
     * Writes arc id.
     * @param arcId arc id to write.
     */
    public void writeArcId(int arcId) throws IOException {
        out.writeInt(arcId);
    }

    /**
     * Writes Name key.
     * @param nameKey name key to write.
     */
    public void writeNameKey(Name nameKey) throws IOException {
        out.writeUTF(nameKey.toString());
    }
    
    /**
     * Writes Orientation.
     * @param orient Orientation.
     */
    public void writeOrientation(Orientation orient) throws IOException {
        Integer i = orients.get(orient);
        if (i != null) {
            out.writeInt(i.intValue());
        } else {
            i = new Integer(orients.size());
            orients.put(orient, i);
            out.writeInt(i.intValue());
            
            out.writeShort(orient.getAngle());
            out.writeBoolean(orient.isXMirrored());
            out.writeBoolean(orient.isYMirrored());
        }
    }
    
    /**
     * Writes coordiante.
     * @param v gridCooridnate.
     */
    public void writeCoord(long v) throws IOException {
        out.writeLong(v);
    }
    
    /**
     * Writes EPoint.
     * @param p EPoint.
     */
    public void writePoint(EPoint p) throws IOException {
        writeCoord(p.getGridX());
        writeCoord(p.getGridY());
    }
    
    /**
     * Writes ERectangle.
     * @param r ERectangle.
     */
    public void writeRectangle(ERectangle r) throws IOException {
        writeCoord(r.getGridX());
        writeCoord(r.getGridY());
        writeCoord(r.getGridWidth());
        writeCoord(r.getGridHeight());
    }
}