001    /*
002    // $Id: Property.java 485 2012-01-17 06:57:57Z jhyde $
003    //
004    // Licensed to Julian Hyde under one or more contributor license
005    // agreements. See the NOTICE file distributed with this work for
006    // additional information regarding copyright ownership.
007    //
008    // Julian Hyde licenses this file to you under the Apache License,
009    // Version 2.0 (the "License"); you may not use this file except in
010    // compliance with the License. You may obtain a copy of the License at:
011    //
012    // http://www.apache.org/licenses/LICENSE-2.0
013    //
014    // Unless required by applicable law or agreed to in writing, software
015    // distributed under the License is distributed on an "AS IS" BASIS,
016    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017    // See the License for the specific language governing permissions and
018    // limitations under the License.
019    */
020    package org.olap4j.metadata;
021    
022    import org.olap4j.impl.Olap4jUtil;
023    
024    import java.util.Collections;
025    import java.util.Set;
026    
027    /**
028     * Definition of a property of a {@link Member} or
029     * {@link org.olap4j.Cell}.
030     *
031     * @author jhyde
032     * @version $Id: Property.java 485 2012-01-17 06:57:57Z jhyde $
033     * @since Aug 23, 2006
034     */
035    public interface Property extends MetadataElement {
036        /**
037         * Returns the datatype of this Property.
038         *
039         * @return datatype of this Property
040         */
041        Datatype getDatatype();
042    
043        /**
044         * Returns a set of flags which describe the type of this Property.
045         *
046         * @return type of this Property
047         */
048        Set<TypeFlag> getType();
049    
050        /**
051         * Returns the content type of this Property.
052         *
053         * @return content type
054         */
055        ContentType getContentType();
056    
057        /**
058         * Enumeration of aspects of the type of a Property. In particular, whether
059         * it belongs to a member or a cell.
060         *
061         * <p>The values are as specified by XMLA for the PROPERTY_TYPE attribute
062         * of the MDSCHEMA_PROPERTIES data set.
063         * For example, XMLA specifies that the value 9 (0x1 | 0x8) means that a
064         * property belongs to a member and is a binary large object (BLOB).
065         * In this case, {@link Property#getType} will return the {@link Set}
066         * {{@link #MEMBER}, {@link #BLOB}}.
067         */
068        enum TypeFlag implements XmlaConstant {
069            /**
070             * Identifies a property of a member. This property can be used in the
071             * DIMENSION PROPERTIES clause of the SELECT statement.
072             */
073            MEMBER(1),
074    
075            /**
076             * Identifies a property of a cell. This property can be used in the
077             * CELL PROPERTIES clause that occurs at the end of the SELECT
078             * statement.
079             */
080            CELL(2),
081    
082            /**
083             * Identifies an internal property.
084             */
085            SYSTEM(4),
086    
087            /**
088             * Identifies a property which contains a binary large object (blob).
089             */
090            BLOB(8);
091    
092            private final int xmlaOrdinal;
093    
094            public static final Set<TypeFlag> CELL_TYPE_FLAG =
095                Collections.unmodifiableSet(
096                    Olap4jUtil.enumSetOf(TypeFlag.CELL));
097            public static final Set<TypeFlag> MEMBER_TYPE_FLAG =
098                Collections.unmodifiableSet(
099                    Olap4jUtil.enumSetOf(TypeFlag.MEMBER));
100            private static final DictionaryImpl<TypeFlag> DICTIONARY =
101                DictionaryImpl.forClass(TypeFlag.class);
102    
103            private TypeFlag(int xmlaOrdinal) {
104                this.xmlaOrdinal = xmlaOrdinal;
105            }
106    
107            public String xmlaName() {
108                return "MDPROP_" + name();
109            }
110    
111            public String getDescription() {
112                return null;
113            }
114    
115            public int xmlaOrdinal() {
116                return xmlaOrdinal;
117            }
118    
119            /**
120             * Per {@link org.olap4j.metadata.XmlaConstant}, returns a dictionary
121             * of all values of this enumeration.
122             *
123             * @return Dictionary of all values
124             */
125            public static Dictionary<TypeFlag> getDictionary() {
126                return DICTIONARY;
127            }
128        }
129    
130        /**
131         * Enumeration of the system properties available for every {@link Member}.
132         *
133         * <p>The following properties are mandatory for members:<ul>
134         * <li>{@link #CATALOG_NAME}</li>
135         * <li>{@link #SCHEMA_NAME}</li>
136         * <li>{@link #CUBE_NAME}</li>
137         * <li>{@link #DIMENSION_UNIQUE_NAME}</li>
138         * <li>{@link #HIERARCHY_UNIQUE_NAME}</li>
139         * <li>{@link #LEVEL_UNIQUE_NAME}</li>
140         * <li>{@link #LEVEL_NUMBER}</li>
141         * <li>{@link #MEMBER_UNIQUE_NAME}</li>
142         * <li>{@link #MEMBER_NAME}</li>
143         * <li>{@link #MEMBER_TYPE}</li>
144         * <li>{@link #MEMBER_GUID}</li>
145         * <li>{@link #MEMBER_CAPTION}</li>
146         * <li>{@link #MEMBER_ORDINAL}</li>
147         * <li>{@link #CHILDREN_CARDINALITY}</li>
148         * <li>{@link #PARENT_LEVEL}</li>
149         * <li>{@link #PARENT_UNIQUE_NAME}</li>
150         * <li>{@link #PARENT_COUNT}</li>
151         * <li>{@link #DESCRIPTION}</li>
152         * </ul>
153         */
154        enum StandardMemberProperty implements Property {
155    
156            /**
157             * Definition of the property which
158             * holds the name of the current catalog.
159             */
160            CATALOG_NAME(
161                Datatype.STRING,
162                10,
163                false,
164                null,
165                "Optional. The name of the catalog to which this member belongs. "
166                + "NULL if the provider does not support catalogs."),
167    
168            /**
169             * Definition of the property which
170             * holds the name of the current schema.
171             */
172            SCHEMA_NAME(
173                Datatype.STRING,
174                11,
175                false,
176                null,
177                "Optional. The name of the schema to which this member belongs. "
178                + "NULL if the provider does not support schemas."),
179    
180            /**
181             * Definition of the property which
182             * holds the name of the current cube.
183             */
184            CUBE_NAME(
185                Datatype.STRING,
186                12,
187                false,
188                null, "Required. Name of the cube to which this member belongs."),
189    
190            /**
191             * Definition of the property which
192             * holds the unique name of the current dimension.
193             */
194            DIMENSION_UNIQUE_NAME(
195                Datatype.STRING,
196                13,
197                false,
198                null,
199                "Required. Unique name of the dimension to which this member "
200                + "belongs. For providers that generate unique names by "
201                + "qualification, each component of this name is delimited."),
202    
203            /**
204             * Definition of the property which
205             * holds the unique name of the current hierarchy.
206             */
207            HIERARCHY_UNIQUE_NAME(
208                Datatype.STRING,
209                14,
210                false,
211                null,
212                "Required. Unique name of the hierarchy. If the member belongs to "
213                + "more than one hierarchy, there is one row for each hierarchy "
214                + "to which it belongs. For providers that generate unique names "
215                + "by qualification, each component of this name is delimited."),
216    
217            /**
218             * Definition of the property which
219             * holds the unique name of the current level.
220             */
221            LEVEL_UNIQUE_NAME(
222                Datatype.STRING,
223                15,
224                false,
225                null,
226                "Required. Unique name of the level to which the member belongs. "
227                + "For providers that generate unique names by qualification, "
228                + "each component of this name is delimited."),
229    
230            /**
231             * Definition of the property which
232             * holds the ordinal of the current level.
233             */
234            LEVEL_NUMBER(
235                Datatype.UNSIGNED_INTEGER,
236                16,
237                false,
238                null,
239                "Required. The distance of the member from the root of the "
240                + "hierarchy. The root level is zero."),
241    
242            /**
243             * Definition of the property which
244             * holds the ordinal of the current member.
245             */
246            MEMBER_ORDINAL(
247                Datatype.UNSIGNED_INTEGER,
248                17,
249                false,
250                null,
251                "Required. Ordinal number of the member. Sort rank of the member "
252                + "when members of this dimension are sorted in their natural "
253                + "sort order. If providers do not have the concept of natural "
254                + "ordering, this should be the rank when sorted by MEMBER_NAME."),
255    
256            /**
257             * Definition of the property which
258             * holds the name of the current member.
259             */
260            MEMBER_NAME(
261                Datatype.STRING,
262                18,
263                false,
264                null,
265                "Required. Name of the member."),
266    
267            /**
268             * Definition of the property which
269             * holds the unique name of the current member.
270             */
271            MEMBER_UNIQUE_NAME(
272                Datatype.STRING,
273                19,
274                false,
275                null,
276                "Required. Unique name of the member. For providers that generate "
277                + "unique names by qualification, each component of this name is "
278                + "delimited."),
279    
280            /**
281             * Definition of the property which
282             * holds the type of the member.
283             */
284            MEMBER_TYPE(
285                Datatype.STRING,
286                20,
287                false,
288                null,
289                "Required. Type of the member. Can be one of the following values: "
290                + "MDMEMBER_Datatype.TYPE_REGULAR, MDMEMBER_Datatype.TYPE_ALL, "
291                + "MDMEMBER_Datatype.TYPE_FORMULA, MDMEMBER_Datatype.TYPE_MEASURE, "
292                + "MDMEMBER_Datatype.TYPE_UNKNOWN. MDMEMBER_Datatype.TYPE_FORMULA "
293                + "takes precedence over MDMEMBER_Datatype.TYPE_MEASURE. "
294                + "Therefore, if there is a formula (calculated) member on the "
295                + "Measures dimension, it is listed as "
296                + "MDMEMBER_Datatype.TYPE_FORMULA."),
297    
298            /**
299             * Definition of the property which
300             * holds the GUID of the member
301             */
302            MEMBER_GUID(
303                Datatype.STRING,
304                21,
305                false,
306                null,
307                "Optional. Member GUID. NULL if no GUID exists."),
308    
309            /**
310             * Definition of the property which
311             * holds the label or caption associated with the member, or the
312             * member's name if no caption is defined.
313             */
314            MEMBER_CAPTION(
315                Datatype.STRING,
316                22,
317                false,
318                null,
319                "Required. A label or caption associated with the member. Used "
320                + "primarily for display purposes. If a caption does not exist, "
321                + "MEMBER_NAME is returned."),
322    
323            /**
324             * Definition of the property which holds the
325             * number of children this member has.
326             */
327            CHILDREN_CARDINALITY(
328                Datatype.UNSIGNED_INTEGER,
329                23,
330                false,
331                null,
332                "Required. Number of children that the member has. This can be an "
333                + "estimate, so consumers should not rely on this to be the exact "
334                + "count. Providers should return the best estimate possible."),
335    
336            /**
337             * Definition of the property which holds the
338             * distance from the root of the hierarchy of this member's parent.
339             */
340            PARENT_LEVEL(
341                Datatype.UNSIGNED_INTEGER,
342                24,
343                false,
344                null,
345                "Required. The distance of the member's parent from the root level "
346                + "of the hierarchy. The root level is zero."),
347    
348            /**
349             * Definition of the property which holds the
350             * Name of the current catalog.
351             */
352            PARENT_UNIQUE_NAME(
353                Datatype.STRING,
354                25,
355                false,
356                null,
357                "Required. Unique name of the member's parent. NULL is returned "
358                + "for any members at the root level. For providers that generate "
359                + "unique names by qualification, each component of this name is "
360                + "delimited."),
361    
362            /**
363             * Definition of the property which holds the
364             * number of parents that this member has. Generally 1, or 0
365             * for root members.
366             */
367            PARENT_COUNT(
368                Datatype.UNSIGNED_INTEGER,
369                26,
370                false,
371                null,
372                "Required. Number of parents that this member has."),
373    
374            /**
375             * Definition of the property which holds the
376             * description of this member.
377             */
378            DESCRIPTION(
379                Datatype.STRING,
380                27,
381                false,
382                null,
383                "Optional. A human-readable description of the member."),
384    
385            /**
386             * Definition of the internal property which holds the
387             * name of the system property which determines whether to show a member
388             * (especially a measure or calculated member) in a user interface such
389             * as JPivot.
390             */
391            $visible(
392                Datatype.BOOLEAN,
393                28,
394                true,
395                null,
396                null),
397    
398            /**
399             * Definition of the internal property which holds the
400             * value of the member key in the original data type. MEMBER_KEY is for
401             * backward-compatibility.  MEMBER_KEY has the same value as KEY0 for
402             * non-composite keys, and MEMBER_KEY property is null for composite
403             * keys.
404             */
405            MEMBER_KEY(
406                Datatype.VARIANT,
407                29,
408                true,
409                null,
410                "Optional. The value of the member key. Null for composite keys."),
411    
412            /**
413             * Definition of the boolean property that indicates whether
414             * a member is a placeholder member for an empty position in a
415             * dimension hierarchy.
416             */
417            IS_PLACEHOLDERMEMBER(
418                Datatype.BOOLEAN,
419                30,
420                false,
421                null,
422                "Required. Whether the member is a placeholder member for an empty "
423                + "position in a dimension hierarchy."),
424    
425            /**
426             * Definition of the property that indicates whether the member is a
427             * data member.
428             */
429            IS_DATAMEMBER(
430                Datatype.BOOLEAN,
431                31,
432                false,
433                null,
434                "Required. whether the member is a data member"),
435    
436            /**
437             * Definition of the property which
438             * holds the level depth of a member.
439             *
440             * <p>Caution: Level depth of members in parent-child hierarchy isn't
441             * from their levels.  It's calculated from the underlying data
442             * dynamically.
443             */
444            DEPTH(
445                Datatype.UNSIGNED_INTEGER,
446                43,
447                true,
448                null,
449                "The level depth of a member"),
450    
451            /**
452             * Definition of the property which
453             * holds the DISPLAY_INFO required by XML/A.
454             *
455             * <p>Caution: This property's value is calculated based on a specified
456             * MDX query, so its value is dynamic at runtime.
457             */
458            DISPLAY_INFO(
459                Datatype.UNSIGNED_INTEGER,
460                44,
461                false,
462                null,
463                "Display instruction of a member for XML/A"),
464    
465            /**
466             * Definition of the property which
467             * holds the value of a cell. Is usually numeric (since most measures
468             * are numeric) but is occasionally another type.
469             */
470            VALUE(
471                Datatype.VARIANT,
472                41,
473                false,
474                null,
475                "The unformatted value of the cell.");
476    
477            private final Datatype type;
478            private final String description;
479            private final boolean internal;
480    
481            private StandardMemberProperty(
482                Datatype type,
483                int ordinal,
484                boolean internal,
485                Class<? extends Enum> enumClazz,
486                String description)
487            {
488    //            assert ordinal == ordinal();
489                this.internal = internal;
490                this.type = type;
491                this.description = description;
492            }
493    
494            public String getName() {
495                return name();
496            }
497    
498            public String getUniqueName() {
499                return name();
500            }
501    
502            public String getCaption() {
503                // NOTE: This caption will be the same in all locales, since
504                // StandardMemberProperty has no way of deducing the current
505                // connection. Providers that wish to localize the caption of
506                // built-in properties should create a wrapper around
507                // StandardMemberProperty that is aware of the current connection or
508                // locale.
509                return name();
510            }
511    
512            public String getDescription() {
513                // NOTE: This description will be the same in all locales, since
514                // StandardMemberProperty has no way of deducing the current
515                // connection. Providers that wish to localize the description of
516                // built-in properties should create a wrapper around
517                // StandardCellProperty that is aware of the current connection or
518                // locale.
519                return description;
520            }
521    
522            public Datatype getDatatype() {
523                return type;
524            }
525    
526            public Set<TypeFlag> getType() {
527                return TypeFlag.MEMBER_TYPE_FLAG;
528            }
529    
530            public ContentType getContentType() {
531                return ContentType.REGULAR;
532            }
533    
534            public boolean isInternal() {
535                return internal;
536            }
537    
538            public boolean isVisible() {
539                return !internal;
540            }
541        }
542    
543        /**
544         * Enumeration of the system properties available for every
545         * {@link org.olap4j.Cell}.
546         *
547         * <p>The following propertiess are mandatory for cells:<ul>
548         * <li>{@link #BACK_COLOR}</li>
549         * <li>{@link #CELL_EVALUATION_LIST}</li>
550         * <li>{@link #CELL_ORDINAL}</li>
551         * <li>{@link #FORE_COLOR}</li>
552         * <li>{@link #FONT_NAME}</li>
553         * <li>{@link #FONT_SIZE}</li>
554         * <li>{@link #FONT_FLAGS}</li>
555         * <li>{@link #FORMAT_STRING}</li>
556         * <li>{@link #FORMATTED_VALUE}</li>
557         * <li>{@link #NON_EMPTY_BEHAVIOR}</li>
558         * <li>{@link #SOLVE_ORDER}</li>
559         * <li>{@link #VALUE}</li>
560         * </ul>
561         */
562        enum StandardCellProperty implements Property {
563            BACK_COLOR(
564                Datatype.STRING,
565                30,
566                false,
567                null,
568                "The background color for displaying the VALUE or FORMATTED_VALUE "
569                + "property. For more information, see FORE_COLOR and BACK_COLOR "
570                + "Contents."),
571    
572            CELL_EVALUATION_LIST(
573                Datatype.STRING,
574                31,
575                false,
576                null,
577                "The semicolon-delimited list of evaluated formulas applicable to "
578                + "the cell, in order from lowest to highest solve order. For more "
579                + "information about solve order, see Understanding Pass Order and "
580                + "Solve Order"),
581    
582            CELL_ORDINAL(
583                Datatype.UNSIGNED_INTEGER,
584                32,
585                false,
586                null,
587                "The ordinal number of the cell in the dataset."),
588    
589            FORE_COLOR(
590                Datatype.STRING,
591                33,
592                false,
593                null,
594                "The foreground color for displaying the VALUE or FORMATTED_VALUE "
595                + "property. For more information, see FORE_COLOR and BACK_COLOR "
596                + "Contents."),
597    
598            FONT_NAME(
599                Datatype.STRING,
600                34,
601                false,
602                null,
603                "The font to be used to display the VALUE or FORMATTED_VALUE "
604                + "property."),
605    
606            FONT_SIZE(
607                Datatype.STRING,
608                35,
609                false,
610                null,
611                "Font size to be used to display the VALUE or FORMATTED_VALUE "
612                + "property."),
613    
614            FONT_FLAGS(
615                Datatype.UNSIGNED_INTEGER,
616                36,
617                false,
618                XmlaConstants.FontFlag.class,
619                "The bitmask detailing effects on the font. The value is the "
620                + "result of a bitwise OR operation of one or more of the "
621                + "following constants: MDFF_BOLD  = 1, MDFF_ITALIC = 2, "
622                + "MDFF_UNDERLINE = 4, MDFF_STRIKEOUT = 8. For example, the value "
623                + "5 represents the combination of bold (MDFF_BOLD) and underline "
624                + "(MDFF_UNDERLINE) font effects."),
625    
626            /**
627             * Definition of the property which
628             * holds the formatted value of a cell.
629             */
630            FORMATTED_VALUE(
631                Datatype.STRING,
632                37,
633                false,
634                null,
635                "The character string that represents a formatted display of the "
636                + "VALUE property."),
637    
638            /**
639             * Definition of the property which
640             * holds the format string used to format cell values.
641             */
642            FORMAT_STRING(
643                Datatype.STRING,
644                38,
645                false,
646                null,
647                "The format string used to create the FORMATTED_VALUE property "
648                + "value. For more information, see FORMAT_STRING Contents."),
649    
650            NON_EMPTY_BEHAVIOR(
651                Datatype.STRING,
652                39,
653                false,
654                null,
655                "The measure used to determine the behavior of calculated members "
656                + "when resolving empty cells."),
657    
658            /**
659             * Definition of the property which
660             * determines the solve order of a calculated member with respect to
661             * other calculated members.
662             */
663            SOLVE_ORDER(
664                Datatype.INTEGER,
665                40,
666                false,
667                null,
668                "The solve order of the cell."),
669    
670            /**
671             * Definition of the property which
672             * holds the value of a cell. Is usually numeric (since most measures
673             * are numeric) but is occasionally another type.
674             */
675            VALUE(
676                Datatype.VARIANT,
677                41,
678                false,
679                null,
680                "The unformatted value of the cell."),
681    
682            /**
683             * Definition of the property which
684             * holds the datatype of a cell. Valid values are "String",
685             * "Numeric", "Integer". The property's value derives from the
686             * "datatype" attribute of the "Measure" element; if the
687             * datatype attribute is not specified, the datatype is
688             * "Numeric" by default, except measures whose aggregator is
689             * "Count", whose datatype is "Integer".
690             */
691            DATATYPE(
692                Datatype.STRING,
693                42,
694                false,
695                null,
696                "The datatype of the cell."),
697    
698            LANGUAGE(
699                Datatype.UNSIGNED_INTEGER,
700                0,
701                false,
702                null,
703                "The locale where the FORMAT_STRING will be applied. LANGUAGE is "
704                + "usually used for currency conversion."),
705    
706            ACTION_TYPE(
707                Datatype.INT4,
708                0,
709                false,
710                XmlaConstants.ActionType.class,
711                "A bitmask that indicates which types of actions exist on the "
712                + "cell."),
713    
714            UPDATEABLE(
715                Datatype.UNSIGNED_INTEGER,
716                0,
717                false,
718                XmlaConstants.Updateable.class,
719                "A value that indicates whether the cell can be updated.");
720    
721            /**
722             * The datatype of the property.
723             */
724            private final Datatype type;
725            private final String description;
726            private final boolean internal;
727    
728            private StandardCellProperty(
729                Datatype type,
730                int ordinal,
731                boolean internal,
732                Class<? extends Enum> enumClazz,
733                String description)
734            {
735                this.type = type;
736                this.internal = internal;
737                this.description = description;
738            }
739    
740            public Datatype getDatatype() {
741                return type;
742            }
743    
744            public Set<TypeFlag> getType() {
745                return TypeFlag.CELL_TYPE_FLAG;
746            }
747    
748            public String getName() {
749                return name();
750            }
751    
752            public String getUniqueName() {
753                return name();
754            }
755    
756            public String getCaption() {
757                // NOTE: This caption will be the same in all locales, since
758                // StandardCellProperty has no way of deducing the current
759                // connection. Providers that wish to localize the caption of
760                // built-in properties should create a wrapper around
761                // StandardCellProperty that is aware of the current connection or
762                // locale.
763                return name();
764            }
765    
766            public String getDescription() {
767                // NOTE: This description will be the same in all locales, since
768                // StandardCellProperty has no way of deducing the current
769                // connection. Providers that wish to localize the description of
770                // built-in properties should create a wrapper around
771                // StandardCellProperty that is aware of the current connection or
772                // locale.
773                return description;
774            }
775    
776            public boolean isInternal() {
777                return internal;
778            }
779    
780            public boolean isVisible() {
781                return !internal;
782            }
783    
784            public ContentType getContentType() {
785                return ContentType.REGULAR;
786            }
787        }
788    
789        /**
790         * Enumeration of the types of a <code>Property</code>.
791         *
792         * <p>The values are as specified by XMLA.
793         * For example, XMLA specifies MD_PROPTYPE_CAPTION with ordinal 0x21,
794         * which corresponds to the value {@link #CAPTION},
795         * whose {@link #xmlaOrdinal} is 0x21.
796         */
797        enum ContentType implements XmlaConstant {
798            REGULAR(0x00),
799            ID(0x01),
800            RELATION_TO_PARENT(0x02),
801            ROLLUP_OPERATOR(0x03),
802            ORG_TITLE(0x11),
803            CAPTION(0x21),
804            CAPTION_SHORT(0x22),
805            CAPTION_DESCRIPTION(0x23),
806            CAPTION_ABREVIATION(0x24),
807            WEB_URL(0x31),
808            WEB_HTML(0x32),
809            WEB_XML_OR_XSL(0x33),
810            WEB_MAIL_ALIAS(0x34),
811            ADDRESS(0x41),
812            ADDRESS_STREET(0x42),
813            ADDRESS_HOUSE(0x43),
814            ADDRESS_CITY(0x44),
815            ADDRESS_STATE_OR_PROVINCE(0x45),
816            ADDRESS_ZIP(0x46),
817            ADDRESS_QUARTER(0x47),
818            ADDRESS_COUNTRY(0x48),
819            ADDRESS_BUILDING(0x49),
820            ADDRESS_ROOM(0x4A),
821            ADDRESS_FLOOR(0x4B),
822            ADDRESS_FAX(0x4C),
823            ADDRESS_PHONE(0x4D),
824            GEO_CENTROID_X(0x61),
825            GEO_CENTROID_Y(0x62),
826            GEO_CENTROID_Z(0x63),
827            GEO_BOUNDARY_TOP(0x64),
828            GEO_BOUNDARY_LEFT(0x65),
829            GEO_BOUNDARY_BOTTOM(0x66),
830            GEO_BOUNDARY_RIGHT(0x67),
831            GEO_BOUNDARY_FRONT(0x68),
832            GEO_BOUNDARY_REAR(0x69),
833            GEO_BOUNDARY_POLYGON(0x6A),
834            PHYSICAL_SIZE(0x71),
835            PHYSICAL_COLOR(0x72),
836            PHYSICAL_WEIGHT(0x73),
837            PHYSICAL_HEIGHT(0x74),
838            PHYSICAL_WIDTH(0x75),
839            PHYSICAL_DEPTH(0x76),
840            PHYSICAL_VOLUME(0x77),
841            PHYSICAL_DENSITY(0x78),
842            PERSON_FULL_NAME(0x82),
843            PERSON_FIRST_NAME(0x83),
844            PERSON_LAST_NAME(0x84),
845            PERSON_MIDDLE_NAME(0x85),
846            PERSON_DEMOGRAPHIC(0x86),
847            PERSON_CONTACT(0x87),
848            QTY_RANGE_LOW(0x91),
849            QTY_RANGE_HIGH(0x92),
850            FORMATTING_COLOR(0xA1),
851            FORMATTING_ORDER(0xA2),
852            FORMATTING_FONT(0xA3),
853            FORMATTING_FONT_EFFECTS(0xA4),
854            FORMATTING_FONT_SIZE(0xA5),
855            FORMATTING_SUB_TOTAL(0xA6),
856            DATE(0xB1),
857            DATE_START(0xB2),
858            DATE_ENDED(0xB3),
859            DATE_CANCELED(0xB4),
860            DATE_MODIFIED(0xB5),
861            DATE_DURATION(0xB6),
862            VERSION(0xC1);
863    
864            private final int xmlaOrdinal;
865            private static final DictionaryImpl<ContentType> DICTIONARY =
866                DictionaryImpl.forClass(ContentType.class);
867    
868            private ContentType(int xmlaOrdinal) {
869                this.xmlaOrdinal = xmlaOrdinal;
870            }
871    
872            public String xmlaName() {
873                return "MD_PROPTYPE_" + name();
874            }
875    
876            public String getDescription() {
877                return null;
878            }
879    
880            public int xmlaOrdinal() {
881                return xmlaOrdinal;
882            }
883    
884            /**
885             * Per {@link org.olap4j.metadata.XmlaConstant}, returns a dictionary
886             * of all values of this enumeration.
887             *
888             * @return Dictionary of all values
889             */
890            public static Dictionary<ContentType> getDictionary() {
891                return DICTIONARY;
892            }
893        }
894    }
895    
896    // End Property.java