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 FieldType implements WikittyTagValueSerializable {

    
to use log facility, just put in your code: log.info(\"...\");
 
     static private Log log = LogFactory.getLog(FieldType.class);

    
serialVersionUID.
 
     private static final long serialVersionUID = -4375308750387837026L;
 
     public static final int NOLIMIT = .;
 
     protected WikittyTypes type;
     protected int lowerBound;
     protected int upperBound;

    
used to store tag/value used by client side ex: editor=xhtml
 
     Map<StringStringtagValues = new HashMap<StringString>();
 
     public FieldType() {
     }
 
     public FieldType(WikittyTypes typeint lowerBoundint upperBound) {
         this. = type;
         this. = lowerBound;
         this. = upperBound;
     }
 
     public void addTagValue(String tagString value) {
         .put(tagvalue);
     }
 
     public String getTagValue(String tag) {
         String result = StringUtils.defaultIfBlank(.get(tag), "");
         return result;
     }
 
     public Set<StringgetTagNames() {
         return .keySet();
     }
 
     public Map<StringStringgetTagValues() {
         return ;
     }
 
     public void setTagValues(Map<StringStringtagValues) {
         this. = tagValues;
     }

    
Return true if this field have upperBound > 1.

Returns:
true is field is collection
    public boolean isCollection() {
        return  > 1;
    }

    
Return string definition for this field.

Parameters:
name field name used for definition
Returns:
field definition
    public String toDefinition(String name) {
        String result =  + " " + name;
        if ( != 0 ||  != 0) {
            if ( != ) {
                result += "[" +  + "-" +  + "]";
            } else {
                result += "[" +  + "-*]";
            }
        }
        result += WikittyUtil.tagValuesToString();
        return result;
    }

    
Convert value in argument in right type for this FieldType. Don't support collection.

Parameters:
value value to convert
Returns:
object in type of this FieldType
    public Object getContainedValidObjectObject value ) {
        // to permit simple migration from cardinality N to 1 for field
        if (value != null && (value instanceof Collection
                // small exception for binary where primitive type is Array of byte
                || (value.getClass().isArray() &&  != .))) {
            int size = CollectionUtils.size(value);
            if (size > 0) {
                value = CollectionUtils.get(value, 0);
                if (size > 1) {
                    .warn("migrate field cardinality N to 1, but collection contains " +
                            size + " values, only first is migrate, all other are loose");
                }
          }
        }
        Object result = null;
        switch () {
        case :
            result = WikittyUtil.toBinary(value); break;
        case :
            result = WikittyUtil.toDate(value); break;
        case :
            result = WikittyUtil.toBigDecimal(value); break;
        case :
            result = WikittyUtil.toBoolean(value); break;
        case :
            result = WikittyUtil.toString(value); break;
        default:
            // if type is not found then type is business type
            // and is wikitty object
            result = WikittyUtil.toWikitty(value); break;
        }
        return result;
    }

    
Return a valid value for this field.

Parameters:
value is casted if possible to an actual correct value.
Returns:
value validity
Throws:
org.nuiton.wikitty.WikittyException if value can't be obtained
    public Object getValidValue(Object valuethrows WikittyException {
        if (value == null && hasDefault()) {
            value = getDefault();
        }
        if (value == null && isNotNull()) {
            throw new WikittyException("Value can't be null for this field");
        }
        Object result;
        if (value == null) {
            result = null;
        } else if (isCollection()) {
            if ( !(value instanceof Collection || value.getClass().isArray()) ) {
                // to simplify migration from field with cardinality 1 to N
                // create collection with value
                value = new Object[]{value};
            }
            Collection<Objectcol;
            if (isUnique()) {
                col = new LinkedHashSet<Object>();
            } else {
                col = new ArrayList<Object>();
            }
            // copy all value in new collections
            if (value instanceof Collection) {
                for ( Object o : (Collection<?>) value ) {
                    Object tmp = getContainedValidObject(o);
                    if (tmp != null) {
                        col.addtmp );
                    }
                }
            } else {
                // is Array
                for ( Object o : (Object[]) value ) {
                    Object tmp = getContainedValidObject(o);
                    if (tmp != null) {
                        col.addtmp );
                    }
                }
            }
            result = col;
            // check bound condition
            if (!(getLowerBound() <= col.size() && col.size() <= getUpperBound())) {
                // if upper bound reached, throw an exception
                throw new WikittyException(String.format(
                        "Can't set collection value, bad size collection: %s <= %s <= %s is false",
                        getLowerBound(), col.size(), getUpperBound()));
            }
        } else {
            result = getContainedValidObject(value);
        }
        return result;
    }

    
Test if value in argument is valid for this field type.

