Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * Wikitty :: api
   * %%
   * Copyright (C) 2009 - 2010 CodeLutin, Benjamin Poussin
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as 
   * published by the Free Software Foundation, either version 3 of the 
  * License, or (at your option) any later version.
  * 
  * This program 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 Lesser Public License for more details.
  * 
  * You should have received a copy of the GNU General Lesser Public 
  * License along with this program.  If not, see
  * <http://www.gnu.org/licenses/lgpl-3.0.html>.
  * #L%
  */
 
 package org.nuiton.wikitty.entities;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

Author(s):
poussin
Version:
$Revision$ Last update: $Date$ by : $Author$
 
 public class WikittyExtension implements Serializable {

    
serialVersionUID.
 
     private static final long serialVersionUID = -3598621577607442972L;

    
Field name pattern only word character [a-zA-Z_0-9] is accepted
 
     static protected Pattern NamePattern = Pattern.compile("^\\w+$");

    
Field name pattern only word character [a-zA-Z_0-9] is accepted
 
     static protected Pattern fieldNamePattern = Pattern.compile("^\\w+$");

    
Property change support. Warning, this transient field is null after deserialization.
 
     protected transient PropertyChangeSupport propertyChangeSupport;

    
Name of this extension.
 
     protected String name;

    
Name of others extensions needed to put this extension to object.
 
     protected List<Stringrequires;

    
use to know version objet, when you change field number, type or other you must change version number.
 
     protected String version = .;

    
used to store tag/value used by client side ex: updatedDate=101212
 
     protected Map<StringStringtagValues = new HashMap<StringString>();

    
fields use ordered map, to keep order insertion of field key: field name value: field type
 
     protected LinkedHashMap<StringFieldTypefields = new LinkedHashMap<StringFieldType>();

    
Default constructor. Used by hibernate.
 
    public WikittyExtension() {
        
    }
    public WikittyExtension(String name) {
        setName(name);
    }
    public WikittyExtension(String nameString version,
            LinkedHashMap<StringFieldTypefields) {
        this(nameversion, (Map)null, (List)nullfields);
    }
    public WikittyExtension(String nameString versionMap<StringStringtagValues,
            String requiresLinkedHashMap<StringFieldTypefields) {
        this(nameversiontagValues, StringUtils.split(requires","), fields);
    }
    public WikittyExtension(String nameString versionMap<StringStringtagValues,
            String[] requiresLinkedHashMap<StringFieldTypefields) {
        this(nameversiontagValues,
                ArrayUtils.isEmpty(requires)?(List)null:Arrays.asList(requires),
                fields);
    }
    public WikittyExtension(String nameString versionMap<StringStringtagValues,
            List<StringrequiresLinkedHashMap<StringFieldTypefields) {
        if (version == null) {
            throw new IllegalArgumentException("Version must not be null");
        }
        setName(name);
        this. = WikittyUtil.normalizeVersion(version);
        setRequires(requires);
        setTagValues(tagValues);
        if (fields != null) {
            addField(fields);
        }
    }
        if ( == null) {
             = new PropertyChangeSupport(this);
        }
        return ;
    }
    public void addPropertyChangeListener(PropertyChangeListener listener) {
    }
    public void removePropertyChangeListener(PropertyChangeListener listener) {
    }
    public void addPropertyChangeListener(String propertyName,
            PropertyChangeListener listener) {
        getPropertyChangeSupport().addPropertyChangeListener(propertyNamelistener);
    }
    public void removePropertyChangeListener(String propertyName,
            PropertyChangeListener listener) {
        getPropertyChangeSupport().removePropertyChangeListener(propertyNamelistener);
    }
    public WikittyExtension cloneForUpgrade() {
        String nextRevision = WikittyUtil.incrementMajorRevision(getVersion());
        
        LinkedHashMap<StringFieldTypenextFields = null;
        if ( != null) {
            nextFields = new LinkedHashMap<StringFieldType>();
            for (Map.Entry<StringFieldTypeentry : .entrySet()) {
                FieldType type = entry.getValue();
                FieldType nextType = new FieldType(
                        type.getType(), type.getLowerBound(), type.getUpperBound());
                Set<StringtagNames = type.getTagNames();
                if (tagNames != null) {
                    for (String tagName : tagNames) {
                        String tagValue = type.getTagValue(tagName);
                        nextType.addTagValue(tagNametagValue);
                    }
                }
                nextFields.put(entry.getKey(), nextType);
            }
        }
        WikittyExtension result = new WikittyExtension(
                nextRevisionnextFields);
        return result;
    }

    
Compute id for extension name and version in argument.

Parameters:
name extension name
version extension version
Returns:
extension string id
    static public String computeId(String nameString version) {
        String result = name + "[" + version + "]";
        return result;
    }

    
Extract name from extension id

