
    
package performa.orm.types;

import java.util.*;
import oneit.utils.*;
import oneit.utils.transform.*;



/**
 * This class was generated using constGen.bat.
 * DO NOT MODIFY THIS CODE.
 * Edit the associated .xml file, and regenerate this file
 * constGen (directory) (file minus extension)
 * e.g. constGen C:\...\sql FieldType
 */

public class Importance extends AbstractEnumerated
{
    
    public static final EnumeratedFactory FACTORY_Importance = new ImportanceFactory();
    
    public static final Importance NOT_APPLICABLE = new Importance ("NOT_APPLICABLE", "NOT_APPLICABLE", "Not Applicable", false);
    
    public static final Importance DESIRABLE = new Importance ("DESIRABLE", "DESIRABLE", "Desirable", false);
    
    public static final Importance HIGHLY_DESIRABLE = new Importance ("HIGHLY_DESIRABLE", "HIGHLY_DESIRABLE", "Highly Desirable", false);
    
    public static final Importance ESSENTIAL = new Importance ("ESSENTIAL", "ESSENTIAL", "Essential", false);

    private static final Importance[] allImportances =
        new Importance[] { NOT_APPLICABLE,DESIRABLE,HIGHLY_DESIRABLE,ESSENTIAL};


    private static Importance[] getAllImportances ()
    {
        return allImportances;
    }

    private transient boolean ConsiderForAssessment;

    private transient Integer WeightingScore;

    private transient String CultureDescription;

    private Importance (String name, String value, String description, boolean disabled)
    {
        super (name, value, description, disabled);
    }

    public boolean getConsiderForAssessment()
    {
    return ConsiderForAssessment;
    }

    public Integer getWeightingScore()
    {
    return WeightingScore;
    }

    public String getCultureDescription()
    {
    return CultureDescription;
    }
    
    public static final Comparator COMPARE_BY_POSITION = new CompareEnumByPosition (allImportances);



    static
    {
        defineAdditionalData ();
    }

    public boolean isEqual (Importance other)
    {
    return this.name.equals (other.name);
    }

    public Enumeration getAllInstances ()
    {
        return Importance.getAll ();
    }


    private Object readResolve() throws java.io.ObjectStreamException
    {
        return Importance.forName (this.name);
    }


    public EnumeratedFactory getFactory ()
    {
        return FACTORY_Importance;
    }

    public static Importance forName (String name)
    {
        if (name == null) { return null; }

        Importance[] all = getAllImportances();
        int enumIndex = AbstractEnumerated.getIndexForName (all, name);

        return all[enumIndex];
    }


    public static Importance forValue (String value)
    {
        if (value == null) { return null; }

        Importance[] all = getAllImportances();
        int enumIndex = AbstractEnumerated.getIndexForValue (getAllImportances (), value);

        return all[enumIndex];
    }


    public static java.util.Enumeration getAll ()
    {
        return AbstractEnumerated.getAll (getAllImportances());
    }
    
    
    public static Importance[] getImportanceArray ()
    {
        return (Importance[])getAllImportances().clone ();
    }


    public static void defineAdditionalData ()
    {
        NOT_APPLICABLE.ConsiderForAssessment = false;
        NOT_APPLICABLE.WeightingScore = 0;
        NOT_APPLICABLE.CultureDescription = "Not Applicable";
        DESIRABLE.ConsiderForAssessment = true;
        DESIRABLE.WeightingScore = 2;
        DESIRABLE.CultureDescription = "Somewhat Important";
        HIGHLY_DESIRABLE.ConsiderForAssessment = true;
        HIGHLY_DESIRABLE.WeightingScore = 5;
        HIGHLY_DESIRABLE.CultureDescription = "Important";
        ESSENTIAL.ConsiderForAssessment = true;
        ESSENTIAL.WeightingScore = 10;
        ESSENTIAL.CultureDescription = "Essential";
        
    }


    static class ImportanceFactory implements EnumeratedFactory
    {
        public AbstractEnumerated getForName (String name)
        {
            return Importance.forName (name);
        }

        public AbstractEnumerated getForValue (String name)
        {
            return Importance.forValue (name);
        }

        public Enumeration getAll ()
        {
            return Importance.getAll ();
        }
    }


    public Map getAdditionalAttributes ()
    {
        Map attribs = new HashMap ();

        attribs.put ("ConsiderForAssessment", ArrayFormatter.toObject(getConsiderForAssessment()));
        attribs.put ("WeightingScore", ArrayFormatter.toObject(getWeightingScore()));
        attribs.put ("CultureDescription", ArrayFormatter.toObject(getCultureDescription()));
        
        return attribs;
    }
    
    public static class ImportancePipeLineFactory<From, Me extends Importance> extends AbstractEnumerated.EnumPipeLine<From, Me>
    {
        public <Prev> ImportancePipeLineFactory (PipeLine<From, Prev> pipeLine, Pipe<Prev, Me> nextPipe)
        {
            super (pipeLine, nextPipe);
        }
        
        public ImportancePipeLineFactory (From seed)
        {
            super(seed);
        }

        public ImportancePipeLineFactory (Collection<From> seed)
        {
            super(seed);
        }
        
        public PipeLine<From, ? extends Object> to(String name)
        {
            if (name.equals ("ConsiderForAssessment"))
            {
                return toConsiderForAssessment ();
            }
            if (name.equals ("WeightingScore"))
            {
                return toWeightingScore ();
            }
            if (name.equals ("CultureDescription"))
            {
                return toCultureDescription ();
            }
            
            return super.to(name);
        }
        
        
        public PipeLine<From, Boolean> toConsiderForAssessment () { return pipe(new EnumAttributePipe<Me, Boolean>("ConsiderForAssessment")); }
        
        public PipeLine<From, Integer> toWeightingScore () { return pipe(new EnumAttributePipe<Me, Integer>("WeightingScore")); }
        
        public PipeLine<From, String> toCultureDescription () { return pipe(new EnumAttributePipe<Me, String>("CultureDescription")); }
    }
}

