Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 JBoss Inc
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.kie.workbench.common.services.datamodel.backend.server.builder.util;
 
 import java.util.List;
 import java.util.Map;
 
 import  org.drools.core.util.MVELSafeHelper;
 import org.mvel2.MVEL;
Use MVEL to load up map/list of valid items for fields - used by the Guided rule editor.
 
 public class DataEnumLoader {
 
     private final List<Stringerrors;
     private final Map<StringString[]> data;

    
This is the source of the asset, which is an MVEL map (minus the outer "[") of course.
 
     public DataEnumLoaderfinal String mvelSource ) {
         thismvelSource,
               Thread.currentThread().getContextClassLoader() );
     }

    
This is the source of the asset, which is an MVEL map (minus the outer "[") of course.
 
     public DataEnumLoaderfinal String mvelSource,
                            final ClassLoader classLoader ) {
         this. = new ArrayList<String>();
         this. = loadEnummvelSource,
                               classLoader );
     }
 
     private Map<StringString[]> loadEnumString mvelSource,
                                             ClassLoader classLoader ) {
 
         if ( mvelSource == null || ( mvelSource.trim().equals"" ) ) ) {
             return Collections.emptyMap();
         }
         if ( mvelSource.startsWith"=" ) ) {
             mvelSource = mvelSource.substring( 1 );
         } else {
             mvelSource = "[ " + addCommasForNewLinesmvelSource ) + " ]";
         }
         final Object mvelData;
 
         try {
 
             final ParserConfiguration pconf = new ParserConfiguration();
             final ParserContext pctx = new ParserContextpconf );
             pconf.setClassLoaderclassLoader );
 
             final Serializable compiled = MVEL.compileExpressionmvelSource,
                                                                   pctx );
 
             mvelData = MVELSafeHelper.getEvaluator().executeExpression( compiled,
                                                                         new HashMap<StringObject>() );
 
         } catch ( RuntimeException e ) {
             addError"Unable to load enumeration data." );
             addErrore.getMessage() );
             addError"Error type: " + e.getClass().getName() );
             return Collections.emptyMap();
         }
         if ( !( mvelData instanceof Map<?, ?> ) ) {
             addError"The expression is not a map, it is a " + mvelData.getClass().getName() );
             return Collections.emptyMap();
         }
 
         @SuppressWarnings("unchecked")
         Map<StringObjectmap = (Map<StringObject>) mvelData;
 
         Map<StringString[]> newMap = new HashMap<StringString[]>();
        for ( Map.Entry<StringObjectentry : map.entrySet() ) {
            String key = makeEnumKeyentry.getKey() );
            validateKeykey );
            Object list = entry.getValue();
            if ( !( list instanceof List<?> || list instanceof String ) ) {
                if ( list == null ) {
                    addError"The item with " + key + " is null." );
                } else {
                    addError"The item with " + key + " is not a list or a string, it is a " + list.getClass().getName() );
                }
                return Collections.emptyMap();
            } else if ( list instanceof String ) {
                newMap.putkeynew String[]{ (Stringlist } );
            } else {
                List<?> items = (List<?>) list;
                String[] newItems = new Stringitems.size() ];
                for ( int i = 0; i < items.size(); i++ ) {
                    Object listItem = items.geti );
                    if ( !( listItem instanceof String ) ) {
                        newItemsi ] = listItem.toString();
                    } else {
                        newItemsi ] = (StringlistItem;
                    }
                }
                newMap.putkeynewItems );
            }
        }
        return newMap;
    }
    private void validateKeyfinal String key ) {
        final Pattern pattern = Pattern.compile".*(\\[.*\\])" );
        final Matcher matcher = pattern.matcherkey );
        if ( !matcher.matches() ) {
            return;
        }
        if ( matcher.groupCount() > 2 ) {
            .add"Invalid dependent definition: Only [..] accepted." );
            return;
        }
        final String dependencySegment = matcher.group( 1 );
        if ( dependencySegment.equals"[]" ) ) {
            .add"Invalid dependent definition: Empty [] detected." );
            return;
        }
        if ( dependencySegment.contains"\"" ) ) {
            .add"Invalid dependent definition: Found quote literal." );
            return;
        }
        if ( dependencySegment.contains"=" ) ) {
            validateSimpleEnumKeydependencySegment );
        } else {
            validateAdvancedEnumKeydependencySegment );
        }
    }
    private void validateSimpleEnumKeyfinal String dependencySegment ) {
        if ( dependencySegment.matches"\\[\\s*=\\s*\\]" ) ) {
            .add"Invalid dependent definition: No field or value detected." );
            return;
        }
        if ( dependencySegment.matches"\\[\\s*=\\S+\\]" ) ) {
            .add"Invalid dependent definition: No field detected." );
            return;
        }
        if ( dependencySegment.matches"\\[\\S+=\\s*\\]" ) ) {
            .add"Invalid dependent definition: No value detected." );
            return;
        }
    }
    private void validateAdvancedEnumKeyfinal String dependencySegment ) {
        if ( dependencySegment.matches"\\[\\s*,\\s*\\]" ) ) {
            .add"Invalid definition: Field definitions are incomplete." );
            return;
        }
        if ( dependencySegment.matches"\\[\\s*,\\S+\\]" ) ) {
            .add"Invalid definition: Field definitions are incomplete." );
            return;
        }
        if ( dependencySegment.matches"\\[\\S+,\\s*\\]" ) ) {
            .add"Invalid definition: Field definitions are incomplete." );
            return;
        }
    }
    private String addCommasForNewLinesString mvelSource ) {
        StringTokenizer st = new StringTokenizermvelSource"\r\n" );
        StringBuilder buf = new StringBuilder();
        while ( st.hasMoreTokens() ) {
            String line = st.nextToken().trim();
            if ( st.hasMoreTokens() && line.endsWith"," ) ) {
                buf.appendline );
            } else {
                buf.appendline );
                if ( st.hasMoreTokens() ) {
                    buf.append"," );
                }
            }
            if ( st.hasMoreTokens() ) {
                buf.append"\n" );
            }
        }
        return buf.toString();
    }
    private void addErrorString string ) {
        this..addstring );
    }

    
Return a list of any errors found.
    public List<StringgetErrors() {
        return this.;
    }
    public boolean hasErrors() {
        return this..size() > 0;
    }

    
Return the map of Fact.field to List (of Strings).
    public Map<StringString[]> getData() {
        return this.;
    }
    private String makeEnumKeyfinal String userDefinedKey ) {
        //Use of "." as a delimiter between Fact and Field leads to problems with fully qualified class names
        String systemDefinedKey = userDefinedKey.replace".",
                                                          "#" );
        return systemDefinedKey;
    }
New to GrepCode? Check out our FAQ X