OoasTools

/**

  *

  *                      OOAS Compiler

  *

  *       Copyright 2015, AIT Austrian Institute of Technology.

  * This code is based on the C# Version of the OOAS Compiler, which is

  * copyright 2015 by the Institute of Software Technology, Graz University

  * of Technology with portions copyright by the AIT Austrian Institute of

  * Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Markus Demetz (AIT)

  *               Christoph Czurda (AIT)

  *

  */

package org.momut.ooas.visitors;

import java.util.ArrayList;

import java.util.EnumMap;

import java.util.List;

import java.util.Set;

import java.util.TreeMap;

public class OoaIdentifierCompressVisitor extends OoaCompleteAstTraversalVisitor {

	public static final String s_methodPrefix    = "m_";

	public static final String s_actionPrefix    = "a_";

	public static final String s_attributePrefix = "at_";

	public static final String s_objectPrefix    = "o_";

	public static final String s_typePrefix      = "t_";

	private final EnumMap<IdentifierKind, TreeMap<String, String> > m_identifierMappings = new EnumMap<>(IdentifierKind.class);

	private final TreeMap<String, String> m_objectMappings = new TreeMap<>();

	private final LabelCompression m_compression;

	private void putMapping(String label, Identifier identifier) {

		TreeMap<String, String> map = m_identifierMappings.get(identifier.kind());

		if (map == null) {

			map = new TreeMap<>();

			m_identifierMappings.put(identifier.kind(), map);

		}

		map.put(label, identifier.tokenText());

	}

	public String mappingFor(Identifier identifier)	{

		final IdentifierKind kind = identifier.kind();

		final TreeMap<String, String> map = m_identifierMappings.get(kind);

		return map.get(identifier.tokenText());

	}

	@Override

	public /*override*/ void visit(AttributeIdentifier attributeIdentifier)	{

		if (m_compression != LabelCompression.All)

			return;

		final String attributeName = labelFor(attributeIdentifier);

		attributeIdentifier.SetTokenText(attributeName);

	}

	@Override

	public /*override*/ void visit(MethodIdentifier methodIdentifier)	{

		final String renamedName = labelFor(methodIdentifier);

		methodIdentifier.SetTokenText(renamedName);

	}

	@Override

	public /*override*/ void visit(NamedActionIdentifier namedActionIdentifier)	{

		final FunctionType functionType = (FunctionType) namedActionIdentifier.type();

		if (functionType.functionType() == FunctionTypeEnum.Internal) {

				final String renamedName = labelFor(namedActionIdentifier);

				namedActionIdentifier.SetTokenText(renamedName);

		}

	}

	public String labelFor(Identifier identifier) {

		String label = identifier.tokenText();

		switch(identifier.kind()) {

			case MethodIdentifier:

				label = s_methodPrefix + convert(methodCount++);

				break;

			case NamedActionIdentifier:

				label = s_actionPrefix + convert(actionCount++);

				break;

			case AttributeIdentifier:

				label = s_attributePrefix + convert(attributeCount++);

				break;

			default:

				throw new NotImplementedException();

		}

		putMapping(label, identifier);

		return label;

	}

	public String labelFor(OoActionSystemInstance instance) {

		final String label = s_objectPrefix + convert(objectCount++);

		m_objectMappings.put(label, instance.Name);

		return label;

	}

	public String originalName(String key) {

		if(m_objectMappings.get(key) != null) {

			return m_objectMappings.get(key);

		}

		return key;

	}

	public List<String> mappingInformation() {

		final List<String> lines = new ArrayList<>();

		final Set<IdentifierKind> kinds = m_identifierMappings.keySet();

		for (final IdentifierKind kind: kinds) {

			final TreeMap<String, String> map = m_identifierMappings.get(kind);

			final Set<String> keys = map.keySet();

			lines.add(String.format("[ Mappings for '%s' ]", kind.name()));

			for(final String key: keys) {

				lines.add(String.format("'%s' => '%s'", key, map.get(key)));

			}

			lines.add("");

		}

		if (m_objectMappings.isEmpty())

			return lines;

		lines.add(String.format("[ Object mappings ]"));

		final Set<String> keys = m_objectMappings.keySet();

		for (final String key: keys) {

			lines.add(String.format("'%s' => '%s'", key, originalName(key)));

		}

		lines.add("");

		return lines;

	}

	public LabelCompression compression() {

		return m_compression;

	}

	static final String CHARS = "abcdefghijklmnopqrstuvwxyz"; /* ABCDEFGHIJKLMNOPQRSTUVWXYZ */

	static final int CHARS_LENGTH = CHARS.length();

	int actionCount = 0;

	int methodCount = 0;

	int attributeCount = 0;

	int objectCount = 0;

	private String convert(int id) {

		final StringBuilder sb = new StringBuilder();

		do {

			sb.append(CHARS.charAt(id % CHARS_LENGTH));

			id = id / CHARS_LENGTH;

		} while(id != 0);

		return sb.toString();

	}

	public OoaIdentifierCompressVisitor(ParserState aState, LabelCompression compression)

	{

		super (aState);

		if (aState == null || compression == null)

			throw new ArgumentException();

		m_compression = compression;

	}

}