001: /*
002: * The contents of this file are subject to the terms of the Common Development
003: * and Distribution License (the License). You may not use this file except in
004: * compliance with the License.
005: *
006: * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
007: * or http://www.netbeans.org/cddl.txt.
008: *
009: * When distributing Covered Code, include this CDDL Header Notice in each file
010: * and include the License file at http://www.netbeans.org/cddl.txt.
011: * If applicable, add the following below the CDDL Header, with the fields
012: * enclosed by brackets [] replaced by your own identifying information:
013: * "Portions Copyrighted [year] [name of copyright owner]"
014: *
015: * The Original Software is NetBeans. The Initial Developer of the Original
016: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
017: * Microsystems, Inc. All Rights Reserved.
018: */
019:
020: package org.netbeans.modules.xml.xpath.ext.metadata.impl;
021:
022: import org.netbeans.modules.xml.xpath.ext.metadata.XPathMetadataUtils;
023: import java.util.ArrayList;
024: import org.netbeans.modules.xml.xpath.ext.metadata.XPathType;
025: import org.netbeans.modules.xml.xpath.ext.metadata.XPathType.XPathSchemaType;
026: import org.netbeans.modules.xml.schema.model.GlobalType;
027: import org.netbeans.modules.xml.schema.model.SchemaComponent;
028:
029: /**
030: *
031: * @author nk160297
032: */
033: public abstract class XPathTypes {
034:
035: public static final class XPathStringType extends XPathSchemaType {
036: public XPathStringType() {
037: super (XPathMetadataUtils.findPrimitiveType("string")); // NOI18N
038: }
039:
040: @Override
041: public MetaType getMetaType() {
042: return MetaType.STRING;
043: }
044:
045: @Override
046: public String getName() {
047: return "String"; // NOI18N
048: }
049:
050: @Override
051: public boolean isAssignableFrom(XPathType otherType) {
052: if (otherType instanceof XPathStringType) {
053: return true;
054: } else if (otherType instanceof XPathSchemaType) {
055: SchemaComponent otherSType = ((XPathSchemaType) otherType)
056: .getSchemaType();
057: if (otherSType == mSchemaType) {
058: return true;
059: }
060: //
061: if (XPathMetadataUtils.isTypeDerived(mSchemaType,
062: otherSType)) {
063: return true;
064: } else {
065: return false;
066: }
067: } else {
068: return false;
069: }
070: }
071:
072: }
073:
074: public static final class XPathBooleanType extends XPathSchemaType {
075: public XPathBooleanType() {
076: super (XPathMetadataUtils.findPrimitiveType("boolean")); // NOI18N
077: }
078:
079: @Override
080: public MetaType getMetaType() {
081: return MetaType.BOOLEAN;
082: }
083:
084: @Override
085: public String getName() {
086: return "Boolean"; // NOI18N
087: }
088:
089: @Override
090: public boolean isAssignableFrom(XPathType otherType) {
091: if (otherType instanceof XPathBooleanType) {
092: return true;
093: } else if (otherType instanceof XPathSchemaType) {
094: SchemaComponent otherSType = ((XPathSchemaType) otherType)
095: .getSchemaType();
096: if (otherSType == mSchemaType) {
097: return true;
098: }
099: //
100: if (XPathMetadataUtils.isTypeDerived(mSchemaType,
101: otherSType)) {
102: return true;
103: } else {
104: return false;
105: }
106: } else {
107: return false;
108: }
109: }
110: }
111:
112: public static final class XPathNumberType implements XPathType {
113:
114: private ArrayList<GlobalType> mNumberTypes;
115:
116: public XPathNumberType() {
117: mNumberTypes = new ArrayList<GlobalType>();
118: //
119: mNumberTypes.add(XPathMetadataUtils
120: .findPrimitiveType("decimal")); // NOI18N
121: mNumberTypes.add(XPathMetadataUtils
122: .findPrimitiveType("double")); // NOI18N
123: mNumberTypes.add(XPathMetadataUtils
124: .findPrimitiveType("float")); // NOI18N
125: mNumberTypes.add(XPathMetadataUtils
126: .findPrimitiveType("hexBinary")); // NOI18N
127: }
128:
129: public MetaType getMetaType() {
130: return MetaType.NUMBER;
131: }
132:
133: public String getName() {
134: return "Number"; // NOI18N
135: }
136:
137: public boolean isAssignableFrom(XPathType otherType) {
138: if (otherType instanceof XPathNumberType) {
139: return true;
140: } else if (otherType instanceof XPathSchemaType) {
141: SchemaComponent otherSType = ((XPathSchemaType) otherType)
142: .getSchemaType();
143: for (GlobalType myAllowedType : mNumberTypes) {
144: if (otherSType == myAllowedType) {
145: return true;
146: }
147: //
148: if (XPathMetadataUtils.isTypeDerived(myAllowedType,
149: otherSType)) {
150: return true;
151: }
152: }
153: //
154: return false;
155: } else {
156: return false;
157: }
158: }
159: }
160:
161: public static final class XPathNodeSetType implements XPathType {
162:
163: public MetaType getMetaType() {
164: return MetaType.NODE_SET;
165: }
166:
167: public String getName() {
168: return "Node Set"; // NOI18N
169: }
170:
171: public boolean isAssignableFrom(XPathType otherType) {
172: if (otherType instanceof XPathNodeSetType
173: || otherType instanceof XPathNodeType) {
174: // One node can be considered as a set with only one element
175: return true;
176: } else {
177: return false;
178: }
179: }
180: }
181:
182: public static final class XPathNodeType implements XPathType {
183:
184: public MetaType getMetaType() {
185: return MetaType.NODE;
186: }
187:
188: public String getName() {
189: return "Node"; // NOI18N
190: }
191:
192: public boolean isAssignableFrom(XPathType otherType) {
193: if (otherType instanceof XPathNodeType) {
194: // A Node Set can't be considered as a Node because
195: // in many cases it can be treated as a mistake.
196: return true;
197: } else {
198: return false;
199: }
200: }
201: }
202:
203: public static final class XPathAnyType implements XPathType {
204:
205: public MetaType getMetaType() {
206: return MetaType.ANY_TYPE;
207: }
208:
209: public String getName() {
210: return "Any Type"; // NOI18N
211: }
212:
213: public boolean isAssignableFrom(XPathType otherType) {
214: return true;
215: }
216: }
217:
218: }
|