defaultdef.java

来自「数据仓库展示程序」· Java 代码 · 共 1,687 行 · 第 1/5 页

                                          final mondrian.recorder.MessageRecorder msgRecorder);
		// END pass-through code block ---
	}

	/**
	 * This is a base class for all elements that can match strings
	 * where the case of the string is important. In addition,
	 * it has an id which services as its tag.
	 */
	public static abstract class CaseMatcher extends Base
	{
		public CaseMatcher()
		{
		}

		public CaseMatcher(org.eigenbase.xom.DOMWrapper _def)
			throws org.eigenbase.xom.XOMException
		{
			try {
				org.eigenbase.xom.DOMElementParser _parser = new org.eigenbase.xom.DOMElementParser(_def, "", DefaultDef.class);
				_parser = _parser;
				id = (String)_parser.getAttribute("id", "String", null, null, true);
				charcase = (String)_parser.getAttribute("charcase", "String", "ignore", _charcase_values, false);
				enabled = (Boolean)_parser.getAttribute("enabled", "Boolean", "true", null, false);
			} catch(org.eigenbase.xom.XOMException _ex) {
				throw new org.eigenbase.xom.XOMException("In element '" + getName() + "': " + _ex.getMessage());
			}
		}

		public String id;  // required attribute
		/** Allowable values for {@link #charcase}. */
		public static final String[] _charcase_values = {"ignore", "exact", "upper", "lower"};
		public String charcase;  // attribute default: ignore


		public String getName()
		{
			return "CaseMatcher";
		}

		public void display(java.io.PrintWriter _out, int _indent)
		{
			_out.println(getName());
			displayAttribute(_out, "id", id, _indent+1);
			displayAttribute(_out, "charcase", charcase, _indent+1);
			displayAttribute(_out, "enabled", enabled, _indent+1);
		}
		public void displayXML(org.eigenbase.xom.XMLOutput _out, int _indent)
		{
			_out.beginTag("(%CaseMatcher;)", new org.eigenbase.xom.XMLAttrVector()
				.add("id", id)
				.add("charcase", charcase)
				.add("enabled", enabled)
				);
			_out.endTag("(%CaseMatcher;)");
		}
		public boolean displayDiff(org.eigenbase.xom.ElementDef _other, java.io.PrintWriter _out, int _indent)
		{
			boolean _diff = true;
			CaseMatcher _cother = (CaseMatcher)_other;
			_diff = _diff && displayAttributeDiff("id", id, _cother.id, _out, _indent+1);
			_diff = _diff && displayAttributeDiff("charcase", charcase, _cother.charcase, _out, _indent+1);
			return _diff;
		}
		// BEGIN pass-through code block ---
public void validate(final AggRules rules, 
                                 final mondrian.recorder.MessageRecorder msgRecorder) {
                // empty
            }
            protected String getTag() {
                return getId();
            }
            public String getId() {
                return id;
            }
            public String getCharCase() {
                return charcase;
            }
		// END pass-through code block ---
	}

	/**
	 * A NameMatcher is a CaseMatcher that prepends and appends
	 * regular expressions to a given string as part of creating
	 * the matching regular expression. Both the pre/post
	 * regular expression can be null in which case matches are
	 * applied simply against the name (modulo case considerations).
	 * The purpose of this class is to allow aggregate tables to
	 * be identified when their table names are formed by placing
	 * text before and/or after the base fact table name.
	 */
	public static abstract class NameMatcher extends CaseMatcher
	{
		public NameMatcher()
		{
		}

		public NameMatcher(org.eigenbase.xom.DOMWrapper _def)
			throws org.eigenbase.xom.XOMException
		{
			try {
				org.eigenbase.xom.DOMElementParser _parser = new org.eigenbase.xom.DOMElementParser(_def, "", DefaultDef.class);
				_parser = _parser;
				pretemplate = (String)_parser.getAttribute("pretemplate", "String", null, null, false);
				posttemplate = (String)_parser.getAttribute("posttemplate", "String", null, null, false);
				basename = (String)_parser.getAttribute("basename", "String", null, null, false);
				id = (String)_parser.getAttribute("id", "String", null, null, true);
				charcase = (String)_parser.getAttribute("charcase", "String", "ignore", _charcase_values, false);
				enabled = (Boolean)_parser.getAttribute("enabled", "Boolean", "true", null, false);
			} catch(org.eigenbase.xom.XOMException _ex) {
				throw new org.eigenbase.xom.XOMException("In element '" + getName() + "': " + _ex.getMessage());
			}
		}

		public String pretemplate;  // optional attribute
		public String posttemplate;  // optional attribute
		public String basename;  // optional attribute


		public String getName()
		{
			return "NameMatcher";
		}

		public void display(java.io.PrintWriter _out, int _indent)
		{
			_out.println(getName());
			displayAttribute(_out, "pretemplate", pretemplate, _indent+1);
			displayAttribute(_out, "posttemplate", posttemplate, _indent+1);
			displayAttribute(_out, "basename", basename, _indent+1);
			displayAttribute(_out, "id", id, _indent+1);
			displayAttribute(_out, "charcase", charcase, _indent+1);
			displayAttribute(_out, "enabled", enabled, _indent+1);
		}
		public void displayXML(org.eigenbase.xom.XMLOutput _out, int _indent)
		{
			_out.beginTag("(%NameMatcher;)", new org.eigenbase.xom.XMLAttrVector()
				.add("pretemplate", pretemplate)
				.add("posttemplate", posttemplate)
				.add("basename", basename)
				.add("id", id)
				.add("charcase", charcase)
				.add("enabled", enabled)
				);
			_out.endTag("(%NameMatcher;)");
		}
		public boolean displayDiff(org.eigenbase.xom.ElementDef _other, java.io.PrintWriter _out, int _indent)
		{
			boolean _diff = true;
			NameMatcher _cother = (NameMatcher)_other;
			_diff = _diff && displayAttributeDiff("pretemplate", pretemplate, _cother.pretemplate, _out, _indent+1);
			_diff = _diff && displayAttributeDiff("posttemplate", posttemplate, _cother.posttemplate, _out, _indent+1);
			_diff = _diff && displayAttributeDiff("basename", basename, _cother.basename, _out, _indent+1);
			return _diff;
		}
		// BEGIN pass-through code block ---
java.util.regex.Pattern baseNamePattern = null;
            public void validate(final AggRules rules, 
                                 final mondrian.recorder.MessageRecorder msgRecorder) {
                msgRecorder.pushContextName(getName());
                try {
                    super.validate(rules, msgRecorder);

                    if (basename != null) {
                        baseNamePattern = 
                            java.util.regex.Pattern.compile(basename);
                    }
                } finally {
                    msgRecorder.popContextName();
                }
            }
            /** 
             * Generate a regular expression string by prepending and appending
             * regular expression to the parameter tableName.
             * 
             * @param tableName 
             * @return regular expression
             */
            public String getRegex(final String name) {
                StringBuffer buf = new StringBuffer();
                if (pretemplate != null) {
                    buf.append(pretemplate);
                }
                if (name != null) {
                    String n = name;
                    if (baseNamePattern != null) {
                        java.util.regex.Matcher matcher = 
                            baseNamePattern.matcher(name);
                        if (matcher.matches() && matcher.groupCount() > 0) {
                            n = matcher.group(1);

                        } else {
                            if (AggRules.getLogger().isDebugEnabled()) {
                                StringBuffer bf = new StringBuffer(64);
                                bf.append(getName());
                                bf.append(".getRegex: for name \"");
                                bf.append(name);
                                bf.append("\" regex is null because basename \"");
                                bf.append(basename);
                                bf.append("\" is not matched.");

                                String msg = bf.toString();
                                AggRules.getLogger().debug(msg);
                            }
                            // If the table name does not match the basename
                            // pattern, then return null for regex.
                            return null;
                        }
                    }
                    buf.append(n);
                }
                if (posttemplate != null) {
                    buf.append(posttemplate);
                }

                String regex = buf.toString();

                if (AggRules.getLogger().isDebugEnabled()) {
                    StringBuffer bf = new StringBuffer(64);
                    bf.append(getName());
                    bf.append(".getRegex: for name \"");
                    bf.append(name);
                    bf.append("\" regex is \"");
                    bf.append(regex);
                    bf.append('"');

                    String msg = bf.toString();
                    AggRules.getLogger().debug(msg);
                }
                return regex;
            }

            protected Recognizer.Matcher getMatcher(String name) {

                final String charcase = getCharCase();
                final String regex;
                int flag = 0;

                if (charcase.equals("ignore")) {
                    // the case of name does not matter
                    // since the Pattern will be create to ignore case
                    regex = getRegex(name);

                    flag = java.util.regex.Pattern.CASE_INSENSITIVE;

                } else if (charcase.equals("exact")) {
                    // the case of name is not changed
                    // since we are interested in exact case matching
                    regex = getRegex(name);

                } else if (charcase.equals("upper")) {
                    // convert name to upper case
                    regex = getRegex(name.toUpperCase());

                } else {
                    // lower
                    // convert name to lower case
                    regex = getRegex(name.toLowerCase());

                }
                // If regex is null, then return a matcher that matches nothing
                if (regex == null) {
                    return new Recognizer.Matcher() {
                        public boolean matches(String name) {
                            return false;
                        }
                    };
                }

                final java.util.regex.Pattern pattern = 
                        java.util.regex.Pattern.compile(regex, flag);

                return new Recognizer.Matcher() {
                    public boolean matches(String name) {
                        boolean b = pattern.matcher(name).matches();
                        if (AggRules.getLogger().isDebugEnabled()) {
                            debug(name);
                        }
                        return b;
                    }
                    private void debug(String name) {
                        StringBuffer bf = new StringBuffer(64);
                        bf.append(NameMatcher.this.getName());
                        bf.append(".Machter.matches:");
                        bf.append(" name "); 
                        bf.append('"');
                        bf.append(name);
                        bf.append('"');
                        bf.append(" patterm  \"");
                        bf.append(pattern.pattern());
                        bf.append('"');
                        if ((pattern.flags() &
                            java.util.regex.Pattern.CASE_INSENSITIVE) != 0) {
                            bf.append(" case_insensitive"); 
                        }

                        String msg = bf.toString();
                        AggRules.getLogger().debug(msg);
                    }
                };
            }
		// END pass-through code block ---
	}

	/**
	 * This is used to identify the "fact_count" column in an aggregate
	 * table. It allows one to match using regular exprssions.
	 * The default is that the name of the fact count colum is simply
	 * the string "fact_count".
	 */
	public static class FactCountMatch extends NameMatcher
	{
		public FactCountMatch()
		{
		}

		public FactCountMatch(org.eigenbase.xom.DOMWrapper _def)
			throws org.eigenbase.xom.XOMException
		{
			try {
				org.eigenbase.xom.DOMElementParser _parser = new org.eigenbase.xom.DOMElementParser(_def, "", DefaultDef.class);
				_parser = _parser;
				factCountName = (String)_parser.getAttribute("factCountName", "String", "fact_count", null, true);
				pretemplate = (String)_parser.getAttribute("pretemplate", "String", null, null, false);
				posttemplate = (String)_parser.getAttribute("posttemplate", "String", null, null, false);
				basename = (String)_parser.getAttribute("basename", "String", null, null, false);
				id = (String)_parser.getAttribute("id", "String", null, null, true);
				charcase = (String)_parser.getAttribute("charcase", "String", "ignore", _charcase_values, false);
				enabled = (Boolean)_parser.getAttribute("enabled", "Boolean", "true", null, false);
			} catch(org.eigenbase.xom.XOMException _ex) {
				throw new org.eigenbase.xom.XOMException("In element '" + getName() + "': " + _ex.getMessage());
			}
		}

		public String factCountName;  // attribute default: fact_count


		public String getName()