org.modelcc.language.syntax.ObjectWrapper Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of ModelCC Show documentation

ModelCC is a model-based parser generator (a.k.a. compiler compiler) that decouples language specification from language processing, avoiding some of the problems caused by grammar-driven parser generators. ModelCC receives a conceptual model as input, along with constraints that annotate it. It is then able to create a parser for the desired textual language and the generated parser fully automates the instantiation of the language conceptual model. ModelCC also includes a built-in reference resolution mechanism that results in abstract syntax graphs, rather than mere abstract syntax trees.

The newest version!

/*
 * ModelCC, distributed under ModelCC Shared Software License, www.modelcc.org
 */

package org.modelcc.language.syntax;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.modelcc.io.java.Reflection;
import org.modelcc.language.metamodel.MemberCollection;
import org.modelcc.language.metamodel.CompositeLanguageElement;
import org.modelcc.language.metamodel.LanguageModel;
import org.modelcc.language.metamodel.LanguageElement;
import org.modelcc.language.metamodel.LanguageMember;

/**
 * Object Wrapper.
 * 
 * @author Luis Quesada ([email protected]) & Fernando Berzal ([email protected])
 */
public class ObjectWrapper implements Serializable 
{    
    /**
     * Wrapped object.
     */
    private Object o;
    
    /**
     * Track used for basic elements.
     */
    private Object track;
    
    /**
     * The model.
     */
    private LanguageModel m;
    
    /**
     * Key
     */
    private boolean key;
    
    /**
     * Hash code
     */
    private int hash;
    
    /**
     * The map.
     */
    private Map mymap;


    /**
     * Constructor
     * @param o the object
     * @param m the model.
     * @param track used for basic elements. 
     */
    public ObjectWrapper(Object o, LanguageModel m, Object track) 
    {
        this.o = o;
        this.m = m;
        this.track = track;
        this.hash = track.hashCode();
        this.mymap = new HashMap();
        this.mymap.put(o, (this));
    }
    
    /**
     * Constructor
     * @param o the object
     * @param m the model.
     * @param hash the hash code.
     * @param mymap my mappings. 
     */
    protected ObjectWrapper (Object o, LanguageModel m, int hash, Map mymap, boolean key) 
    {
        this.o = o;
        this.m = m;
        this.hash = hash;
        this.key = key;
        this.mymap = mymap;
    }


    /**
     * Element members
     * @param cme Composite element
     * @param key is key?
     * @return key members when key is true, all members when key is false
     */
    private static List getMembers (CompositeLanguageElement cme, boolean key)
    {
    	if (key)
    		return cme.getKeyMembers();
		else
			return cme.getMembers();
    }
    
    /**
     * Gets a ObjectWrapper
     * @param o the object to wrap
     * @param m the model
     * @param map the object wrappers map.
     * @return the object wrapper.
     */
    public static ObjectWrapper createObjectWrapper(Object o,LanguageModel m,Map map) 
    {
        return createObjectWrapper(o,m,map,null,false);
    }

    /**
	 * Gets a KeyWrapper
	 * @param o the object to wrap
	 * @param m the model
	 * @param map the object wrappers map.
	 * @return the key wrapper.
	 */
	public static ObjectWrapper createKeyWrapper (Object o,LanguageModel m,Map map) 
	{
		return createObjectWrapper(o,m,map,null,true);
	} 
    
    /**
     * Gets a ObjectWrapper
     * @param o the object to wrap
     * @param m the model
     * @param map the object wrappers map.
     * @param added last added mappings.
     * @return the object wrapper.
     */
    private static ObjectWrapper createObjectWrapper (
    		Object o,
    		LanguageModel m,
    		Map map,
    		Map added, 
    		boolean key ) 
    {
        int hash = 0;
        
        ObjectWrapper kw = map.get(o);
        if (kw != null) {
            if (added != null) {
                added.putAll(kw.mymap);
            }
            return kw;
        }
        
        LanguageElement e = m.getClassToElement().get(o.getClass());
    	Map myadded = new HashMap();
        
        if (e instanceof CompositeLanguageElement) {
        	hash = hashComposite(o, m, map, key, myadded, (CompositeLanguageElement) e);
        } else {
        	hash = o.hashCode();        	
        }
        //System.err.println("LE "+e +"OBJ "+o+" "+o.getClass()+" hash="+hash);
    	        
        ObjectWrapper th = new ObjectWrapper(o, m, hash, myadded, key);

        map.put(o,th);
        if (added != null)
            added.putAll(myadded);
        
        return th;
    }

	private static int hashComposite(
			Object o, LanguageModel m,
			Map map, boolean key,
			Map myadded, CompositeLanguageElement me) 
	{
		int hash = 0;
		
		try {
			for (LanguageMember em: getMembers(me,key) ) {
				Field fld = Reflection.findField(me.getElementClass(),em.getID());
				fld.setAccessible(true);
				Object val = fld.get(o);
				if (val == null) {
					hash *= 53;
				} else {
					if (MemberCollection.class.isAssignableFrom(em.getClass())) {
						hash = hashCollection(m, map, myadded, (MemberCollection) em, val, hash);
					} else {
						ObjectWrapper ow = createObjectWrapper(val,m,map,myadded,key);
						map.put(val,ow);
						hash += val.toString().hashCode(); // vs. ow.hashCode();
						hash *= 53;
					}
				}
			}
		} catch (Exception ex) {
			Logger.getLogger(ObjectWrapper.class.getName()).log(Level.SEVERE, null, ex);
		}
		return hash;
	}

	private static int hashCollection(
			LanguageModel m, Map map, Map myadded,
			MemberCollection mem, Object val, int hash) 
	{
		switch (mem.getCollection()) {
		
		case ARRAY:
			Object[] array = (Object[])val;
			for (int j = 0;j < array.length;j++) {
				ObjectWrapper ow = createObjectWrapper(array[j],m,map,myadded,false);
				map.put(array[j],ow);
				hash += ow.hashCode();
				hash *= 53;
			}
			break;
		case LIST:
			List list = (List)val;
			for (int j = 0;j < list.size();j++) {
				ObjectWrapper ow = createObjectWrapper(list.get(j),m,map,myadded,false);
				map.put(list.get(j),ow);
				hash += ow.hashCode();
				hash *= 53;
			}
			break;
		case SET:
			Set dictionary = new HashSet();
			Set