Parameters:
id id like MonExtension[3.0]
Returns:
extension name. Example 'MonExtension'
    static public String computeName(String id) {
        int i = id.lastIndexOf("[");
        String result = id;
        if (i != -1) {
            result = id.substring(0, i);
        }
        return result;
    }

    
Extract extension version from extension id. If id contains no version this method return '0.0'.

Parameters:
id id like MonExtension[3.0]
Returns:
extension version. Example '3.0'
    static public String computeVersion(String id) {
        int b = id.lastIndexOf("[");
        int e = id.lastIndexOf("]");
        String result = null;
        if (b != -1 && e != -1) {
            result = id.substring(b+1, e);
        }
        result = WikittyUtil.normalizeVersion(result);
        return result;
    }
    static public boolean isFqField(String fieldName) {
        int i = fieldName.indexOf(.);
        boolean result = i > 0;
        return result;
    }

    
Extract extension name from fully qualified field name

Parameters:
fqFieldName fully qualified field name like 'WikittyUser.login'
Returns:
return extension name. Example 'WikittyUser'
Throws:
WikittyException if bad fqFieldName format
    static public String extractExtensionName(String fqFieldName) {
        int i = fqFieldName.indexOf(.);
        if (i > 0) {
            String result = fqFieldName.substring(0, i);
            return result;
        } else {
            throw new IllegalArgumentException(String.format(
                    "Your argument '%s' is not fully qualified field name"fqFieldName));
        }
    }

    
Extract field name from fully qualified field name (suppression [n/m] if field is collection) and suppress TYPE if needed

Parameters:
fqFieldName fully qualified field name like 'WikittyUser.login'
Returns:
return field name. Example 'login'
    static public String extractFieldName(String fqFieldName) {
        int i = fqFieldName.indexOf(.);
        if (i > 0) {
            String result = fqFieldName.substring(i+1);
            int b = result.lastIndexOf("[");
            if (b > 0) {
                result = result.substring(0, b);
            }
            return result;
        } else {
            throw new IllegalArgumentException(String.format(
                    "Your argument '%s' is not fully qualified field name"fqFieldName));
        }
    }
    public String getId() {
        String result = computeId(getName(), getVersion());
        return result;
    }
    public String getName() {
        return ;
    }

    
Set extension name. Check for invalid extension name (non alphanumeric characters).

Parameters:
name name
    public void setName(String name) {
        // check alphanumeric characters
        if (name == null) {
            throw new IllegalArgumentException("Name must not be null");
        }
        if (!.matcher(name).matches()) {
            throw new IllegalArgumentException("Name contains non alphanumeric characters");
        }
        this. = name;
    }
    public String getVersion() {
        return ;
    }
    public void setVersion(String version) {
        this. = version;
    }
    public List<StringgetRequires() {
        return ;
    }
    public void setRequires(List<Stringrequires) {
        if (requires == null) {
            requires = .;
        }
        this. = Collections.unmodifiableList(new ArrayList<String>(requires));
        getPropertyChangeSupport().firePropertyChange("requires"nullthis.);
    }
    
    public FieldType getFieldType(String fieldName) {
        return .get(fieldName);
    }
    public Collection<StringgetFieldNames() {
        Collection<Stringresult = .keySet();
        return result;
    }

    
Cette methode ne doit-etre utilise que par des methodes qui tri par la suite la Map de champs, car celle-ci ne le fait pas

Parameters:
fieldName
type
    protected void addField(Map<StringFieldTypenewFields) {
        // check fieldname and fieldType
        for (Map.Entry<StringFieldTypee : newFields.entrySet()) {
            if (null == e.getValue()) {
                throw new IllegalArgumentException(
                        "FieldType must not be null for field '" + e.getKey() +"'");
            }
            Matcher matcher = .matcher(e.getKey());
            if(!matcher.find()) {
                throw new IllegalArgumentException(
                        "For field name [" + e.getKey() +"], only word character [a-zA-Z_0-9] is accepted");
            }
        }
        .putAll(newFields);
        // sort field on TAG_FIELD_INDEX after add
         = sortField();
        
        getPropertyChangeSupport().firePropertyChange("fields"null);
    }

    
Ajoute un nouveau champs a l'extension, la liste des champs est automatiquement trie apr├Ęs chaque insertion.

Parameters:
fieldName le nom du champs
type le type du champs contenant un tag TAG_FIELD_INDEX pour le tri
    public void addField(String fieldNameFieldType type) {
        if (null == type) {
            throw new IllegalArgumentException(
                    "FieldType must not be null for field '" + fieldName +"'");
        }
        Matcher matcher = .matcher(fieldName);
        if(matcher.find()) {
            .put(fieldNametype);
            // sort field on TAG_FIELD_INDEX after add
             = sortField();
            // TODO EC20100610 null for old value
            getPropertyChangeSupport().firePropertyChange("fields"null);
        } else {
            throw new IllegalArgumentException("For field name [" + fieldName +"], only word character [a-zA-Z_0-9] is accepted");
        }
    }

    
