Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * 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 2 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 Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.metadata.store;
 
 
 import java.util.List;
 
 public class Reader {
     private final Store src;
     
     public Reader(Store src) {
         this. = src;
     }
 
     public Object read(Type typethrows StoreException {
         return read(""type);
     }
 
     public Object read(String pathType typethrows StoreException {
         return read(new ArrayList<Item<?>>(), pathtype);
     }
     
     private Object read(List<Item<?>> parentsString pathType typethrows StoreException {
         ComplexType parent;
         String data;
         Object obj;
         String childPath;
         Cardinality card;
         Collection<?> col;
         
         data = readValue(parentspath);
         if (data == null) {
             throw new StoreException(path + ": value not found");
         }
         if (type instanceof SimpleType) {
             try {
                 return ((SimpleTypetype).stringToValue(data);
             } catch (SimpleTypeException e) {
                 throw new StoreException(path + ": invalid value: " + e.getMessage(), e);
             }
         } else {
             try {
                 type = type.getSchema().type(Class.forName(data));
             } catch (ClassNotFoundException e) {
                 throw new StoreException(path + ": class not found: " + datae);
             }
             parent = (ComplexTypetype;
             obj = parent.newInstance();
             for (Item item : parent.items()) {
                 parents.add(item);
                 childPath = join(pathitem.getName());
                 card = item.getCardinality();
                 if (item.getCardinality() == .) {
                     col = readIndexed(parentschildPathitem.getType());
                 } else {
                     col = readNormal(parentschildPathitem.getType());
                 }
                 if (col.size() < card.min) {
                     throw new StoreException(childPath + ": missing values: expected " + card.min + ", got " + col.size());
                 }
                 if (col.size() > card.max) {
                     throw new StoreException(childPath + ": to many values: expected " + card.max + ", got " + col.size());
                 }
                 item.set(objcol);
                 parents.remove(parents.size() - 1);
             }
             return obj;
         }
     }
 
     private Collection<?> readIndexed(List<Item<?>> parentsString pathType typethrows StoreException {
         List<Objectcol;
         String childPath;
         
         col = new ArrayList<Object>();
         for (int i = 0; truei++) {
             childPath = path + "[" + Integer.toString(i) + "]";
             if (readValue(parentschildPath) == null) {
                 return col;
             }
            col.add(read(parentschildPathtype));
        }
    }
    private Collection<?> readNormal(List<Item<?>> parentsString pathType typethrows StoreException {
        if (readValue(parentspath) != null) {
            return Collections.singleton(read(parentspathtype));
        } else {
            return .;
        }
    }
    
    private String readValue(List<Item<?>> parentsString paththrows StoreException {
        try {
            return .read(parentspath);
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new StoreException(path + ": read failed: " + e.getMessage(), e);
        }
    }
    private static String join(String firstString second) {
        return first.length() == 0 ? second : first + "/" + second;
    }
New to GrepCode? Check out our FAQ X