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*/
020package org.olap4j.metadata;
021
022import org.olap4j.impl.Olap4jUtil;
023
024import java.util.Collections;
025import 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 */
035public 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