Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.nuiton.wikitty.query.function;
  
  /*
   * #%L
   * Wikitty :: api
   * %%
   * Copyright (C) 2009 - 2013 CodeLutin
   * %%
   * 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%
  */
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
Herite de Element et utilise value pour stocker la methode a appeler

Author(s):
poussin
Version:
$Revision$ Last update: $Date$ by : $Author$
 
 public abstract class WikittyQueryFunction {

    
to use log facility, just put in your code: log.info(\"...\");
 
     static private Log log = LogFactory.getLog(WikittyQueryFunction.class);
 
     private static final long serialVersionUID = 1L;

    
le nom de la methode a appeler
 
     protected String methodName;
    
le nom que l'utilisateur a donné au resultat: ex: Sum(amount) as Toto
 
     protected String name;
    
la liste des arguments de la fonction
 
     protected List<WikittyQueryFunctionargs = new ArrayList<WikittyQueryFunction>();
    
le nombre d'argument que la function peut prendre. Integer.MAX_VALUE = infini
 
     protected int numArg = .;
 
     abstract public List<Map<StringObject>> call(
             WikittyQuery queryList<Map<StringObject>> data);
 
         WikittyQueryFunction result;
         if (args.size() == 1) {
             result = args.get(0);
         } else {
             result = new FunctionFusion(args);
         }
         return result;
     }
     
     static public WikittyQueryFunction create(String methodNameString nameList<WikittyQueryFunctionargs) {
         WikittyQueryFunction result;
         if ("fieldValue".equalsIgnoreCase(methodName)) {
             result = new FunctionFieldValue(methodNamenameargs);
         } else if ("Fusion".equalsIgnoreCase(methodName)) {
             result = new FunctionFusion(methodNamenameargs);
         } else if ("sum".equalsIgnoreCase(methodName)) {
             result = new FunctionSum(methodNamenameargs);
         } else if ("min".equalsIgnoreCase(methodName)) {
             result = new FunctionMin(methodNamenameargs);
         } else if ("max".equalsIgnoreCase(methodName)) {
             result = new FunctionMax(methodNamenameargs);
         } else if ("avg".equalsIgnoreCase(methodName)) {
             result = new FunctionAvg(methodNamenameargs);
         } else if ("count".equalsIgnoreCase(methodName)) {
             result = new FunctionCount(methodNamenameargs);
        } else if ("distinct".equalsIgnoreCase(methodName)) {
            result = new FunctionDistinct(methodNamenameargs);
        } else if ("toBigDecimal".equalsIgnoreCase(methodName)) {
            result = new WikittyQueryFunctionWrapper(WikittyUtil.class.getName() + "#toBigDecimal"nameargs);
        } else if ("toBoolean".equalsIgnoreCase(methodName)) {
            result = new WikittyQueryFunctionWrapper(WikittyUtil.class.getName() + "#toBoolean"nameargs);
        } else if ("toString".equalsIgnoreCase(methodName)) {
            result = new WikittyQueryFunctionWrapper(WikittyUtil.class.getName() + "#toString"nameargs);
        } else if ("toDate".equalsIgnoreCase(methodName)) {
            result = new WikittyQueryFunctionWrapper(WikittyUtil.class.getName() + "#toDate"nameargs);
        } else if ("year".equalsIgnoreCase(methodName)) {
            result = new FunctionYear(methodNamenameargs);
        } else {
            if (StringUtils.contains(methodName.)) {
                // c'est une methode quelconque.
                result = new WikittyQueryFunctionWrapper(methodNamenameargs);
            } else {
                try {
                    // c'est peut-etre une classe qui herite de WikittyQueryFunction
                    Class c = Class.forName(methodName);
                    result = (WikittyQueryFunction)ConstructorUtils.invokeConstructor(c,
                            new Object[]{methodNamenameargs},
                            new Class[]{String.classString.classList.class});
                } catch (Exception eee) {
                    throw new WikittyException(String.format(
                            "Can't instantiate function '%s'"methodName), eee);
                }
            }
        }
        return result;
    }
    public WikittyQueryFunction(String methodNameString nameList<WikittyQueryFunctionargs) {
        this. = methodName;
        if (name == null) {
            this. = UUID.randomUUID().toString();
        } else {
            this. = name;
        }
        addArgs(args);
    }
    @Override
    public boolean equals(Object o) {
        boolean result;
        if (o == null) {
            result = false;
        } else if (this == o) {
            result = true;
        }else if (this.getClass().equals(o.getClass())) {
            WikittyQueryFunction other = (WikittyQueryFunction)o;
            result = StringUtils.equals(this.getMethodName(), other.getMethodName())
                    // TODO a revoir
                    // name est genere pour etre unique s'il n'est pas fixe, donc on ne peut pas faire de check dessus
                    // est-ce que laisser null, si name n'est pas fixer ne serait pas preferable ? Est-ce que les map accept null comme cle ?
//                    && StringUtils.equals(this.getName(), other.getName())
                    && ObjectUtils.equals(this.getArgs(), other.getArgs());
        } else {
            return false;
        }
        return result;
    }
    public void accept(WikittyQueryVisitor visitor) {
        boolean walk = visitor.visitEnter(this);
        if (walk &&  != null) {
            boolean notFirst = false;
            for(WikittyQueryFunction a : ) {
                if (notFirst) {
                    walk = visitor.visitMiddle(this);
                    if (!walk) {
                        // le visiteur demande l'arret de la visite
                        break;
                    }
                } else {
                    notFirst = true;
                }
                a.accept(visitor);
            }
        }
        visitor.visitLeave(thiswalk);
    }
    public String getName() {
        return ;
    }
    public String getMethodName() {
        return ;
    }
    public List<WikittyQueryFunctiongetArgs() {
        return ;
    }
    public void addArgs(List<WikittyQueryFunctionargs) {
        if (args != null) {
            if (this..size() + args.size() <= getNumArg()) {
                this..addAll(args);
            } else {
                throw new IllegalStateException(String.format(
                        "This function '%s' can't take more arguments than %s, currently '%s', you try to add %s arguments",
                        this.getClass().getSimpleName(), getNumArg(), this..size(), args.size()));
            }
        }
    }
    public void addArgs(WikittyQueryFunction arg) {
        if (acceptMoreArgs()) {
            .add(arg);
        } else {
            throw new IllegalStateException(String.format(
                    "This function '%s' can't take more arguments, currently '%s'",
                    this.getClass().getSimpleName(), .size()));
        }
    }
    public int getNumArg() {
        return ;
    }
    public boolean acceptMoreArgs() {
        boolean result = .size() < getNumArg();
        return result;
    }
    @Override
    public String toString() {
        accept(v);
        String result = v.getText();
        return result;
    }
    protected List<Map<StringObject>> fusion(List<List<Map<StringObject>>> listData) {
        List<Map<StringObject>> result = new ArrayList<Map<StringObject>>();
        // check size, all list must have same size
        int size = -1;
        for (List<Map<StringObject>> e : listData) {
            if (size == -1) {
                size = e.size();
            } else {
                if (size != e.size()) {
                    throw new IllegalArgumentException(String.format(
                            "Each list must have same size %s != %s (%s)",
                            sizee.size(), listData));
                }
            }
        }
        // init des maps
        for (int i=0; i<sizei++) {
            result.add(new LinkedHashMap<StringObject>());
        }
        // ajout de chaque map dans la map du resultat
        for (List<Map<StringObject>> e : listData) {
            int i=0;
            for (Map<StringObjectm : e) {
                Map<StringObjectr = result.get(i++);
                r.putAll(m);
            }
        }
        
        return result;
    }
    protected Object getUniqueValue(List<Map<StringObject>> data) {
        Object result = null;
        if (data.size() != 1) {
            throw new IllegalStateException("Data don't contains 1 value exactly");
        }
        for (Map<StringObjecto : data) {
            if (o.size() != 1) {
                throw new IllegalStateException("Map don't contains 1 value exactly");
            } else {
                for (Object s : o.values()) {
                    result = s;
                }
            }
        }
        return result;
    }
    protected Object getUniqueValue(Map<StringObjecto) {
        Object result = null;
        if (o.size() != 1) {
            throw new IllegalStateException("Map don't contains 1 value exactly");
        } else {
            for (Object s : o.values()) {
                result = s;
            }
        }
        return result;
    }
    protected Object getFirstFieldName(List<Map<StringObject>> data) {
        for (Map<StringObjecto : data) {
            for (Object s : o.keySet()) {
                return s;
            }
        }
        return null;
    }

    

Parameters:
fqMethod une methode d du style le.package.objet#method
Returns:
    protected Method getMethod(String fqMethod) {
        List<Methodmethods = ObjectUtil.getMethod(fqMethodtrue);
        Method result;
        if (methods.isEmpty()) {
            throw new IllegalArgumentException(String.format(
                    "Can't find method '%s'"fqMethod));
        } else {
            if (methods.size() > 1) {
                .warn(String.format(
                        "More than one method found for '%s', used the first: %s",
                        fqMethodmethods));
            }
            result = methods.get(0);
        }
        return result;
    }
New to GrepCode? Check out our FAQ X