Tri la map en entree suivant la valeur de TAG_FIELD_INDEX de la valeur
    protected LinkedHashMap<StringFieldTypesortField(Map<StringFieldTypemap) {
        List<Map.Entry<StringFieldType>> list =
                new ArrayList<Map.Entry<StringFieldType>>(map.entrySet());
        Collections.sort(listnew Comparator<Map.Entry<StringFieldType>>() {
            public int compare(Map.Entry<StringFieldTypeo1Map.Entry<StringFieldTypeo2) {
                Double f1 = o1.getValue().getFieldIndex();
                Double f2 = o2.getValue().getFieldIndex();
                int result = f1.compareTo(f2);
                return result;
            }
        });
        LinkedHashMap<StringFieldTyperesult = new LinkedHashMap<StringFieldType>();
        for (Map.Entry<StringFieldTypee : list) {
            result.put(e.getKey(), e.getValue());
        }
        return result;
    }
    public void removeField(String fieldName) {
        .remove(fieldName);
        // TODO EC20100610 null for old value
        getPropertyChangeSupport().firePropertyChange("fields"null);
    }
    @Override
    public int hashCode() {
        return getId().hashCode();
    }
    public void addTagValue(String tagString value) {
        .put(tagvalue);
        // TODO EC20100610 null for old value
        getPropertyChangeSupport().firePropertyChange("tagValues"null);
    }
    public String getTagValue(String tag) {
        String result = .get(tag);
        return result;
    }
    public Set<StringgetTagNames() {
        return .keySet();
    }
    public Map<StringStringgetTagValues() {
        return ;
    }

    
Set all tag values. If argument is null, new empty map is created.
    public void setTagValues(Map<StringStringtagValues) {
        if (tagValues == null) {
            tagValues = new HashMap<StringString>();
        }
        Map<StringStringoldValue = this.;
        this. = tagValues;
        getPropertyChangeSupport().firePropertyChange("tagValues"oldValuetagValues);
    }
    
    public boolean hasTagValueToString() {
        boolean result = StringUtils.isNotBlank(getTagValueToString());
        return result;
    }
    
    public String getTagValueToString() {
        String result = getTagValue(.);
        return result;
    }
    public boolean hasTagValueSortOrder() {
        boolean result = StringUtils.isNotBlank(getTagValueSortOrder());
        return result;
    }
    
    public String getTagValueSortOrder() {
        String result = getTagValue(.);
        return result;
    }

    
Retourne la liste des champs a trier de facon ascendante

Returns:
une liste contenant les champs de tri ou une liste vide
    public List<ElementgetSortAscending() {
        List<Elementresult = new ArrayList<Element>();
        String sortOrder = getTagValueSortOrder();
        String[] orders = StringUtils.split(sortOrder",");
        if (orders != null) {
            for (String order : orders) {
                String s = StringUtils.substringAfterLast(order" ");
                s = StringUtils.trim(s);
                if (StringUtils.isBlank(s) || StringUtils.equalsIgnoreCase("asc"s)) {
                    String field = StringUtils.substringBefore(order" ");
                    field = StringUtils.trim(field);
                    result.add(Element.get(field));
                }
            }
        }
        return result;
    }

    
Retourne la liste des champs a trier de facon descendante

Returns:
une liste contenant les champs de tri ou une liste vide
    public List<ElementgetSortDescending() {
        List<Elementresult = new ArrayList<Element>();
        String sortOrder = getTagValueSortOrder();
        String[] orders = StringUtils.split(sortOrder",");
        if (orders != null) {
            for (String order : orders) {
                String s = StringUtils.substringAfterLast(order" ");
                s = StringUtils.trim(s);
                if (StringUtils.equalsIgnoreCase("desc"s)) {
                    String field = StringUtils.substringBefore(order" ");
                    field = StringUtils.trim(field);
                    result.add(Element.get(field));
                }
            }
        }
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        boolean result = false;
        if (obj instanceof WikittyExtension) {
            WikittyExtension other = (WikittyExtension)obj;
            result = this.getId().equals(other.getId());
        }
        return result;
    }
    @Override
    public String toString() {
        return getId();
    }
    
    public String toDefinition() {
        String result = "Extension " + getId();
        result += WikittyUtil.tagValuesToString();
        result += " {\n";
        for (String fieldName : getFieldNames()) {
            result += .get(fieldName).toDefinition(fieldName) + "\n";
        }
        result += "}";
        return result;
    }

    
Return toString representation. Use tagValue 'toString' format if exist, else standard Wikitty.toString is call

Parameters:
wikitty
Returns:
    public String toString(Wikitty wikitty) {
        String result;
        String format = getTagValue(.);
        if (StringUtils.isNotBlank(format)) {
            result = WikittyUtil.format(formatwikitty);
        } else {
            result = wikitty.toStringAllField();
        }
        return result;
    }
New to GrepCode? Check out our FAQ X