Parameters:
value to test
Returns:
true if value is valid
    public boolean isValidValue(Object value) {
        boolean result;
        if (value == null && isNotNull()) {
            result = false;
        } else {
            try {
                getValidValue(value);
                // no exception value is valid
                result = true;
            } catch (Exception eee) {
                if (.isDebugEnabled()) {
                    .debug("Can't convert value, value is not valid, return false"eee);
                }
                // exception value is not valid
                result = false;
            }
        }
        return result;
    }
    public WikittyTypes getType() {
        return ;
    }
    public void setType(WikittyTypes type) {
        this. = type;
    }
    public int getLowerBound() {
        return ;
    }
    public void setLowerBound(int lowerBound) {
        this. = lowerBound;
    }
    public int getUpperBound() {
        return ;
    }
    public void setUpperBound(int upperBound) {
        this. = upperBound;
    }

    
    public boolean hasFieldIndex() {
        return null != getTagValue();
    }

    
    public double getFieldIndex() {
        double result = .;
        String fieldIndex = getTagValue();
        if (fieldIndex != null) {
            try {
                result = Double.parseDouble(fieldIndex);
            } catch (NumberFormatException eee) {
                if (.isDebugEnabled()) {
                    .debug(String.format("Bad fieldIndex value '%s'"fieldIndex), eee);
                }
            }
        }
        return result;
    }

    
    public boolean hasDefault() {
        return .containsKey();
    }
    public Object getDefault() {
        Object result = null;
        
        Object val = .get();
        if (val != null) {
            if (isCollection()) {
                val = Collections.singleton(val);
            }
            result = getValidValue(val);
        }
        return result;
    }

    
    public boolean isUnique() {
        return "true".equalsIgnoreCase(getTagValue());
    }

    
    public boolean isNotNull() {
        return "true".equalsIgnoreCase(getTagValue());
    }

    
    public boolean isIndexed() {
        String indexed = getTagValue();
        boolean result =
                !isCrypted() && !StringUtils.equalsIgnoreCase("false"indexed);
        return result;
    }

    
    public boolean hasPattern() {
        boolean result = StringUtils.isNotBlank(getTagValue());
        return result;
    }

    
    public String getPattern() {
        String result = getTagValue();
        return result;
    }

    
    public boolean isCrypted() {
        boolean result = StringUtils.isNotBlank(getTagValue());
        return result;
    }

    
    public String getCryptAlgo() {
        String crypt = getTagValue();
        String result = StringUtils.substringBefore(crypt":");
        return result;
    }

    

Returns:
password or "" if general password must be used
See also:
org.nuiton.wikitty.generator.WikittyTagValue.TAG_CRYPT
    public String getCryptPassword() {
        String crypt = getTagValue();
        String result = StringUtils.substringAfter(crypt":");
        return result;
    }

    
    public String getSubtype() {
        String result = getTagValue();
        if (StringUtils.isBlank(result)) {
            switch() {
                case :
                    result = "";
                    break;
                case :
                    result = "real";
                    break;
                case :
                    result = "monoline";
                    break;
            }
        }
        return result;
    }
    
    public String getAllowed() {
        String allowed = getTagValue();
        return allowed;
    }
    
    public String getAllowedQuery() {
        String allowed = getTagValue();
        return allowed;
    }
    
    public String getChoice() {
        String result = getTagValue();
        return result;
    }
    
    public String getChoiceQuery() {
        String result = getTagValue();
        return result;
    }
    
    public String getMin() {
        String result = getTagValue();
        return result;
    }
    
    public String getMinQuery() {
        String result = getTagValue();
        return result;
    }
    
    public String getMax() {
        String result = getTagValue();
        return result;
    }
    
    public String getMaxQuery() {
        String result = getTagValue();
        return result;
    }
    
    public String getToString() {
        String result = getTagValue();
        return result;
    }
    

Returns:
list or null if not spcified allowed extension
See also:
org.nuiton.wikitty.generator.WikittyTagValue.TAG_ALLOWED
    public List<StringgetAllowedAsList() {
        List<Stringresult = null;
        String allowed = getAllowed();
        if (StringUtils.isNotBlank(allowed)) {
            String[] v = allowed.split("\\s*,\\s*");
            result = Arrays.asList(v);
        }
        return result;
    }

    
Si les extensions autorisees pour ce champs est contrainte par le tag value org.nuiton.wikitty.generator.WikittyTagValue.TAG_ALLOWED alors retourne true, sinon false.

    public boolean isRestrited() {
        boolean result = hasAllowed() || hasAllowedQuery();
        return result;
    }
    public boolean hasAllowed() {
        boolean result = StringUtils.isNotBlank(getAllowed());
        return result;
    }
    public boolean hasAllowedQuery() {
        boolean result = StringUtils.isNotBlank(getAllowedQuery());
        return result;
    }
    public boolean hasChoice() {
        boolean result = StringUtils.isNotBlank(getChoice());
        return result;
    }
    public boolean hasChoiceQuery() {
        boolean result = StringUtils.isNotBlank(getChoiceQuery());
        return result;
    }
    public boolean hasMin() {
        boolean result = StringUtils.isNotBlank(getMin());
        return result;
    }
    public boolean hasMinQuery() {
        boolean result = StringUtils.isNotBlank(getMinQuery());
        return result;
    }
    public boolean hasMax() {
        boolean result = StringUtils.isNotBlank(getMax());
        return result;
    }
    public boolean hasMaxQuery() {
        boolean result = StringUtils.isNotBlank(getMaxQuery());
        return result;
    }
    public boolean hasToString() {
        boolean result = StringUtils.isNotBlank(getToString());
        return result;
    }
New to GrepCode? Check out our FAQ X