zorba-coders team mailing list archive
-
zorba-coders team
-
Mailing list archive
-
Message #23131
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
Markos Zaharioudakis has proposed merging lp:~zorba-coders/zorba/type-api into lp:zorba.
Commit message:
Renamed class TypeIdentifier to SequenceType and changed its api and implementation (fix for bug #1056787)
Requested reviews:
Markos Zaharioudakis (markos-za)
For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/type-api/+merge/169278
Renamed class TypeIdentifier to SequenceType and changed its api and implementation (fix for bug #1056787)
--
https://code.launchpad.net/~zorba-coders/zorba/type-api/+merge/169278
Your team Zorba Coders is subscribed to branch lp:zorba.
=== modified file 'include/zorba/api_shared_types.h'
--- include/zorba/api_shared_types.h 2013-06-12 04:55:14 +0000
+++ include/zorba/api_shared_types.h 2013-06-13 19:26:32 +0000
@@ -21,6 +21,7 @@
namespace zorba {
+<<<<<<< TREE
///////////////////////////////////////////////////////////////////////////////
class Annotation;
@@ -42,10 +43,41 @@
class StatelessExternalFunction;
class StaticCollectionManager;
class StaticContext;
+=======
+ class Zorba;
+ class XQuery;
+ class StaticContext;
+ class DynamicContext;
+ class XmlDataManager;
+ class DocumentManager;
+ class CollectionManager;
+ class StaticCollectionManager;
+ class ItemFactory;
+ class Iterator;
+ class StatelessExternalFunction;
+ class ExternalFunctionParameter;
+ class ExternalModule;
+ class SequenceType;
+ class ItemSequence;
+ class Collection;
+ class Function;
+ class Annotation;
+ class SerializationCallback;
+ class File;
+ class DirectoryIterator;
+ class Serializer;
+ class ModuleInfo;
+
+ class DiagnosticHandler;
+ class QueryLocation;
+ typedef SmartPtr<QueryLocation> QueryLocation_t;
+
+>>>>>>> MERGE-SOURCE
#ifndef ZORBA_NO_FULL_TEXT
class StemmerProvider;
class TokenizerProvider;
#endif /* ZORBA_NO_FULL_TEXT */
+<<<<<<< TREE
class TypeIdentifier;
class XmlDataManager;
class XQuery;
@@ -83,4 +115,38 @@
} // namespace zorba
#endif /* ZORBA_SHARED_TYPES_INCL_H */
+=======
+
+ // smart pointers
+ typedef zorba::SmartPtr<XQuery> XQuery_t;
+ typedef zorba::SmartPtr<StaticContext> StaticContext_t;
+ typedef zorba::SmartPtr<Iterator> Iterator_t;
+ typedef zorba::SmartPtr<Collection> Collection_t;
+ typedef zorba::SmartPtr<Function> Function_t;
+ typedef zorba::SmartPtr<Annotation> Annotation_t;
+ typedef zorba::SmartPtr<File> File_t;
+ typedef zorba::SmartPtr<DirectoryIterator> DirectoryIterator_t;
+ typedef zorba::SmartPtr<Serializer> Serializer_t;
+ typedef zorba::SmartPtr<ItemSequence> ItemSequence_t;
+ typedef zorba::SmartPtr<ModuleInfo> ModuleInfo_t;
+
+ // data handlers
+ class Item;
+ class String;
+
+ // uri resolvers
+ class URIMapper;
+ class Resource;
+ class URLResolver;
+
+ namespace audit
+ {
+ class Provider;
+ class Event;
+ class ScopedRecord;
+ }
+
+} /* namespace zorba */
+#endif
+>>>>>>> MERGE-SOURCE
/* vim:set et sw=2 ts=2: */
=== modified file 'include/zorba/collection.h'
--- include/zorba/collection.h 2013-02-07 17:24:36 +0000
+++ include/zorba/collection.h 2013-06-13 19:26:32 +0000
@@ -210,7 +210,7 @@
*
* @see isStatic()
*/
- virtual TypeIdentifier_t
+ virtual SequenceType
getType() const = 0;
/** \brief Register a DiagnosticHandler to which errors
=== removed file 'include/zorba/identtypes.h'
--- include/zorba/identtypes.h 2013-03-05 12:34:19 +0000
+++ include/zorba/identtypes.h 1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-/*
- * Copyright 2006-2008 The FLWOR Foundation.
- *
- * 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.
- */
-#ifndef ZORBA_TYPEIDENT_TYPES_API_H
-#define ZORBA_TYPEIDENT_TYPES_API_H
-
-#include <zorba/config.h>
-#include <iostream>
-
-namespace zorba
-{
-
-class ZORBA_DLL_PUBLIC IdentTypes
-{
-public:
- typedef enum
- {
- NAMED_TYPE, // AtomicOrUnionType
- ELEMENT_TYPE,
- ATTRIBUTE_TYPE,
- DOCUMENT_TYPE,
- PI_TYPE,
- TEXT_TYPE,
- COMMENT_TYPE,
- NAMESPACE_TYPE,
- ANY_NODE_TYPE, // node()
- STRUCTURED_ITEM_TYPE, // structured-item
-#ifdef ZORBA_WITH_JSON
- JSON_ITEM_TYPE,
- JSON_OBJECT_TYPE,
- JSON_ARRAY_TYPE,
-#endif
- ITEM_TYPE, // item()
- EMPTY_TYPE, // empty-sequence()
- SCHEMA_ELEMENT_TYPE,
- SCHEMA_ATTRIBUTE_TYPE,
- INVALID_TYPE
- } kind_t;
-
- static char const *const kind_string_of[];
-
- typedef enum
- {
- QUANT_ONE,
- QUANT_QUESTION,
- QUANT_PLUS,
- QUANT_STAR
- } quantifier_t;
-
- static char const *const quantifier_string_of[];
-};
-}
-
-namespace std {
-
-ZORBA_DLL_PUBLIC ostream& operator<<(ostream& o, const zorba::IdentTypes::kind_t ik);
-ZORBA_DLL_PUBLIC ostream& operator<<(ostream& o, const zorba::IdentTypes::quantifier_t iq);
-
-}
-
-#endif
-/* vim:set et sw=2 ts=2: */
=== modified file 'include/zorba/static_context.h'
--- include/zorba/static_context.h 2013-06-12 04:55:14 +0000
+++ include/zorba/static_context.h 2013-06-13 19:26:32 +0000
@@ -36,21 +36,22 @@
namespace zorba {
- /** \brief Instances of the class StaticContext contain the information that is available
- * at the time the query is compiled.
- *
- * This class contains the information that is defined in the %XQuery specification
- * (see http://www.w3.org/TR/xquery/#static_context).
- *
- * A StaticContext can be created by calling Zorba::createStaticContext and then be passed
- * to the Zorba::compileQuery or XQuery::compile functions.
- * If no static context has been passed to any of these functions, a default static context
- * is used. It can be accessed by calling XQuery::getStaticContext on a compiled XQuery object.
- *
- * Note: This class is reference counted. When writing multi-threaded clients,
- * it is the responibility of the client code to synchronize assignments to the
- * SmartPtr holding this object.
- */
+/** \brief Instances of the class StaticContext contain the information that is
+ * available at the time the query is compiled and run.
+ *
+ * This class contains the information that is defined in the %XQuery specification
+ * (see http://www.w3.org/TR/xquery/#static_context).
+ *
+ * A StaticContext can be created by calling Zorba::createStaticContext and then
+ * be passed to the Zorba::compileQuery or XQuery::compile functions. If no
+ * static context has been passed to any of these functions, a default static
+ * context is used. It can be accessed by calling XQuery::getStaticContext on
+ * a compiled XQuery object.
+ *
+ * Note: This class is reference counted. When writing multi-threaded clients,
+ * it is the responibility of the client code to synchronize assignments to the
+ * SmartPtr holding this object.
+ */
class ZORBA_DLL_PUBLIC StaticContext : public SmartObject
{
public:
@@ -399,21 +400,21 @@
/** \brief Set the type of a statically known document
*/
virtual void
- setDocumentType(const String& aDocUri, TypeIdentifier_t type) = 0;
+ setDocumentType(const String& aDocUri, const SequenceType& type) = 0;
/** \brief Get the type of a statically known document
*/
- virtual TypeIdentifier_t
+ virtual SequenceType
getDocumentType(const String& aDocUri) const = 0;
/** \brief Set the type of a statically known collection
*/
virtual void
- setCollectionType(const String& aCollectionUri, TypeIdentifier_t type) = 0;
+ setCollectionType(const String& aCollectionUri, const SequenceType& type) = 0;
/** \brief Get the type of a statically known collection
*/
- virtual TypeIdentifier_t
+ virtual SequenceType
getCollectionType(const String& aCollectionUri) const = 0;
/** \brief Check if a function with the given name and arity are registered in the context.
@@ -456,11 +457,11 @@
/** \brief Set the type of the context item.
*/
virtual void
- setContextItemStaticType(TypeIdentifier_t type) = 0;
+ setContextItemStaticType(const SequenceType& type) = 0;
/** \brief Fetch the type of the context item.
*/
- virtual TypeIdentifier_t
+ virtual SequenceType
getContextItemStaticType() const = 0;
/** \brief Set the output stream that is used by the fn:trace function
=== modified file 'include/zorba/typeident.h'
--- include/zorba/typeident.h 2013-03-05 12:34:19 +0000
+++ include/zorba/typeident.h 2013-06-13 19:26:32 +0000
@@ -18,156 +18,212 @@
#include <zorba/config.h>
#include <zorba/api_shared_types.h>
-#include <zorba/identtypes.h>
#include <zorba/zorba_string.h>
#include <iostream>
namespace zorba {
-/** \brief Type identifiers
+
+class XQType;
+
+
+/**
+ * \brief Representation and factory for xquery sequence types.
*
- * The type identifiers are not used, yet.
+ * Class SequenceType represents xquery sequence types, as defined in
+ * http://www.w3.org/TR/xquery-30/#id-sequencetype-syntax. Instances of
+ * SequenceType may be returned by methods of Zorba's C++ API. The class also
+ * provides static methods to create instances of SequenceType, which can then
+ * be passed as arguments to other methods of Zorba's C++ API.
*
* Note: This class is reference counted. When writing multi-threaded clients,
* it is the responibility of the client code to synchronize assignments to the
* SmartPtr holding this object.
*/
-class ZORBA_DLL_PUBLIC TypeIdentifier : public SmartObject
+class ZORBA_DLL_PUBLIC SequenceType
{
- public:
- /** \brief Destructor
- */
- ~TypeIdentifier();
-
- static TypeIdentifier_t
- createNamedType(
- const String& uri,
- const String& localName,
- IdentTypes::quantifier_t quantifier = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createElementType(
- const String& uri,
- bool uriWildcard,
- const String& localName,
- bool localNameWildcard,
- TypeIdentifier_t contentType,
- IdentTypes::quantifier_t quantifier = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createAttributeType(
- const String& uri,
- bool uriWildcard,
- const String& localName,
- bool localNameWildcard,
- TypeIdentifier_t contentType,
- IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createDocumentType(
- TypeIdentifier_t contentType,
- IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createPIType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createNamespaceType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createTextType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createCommentType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createAnyNodeType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createStructuredItemType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
-#ifdef ZORBA_WITH_JSON
- static TypeIdentifier_t
- createJSONItemType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createJSONObjectType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createJSONArrayType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-#endif
-
- static TypeIdentifier_t
- createItemType(IdentTypes::quantifier_t q = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createEmptyType();
-
- static TypeIdentifier_t
- createSchemaElementType(
- const String& uri,
- const String& localName,
- IdentTypes::quantifier_t quantifier = IdentTypes::QUANT_ONE);
-
- static TypeIdentifier_t
- createSchemaAttributeType(
- const String& uri,
- const String& localName,
- IdentTypes::quantifier_t quantifier = IdentTypes::QUANT_ONE);
-
- IdentTypes::kind_t
- getKind() const;
-
- IdentTypes::quantifier_t
- getQuantifier() const;
-
- const String&
- getUri() const;
-
- bool
- isUriWildcard() const;
-
- const String&
- getLocalName() const;
-
- bool
- isLocalNameWildcard() const;
-
- TypeIdentifier_t
- getContentType() const;
-
- std::ostream&
- emit(std::ostream&) const;
-
- private:
- TypeIdentifier();
-
- std::ostream&
- emitItemType(std::ostream&) const;
-
- std::ostream&
- emitName(std::ostream&) const;
-
- IdentTypes::kind_t m_kind;
- IdentTypes::quantifier_t m_quantifier;
- String m_uri;
- bool m_uriWildcard;
- String m_localName;
- bool m_localNameWildcard;
- TypeIdentifier_t m_contentType;
+public:
+ typedef enum
+ {
+ EMPTY_TYPE, // empty-sequence()
+ ITEM_TYPE, // item()
+ ATOMIC_OR_UNION_TYPE, // AtomicOrUnionType
+ FUNCTION_TYPE, // function(*) and subtypes
+ STRUCTURED_ITEM_TYPE, // structured-item()
+ NODE_TYPE, // node()
+ DOCUMENT_TYPE,
+ ELEMENT_TYPE,
+ SCHEMA_ELEMENT_TYPE,
+ ATTRIBUTE_TYPE,
+ SCHEMA_ATTRIBUTE_TYPE,
+ PI_TYPE,
+ TEXT_TYPE,
+ COMMENT_TYPE,
+ NAMESPACE_TYPE,
+ JSON_ITEM_TYPE,
+ JSON_OBJECT_TYPE,
+ JSON_ARRAY_TYPE,
+ INVALID_TYPE
+ } Kind;
+
+
+ typedef enum
+ {
+ QUANT_ONE,
+ QUANT_QUESTION,
+ QUANT_STAR,
+ QUANT_PLUS,
+ QUANT_INVALID
+ } Quantifier;
+
+
+ public:
+ /**
+ * \brief Create an empty-sequence() type
+ */
+ static SequenceType createEmptyType();
+
+ /**
+ * \brief Create an item() type with quantifier
+ */
+ static SequenceType createItemType(Quantifier q = QUANT_ONE);
+
+ /**
+ * \brief Create an AtomicOrUnion type with quantifier
+ *
+ * An AtomicOrUnion type is specified simply as a QName, which may identify
+ * an XMLSchema builtin atomic type or a user-defined atomic or union type.
+ * In the case of user-defined types, the QName must be among the in-scope
+ * type names of a given static context. Otherwise, for builtin types, the
+ * given sctx may be NULL.
+ */
+ static SequenceType createAtomicOrUnionType(
+ const StaticContext_t& sctx,
+ const String& uri,
+ const String& localName,
+ Quantifier q = QUANT_ONE);
+
+ /**
+ * \brief Create an structured-item() type with quantifier
+ */
+ static SequenceType createStructuredItemType(Quantifier q = QUANT_ONE);
+
+ /**
+ * \brief Create an node() type with quantifier
+ */
+ static SequenceType createAnyNodeType(Quantifier q = QUANT_ONE);
+
+ /**
+ * \brief Create a document-node() type or subtype with quantifier
+ */
+ static SequenceType createDocumentType(
+ const SequenceType& contentType,
+ Quantifier q = QUANT_ONE);
+
+ /**
+ * \brief Create an element() type or subtype with quantifier
+ */
+ static SequenceType createElementType(
+ const StaticContext_t& sctx,
+ const String& nodeUri,
+ const String& nodeLocalName,
+ const String& contentTypeUri,
+ const String& contentTypeLocalName,
+ bool nillable,
+ Quantifier quant = QUANT_ONE);
+
+ static SequenceType createSchemaElementType(
+ const StaticContext_t& sctx,
+ const String& uri,
+ const String& localName,
+ Quantifier quant = QUANT_ONE);
+
+ static SequenceType createAttributeType(
+ const StaticContext_t& sctx,
+ const String& nodeUri,
+ const String& nodeLocalName,
+ const String& contentTypeUri,
+ const String& contentTypeLocalName,
+ Quantifier quant = QUANT_ONE);
+
+ static SequenceType createSchemaAttributeType(
+ const StaticContext_t& sctx,
+ const String& uri,
+ const String& localName,
+ Quantifier quant = QUANT_ONE);
+
+ static SequenceType createPIType(Quantifier q = QUANT_ONE);
+
+ static SequenceType createTextType(Quantifier q = QUANT_ONE);
+
+ static SequenceType createCommentType(Quantifier q = QUANT_ONE);
+
+ static SequenceType createNamespaceType(Quantifier q = QUANT_ONE);
+
+ static SequenceType createJSONItemType(Quantifier q = QUANT_ONE);
+
+ static SequenceType createJSONObjectType(Quantifier q = QUANT_ONE);
+
+ static SequenceType createJSONArrayType(Quantifier q = QUANT_ONE);
+
+ public:
+ SequenceType();
+
+ SequenceType(const SequenceType& other);
+
+ /**
+ * \brief Destructor
+ */
+ ~SequenceType();
+
+ bool isValid() const;
+
+ Kind getKind() const;
+
+ Quantifier getQuantifier() const;
+
+ String getTypeUri() const;
+
+ String getTypeLocalName() const;
+
+ String getNodeUri() const;
+
+ String getNodeLocalName() const;
+
+ bool isWildcard() const;
+
+ String getContentTypeUri() const;
+
+ String getContentTypeLocalName() const;
+
+ bool isSchemaTest() const;
+
+ std::ostream& emit(std::ostream&) const;
+
+ private:
+ SequenceType(const XQType* t);
+
+ public:
+ static char const *const kind_string_of[];
+
+ static char const *const quantifier_string_of[];
+
+ private:
+ friend class Unmarshaller;
+
+ const XQType * theType;
};
-#ifdef WIN32
- template class ZORBA_DLL_PUBLIC zorba::SmartPtr<TypeIdentifier>;
-#endif
-
} /* namespace zorba */
-namespace std {
-
-ZORBA_DLL_PUBLIC ostream& operator<<(ostream& o, const zorba::TypeIdentifier& ti);
-ZORBA_DLL_PUBLIC ostream& operator<<(ostream& o, const zorba::TypeIdentifier_t ti);
+namespace std
+{
+
+ZORBA_DLL_PUBLIC ostream& operator<<(ostream& o, const zorba::SequenceType& ti);
+
+ZORBA_DLL_PUBLIC ostream& operator<<(ostream& o, const zorba::SequenceType::Kind k);
+ZORBA_DLL_PUBLIC ostream& operator<<(ostream& o, const zorba::SequenceType::Quantifier q);
}
=== modified file 'src/api/CMakeLists.txt'
--- src/api/CMakeLists.txt 2013-05-31 03:38:45 +0000
+++ src/api/CMakeLists.txt 2013-06-13 19:26:32 +0000
@@ -27,8 +27,7 @@
zorba_string.cpp
itemfactoryimpl.cpp
item.cpp
- identtypesimpl.cpp
- typeidentimpl.cpp
+ sequencetype.cpp
unmarshaller.cpp
xmldatamanagerimpl.cpp
documentmanagerimpl.cpp
=== modified file 'src/api/collectionimpl.cpp'
--- src/api/collectionimpl.cpp 2013-02-07 17:24:36 +0000
+++ src/api/collectionimpl.cpp 2013-06-13 19:26:32 +0000
@@ -372,7 +372,7 @@
/*******************************************************************************
********************************************************************************/
-TypeIdentifier_t
+SequenceType
CollectionImpl::getType() const
{
ZORBA_DM_TRY
@@ -384,16 +384,16 @@
const StaticallyKnownCollection* lColl = lCtx->lookup_collection(lQName);
if (!lColl)
{
- return 0;
+ return SequenceType();
}
- const XQType* lType = lColl->getCollectionType();
+ const XQType* type = lColl->getCollectionType();
- return TypeOps::get_type_identifier(lCtx->get_typemanager(), *lType);
+ return Unmarshaller::createSequenceType(type);
}
ZORBA_DM_CATCH
- return 0;
+ return Unmarshaller::createSequenceType(NULL);
}
=== modified file 'src/api/collectionimpl.h'
--- src/api/collectionimpl.h 2013-02-07 17:24:36 +0000
+++ src/api/collectionimpl.h 2013-06-13 19:26:32 +0000
@@ -135,7 +135,7 @@
virtual bool
isStatic() const;
- virtual TypeIdentifier_t
+ virtual SequenceType
getType() const;
}; /* class CollectionImpl */
=== modified file 'src/api/dynamiccontextimpl.cpp'
--- src/api/dynamiccontextimpl.cpp 2013-05-08 20:14:47 +0000
+++ src/api/dynamiccontextimpl.cpp 2013-06-13 19:26:32 +0000
@@ -581,21 +581,14 @@
ZorbaImpl::checkItem(lItem);
- TypeManager* tm = theStaticContext->get_typemanager();
-
- xqtref_t lItemType = tm->create_named_type(lItem->getType(),
- TypeConstants::QUANT_ONE,
- QueryLoc::null);
-
- if (!TypeOps::is_subtype(tm,
- *lItemType,
- *GENV_TYPESYSTEM.DATETIME_TYPE_ONE,
- QueryLoc::null))
+ if (!TypeOps::is_subtype(lItem->getTypeCode(), store::XS_DATETIME))
{
+ TypeManager* tm = theStaticContext->get_typemanager();
+ xqtref_t type = tm->create_value_type(lItem);
RAISE_ERROR_NO_LOC(zerr::ZAPI0014_INVALID_ARGUMENT,
- ERROR_PARAMS(lItemType->toString(),
+ ERROR_PARAMS(type->toSchemaString(),
ZED(TypeIsNotSubtype),
- GENV_TYPESYSTEM.DATETIME_TYPE_ONE->toString()));
+ GENV_TYPESYSTEM.DATETIME_TYPE_ONE->toSchemaString()));
}
theCtx->set_current_date_time(lItem);
=== removed file 'src/api/identtypesimpl.cpp'
--- src/api/identtypesimpl.cpp 2013-03-05 12:34:19 +0000
+++ src/api/identtypesimpl.cpp 1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-/*
- * Copyright 2006-2008 The FLWOR Foundation.
- *
- * 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.
- */
-
-#include "stdafx.h"
-#include <zorba/identtypes.h>
-
-namespace zorba {
-
-char const *const IdentTypes::kind_string_of[] =
-{
- "NAMED",
- "element",
- "attribute",
- "document-node",
- "processing-instruction",
- "text",
- "comment",
- "namespace-node",
- "node",
- "item",
- "empty-sequence",
- "schema-element",
- "schema-attribute",
- "INVALID",
- 0
-};
-
-
-char const *const IdentTypes::quantifier_string_of[] =
-{
- "",
- "?",
- "+",
- "*",
- 0
-};
-
-}
-
-namespace std {
-
-ostream& operator<<(ostream& o, const zorba::IdentTypes::kind_t ik)
-{
- return o << zorba::IdentTypes::kind_string_of[ik];
-}
-
-ostream& operator<<(ostream& o, const zorba::IdentTypes::quantifier_t iq)
-{
- return o << zorba::IdentTypes::quantifier_string_of[iq];
-}
-
-}
-
-/* vim:set et sw=2 ts=2: */
=== modified file 'src/api/staticcontextimpl.cpp'
--- src/api/staticcontextimpl.cpp 2013-05-31 03:38:45 +0000
+++ src/api/staticcontextimpl.cpp 2013-06-13 19:26:32 +0000
@@ -788,18 +788,17 @@
/*******************************************************************************
URI Mapper
*******************************************************************************/
-void
-StaticContextImpl::registerURIMapper(URIMapper* aMapper)
+void StaticContextImpl::registerURIMapper(URIMapper* aMapper)
{
// QQQ memory management?
theCtx->add_uri_mapper(new URIMapperWrapper(*aMapper));
}
+
/*******************************************************************************
URL Resolver
*******************************************************************************/
-void
-StaticContextImpl::registerURLResolver(URLResolver* aResolver)
+void StaticContextImpl::registerURLResolver(URLResolver* aResolver)
{
// QQQ memory management?
theCtx->add_url_resolver(new URLResolverWrapper(*aResolver));
@@ -810,15 +809,13 @@
/*******************************************************************************
********************************************************************************/
-void
-StaticContextImpl::setDocumentType(const String& aDocUri, TypeIdentifier_t type)
+void StaticContextImpl::setDocumentType(const String& aDocUri, const SequenceType& type)
{
- xqtref_t xqType = NULL;
- if (type != NULL) {
- xqType = theCtx->get_typemanager()->create_type(*type);
- }
-
+ xqtref_t xqType = Unmarshaller::getInternalType(type);
const zstring& uri = Unmarshaller::getInternalString(aDocUri);
+
+ ZORBA_ASSERT(xqType != NULL);
+
theCtx->bind_document(uri, xqType);
}
@@ -826,33 +823,27 @@
/*******************************************************************************
********************************************************************************/
-TypeIdentifier_t
-StaticContextImpl::getDocumentType(const String& aDocUri) const
+SequenceType StaticContextImpl::getDocumentType(const String& aDocUri) const
{
const zstring& uri = Unmarshaller::getInternalString(aDocUri);
xqtref_t xqType = theCtx->lookup_document(uri);
- TypeIdentifier_t type = NULL;
- if (xqType == NULL)
- {
- return NULL;
- }
- return TypeOps::get_type_identifier(theCtx->get_typemanager(), *xqType);
+ return Unmarshaller::createSequenceType(xqType.getp());
}
/*******************************************************************************
********************************************************************************/
-void
-StaticContextImpl::setCollectionType(const String& aCollectionUri, TypeIdentifier_t type)
+void StaticContextImpl::setCollectionType(
+ const String& aCollectionUri,
+ const SequenceType& type)
{
- xqtref_t xqType = NULL;
- if (type != NULL)
- {
- xqType = theCtx->get_typemanager()->create_type(*type);
- }
+ xqtref_t xqType = Unmarshaller::getInternalType(type);
zstring& uri = Unmarshaller::getInternalString(aCollectionUri);
+
+ ZORBA_ASSERT(xqType != NULL);
+
theCtx->bind_w3c_collection(uri, xqType);
}
@@ -860,20 +851,17 @@
/*******************************************************************************
********************************************************************************/
-TypeIdentifier_t
-StaticContextImpl::getCollectionType(const String& aCollectionUri) const
+SequenceType StaticContextImpl::getCollectionType(const String& uri) const
{
- const zstring& uri = Unmarshaller::getInternalString(aCollectionUri);
- const XQType* xqType = theCtx->lookup_w3c_collection(uri);
- TypeIdentifier_t type = NULL;
- if (xqType == NULL)
- {
- return NULL;
- }
- return TypeOps::get_type_identifier(theCtx->get_typemanager(), *xqType);
+ const zstring& uri2 = Unmarshaller::getInternalString(uri);
+
+ const XQType* xqType = theCtx->lookup_w3c_collection(uri2);
+
+ return Unmarshaller::createSequenceType(xqType);
}
+
/*******************************************************************************
********************************************************************************/
@@ -1020,27 +1008,21 @@
}
-void
-StaticContextImpl::setContextItemStaticType(TypeIdentifier_t type)
+void StaticContextImpl::setContextItemStaticType(const SequenceType& type)
{
- xqtref_t xqType = NULL;
- if (type != NULL)
- {
- xqType = theCtx->get_typemanager()->create_type(*type);
- }
+ xqtref_t xqType = Unmarshaller::getInternalType(type);
+
+ ZORBA_ASSERT(xqType != NULL);
+
theCtx->set_context_item_type(xqType, QueryLoc::null);
}
-TypeIdentifier_t
-StaticContextImpl::getContextItemStaticType() const
+SequenceType StaticContextImpl::getContextItemStaticType() const
{
xqtref_t type = theCtx->get_context_item_type();
- if (type == NULL)
- {
- return NULL;
- }
- return TypeOps::get_type_identifier(theCtx->get_typemanager(), *type);
+
+ return Unmarshaller::createSequenceType(type.getp());
}
=== modified file 'src/api/staticcontextimpl.h'
--- src/api/staticcontextimpl.h 2013-03-25 23:02:19 +0000
+++ src/api/staticcontextimpl.h 2013-06-13 19:26:32 +0000
@@ -17,7 +17,6 @@
#ifndef ZORBA_API_STATIC_CONTEXT_IMPL_H
#define ZORBA_API_STATIC_CONTEXT_IMPL_H
-#include <zorba/typeident.h>
#include <zorba/static_context.h>
#include <zorba/api_shared_types.h>
#include <map>
@@ -182,9 +181,9 @@
registerModule(ExternalModule* aModule);
virtual void
- setDocumentType(const String& aDocUri, TypeIdentifier_t type);
+ setDocumentType(const String& aDocUri, const SequenceType& type);
- virtual TypeIdentifier_t
+ virtual SequenceType
getDocumentType(const String& aDocUri) const;
virtual void
@@ -194,9 +193,9 @@
registerURLResolver(URLResolver* aResolver);
virtual void
- setCollectionType(const String& aCollectionUri, TypeIdentifier_t type);
+ setCollectionType(const String& aCollectionUri, const SequenceType& type);
- virtual TypeIdentifier_t
+ virtual SequenceType
getCollectionType(const String& aCollectionUri) const;
virtual bool
@@ -224,9 +223,9 @@
std::vector<Function_t>& aFunctions) const;
virtual void
- setContextItemStaticType(TypeIdentifier_t type);
+ setContextItemStaticType(const SequenceType& type);
- virtual TypeIdentifier_t
+ virtual SequenceType
getContextItemStaticType() const;
virtual void
=== removed file 'src/api/typeidentimpl.cpp'
--- src/api/typeidentimpl.cpp 2013-03-05 12:34:19 +0000
+++ src/api/typeidentimpl.cpp 1970-01-01 00:00:00 +0000
@@ -1,402 +0,0 @@
-/*
- * Copyright 2006-2008 The FLWOR Foundation.
- *
- * 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.
- */
-#include "stdafx.h"
-
-#ifndef ZORBA_TYPEIDENT_IMPL_H
-#define ZORBA_TYPEIDENT_IMPL_H
-
-#include <zorba/typeident.h>
-
-#include "diagnostics/assert.h"
-
-namespace zorba {
-
-TypeIdentifier::TypeIdentifier()
- :
- m_kind(IdentTypes::INVALID_TYPE),
- m_quantifier(IdentTypes::QUANT_ONE),
- m_uri(""),
- m_uriWildcard(false),
- m_localName(""),
- m_localNameWildcard(false),
- m_contentType()
-{
-}
-
-
-TypeIdentifier::~TypeIdentifier()
-{
-}
-
-
-IdentTypes::kind_t TypeIdentifier::getKind() const
-{
- return m_kind;
-}
-
-
-IdentTypes::quantifier_t TypeIdentifier::getQuantifier() const
-{
- return m_quantifier;
-}
-
-
-const String& TypeIdentifier::getUri() const
-{
- return m_uri;
-}
-
-
-bool TypeIdentifier::isUriWildcard() const
-{
- return m_uriWildcard;
-}
-
-
-const String& TypeIdentifier::getLocalName() const
-{
- return m_localName;
-}
-
-
-bool TypeIdentifier::isLocalNameWildcard() const
-{
- return m_localNameWildcard;
-}
-
-
-TypeIdentifier_t TypeIdentifier::getContentType() const
-{
- return m_contentType;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createNamedType(
- const String& uri,
- const String& localName,
- IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::NAMED_TYPE;
- ti->m_quantifier = quantifier;
- ti->m_uri = uri;
- ti->m_localName = localName;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createElementType(
- const String& uri,
- bool uriWildcard,
- const String& localName,
- bool localNameWildcard,
- TypeIdentifier_t contentType,
- IdentTypes::quantifier_t quantifier)
-{
- // not sure why those were 2 different flags, we maintain 2 flags for
- // compatibility, but they always need to be the same
- ZORBA_ASSERT(uriWildcard == localNameWildcard);
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::ELEMENT_TYPE;
- ti->m_quantifier = quantifier;
- ti->m_uri = uri;
- ti->m_uriWildcard = uriWildcard;
- ti->m_localName = localName;
- ti->m_localNameWildcard = localNameWildcard;
- ti->m_contentType = contentType;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createAttributeType(
- const String& uri,
- bool uriWildcard,
- const String& localName,
- bool localNameWildcard,
- TypeIdentifier_t contentType,
- IdentTypes::quantifier_t quantifier)
-{
- // not sure why those were 2 different flags, we maintain 2 flags for
- // compatibility, but they always need to be the same
- ZORBA_ASSERT(uriWildcard == localNameWildcard);
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::ATTRIBUTE_TYPE;
- ti->m_quantifier = quantifier;
- ti->m_uri = uri;
- ti->m_uriWildcard = uriWildcard;
- ti->m_localName = localName;
- ti->m_localNameWildcard = localNameWildcard;
- ti->m_contentType = contentType;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createDocumentType(
- TypeIdentifier_t contentType,
- IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::DOCUMENT_TYPE;
- ti->m_quantifier = quantifier;
- ti->m_contentType = contentType;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createPIType(IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::PI_TYPE;
- ti->m_quantifier = quantifier;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createTextType(IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::TEXT_TYPE;
- ti->m_quantifier = quantifier;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createCommentType(IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::COMMENT_TYPE;
- ti->m_quantifier = quantifier;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createNamespaceType(IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::NAMESPACE_TYPE;
- ti->m_quantifier = quantifier;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createAnyNodeType(IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::ANY_NODE_TYPE;
- ti->m_quantifier = quantifier;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createStructuredItemType(IdentTypes::quantifier_t q)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::STRUCTURED_ITEM_TYPE;
- ti->m_quantifier = q;
-
- return ti;
-}
-
-
-#ifdef ZORBA_WITH_JSON
-
-TypeIdentifier_t TypeIdentifier::createJSONItemType(IdentTypes::quantifier_t q)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::JSON_ITEM_TYPE;
- ti->m_quantifier = q;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createJSONObjectType(IdentTypes::quantifier_t q)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::JSON_OBJECT_TYPE;
- ti->m_quantifier = q;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createJSONArrayType(IdentTypes::quantifier_t q)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::JSON_ARRAY_TYPE;
- ti->m_quantifier = q;
-
- return ti;
-}
-
-
-#endif
-
-
-TypeIdentifier_t TypeIdentifier::createItemType(IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::ITEM_TYPE;
- ti->m_quantifier = quantifier;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createEmptyType()
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::EMPTY_TYPE;
- ti->m_quantifier = IdentTypes::QUANT_ONE;
-
- return ti;
-}
-
-TypeIdentifier_t TypeIdentifier::createSchemaElementType(
- const String& uri,
- const String& localName,
- IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::SCHEMA_ELEMENT_TYPE;
- ti->m_quantifier = quantifier;
- ti->m_uri = uri;
- ti->m_uriWildcard = false;
- ti->m_localName = localName;
- ti->m_localNameWildcard = false;
-
- return ti;
-}
-
-
-TypeIdentifier_t TypeIdentifier::createSchemaAttributeType(
- const String& uri,
- const String& localName,
- IdentTypes::quantifier_t quantifier)
-{
- TypeIdentifier_t ti(new TypeIdentifier());
- ti->m_kind = IdentTypes::SCHEMA_ATTRIBUTE_TYPE;
- ti->m_quantifier = quantifier;
- ti->m_uri = uri;
- ti->m_uriWildcard = false;
- ti->m_localName = localName;
- ti->m_localNameWildcard = false;
-
- return ti;
-}
-
-
-std::ostream& TypeIdentifier::emit(std::ostream& os) const
-{
- emitItemType(os);
- return os << m_quantifier;
-}
-
-
-std::ostream& TypeIdentifier::emitItemType(std::ostream& os) const
-{
- if (m_kind == IdentTypes::NAMED_TYPE)
- {
- return emitName(os);
- }
-
- os << m_kind;
-
- switch (m_kind)
- {
- case IdentTypes::DOCUMENT_TYPE:
- os << "(";
- if (m_contentType != NULL)
- {
- os << m_contentType;
- }
- return os << ")";
-
- case IdentTypes::ELEMENT_TYPE:
- case IdentTypes::ATTRIBUTE_TYPE:
- os << "(";
- if (m_uriWildcard)
- {
- os << "*";
- }
- else
- {
- emitName(os);
- }
- if (! m_contentType.isNull())
- {
- os << "," << m_contentType;
- }
- return os << ")";
-
- case IdentTypes::SCHEMA_ELEMENT_TYPE:
- case IdentTypes::SCHEMA_ATTRIBUTE_TYPE:
- os << "(";
- emitName(os);
- return os << ")";
-
- case IdentTypes::ANY_NODE_TYPE:
- case IdentTypes::COMMENT_TYPE:
- case IdentTypes::EMPTY_TYPE:
- case IdentTypes::ITEM_TYPE:
- case IdentTypes::PI_TYPE:
- case IdentTypes::TEXT_TYPE:
- return os << "()";
-
- case IdentTypes::INVALID_TYPE:
- return os;
-
- case IdentTypes::NAMED_TYPE:
- default:
- ZORBA_ASSERT(false);
- }
-}
-
-
-std::ostream& TypeIdentifier::emitName(std::ostream& os) const
-{
- return os << "{" << m_uri << "}" << m_localName;
-}
-
-}
-
-namespace std
-{
-
-ostream& operator<<(ostream& o, const zorba::TypeIdentifier& ti)
-{
- return ti.emit(o);
-}
-
-ostream& operator<<(ostream& o, const zorba::TypeIdentifier_t ti)
-{
- return ti->emit(o);
-}
-
-}
-
-
-#endif
-/* vim:set et sw=2 ts=2: */
=== modified file 'src/api/unmarshaller.cpp'
--- src/api/unmarshaller.cpp 2013-02-07 17:24:36 +0000
+++ src/api/unmarshaller.cpp 2013-06-13 19:26:32 +0000
@@ -79,6 +79,18 @@
}
+const XQType* Unmarshaller::getInternalType(const SequenceType& type)
+{
+ return type.theType;
+}
+
+
+SequenceType Unmarshaller::createSequenceType(const XQType* type)
+{
+ return type;
+}
+
+
#define THE_STRING(STRING_OBJ) \
(const_cast<zstring*>( \
reinterpret_cast<zstring const*>( &(STRING_OBJ).string_storage_ ) \
=== modified file 'src/api/unmarshaller.h'
--- src/api/unmarshaller.h 2013-02-07 17:24:36 +0000
+++ src/api/unmarshaller.h 2013-06-13 19:26:32 +0000
@@ -24,16 +24,22 @@
#include "common/shared_types.h"
#include "zorbatypes/zstring.h"
-namespace zorba {
+namespace zorba
+{
class ZORBA_DLL_PUBLIC Unmarshaller
{
public:
static store::Item* getInternalItem(const Item& aItem);
+ static const XQType* getInternalType(const SequenceType& type);
+
+ static SequenceType createSequenceType(const XQType* type);
+
static zstring& getInternalString(const String& aString);
- static String newString( zstring const &s ) {
+ static String newString(const zstring& s)
+ {
String::zstring_ptr const p = { &s };
return String( p );
}
=== modified file 'src/compiler/codegen/plan_visitor.cpp'
--- src/compiler/codegen/plan_visitor.cpp 2013-05-08 08:01:05 +0000
+++ src/compiler/codegen/plan_visitor.cpp 2013-06-13 19:26:32 +0000
@@ -667,7 +667,7 @@
xqtref_t exprType = initExpr->get_return_type();
- if (exprType->get_quantifier() == TypeConstants::QUANT_ONE)
+ if (exprType->get_quantifier() == SequenceType::QUANT_ONE)
singleItem = true;
}
@@ -710,7 +710,7 @@
(varExpr->get_kind() == var_expr::local_var),
exprIter);
- if (exprType->get_quantifier() == TypeConstants::QUANT_ONE)
+ if (exprType->get_quantifier() == SequenceType::QUANT_ONE)
iter->setSingleItem();
push_itstack(iter);
@@ -1023,7 +1023,7 @@
{
xqtref_t domainType = domExpr->get_return_type();
- if (domainType->get_quantifier() != TypeConstants::QUANT_ONE)
+ if (domainType->get_quantifier() != SequenceType::QUANT_ONE)
++numForClauses;
}
@@ -1252,9 +1252,9 @@
clauseVarMap->theVarExprs.push_back(lc->get_var());
clauseVarMap->theVarRebinds.push_back(varRebind);
- if (domType->get_quantifier() == TypeConstants::QUANT_ONE)
+ if (domType->get_quantifier() == SequenceType::QUANT_ONE)
varRebind->theIsFakeLetVar = true;
- else if (domType->get_quantifier() == TypeConstants::QUANT_QUESTION)
+ else if (domType->get_quantifier() == SequenceType::QUANT_QUESTION)
varRebind->theIsSingleItemLetVar = true;
break;
@@ -2761,7 +2761,7 @@
if (typeName != NULL)
{
prd->setType(sctx->get_typemanager()->create_named_type(typeName,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc,
XPTY0004));
}
@@ -2984,7 +2984,7 @@
{
axisItep->setType(sctx->get_typemanager()->
create_named_type(typeName,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
qloc));
}
axisItep->setNilledAllowed(v.getNilledAllowed());
=== modified file 'src/compiler/expression/expr.cpp'
--- src/compiler/expression/expr.cpp 2013-05-15 23:22:01 +0000
+++ src/compiler/expression/expr.cpp 2013-06-13 19:26:32 +0000
@@ -337,9 +337,9 @@
cast_base_expr(ccb, sctx, udf, loc, cast_expr_kind, inputExpr, type),
theAllowsEmtpyInput(allowsEmptyInput)
{
- assert(type->get_quantifier() == TypeConstants::QUANT_ONE ||
- type->get_quantifier() == TypeConstants::QUANT_QUESTION ||
- type->get_quantifier() == TypeConstants::QUANT_STAR);
+ assert(type->get_quantifier() == SequenceType::QUANT_ONE ||
+ type->get_quantifier() == SequenceType::QUANT_QUESTION ||
+ type->get_quantifier() == SequenceType::QUANT_STAR);
setNonDiscardable(ANNOTATION_TRUE_FIXED);
}
=== modified file 'src/compiler/expression/expr_base.cpp'
--- src/compiler/expression/expr_base.cpp 2013-05-29 04:17:01 +0000
+++ src/compiler/expression/expr_base.cpp 2013-06-13 19:26:32 +0000
@@ -820,9 +820,9 @@
return false;
xqtref_t type = e->get_return_type();
- TypeConstants::quantifier_t q = type->get_quantifier();
+ SequenceType::Quantifier q = type->get_quantifier();
- if (q == TypeConstants::QUANT_ONE || q == TypeConstants::QUANT_QUESTION)
+ if (q == SequenceType::QUANT_ONE || q == SequenceType::QUANT_QUESTION)
return true;
bool found = false;
@@ -1051,9 +1051,9 @@
case treat_expr_kind:
{
const treat_expr* treatExpr = static_cast<const treat_expr*>(this);
- TypeConstants::quantifier_t q = treatExpr->get_target_type()->get_quantifier();
+ SequenceType::Quantifier q = treatExpr->get_target_type()->get_quantifier();
- if (q == TypeConstants::QUANT_STAR || q == TypeConstants::QUANT_PLUS)
+ if (q == SequenceType::QUANT_STAR || q == SequenceType::QUANT_PLUS)
{
const expr* argExpr = treatExpr->get_input();
return argExpr->is_map_internal(e, found);
@@ -1065,9 +1065,9 @@
case promote_expr_kind:
{
const promote_expr* promoteExpr = static_cast<const promote_expr*>(this);
- TypeConstants::quantifier_t q = promoteExpr->get_target_type()->get_quantifier();
+ SequenceType::Quantifier q = promoteExpr->get_target_type()->get_quantifier();
- if (q == TypeConstants::QUANT_STAR || q == TypeConstants::QUANT_PLUS)
+ if (q == SequenceType::QUANT_STAR || q == SequenceType::QUANT_PLUS)
{
const expr* argExpr = promoteExpr->get_input();
return argExpr->is_map_internal(e, found);
=== modified file 'src/compiler/expression/expr_type.cpp'
--- src/compiler/expression/expr_type.cpp 2013-05-28 19:57:02 +0000
+++ src/compiler/expression/expr_type.cpp 2013-06-13 19:26:32 +0000
@@ -52,7 +52,7 @@
TypeManager* tm,
store::StoreConsts::NodeKind nodekind,
const store::Item_t& nodename,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool untyped);
@@ -121,11 +121,11 @@
{
flwor_expr* e = static_cast<flwor_expr*>(this);
- TypeConstants::quantifier_t quant = TypeConstants::QUANT_ONE;
+ SequenceType::Quantifier quant = SequenceType::QUANT_ONE;
csize numClauses = e->num_clauses();
- for (csize i = 0; i < numClauses && quant != TypeConstants::QUANT_STAR; ++i)
+ for (csize i = 0; i < numClauses && quant != SequenceType::QUANT_STAR; ++i)
{
const flwor_clause* c = e->theClauses[i];
@@ -140,12 +140,12 @@
}
case flwor_clause::window_clause :
{
- quant = TypeConstants::QUANT_STAR;
+ quant = SequenceType::QUANT_STAR;
break;
}
case flwor_clause::where_clause :
{
- quant = TypeOps::union_quant(quant, TypeConstants::QUANT_QUESTION);
+ quant = TypeOps::union_quant(quant, SequenceType::QUANT_QUESTION);
break;
}
default:
@@ -202,7 +202,7 @@
if (e->get_forlet_clause()->is_allowing_empty())
{
- derivedType = tm->create_type(*derivedType, TypeConstants::QUANT_QUESTION);
+ derivedType = tm->create_type(*derivedType, SequenceType::QUANT_QUESTION);
}
}
else if (varKind == var_expr::wincond_in_var ||
@@ -211,11 +211,11 @@
// TODO: we can be a little more specific here: if the quantifier of the
// domain type is PLUS or ONE, then the quantifier of the "current" cond
// var is ONE.
- derivedType = tm->create_type(*domainType, TypeConstants::QUANT_QUESTION);
+ derivedType = tm->create_type(*domainType, SequenceType::QUANT_QUESTION);
}
else if (varKind == var_expr::non_groupby_var)
{
- derivedType = tm->create_type(*domainType, TypeConstants::QUANT_STAR);
+ derivedType = tm->create_type(*domainType, SequenceType::QUANT_STAR);
}
else
{
@@ -373,20 +373,20 @@
cast_expr* e = static_cast<cast_expr*>(this);
xqtref_t argType = e->theInput->get_return_type();
- TypeConstants::quantifier_t argQuant = argType->get_quantifier();
- TypeConstants::quantifier_t targetQuant = e->theTargetType->get_quantifier();
+ SequenceType::Quantifier argQuant = argType->get_quantifier();
+ SequenceType::Quantifier targetQuant = e->theTargetType->get_quantifier();
if (TypeOps::is_equal(tm, *argType, *rtm.EMPTY_TYPE, get_loc()))
{
- if (targetQuant == TypeConstants::QUANT_QUESTION ||
- targetQuant == TypeConstants::QUANT_STAR)
+ if (targetQuant == SequenceType::QUANT_QUESTION ||
+ targetQuant == SequenceType::QUANT_STAR)
newType = rtm.EMPTY_TYPE;
else
newType = rtm.NONE_TYPE;
}
else if (e->theTargetType->isAtomicAny())
{
- TypeConstants::quantifier_t q = TypeOps::intersect_quant(argQuant, targetQuant);
+ SequenceType::Quantifier q = TypeOps::intersect_quant(argQuant, targetQuant);
newType = tm->create_type(*e->theTargetType, q);
}
@@ -400,13 +400,13 @@
if (targetType->isList())
{
newType = tm->create_type(*targetType->getListItemType(),
- TypeConstants::QUANT_STAR);
+ SequenceType::QUANT_STAR);
}
else
{
assert(targetType->isAtomicAny() || targetType->isUnion());
- TypeConstants::quantifier_t q = TypeOps::intersect_quant(argQuant, targetQuant);
+ SequenceType::Quantifier q = TypeOps::intersect_quant(argQuant, targetQuant);
newType = tm->create_type(*e->theTargetType, q);
}
@@ -423,7 +423,7 @@
xqtref_t input_ptype = TypeOps::prime_type(tm, *input_type);
xqtref_t target_ptype = TypeOps::prime_type(tm, *e->theTargetType);
- TypeConstants::quantifier_t q =
+ SequenceType::Quantifier q =
TypeOps::intersect_quant(input_type->get_quantifier(),
e->theTargetType->get_quantifier());
@@ -446,7 +446,7 @@
xqtref_t in_ptype = TypeOps::prime_type(tm, *in_type);
xqtref_t target_ptype = TypeOps::prime_type(tm, *e->theTargetType);
- TypeConstants::quantifier_t q =
+ SequenceType::Quantifier q =
TypeOps::intersect_quant(in_type->get_quantifier(),
e->theTargetType->get_quantifier());
@@ -512,7 +512,7 @@
newType = tm->create_node_type(store::StoreConsts::documentNode,
NULL,
contentType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
break;
@@ -527,7 +527,7 @@
newType = tm->create_node_type(store::StoreConsts::elementNode,
NULL,
contentType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
break;
@@ -551,7 +551,7 @@
store::StoreConsts::NodeKind nodeKind;
- TypeConstants::quantifier_t q = TypeConstants::QUANT_ONE;
+ SequenceType::Quantifier q = SequenceType::QUANT_ONE;
switch (e->type)
{
@@ -563,7 +563,7 @@
newType = t;
else if (t->min_card() == 0)
- q = TypeConstants::QUANT_QUESTION;
+ q = SequenceType::QUANT_QUESTION;
nodeKind = store::StoreConsts::textNode;
break;
@@ -593,7 +593,7 @@
newType = tm->create_node_type(store::StoreConsts::piNode,
NULL,
contentType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
break;
@@ -672,7 +672,7 @@
for (csize i = 0; i < fiExpr->get_function()->getSignature().paramCount(); ++i)
paramTypes.push_back(fiExpr->get_function()->getSignature()[i]);
- theType = new FunctionXQType(&rtm, paramTypes, retType, TypeConstants::QUANT_ONE);
+ theType = new FunctionXQType(&rtm, paramTypes, retType, SequenceType::QUANT_ONE);
}
return;
}
@@ -852,11 +852,11 @@
store::Item* testNodeName = nodeTest->getQName();
match_wild_t wildKind = nodeTest->getWildKind();
- TypeConstants::quantifier_t inQuant = inputType->get_quantifier();
+ SequenceType::Quantifier inQuant = inputType->get_quantifier();
store::StoreConsts::NodeKind inNodeKind = inputType->get_node_kind();
xqtref_t inContentType = inputType->get_content_type();
- TypeConstants::quantifier_t star = TypeConstants::QUANT_STAR;
+ SequenceType::Quantifier star = SequenceType::QUANT_STAR;
bool inUntyped = false;
if (inContentType != NULL)
@@ -1254,7 +1254,7 @@
TypeManager* tm,
store::StoreConsts::NodeKind nodekind,
const store::Item_t& nodename,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool untyped)
{
RootTypeManager& RTM = GENV_TYPESYSTEM;
@@ -1267,12 +1267,12 @@
else
contentType = RTM.UNTYPED_TYPE;
- if (TypeOps::is_sub_quant(quant, TypeConstants::QUANT_QUESTION))
+ if (TypeOps::is_sub_quant(quant, SequenceType::QUANT_QUESTION))
{
return tm->create_node_type(nodekind,
nodename,
contentType,
- TypeConstants::QUANT_QUESTION,
+ SequenceType::QUANT_QUESTION,
false,
false);
}
@@ -1281,7 +1281,7 @@
return tm->create_node_type(nodekind,
nodename,
contentType,
- TypeConstants::QUANT_STAR,
+ SequenceType::QUANT_STAR,
false,
false);
}
@@ -1294,12 +1294,12 @@
else
contentType = RTM.ANY_TYPE;
- if (TypeOps::is_sub_quant(quant, TypeConstants::QUANT_QUESTION))
+ if (TypeOps::is_sub_quant(quant, SequenceType::QUANT_QUESTION))
{
return tm->create_node_type(nodekind,
nodename,
contentType,
- TypeConstants::QUANT_QUESTION,
+ SequenceType::QUANT_QUESTION,
false,
false);
}
@@ -1308,7 +1308,7 @@
return tm->create_node_type(nodekind,
nodename,
contentType,
- TypeConstants::QUANT_STAR,
+ SequenceType::QUANT_STAR,
false,
false);
}
=== modified file 'src/compiler/expression/flwor_expr.cpp'
--- src/compiler/expression/flwor_expr.cpp 2013-05-24 16:34:11 +0000
+++ src/compiler/expression/flwor_expr.cpp 2013-06-13 19:26:32 +0000
@@ -144,14 +144,14 @@
{
if (kind == flwor_clause::for_clause)
{
- TypeConstants::quantifier_t domQuant = domainType->get_quantifier();
- TypeConstants::quantifier_t declQuant = declaredType->get_quantifier();
+ SequenceType::Quantifier domQuant = domainType->get_quantifier();
+ SequenceType::Quantifier declQuant = declaredType->get_quantifier();
if (theAllowingEmpty &&
- (declQuant == TypeConstants::QUANT_ONE ||
- declQuant == TypeConstants::QUANT_PLUS))
+ (declQuant == SequenceType::QUANT_ONE ||
+ declQuant == SequenceType::QUANT_PLUS))
{
- declaredType = tm->create_type(*declaredType, TypeConstants::QUANT_PLUS);
+ declaredType = tm->create_type(*declaredType, SequenceType::QUANT_PLUS);
}
else
{
=== modified file 'src/compiler/parser/parser.y'
--- src/compiler/parser/parser.y 2013-06-10 15:05:28 +0000
+++ src/compiler/parser/parser.y 2013-06-13 19:26:32 +0000
@@ -1729,7 +1729,7 @@
{
$$ = new VarNameAndType(LOC(@$),
static_cast<QName*>($3),
- dynamic_cast<SequenceType *>($4),
+ dynamic_cast<SequenceTypeAST *>($4),
NULL);
}
|
@@ -1745,7 +1745,7 @@
{
$$ = new VarNameAndType(LOC(@$),
static_cast<QName*>($4),
- dynamic_cast<SequenceType *>($5),
+ dynamic_cast<SequenceTypeAST *>($5),
static_cast<AnnotationListParsenode*>($1));
}
;
@@ -1897,12 +1897,12 @@
|
LPAR RPAR AS SequenceType
{
- $$ = new FunctionSig(NULL, dynamic_cast<SequenceType*>($4));
+ $$ = new FunctionSig(NULL, dynamic_cast<SequenceTypeAST*>($4));
}
|
LPAR ParamList RPAR AS SequenceType
{
- $$ = new FunctionSig(dynamic_cast<ParamList*>($2), dynamic_cast<SequenceType*>($5));
+ $$ = new FunctionSig(dynamic_cast<ParamList*>($2), dynamic_cast<SequenceTypeAST*>($5));
}
;
@@ -1935,7 +1935,7 @@
{
$$ = new Param(LOC(@$),
static_cast<QName*>($2),
- dynamic_cast<SequenceType *>($3));
+ dynamic_cast<SequenceTypeAST *>($3));
}
;
@@ -1955,7 +1955,7 @@
$$ = new CollectionDecl( LOC(@$),
static_cast<QName*>($3),
0,
- static_cast<SequenceType*>($5));
+ static_cast<SequenceTypeAST*>($5));
static_cast<CollectionDecl*>($$)->setComment(SYMTAB($1));
}
@@ -1973,7 +1973,7 @@
$$ = new CollectionDecl( LOC(@$),
static_cast<QName*>($4),
static_cast<AnnotationListParsenode*>($2),
- static_cast<SequenceType*>($6));
+ static_cast<SequenceTypeAST*>($6));
static_cast<CollectionDecl*>($$)->setComment(SYMTAB($1));
}
@@ -1982,21 +1982,21 @@
CollectionTypeDecl :
KindTest
{
- $$ = static_cast<parsenode*>(new SequenceType(LOC(@$), $1, NULL));
+ $$ = static_cast<parsenode*>(new SequenceTypeAST(LOC(@$), $1, NULL));
}
| KindTest OccurrenceIndicator
{
- $$ = static_cast<parsenode*>(new SequenceType(LOC(@$),
+ $$ = static_cast<parsenode*>(new SequenceTypeAST(LOC(@$),
$1,
dynamic_cast<OccurrenceIndicator*>($2)));
}
| JSONTest
{
- $$ = static_cast<parsenode*>(new SequenceType(LOC(@$), $1, NULL));
+ $$ = static_cast<parsenode*>(new SequenceTypeAST(LOC(@$), $1, NULL));
}
| JSONTest OccurrenceIndicator
{
- $$ = static_cast<parsenode*>(new SequenceType(LOC(@$),
+ $$ = static_cast<parsenode*>(new SequenceTypeAST(LOC(@$),
$1,
dynamic_cast<OccurrenceIndicator*>($2)));
@@ -2051,7 +2051,7 @@
{
$$ = new IndexKeySpec(LOC(@$),
$1,
- dynamic_cast<SequenceType*>($2),
+ dynamic_cast<SequenceTypeAST*>($2),
NULL);
}
| PathExpr OrderCollationSpec
@@ -2065,7 +2065,7 @@
{
$$ = new IndexKeySpec(LOC(@$),
$1,
- dynamic_cast<SequenceType*>($2),
+ dynamic_cast<SequenceTypeAST*>($2),
dynamic_cast<OrderCollationSpec*>($3));
}
;
@@ -2339,7 +2339,7 @@
{
LocalVarDecl* vd = new LocalVarDecl(LOC(@$),
static_cast<QName*>($2),
- dynamic_cast<SequenceType*>($3), // type
+ dynamic_cast<SequenceTypeAST*>($3), // type
NULL, // no init expr
NULL); // no annotations
$$ = vd;
@@ -2357,7 +2357,7 @@
{
LocalVarDecl* vd = new LocalVarDecl(LOC(@$),
static_cast<QName*>($2),
- dynamic_cast<SequenceType*>($3), // type
+ dynamic_cast<SequenceTypeAST*>($3), // type
$5, // init expr
NULL); // no annotations
$$ = vd;
@@ -2839,7 +2839,7 @@
{
$$ = new VarInDecl(LOC(@$),
static_cast<QName*>($1),
- dynamic_cast<SequenceType *>($2),
+ dynamic_cast<SequenceTypeAST *>($2),
NULL,
NULL,
$4,
@@ -2849,7 +2849,7 @@
{
$$ = new VarInDecl(LOC(@$),
static_cast<QName*>($1),
- dynamic_cast<SequenceType *>($2),
+ dynamic_cast<SequenceTypeAST *>($2),
NULL,
NULL,
$6,
@@ -2879,7 +2879,7 @@
{
$$ = new VarInDecl(LOC(@$),
static_cast<QName*>($1),
- dynamic_cast<SequenceType *>($2),
+ dynamic_cast<SequenceTypeAST *>($2),
dynamic_cast<PositionalVar*>($3),
NULL,
$5,
@@ -2889,7 +2889,7 @@
{
$$ = new VarInDecl(LOC(@$),
static_cast<QName*>($1),
- dynamic_cast<SequenceType *>($2),
+ dynamic_cast<SequenceTypeAST *>($2),
dynamic_cast<PositionalVar*>($5),
NULL,
$7,
@@ -2909,7 +2909,7 @@
{
$$ = new VarInDecl(LOC(@$),
static_cast<QName*>($1),
- dynamic_cast<SequenceType *>($2),
+ dynamic_cast<SequenceTypeAST *>($2),
NULL,
dynamic_cast<FTScoreVar*>($3),
$5,
@@ -2929,7 +2929,7 @@
{
$$ = new VarInDecl(LOC (@$),
static_cast<QName*>($1),
- dynamic_cast<SequenceType *>($2),
+ dynamic_cast<SequenceTypeAST *>($2),
dynamic_cast<PositionalVar*>($3),
dynamic_cast<FTScoreVar*>($4),
$6,
@@ -2997,7 +2997,7 @@
{
$$ = new VarGetsDecl(LOC (@$),
static_cast<QName*>($2),
- dynamic_cast<SequenceType *>($3),
+ dynamic_cast<SequenceTypeAST *>($3),
NULL,
$5);
}
@@ -3015,7 +3015,7 @@
{
$$ = new VarGetsDecl(LOC (@$),
static_cast<QName*>($2),
- dynamic_cast<SequenceType *>($3),
+ dynamic_cast<SequenceTypeAST *>($3),
dynamic_cast<FTScoreVar*>($4),
$6);
}
@@ -3033,7 +3033,7 @@
{
$$ = new WindowVarDecl(LOC (@$),
static_cast<QName*>($2),
- dynamic_cast<SequenceType *>($3),
+ dynamic_cast<SequenceTypeAST *>($3),
$5);
}
;
@@ -3124,7 +3124,7 @@
{
$$ = new GroupSpec(LOC(@$),
static_cast<QName*>($2),
- static_cast<SequenceType*>($3),
+ static_cast<SequenceTypeAST*>($3),
$5,
NULL);
}
@@ -3132,7 +3132,7 @@
{
$$ = new GroupSpec(LOC(@$),
static_cast<QName*>($2),
- static_cast<SequenceType*>($3),
+ static_cast<SequenceTypeAST*>($3),
$5,
static_cast<GroupCollationSpec*>($6));
}
@@ -3361,7 +3361,7 @@
{
$$ = new QVarInDecl(LOC(@$),
static_cast<QName*>($1),
- dynamic_cast<SequenceType *>($2),
+ dynamic_cast<SequenceTypeAST *>($2),
$4);
}
;
@@ -3555,13 +3555,13 @@
SequenceType
{
SequenceTypeList* seqList = new SequenceTypeList(LOC(@$));
- seqList->push_back(static_cast<SequenceType*>($1));
+ seqList->push_back(static_cast<SequenceTypeAST*>($1));
$$ = seqList;
}
| SequenceTypeList VBAR SequenceType
{
SequenceTypeList* seqList = static_cast<SequenceTypeList*>($1);
- seqList->push_back(static_cast<SequenceType*>($3));
+ seqList->push_back(static_cast<SequenceTypeAST*>($3));
$$ = $1;
}
;
@@ -3864,7 +3864,7 @@
| TreatExpr INSTANCE OF SequenceType
{
$$ = new InstanceofExpr(
- LOC(@$), $1, dynamic_cast<SequenceType*>($4)
+ LOC(@$), $1, dynamic_cast<SequenceTypeAST*>($4)
);
}
;
@@ -3878,7 +3878,7 @@
| CastableExpr TREAT AS SequenceType
{
$$ = new TreatExpr(
- LOC(@$), $1, dynamic_cast<SequenceType*>($4)
+ LOC(@$), $1, dynamic_cast<SequenceTypeAST*>($4)
);
}
;
@@ -5233,22 +5233,22 @@
SequenceType :
ItemType %prec SEQUENCE_TYPE_REDUCE
{
- $$ = new SequenceType( LOC(@$), $1, NULL );
+ $$ = new SequenceTypeAST( LOC(@$), $1, NULL );
}
| ItemType OccurrenceIndicator
{
- $$ = new SequenceType(LOC(@$), $1, dynamic_cast<OccurrenceIndicator*>($2));
+ $$ = new SequenceTypeAST(LOC(@$), $1, dynamic_cast<OccurrenceIndicator*>($2));
}
| EMPTY_SEQUENCE LPAR RPAR
{
- $$ = new SequenceType( LOC(@$), NULL, NULL );
+ $$ = new SequenceTypeAST( LOC(@$), NULL, NULL );
}
#ifdef JSONIQ_PARSER
| LPAR RPAR
{
// this warning will be added only if common-language is enabled
driver.addCommonLanguageWarning(@1, ZED(ZWST0009_JSONIQ_EMPTY_SEQUENCE));
- $$ = new SequenceType( LOC(@$), NULL, NULL );
+ $$ = new SequenceTypeAST( LOC(@$), NULL, NULL );
}
#endif
;
@@ -5354,13 +5354,13 @@
SequenceType
{
TypeList* aTypeList = new TypeList(LOC (@$));
- aTypeList->push_back(dynamic_cast<SequenceType *>($1));
+ aTypeList->push_back(dynamic_cast<SequenceTypeAST *>($1));
$$ = aTypeList;
}
| TypeList COMMA SequenceType
{
TypeList* aTypeList = dynamic_cast<TypeList *>($1);
- aTypeList->push_back(dynamic_cast<SequenceType *>($3));
+ aTypeList->push_back(dynamic_cast<SequenceTypeAST *>($3));
$$ = $1;
}
;
@@ -5679,13 +5679,13 @@
TypedFunctionTest :
FUNCTION LPAR RPAR AS SequenceType
{
- $$ = new TypedFunctionTest(LOC (@$), dynamic_cast<SequenceType *>($5));
+ $$ = new TypedFunctionTest(LOC (@$), dynamic_cast<SequenceTypeAST *>($5));
}
| FUNCTION LPAR TypeList RPAR AS SequenceType
{
$$ = new TypedFunctionTest(LOC (@$),
dynamic_cast<TypeList *>($3),
- dynamic_cast<SequenceType *>($6));
+ dynamic_cast<SequenceTypeAST *>($6));
}
;
=== modified file 'src/compiler/parsetree/parsenode_print_xml_visitor.cpp'
--- src/compiler/parsetree/parsenode_print_xml_visitor.cpp 2013-05-08 20:14:47 +0000
+++ src/compiler/parsetree/parsenode_print_xml_visitor.cpp 2013-06-13 19:26:32 +0000
@@ -812,7 +812,7 @@
BEGIN_END_TAG (SchemaElementTest)
END_TAG (SchemaImport)
BEGIN_END_TAG (SchemaPrefix)
-BEGIN_END_TAG (SequenceType)
+BEGIN_END_TAG (SequenceTypeAST)
BEGIN_END_TAG (SignList)
BEGIN_END_TAG (SIND_DeclList)
BEGIN_END_TAG (DecimalFormatNode)
=== modified file 'src/compiler/parsetree/parsenode_print_xqdoc_visitor.cpp'
--- src/compiler/parsetree/parsenode_print_xqdoc_visitor.cpp 2013-04-16 21:12:12 +0000
+++ src/compiler/parsetree/parsenode_print_xqdoc_visitor.cpp 2013-06-13 19:26:32 +0000
@@ -1496,7 +1496,7 @@
XQDOC_NO_BEGIN_END_TAG (SchemaAttributeTest)
XQDOC_NO_BEGIN_END_TAG (SchemaElementTest)
XQDOC_NO_BEGIN_END_TAG (SchemaPrefix)
-XQDOC_NO_BEGIN_END_TAG (SequenceType)
+XQDOC_NO_BEGIN_END_TAG (SequenceTypeAST)
XQDOC_NO_BEGIN_END_TAG (SignList)
XQDOC_NO_BEGIN_END_TAG (SIND_DeclList)
XQDOC_NO_BEGIN_END_TAG (SingleType)
=== modified file 'src/compiler/parsetree/parsenode_print_xquery_visitor.cpp'
--- src/compiler/parsetree/parsenode_print_xquery_visitor.cpp 2013-03-22 00:38:18 +0000
+++ src/compiler/parsetree/parsenode_print_xquery_visitor.cpp 2013-06-13 19:26:32 +0000
@@ -944,7 +944,7 @@
}
DEFAULT_END_VISIT (SchemaImport)
- void* begin_visit(const SequenceType& n)
+ void* begin_visit(const SequenceTypeAST& n)
{
if(n.get_itemtype() == 0)
{
@@ -952,7 +952,7 @@
}
return no_state;
}
- DEFAULT_END_VISIT (SequenceType)
+ DEFAULT_END_VISIT (SequenceTypeAST)
void* begin_visit(const SignList& n)
{
@@ -2006,7 +2006,7 @@
{
os << ", ";
}
- const SequenceType* e_p = n[i];
+ const SequenceTypeAST* e_p = n[i];
e_p->accept(*this);
}
return 0;
=== modified file 'src/compiler/parsetree/parsenode_visitor.h'
--- src/compiler/parsetree/parsenode_visitor.h 2013-03-22 00:38:18 +0000
+++ src/compiler/parsetree/parsenode_visitor.h 2013-06-13 19:26:32 +0000
@@ -122,7 +122,7 @@
DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( SchemaElementTest );
DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( SchemaImport );
DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( SchemaPrefix );
- DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( SequenceType );
+ DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( SequenceTypeAST );
DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( SignList );
DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( SingleType );
DECL_PARSENODE_VISITOR_VISIT_MEM_FNS( TextTest );
=== modified file 'src/compiler/parsetree/parsenodes.cpp'
--- src/compiler/parsetree/parsenodes.cpp 2013-06-06 18:04:54 +0000
+++ src/compiler/parsetree/parsenodes.cpp 2013-06-13 19:26:32 +0000
@@ -769,7 +769,7 @@
GlobalVarDecl::GlobalVarDecl(
const QueryLoc& loc,
QName* varname,
- SequenceType* type_decl,
+ SequenceTypeAST* type_decl,
exprnode* init_expr,
AnnotationListParsenode* annotations,
bool external)
@@ -797,7 +797,7 @@
const QueryLoc& loc,
QName* name,
ParamList* params,
- SequenceType* retType,
+ SequenceTypeAST* retType,
exprnode* body,
bool updating,
bool external)
@@ -865,7 +865,7 @@
Param::Param(
const QueryLoc& loc,
rchandle<QName> name,
- rchandle<SequenceType> type)
+ rchandle<SequenceTypeAST> type)
:
parsenode(loc),
theName(name),
@@ -956,7 +956,7 @@
const QueryLoc& aLoc,
QName* aName,
rchandle<AnnotationListParsenode> aAnnotations,
- SequenceType* aTypeDecl)
+ SequenceTypeAST* aTypeDecl)
:
XQDocumentable(aLoc),
theName(aName),
@@ -1264,7 +1264,7 @@
LocalVarDecl::LocalVarDecl(
const QueryLoc& loc,
QName* varname,
- SequenceType* type_decl,
+ SequenceTypeAST* type_decl,
exprnode* init_expr,
AnnotationListParsenode* annotations)
:
@@ -1648,7 +1648,7 @@
VarInDecl::VarInDecl(
const QueryLoc& loc,
rchandle<QName> varname,
- rchandle<SequenceType> typedecl_h,
+ rchandle<SequenceTypeAST> typedecl_h,
rchandle<PositionalVar> _posvar_h,
rchandle<FTScoreVar> _ftscorevar_h,
rchandle<exprnode> valexpr_h,
@@ -1840,7 +1840,7 @@
GroupSpec::GroupSpec(
const QueryLoc& loc,
rchandle<QName> name,
- rchandle<SequenceType> type,
+ rchandle<SequenceTypeAST> type,
rchandle<exprnode> expr,
rchandle<GroupCollationSpec> collation)
:
@@ -2105,7 +2105,7 @@
QVarInDecl::QVarInDecl(
const QueryLoc& loc_,
rchandle<QName> _name,
- rchandle<SequenceType> _typedecl_h,
+ rchandle<SequenceTypeAST> _typedecl_h,
rchandle<exprnode> _val_h)
:
parsenode(loc_),
@@ -2630,7 +2630,7 @@
InstanceofExpr::InstanceofExpr(
const QueryLoc& loc_,
rchandle<exprnode> _treat_expr_h,
- rchandle<SequenceType> _seqtype_h)
+ rchandle<SequenceTypeAST> _seqtype_h)
:
exprnode(loc_),
treat_expr_h(_treat_expr_h),
@@ -2654,7 +2654,7 @@
TreatExpr::TreatExpr(
const QueryLoc& loc_,
rchandle<exprnode> _castable_expr_h,
- rchandle<SequenceType> _seqtype_h)
+ rchandle<SequenceTypeAST> _seqtype_h)
:
exprnode(loc_),
castable_expr_h(_castable_expr_h),
@@ -4338,9 +4338,9 @@
}
-// [119] SequenceType
+// [119] SequenceTypeAST
// ------------------
-SequenceType::SequenceType(
+SequenceTypeAST::SequenceTypeAST(
const QueryLoc& loc_,
rchandle<parsenode> _itemtype_h,
rchandle<OccurrenceIndicator> _occur_h)
@@ -4353,7 +4353,7 @@
//-SequenceType::
-void SequenceType::accept( parsenode_visitor &v ) const
+void SequenceTypeAST::accept( parsenode_visitor &v ) const
{
BEGIN_VISITOR();
ACCEPT (itemtype_h);
@@ -5911,7 +5911,7 @@
void TypeList::accept(parsenode_visitor& v) const
{
BEGIN_VISITOR ();
- std::vector<rchandle<SequenceType> >::const_iterator it = theTypes.begin();
+ std::vector<rchandle<SequenceTypeAST> >::const_iterator it = theTypes.begin();
for (; it!=theTypes.end(); ++it)
{
const parsenode* e_p = &**it;
=== modified file 'src/compiler/parsetree/parsenodes.h'
--- src/compiler/parsetree/parsenodes.h 2013-06-06 18:04:54 +0000
+++ src/compiler/parsetree/parsenodes.h 2013-06-13 19:26:32 +0000
@@ -228,7 +228,7 @@
class SchemaElementTest;
class SchemaImport;
class SchemaPrefix;
-class SequenceType;
+class SequenceTypeAST;
class SequenceTypeList;
class SignList;
class SingleType;
@@ -959,14 +959,14 @@
{
protected:
rchandle<QName> theName;
- rchandle<SequenceType> theType;
+ rchandle<SequenceTypeAST> theType;
rchandle<exprnode> theExpr;
public:
VarDeclWithInit(
const QueryLoc& loc,
rchandle<QName> name,
- rchandle<SequenceType> type,
+ rchandle<SequenceTypeAST> type,
rchandle<exprnode> expr)
:
XQDocumentable(loc),
@@ -980,7 +980,7 @@
void set_var_name(rchandle<QName> name) { theName = name; }
- rchandle<SequenceType> get_var_type() const { return theType; }
+ rchandle<SequenceTypeAST> get_var_type() const { return theType; }
rchandle<exprnode> get_binding_expr() const { return theExpr; }
};
@@ -1000,7 +1000,7 @@
GlobalVarDecl(
const QueryLoc& loc,
QName* varname,
- SequenceType* type_decl,
+ SequenceTypeAST* type_decl,
exprnode* init_expr,
AnnotationListParsenode* annotations,
bool external);
@@ -1025,13 +1025,13 @@
{
public:
rchandle<QName> theName;
- rchandle<SequenceType> theType;
+ rchandle<SequenceTypeAST> theType;
rchandle<AnnotationListParsenode> theAnnotations;
VarNameAndType(
const QueryLoc& loc_,
rchandle<QName> name,
- rchandle<SequenceType> type,
+ rchandle<SequenceTypeAST> type,
rchandle<AnnotationListParsenode> annotations)
:
XQDocumentable(loc_),
@@ -1068,7 +1068,7 @@
protected:
rchandle<QName> theName;
rchandle<ParamList> theParams;
- rchandle<SequenceType> theReturnType;
+ rchandle<SequenceTypeAST> theReturnType;
rchandle<exprnode> theBody;
bool theIsExternal;
@@ -1082,7 +1082,7 @@
const QueryLoc& loc,
QName* name,
ParamList* params,
- SequenceType* retType,
+ SequenceTypeAST* retType,
exprnode* body,
bool updating,
bool external);
@@ -1093,7 +1093,7 @@
csize get_param_count() const;
- rchandle<SequenceType> get_return_type() const { return theReturnType; }
+ rchandle<SequenceTypeAST> get_return_type() const { return theReturnType; }
rchandle<exprnode> get_body() const { return theBody; }
@@ -1119,9 +1119,9 @@
{
public:
rchandle<ParamList> theParams;
- rchandle<SequenceType> theReturnType;
+ rchandle<SequenceTypeAST> theReturnType;
- FunctionSig(ParamList* param, SequenceType* ret = NULL)
+ FunctionSig(ParamList* param, SequenceTypeAST* ret = NULL)
:
theParams(param),
theReturnType(ret)
@@ -1162,17 +1162,17 @@
{
protected:
rchandle<QName> theName;
- rchandle<SequenceType> theType;
+ rchandle<SequenceTypeAST> theType;
public:
Param(
const QueryLoc& loc,
rchandle<QName> name,
- rchandle<SequenceType> type);
+ rchandle<SequenceTypeAST> type);
const QName* get_name() const { return theName.getp(); }
- rchandle<SequenceType> get_typedecl() const { return theType; }
+ rchandle<SequenceTypeAST> get_typedecl() const { return theType; }
void accept(parsenode_visitor&) const;
};
@@ -1293,7 +1293,7 @@
{
protected:
rchandle<QName> theName;
- rchandle<SequenceType> theTypeDecl;
+ rchandle<SequenceTypeAST> theTypeDecl;
rchandle<AnnotationListParsenode> theAnnotations;
public:
@@ -1301,7 +1301,7 @@
const QueryLoc& aLoc,
QName* aName,
rchandle<AnnotationListParsenode>,
- SequenceType* aTypeDecl);
+ SequenceTypeAST* aTypeDecl);
const QName* getName() const { return theName.getp(); }
@@ -1310,7 +1310,7 @@
return theAnnotations.getp();
}
- const SequenceType* getType() const { return theTypeDecl.getp(); }
+ const SequenceTypeAST* getType() const { return theTypeDecl.getp(); }
void accept(parsenode_visitor&) const;
};
@@ -1396,14 +1396,14 @@
{
protected:
rchandle<exprnode> theExpr;
- rchandle<SequenceType> theType;
+ rchandle<SequenceTypeAST> theType;
rchandle<OrderCollationSpec> theCollationSpec;
public:
IndexKeySpec(
const QueryLoc& loc,
exprnode* expr,
- SequenceType* type,
+ SequenceTypeAST* type,
OrderCollationSpec* collation)
:
parsenode(loc),
@@ -1415,7 +1415,7 @@
const exprnode* getExpr() const { return theExpr.getp(); }
- const SequenceType* getType() const { return theType.getp(); }
+ const SequenceTypeAST* getType() const { return theType.getp(); }
const OrderCollationSpec* getCollationSpec() const { return theCollationSpec.getp(); }
@@ -1708,7 +1708,7 @@
LocalVarDecl(
const QueryLoc& loc,
QName* varname,
- SequenceType* type_decl,
+ SequenceTypeAST* type_decl,
exprnode* init_expr,
AnnotationListParsenode* annotations);
@@ -2084,7 +2084,7 @@
VarInDecl(
const QueryLoc&,
rchandle<QName> varname,
- rchandle<SequenceType>,
+ rchandle<SequenceTypeAST>,
rchandle<PositionalVar>,
rchandle<FTScoreVar>,
rchandle<exprnode>,
@@ -2180,7 +2180,7 @@
VarGetsDecl(
const QueryLoc& loc,
rchandle<QName> varname,
- rchandle<SequenceType> typedecl_h,
+ rchandle<SequenceTypeAST> typedecl_h,
rchandle<FTScoreVar> ftscorevar_h,
rchandle<exprnode> valexpr_h,
enum var_kind kind_ = let_var)
@@ -2293,7 +2293,7 @@
GroupSpec(
const QueryLoc& loc,
rchandle<QName> name,
- rchandle<SequenceType> type,
+ rchandle<SequenceTypeAST> type,
rchandle<exprnode> expr,
rchandle<GroupCollationSpec> collation);
@@ -2555,7 +2555,7 @@
WindowVarDecl (
const QueryLoc& loc_,
rchandle<QName> varname_,
- rchandle<SequenceType> td_,
+ rchandle<SequenceTypeAST> td_,
rchandle<exprnode> init_)
:
VarDeclWithInit (loc_, varname_, td_, init_)
@@ -2724,7 +2724,7 @@
{
protected:
rchandle<QName> name;
- rchandle<SequenceType> typedecl_h;
+ rchandle<SequenceTypeAST> typedecl_h;
rchandle<exprnode> val_h;
public:
@@ -2736,12 +2736,12 @@
QVarInDecl(
const QueryLoc&,
rchandle<QName> name,
- rchandle<SequenceType>,
+ rchandle<SequenceTypeAST>,
rchandle<exprnode>);
const QName* get_name() const { return name.getp(); }
- rchandle<SequenceType> get_typedecl() const { return typedecl_h; }
+ rchandle<SequenceTypeAST> get_typedecl() const { return typedecl_h; }
rchandle<exprnode> get_val() const { return val_h; }
@@ -2945,7 +2945,7 @@
{
protected:
rchandle<QName> theVarName;
- std::vector<rchandle<SequenceType> > theTypes;
+ std::vector<rchandle<SequenceTypeAST> > theTypes;
rchandle<exprnode> theExpr;
public:
@@ -2957,7 +2957,7 @@
csize num_types() const { return theTypes.size(); }
- SequenceType* get_type(csize i) const { return theTypes[i].getp(); }
+ SequenceTypeAST* get_type(csize i) const { return theTypes[i].getp(); }
exprnode* get_expr() const { return theExpr.getp(); }
@@ -2975,12 +2975,12 @@
friend class CaseClause;
protected:
- std::vector<rchandle<SequenceType> > theTypes;
+ std::vector<rchandle<SequenceTypeAST> > theTypes;
public:
SequenceTypeList(const QueryLoc& loc) : parsenode(loc) {}
- void push_back(SequenceType* t) { theTypes.push_back(t); }
+ void push_back(SequenceTypeAST* t) { theTypes.push_back(t); }
void accept(parsenode_visitor&) const;
};
@@ -3348,16 +3348,16 @@
{
protected:
rchandle<exprnode> treat_expr_h;
- rchandle<SequenceType> seqtype_h;
+ rchandle<SequenceTypeAST> seqtype_h;
public:
InstanceofExpr(
const QueryLoc&,
rchandle<exprnode>,
- rchandle<SequenceType>);
+ rchandle<SequenceTypeAST>);
rchandle<exprnode> get_treat_expr() const { return treat_expr_h; }
- rchandle<SequenceType> get_seqtype() const { return seqtype_h; }
+ rchandle<SequenceTypeAST> get_seqtype() const { return seqtype_h; }
virtual void accept(parsenode_visitor&) const;
};
@@ -3370,16 +3370,16 @@
{
protected:
rchandle<exprnode> castable_expr_h;
- rchandle<SequenceType> seqtype_h;
+ rchandle<SequenceTypeAST> seqtype_h;
public:
TreatExpr(
const QueryLoc&,
rchandle<exprnode>,
- rchandle<SequenceType>);
+ rchandle<SequenceTypeAST>);
rchandle<exprnode> get_castable_expr() const { return castable_expr_h; }
- rchandle<SequenceType> get_seqtype() const { return seqtype_h; }
+ rchandle<SequenceTypeAST> get_seqtype() const { return seqtype_h; }
virtual void accept(parsenode_visitor&) const;
};
@@ -4411,14 +4411,14 @@
{
private:
rchandle<ParamList> theParamList;
- rchandle<SequenceType> theReturnType;
+ rchandle<SequenceTypeAST> theReturnType;
rchandle<exprnode> theEnclosedExpr;
public:
InlineFunction(
const QueryLoc& loc_,
rchandle<ParamList> aParamList,
- rchandle<SequenceType> aReturnType,
+ rchandle<SequenceTypeAST> aReturnType,
rchandle<exprnode> aEnclosedExpr)
:
exprnode(loc_),
@@ -4429,7 +4429,7 @@
rchandle<ParamList> getParamList() const { return theParamList; }
- rchandle<SequenceType> getReturnType() const { return theReturnType; }
+ rchandle<SequenceTypeAST> getReturnType() const { return theReturnType; }
rchandle<exprnode> getEnclosedExpr() const { return theEnclosedExpr; }
@@ -5248,14 +5248,14 @@
[145] SequenceType ::= ("empty-sequence" "(" ")") |
(ItemType OccurrenceIndicator?)
********************************************************************************/
-class SequenceType : public parsenode
+class SequenceTypeAST : public parsenode
{
protected:
rchandle<parsenode> itemtype_h;
rchandle<OccurrenceIndicator> occur_h;
public:
- SequenceType(
+ SequenceTypeAST(
const QueryLoc&,
rchandle<parsenode>,
rchandle<OccurrenceIndicator>);
@@ -5612,12 +5612,12 @@
{
protected:
rchandle<TypeList> theArgTypes;
- rchandle<SequenceType> theReturnType;
+ rchandle<SequenceTypeAST> theReturnType;
public:
TypedFunctionTest(
const QueryLoc& loc_,
- rchandle<SequenceType> aReturnType)
+ rchandle<SequenceTypeAST> aReturnType)
:
parsenode(loc_),
theArgTypes(0),
@@ -5628,7 +5628,7 @@
TypedFunctionTest(
const QueryLoc& loc_,
rchandle<TypeList> aTypeList,
- rchandle<SequenceType> aReturnType)
+ rchandle<SequenceTypeAST> aReturnType)
:
parsenode(loc_),
theArgTypes(aTypeList),
@@ -5638,7 +5638,7 @@
const rchandle<TypeList>& getArgumentTypes() const { return theArgTypes; }
- const rchandle<SequenceType>& getReturnType() const { return theReturnType; }
+ const rchandle<SequenceTypeAST>& getReturnType() const { return theReturnType; }
void accept(parsenode_visitor&) const;
};
@@ -5650,14 +5650,14 @@
class TypeList: public parsenode
{
protected:
- std::vector<rchandle<SequenceType> > theTypes;
+ std::vector<rchandle<SequenceTypeAST> > theTypes;
public:
TypeList(const QueryLoc& loc_): parsenode(loc_){}
- void push_back(rchandle<SequenceType> aType) { theTypes.push_back(aType); }
+ void push_back(rchandle<SequenceTypeAST> aType) { theTypes.push_back(aType); }
- rchandle<SequenceType> operator[](int i) const { return theTypes[i]; }
+ rchandle<SequenceTypeAST> operator[](int i) const { return theTypes[i]; }
ulong size() const { return (ulong)theTypes.size (); }
=== modified file 'src/compiler/rewriter/rules/flwor_rules.cpp'
--- src/compiler/rewriter/rules/flwor_rules.cpp 2013-05-24 16:34:11 +0000
+++ src/compiler/rewriter/rules/flwor_rules.cpp 2013-06-13 19:26:32 +0000
@@ -274,7 +274,7 @@
bool outerFor = fc->is_allowing_empty();
expr* domExpr = fc->get_expr();
xqtref_t domType = domExpr->get_return_type();
- TypeConstants::quantifier_t domQuant = domType->get_quantifier();
+ SequenceType::Quantifier domQuant = domType->get_quantifier();
ulong domCount = domType->max_card();
var_expr* pvar = fc->get_pos_var();
var = fc->get_var();
@@ -316,7 +316,7 @@
// FOR clause with cardinality 0 or 1
else
{
- if (pvar != NULL && (domQuant == TypeConstants::QUANT_ONE || ! outerFor))
+ if (pvar != NULL && (domQuant == SequenceType::QUANT_ONE || ! outerFor))
{
expr* constExpr = rCtx.theEM->
create_const_expr(sctx, udf, loc, numeric_consts<xs_integer>::one());
@@ -532,7 +532,7 @@
bool isSafeVar =
(varClause->get_kind() == flwor_clause::let_clause ||
varClause->is_allowing_empty() ||
- varDomExpr->get_return_type()->get_quantifier() == TypeConstants::QUANT_ONE);
+ varDomExpr->get_return_type()->get_quantifier() == SequenceType::QUANT_ONE);
if (is_trivial_expr(varDomExpr))
{
@@ -797,7 +797,7 @@
expr* varDomExpr = varClause->get_expr();
if (varClause->get_kind() == flwor_clause::for_clause &&
- varDomExpr->get_return_type()->get_quantifier() != TypeConstants::QUANT_ONE)
+ varDomExpr->get_return_type()->get_quantifier() != SequenceType::QUANT_ONE)
{
// We are considering folding a FOR var whose domain expr may be the
// empty sequence. We can fold only if doing so will cause the result
@@ -1650,7 +1650,7 @@
xqtref_t nestedDomainType =
static_cast<for_clause*>(nestedClause)->get_expr()->get_return_type();
- if (nestedDomainType->get_quantifier() != TypeConstants::QUANT_ONE)
+ if (nestedDomainType->get_quantifier() != SequenceType::QUANT_ONE)
{
merge = false;
break;
=== modified file 'src/compiler/rewriter/rules/fold_rules.cpp'
--- src/compiler/rewriter/rules/fold_rules.cpp 2013-05-24 16:34:11 +0000
+++ src/compiler/rewriter/rules/fold_rules.cpp 2013-06-13 19:26:32 +0000
@@ -711,7 +711,7 @@
if (!arg->isNonDiscardable())
{
xqtref_t argType = arg->get_return_type();
- TypeConstants::quantifier_t argQuant = argType->get_quantifier();
+ SequenceType::Quantifier argQuant = argType->get_quantifier();
int type_cnt = argType->card();
if (fkind == FunctionConsts::FN_COUNT_1 && type_cnt != -1)
@@ -725,8 +725,8 @@
{
return rCtx.theEM->create_const_expr(sctx, udf, fo->get_loc(), true);
}
- else if (argQuant == TypeConstants::QUANT_ONE ||
- argQuant == TypeConstants::QUANT_PLUS)
+ else if (argQuant == SequenceType::QUANT_ONE ||
+ argQuant == SequenceType::QUANT_PLUS)
{
return rCtx.theEM->create_const_expr(sctx, udf, fo->get_loc(), false);
}
@@ -737,8 +737,8 @@
{
return rCtx.theEM->create_const_expr(sctx, udf, fo->get_loc(), false);
}
- else if (argQuant == TypeConstants::QUANT_ONE ||
- argQuant == TypeConstants::QUANT_PLUS)
+ else if (argQuant == SequenceType::QUANT_ONE ||
+ argQuant == SequenceType::QUANT_PLUS)
{
return rCtx.theEM->create_const_expr(sctx, udf, fo->get_loc(), true);
}
@@ -907,7 +907,7 @@
if (TypeOps::is_subtype(tm,
*tm->create_named_type(val->getType(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
fo.get_loc(),
true),
*rtm.INTEGER_TYPE_ONE,
=== modified file 'src/compiler/rewriter/rules/index_join_rule.cpp'
--- src/compiler/rewriter/rules/index_join_rule.cpp 2013-05-24 16:34:11 +0000
+++ src/compiler/rewriter/rules/index_join_rule.cpp 2013-06-13 19:26:32 +0000
@@ -500,8 +500,8 @@
xqtref_t innerType = predInfo.theInnerOp->get_return_type();
xqtref_t primeOuterType = TypeOps::prime_type(tm, *outerType);
xqtref_t primeInnerType = TypeOps::prime_type(tm, *innerType);
- TypeConstants::quantifier_t outerQuant = outerType->get_quantifier();
- TypeConstants::quantifier_t innerQuant = innerType->get_quantifier();
+ SequenceType::Quantifier outerQuant = outerType->get_quantifier();
+ SequenceType::Quantifier innerQuant = innerType->get_quantifier();
const QueryLoc& innerLoc = predInfo.theInnerOp->get_loc();
const QueryLoc& outerLoc = predInfo.theOuterOp->get_loc();
@@ -513,12 +513,12 @@
// check again here and reject the hashjoin rewrite if these conditions
// are violated.
- if (innerQuant != TypeConstants::QUANT_ONE &&
- innerQuant != TypeConstants::QUANT_QUESTION)
+ if (innerQuant != SequenceType::QUANT_ONE &&
+ innerQuant != SequenceType::QUANT_QUESTION)
return false;
- if (outerQuant != TypeConstants::QUANT_ONE &&
- outerQuant != TypeConstants::QUANT_QUESTION)
+ if (outerQuant != SequenceType::QUANT_ONE &&
+ outerQuant != SequenceType::QUANT_QUESTION)
return false;
// The type of the inner operand in the join predicate must not be
@@ -588,13 +588,13 @@
curExpr = fc->get_expr();
xqtref_t domainType = curExpr->get_return_type();
- TypeConstants::quantifier_t quant = domainType->get_quantifier();
+ SequenceType::Quantifier quant = domainType->get_quantifier();
- if (quant == TypeConstants::QUANT_STAR || quant == TypeConstants::QUANT_PLUS)
+ if (quant == SequenceType::QUANT_STAR || quant == SequenceType::QUANT_PLUS)
{
return var;
}
- else if (quant == TypeConstants::QUANT_ONE)
+ else if (quant == SequenceType::QUANT_ONE)
{
// this FOR var is equivalent to a LET var, so we drill into its
// domain expr
=== modified file 'src/compiler/rewriter/rules/nodeid_rules.cpp'
--- src/compiler/rewriter/rules/nodeid_rules.cpp 2013-05-24 16:34:11 +0000
+++ src/compiler/rewriter/rules/nodeid_rules.cpp 2013-06-13 19:26:32 +0000
@@ -419,7 +419,7 @@
expr* arg = curExpr->get_input();
xqtref_t targetType = curExpr->get_target_type();
- TypeConstants::quantifier_t q = targetType->get_quantifier();
+ SequenceType::Quantifier q = targetType->get_quantifier();
set_ignores_sorted_nodes(arg, ANNOTATION_TRUE);
@@ -427,8 +427,8 @@
{
set_ignores_duplicate_nodes(arg, ANNOTATION_TRUE);
}
- else if (q == TypeConstants::QUANT_STAR ||
- (q == TypeConstants::QUANT_PLUS &&
+ else if (q == SequenceType::QUANT_STAR ||
+ (q == SequenceType::QUANT_PLUS &&
arg->get_return_type()->min_card() >= 1))
{
set_ignores_duplicate_nodes(arg, ANNOTATION_TRUE);
@@ -449,7 +449,7 @@
expr* arg = curExpr->get_input();
xqtref_t targetType = curExpr->get_target_type();
- TypeConstants::quantifier_t q = targetType->get_quantifier();
+ SequenceType::Quantifier q = targetType->get_quantifier();
if (targetType->is_empty())
{
@@ -458,7 +458,7 @@
}
else
{
- if (q == TypeConstants::QUANT_ONE || q == TypeConstants::QUANT_QUESTION)
+ if (q == SequenceType::QUANT_ONE || q == SequenceType::QUANT_QUESTION)
{
set_ignores_sorted_nodes(arg, ANNOTATION_TRUE);
}
@@ -468,8 +468,8 @@
}
if (curExpr->getIgnoresDuplicateNodes() == ANNOTATION_TRUE &&
- (q == TypeConstants::QUANT_STAR ||
- (q == TypeConstants::QUANT_PLUS &&
+ (q == SequenceType::QUANT_STAR ||
+ (q == SequenceType::QUANT_PLUS &&
arg->get_return_type()->min_card() >= 1)))
{
set_ignores_duplicate_nodes(arg, ANNOTATION_TRUE);
=== modified file 'src/compiler/rewriter/rules/type_rules.cpp'
--- src/compiler/rewriter/rules/type_rules.cpp 2013-05-22 21:03:15 +0000
+++ src/compiler/rewriter/rules/type_rules.cpp 2013-06-13 19:26:32 +0000
@@ -134,7 +134,7 @@
expr* arg = fo->get_arg(0);
xqtref_t arg_type = arg->get_return_type();
- if (arg_type->get_quantifier() == TypeConstants::QUANT_ONE)
+ if (arg_type->get_quantifier() == SequenceType::QUANT_ONE)
return arg;
if (arg_type->max_card() == 0)
=== modified file 'src/compiler/rewriter/tools/dataflow_annotations.cpp'
--- src/compiler/rewriter/tools/dataflow_annotations.cpp 2013-05-29 04:17:01 +0000
+++ src/compiler/rewriter/tools/dataflow_annotations.cpp 2013-06-13 19:26:32 +0000
@@ -275,9 +275,9 @@
bool DataflowAnnotationsComputer::generic_compute(expr* e)
{
xqtref_t rt = e->get_return_type();
- TypeConstants::quantifier_t quant = rt->get_quantifier();
+ SequenceType::Quantifier quant = rt->get_quantifier();
- if (quant == TypeConstants::QUANT_ONE || quant == TypeConstants::QUANT_QUESTION)
+ if (quant == SequenceType::QUANT_ONE || quant == SequenceType::QUANT_QUESTION)
{
SORTED_NODES(e);
DISTINCT_NODES(e);
@@ -384,10 +384,10 @@
expr* domainExpr = flc->get_expr();
xqtref_t domainType = domainExpr->get_return_type();
- TypeConstants::quantifier_t domainQuant = domainType->get_quantifier();
+ SequenceType::Quantifier domainQuant = domainType->get_quantifier();
- if (domainQuant != TypeConstants::QUANT_ONE &&
- domainQuant != TypeConstants::QUANT_QUESTION)
+ if (domainQuant != SequenceType::QUANT_ONE &&
+ domainQuant != SequenceType::QUANT_QUESTION)
{
fc = flc;
++numForClauses;
=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp 2013-06-11 18:13:29 +0000
+++ src/compiler/translator/translator.cpp 2013-06-13 19:26:32 +0000
@@ -3931,7 +3931,7 @@
++it)
{
const Param* param = (*it);
- const SequenceType* paramType = param->get_typedecl();
+ const SequenceTypeAST* paramType = param->get_typedecl();
if (paramType == NULL)
{
paramTypes.push_back(GENV_TYPESYSTEM.ITEM_TYPE_STAR);
@@ -4952,12 +4952,12 @@
// Get the static type of the root nodes
xqtref_t lNodeType;
xqtref_t lCollectionType;
- TypeConstants::quantifier_t quant;
+ SequenceType::Quantifier quant;
if (v.getType() == 0)
{
lNodeType = theRTM.ANY_NODE_UNTYPED_TYPE_ONE;
lCollectionType = theRTM.ANY_NODE_UNTYPED_TYPE_STAR;
- quant = TypeConstants::QUANT_STAR;
+ quant = SequenceType::QUANT_STAR;
}
else
{
@@ -5069,7 +5069,7 @@
// Create an IC to check that the cardinality of the collection matches its
// declared type.
- if (quant != TypeConstants::QUANT_STAR)
+ if (quant != SequenceType::QUANT_STAR)
{
// TODO
}
@@ -5329,7 +5329,7 @@
{
type = pop_tstack();
ptype = TypeOps::prime_type(tm, *type);
- TypeConstants::quantifier_t quant = type->get_quantifier();
+ SequenceType::Quantifier quant = type->get_quantifier();
if (!TypeOps::is_subtype(tm, *ptype, *theRTM.ANY_ATOMIC_TYPE_STAR, kloc))
{
@@ -5339,8 +5339,8 @@
}
if (!index->isGeneral() &&
- quant != TypeConstants::QUANT_ONE &&
- quant != TypeConstants::QUANT_QUESTION)
+ quant != SequenceType::QUANT_ONE &&
+ quant != SequenceType::QUANT_QUESTION)
{
RAISE_ERROR(zerr::ZDST0027_INDEX_BAD_KEY_TYPE, kloc,
ERROR_PARAMS(index->getName()->getStringValue(),
@@ -9224,12 +9224,12 @@
{
xqtref_t type = pop_tstack();
- assert(type->get_quantifier() == TypeConstants::QUANT_ONE ||
- type->get_quantifier() == TypeConstants::QUANT_STAR);
+ assert(type->get_quantifier() == SequenceType::QUANT_ONE ||
+ type->get_quantifier() == SequenceType::QUANT_STAR);
- if (type->get_quantifier() == TypeConstants::QUANT_ONE)
+ if (type->get_quantifier() == SequenceType::QUANT_ONE)
{
- theTypeStack.push(CTX_TM->create_type(*type, TypeConstants::QUANT_QUESTION));
+ theTypeStack.push(CTX_TM->create_type(*type, SequenceType::QUANT_QUESTION));
}
}
// else leave type as it is on tstack
@@ -11543,7 +11543,7 @@
expand_type_qname(qnameItem, qname, loc);
xqtref_t type =
- tm->create_named_type(qnameItem, TypeConstants::QUANT_QUESTION, loc);
+ tm->create_named_type(qnameItem, SequenceType::QUANT_QUESTION, loc);
if (type != NULL)
{
@@ -12478,7 +12478,7 @@
if (f == NULL)
{
type = CTX_TM->
- create_named_type(qnameItem, TypeConstants::QUANT_QUESTION, loc);
+ create_named_type(qnameItem, SequenceType::QUANT_QUESTION, loc);
if (type == NULL ||
arity != 1 ||
@@ -12862,7 +12862,7 @@
for(; lIt != params->end(); ++lIt)
{
const Param* param = lIt->getp();
- const SequenceType* paramType = param->get_typedecl().getp();
+ const SequenceTypeAST* paramType = param->get_typedecl().getp();
if (paramType == NULL)
{
paramTypes.push_back(GENV_TYPESYSTEM.ITEM_TYPE_STAR);
@@ -14236,7 +14236,7 @@
********************************************************************************/
-void* begin_visit(const SequenceType& v)
+void* begin_visit(const SequenceTypeAST& v)
{
TRACE_VISIT();
@@ -14249,7 +14249,7 @@
return no_state;
}
-void end_visit(const SequenceType& v, void* /*visit_state*/)
+void end_visit(const SequenceTypeAST& v, void* /*visit_state*/)
{
TRACE_VISIT_OUT();
}
@@ -14259,22 +14259,22 @@
{
TRACE_VISIT();
- TypeConstants::quantifier_t q = TypeConstants::QUANT_STAR;
+ SequenceType::Quantifier q = SequenceType::QUANT_STAR;
switch(v.get_type())
{
case ParseConstants::occurs_exactly_one:
- q = TypeConstants::QUANT_ONE; break;
+ q = SequenceType::QUANT_ONE; break;
case ParseConstants::occurs_one_or_more:
- q = TypeConstants::QUANT_PLUS; break;
+ q = SequenceType::QUANT_PLUS; break;
case ParseConstants::occurs_optionally:
- q = TypeConstants::QUANT_QUESTION; break;
+ q = SequenceType::QUANT_QUESTION; break;
case ParseConstants::occurs_zero_or_more:
- q = TypeConstants::QUANT_STAR; break;
+ q = SequenceType::QUANT_STAR; break;
case ParseConstants::occurs_never:
ZORBA_ASSERT(false);
}
- if (q != TypeConstants::QUANT_ONE)
+ if (q != SequenceType::QUANT_ONE)
theTypeStack.push(CTX_TM->create_type(*pop_tstack(), q));
return no_state;
@@ -14303,7 +14303,7 @@
xqtref_t t = CTX_TM->create_named_simple_type(qnameItem);
if (t == NULL ||
- t->get_quantifier() != TypeConstants::QUANT_ONE)
+ t->get_quantifier() != SequenceType::QUANT_ONE)
{
RAISE_ERROR(err::XPST0051, loc,
ERROR_PARAMS(ZED(XPST0051_GenAtomic_2), qname->get_qname()));
@@ -14486,7 +14486,7 @@
xqtref_t docTest = CTX_TM->create_node_type(store::StoreConsts::documentNode,
NULL,
elementOrSchemaTest,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
theTypeStack.push(docTest);
@@ -14534,7 +14534,7 @@
if (typeName != NULL)
{
contentType = CTX_TM->create_named_type(typeNameItem,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc);
if (contentType == NULL)
@@ -14561,7 +14561,7 @@
xqtref_t seqmatch = CTX_TM->create_node_type(store::StoreConsts::elementNode,
elemNameItem,
contentType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
nillable,
false);
theTypeStack.push(seqmatch);
@@ -14603,7 +14603,7 @@
else
{
xqtref_t seqmatch = CTX_TM->create_schema_element_type(elemQNameItem,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc);
theTypeStack.push(seqmatch);
}
@@ -14653,7 +14653,7 @@
expand_elem_qname(typeNameItem, typeName->get_name(), typeName->get_location());
contentType = CTX_TM->create_named_type(typeNameItem,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc);
if (contentType == NULL)
@@ -14684,7 +14684,7 @@
xqtref_t seqmatch = CTX_TM->create_node_type(store::StoreConsts::attributeNode,
attrNameItem,
contentType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
@@ -14726,7 +14726,7 @@
else
{
xqtref_t seqmatch = CTX_TM->
- create_schema_attribute_type(attrQNameItem, TypeConstants::QUANT_ONE, loc);
+ create_schema_attribute_type(attrQNameItem, SequenceType::QUANT_ONE, loc);
theTypeStack.push(seqmatch);
}
@@ -14884,7 +14884,7 @@
xqtref_t t = GENV_TYPESYSTEM.create_node_type(store::StoreConsts::piNode,
qname,
NULL,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
theTypeStack.push(t);
@@ -14930,7 +14930,7 @@
{
TRACE_VISIT_OUT ();
const rchandle<TypeList>& lParamTypes = v.getArgumentTypes();
- const rchandle<SequenceType>& lRetType = v.getReturnType();
+ const rchandle<SequenceTypeAST>& lRetType = v.getReturnType();
std::vector<xqtref_t> lParamXQTypes;
xqtref_t lRetXQType;
@@ -14939,7 +14939,7 @@
{
for (int i = 0; i < (int)lParamTypes->size(); ++i)
{
- const SequenceType* lParamType = (*lParamTypes)[i];
+ const SequenceTypeAST* lParamType = (*lParamTypes)[i];
if (lParamType == 0)
{
@@ -14959,7 +14959,7 @@
lRetXQType = pop_tstack();
}
- TypeConstants::quantifier_t lQuant = TypeConstants::QUANT_ONE;
+ SequenceType::Quantifier lQuant = SequenceType::QUANT_ONE;
theTypeStack.push (GENV_TYPESYSTEM.create_function_type(
lParamXQTypes, lRetXQType, lQuant));
}
=== modified file 'src/functions/func_accessors_impl.cpp'
--- src/functions/func_accessors_impl.cpp 2013-02-07 17:24:36 +0000
+++ src/functions/func_accessors_impl.cpp 2013-06-13 19:26:32 +0000
@@ -76,7 +76,7 @@
if (TypeOps::is_subtype(tm, *argType, *RTM.ANY_ATOMIC_TYPE_STAR, loc))
return argType; // includes () case
- TypeConstants::quantifier_t q = argType->get_quantifier();
+ SequenceType::Quantifier q = argType->get_quantifier();
if (argType->type_kind() == XQType::NODE_TYPE_KIND)
{
@@ -103,7 +103,7 @@
{
const XQType* itemType = static_cast<const UserDefinedXQType*>(cType.getp())->
getListItemType();
- return tm->create_type(*itemType, TypeConstants::QUANT_STAR);
+ return tm->create_type(*itemType, SequenceType::QUANT_STAR);
}
else if (TypeOps::is_equal(tm, *cType, *RTM.UNTYPED_ATOMIC_TYPE_ONE))
{
=== modified file 'src/functions/func_booleans_impl.cpp'
--- src/functions/func_booleans_impl.cpp 2013-06-11 09:43:21 +0000
+++ src/functions/func_booleans_impl.cpp 2013-06-13 19:26:32 +0000
@@ -140,23 +140,23 @@
const QueryLoc& loc = caller->get_loc();
xqtref_t empty = GENV_TYPESYSTEM.EMPTY_TYPE;
- TypeConstants::quantifier_t quant = TypeConstants::QUANT_ONE;
+ SequenceType::Quantifier quant = SequenceType::QUANT_ONE;
for (int i = 0; i < 2; i++)
{
if (TypeOps::is_equal(tm, *empty, *caller->get_arg(i)->get_return_type(), loc))
return empty;
- TypeConstants::quantifier_t aq =
+ SequenceType::Quantifier aq =
caller->get_arg(i)->get_return_type()->get_quantifier();
- if (aq == TypeConstants::QUANT_QUESTION || aq == TypeConstants::QUANT_STAR)
+ if (aq == SequenceType::QUANT_QUESTION || aq == SequenceType::QUANT_STAR)
{
- quant = TypeConstants::QUANT_QUESTION;
+ quant = SequenceType::QUANT_QUESTION;
}
}
- return (quant == TypeConstants::QUANT_QUESTION ?
+ return (quant == SequenceType::QUANT_QUESTION ?
GENV_TYPESYSTEM.BOOLEAN_TYPE_QUESTION :
GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE);
}
=== modified file 'src/functions/func_fn_hof_functions_impl.cpp'
--- src/functions/func_fn_hof_functions_impl.cpp 2013-06-04 21:47:40 +0000
+++ src/functions/func_fn_hof_functions_impl.cpp 2013-06-13 19:26:32 +0000
@@ -150,7 +150,7 @@
xqtref_t hofParamType = GENV_TYPESYSTEM.create_function_type(
args,
GENV_TYPESYSTEM.ITEM_TYPE_STAR,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
DECL_WITH_KIND(sctx,
fn_for_each_3_0,
@@ -168,7 +168,7 @@
xqtref_t hofParamType = GENV_TYPESYSTEM.create_function_type(
args,
GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
DECL_WITH_KIND(sctx,
fn_filter,
@@ -187,7 +187,7 @@
xqtref_t hofParamType = GENV_TYPESYSTEM.create_function_type(
args,
GENV_TYPESYSTEM.ITEM_TYPE_STAR,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
DECL_WITH_KIND(sctx,
fn_for_each_pair_3_0,
@@ -208,7 +208,7 @@
hofParamType = GENV_TYPESYSTEM.create_function_type(
args,
GENV_TYPESYSTEM.ITEM_TYPE_STAR,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
DECL_WITH_KIND(sctx,
fn_fold_left_3_0,
@@ -225,7 +225,7 @@
hofParamType = GENV_TYPESYSTEM.create_function_type(
args,
GENV_TYPESYSTEM.ITEM_TYPE_STAR,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
DECL_WITH_KIND(sctx,
fn_fold_right_3_0,
=== modified file 'src/functions/func_ft_module_impl.cpp'
--- src/functions/func_ft_module_impl.cpp 2013-02-07 17:24:36 +0000
+++ src/functions/func_ft_module_impl.cpp 2013-06-13 19:26:32 +0000
@@ -80,7 +80,7 @@
GENV_TYPESYSTEM.create_node_type(store::StoreConsts::elementNode,
createQName(FT_MODULE_NS, "", "compare-options"),
NULL,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
{
@@ -95,7 +95,7 @@
GENV_TYPESYSTEM.create_node_type(store::StoreConsts::elementNode,
createQName(FT_MODULE_NS, "", "token"),
NULL,
- TypeConstants::QUANT_STAR,
+ SequenceType::QUANT_STAR,
false,
false);
{
@@ -139,7 +139,7 @@
GENV_TYPESYSTEM.create_node_type(store::StoreConsts::elementNode,
createQName(FT_MODULE_NS, "", "tokenizer-properties"),
NULL,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false);
{
=== modified file 'src/functions/func_jsoniq_functions_impl.cpp'
--- src/functions/func_jsoniq_functions_impl.cpp 2013-06-08 05:33:57 +0000
+++ src/functions/func_jsoniq_functions_impl.cpp 2013-06-13 19:26:32 +0000
@@ -149,7 +149,7 @@
{
xqtref_t type = fo->get_arg(0)->get_return_type();
- if (type->get_quantifier() == TypeConstants::QUANT_ONE)
+ if (type->get_quantifier() == SequenceType::QUANT_ONE)
return type;
if (type->max_card() == 0)
=== modified file 'src/functions/func_numerics_impl.cpp'
--- src/functions/func_numerics_impl.cpp 2013-02-07 17:24:36 +0000
+++ src/functions/func_numerics_impl.cpp 2013-06-13 19:26:32 +0000
@@ -731,29 +731,29 @@
const QueryLoc& loc = caller->get_loc();
const XQType& argType = *(caller->get_arg(0)->get_return_type());
- TypeConstants::quantifier_t quant = argType.get_quantifier();
+ SequenceType::Quantifier quant = argType.get_quantifier();
if (TypeOps::is_subtype(tm, argType, *rtm.DOUBLE_TYPE_QUESTION, loc))
{
- return (quant == TypeConstants::QUANT_ONE ?
+ return (quant == SequenceType::QUANT_ONE ?
rtm.DOUBLE_TYPE_ONE :
rtm.DOUBLE_TYPE_QUESTION);
}
else if (TypeOps::is_subtype(tm, argType, *rtm.FLOAT_TYPE_QUESTION, loc))
{
- return (quant == TypeConstants::QUANT_ONE ?
+ return (quant == SequenceType::QUANT_ONE ?
rtm.FLOAT_TYPE_ONE :
rtm.FLOAT_TYPE_QUESTION);
}
else if (TypeOps::is_subtype(tm, argType, *rtm.INTEGER_TYPE_QUESTION, loc))
{
- return (quant == TypeConstants::QUANT_ONE ?
+ return (quant == SequenceType::QUANT_ONE ?
rtm.INTEGER_TYPE_ONE :
rtm.INTEGER_TYPE_QUESTION);
}
else if (TypeOps::is_subtype(tm, argType, *rtm.DECIMAL_TYPE_QUESTION, loc))
{
- return (quant == TypeConstants::QUANT_ONE ?
+ return (quant == SequenceType::QUANT_ONE ?
rtm.DECIMAL_TYPE_ONE :
rtm.DECIMAL_TYPE_QUESTION);
}
=== modified file 'src/functions/func_parse_fragment_impl.cpp'
--- src/functions/func_parse_fragment_impl.cpp 2012-11-22 21:06:39 +0000
+++ src/functions/func_parse_fragment_impl.cpp 2013-06-13 19:26:32 +0000
@@ -42,7 +42,7 @@
store::StoreConsts::elementNode,
createQName("http://www.zorba-xquery.com/modules/xml-options","","options";),
NULL,
- TypeConstants::QUANT_QUESTION,
+ SequenceType::QUANT_QUESTION,
false,
false
);
=== modified file 'src/functions/func_sequences_impl.cpp'
--- src/functions/func_sequences_impl.cpp 2013-05-14 05:21:11 +0000
+++ src/functions/func_sequences_impl.cpp 2013-06-13 19:26:32 +0000
@@ -320,15 +320,15 @@
else
{
xqtref_t t = caller->get_arg(0)->get_return_type();
- TypeConstants::quantifier_t q = TypeConstants::QUANT_STAR;
+ SequenceType::Quantifier q = SequenceType::QUANT_STAR;
for (csize i = 1; i < sz; i++)
{
t = TypeOps::union_type(*t, *caller->get_arg(i)->get_return_type(), tm);
- TypeConstants::quantifier_t pq = t->get_quantifier();
+ SequenceType::Quantifier pq = t->get_quantifier();
- if (pq == TypeConstants::QUANT_ONE || pq == TypeConstants::QUANT_PLUS)
- q = TypeConstants::QUANT_PLUS;
+ if (pq == SequenceType::QUANT_ONE || pq == SequenceType::QUANT_PLUS)
+ q = SequenceType::QUANT_PLUS;
}
return tm->create_type_x_quant(*t, q);
@@ -452,7 +452,7 @@
TypeManager* tm = caller->get_type_manager();
return tm->create_type_x_quant(*caller->get_arg(0)->get_return_type(),
- TypeConstants::QUANT_QUESTION);
+ SequenceType::QUANT_QUESTION);
}
@@ -560,10 +560,10 @@
store::Item* len = static_cast<const_expr*>(caller->get_arg(2))->get_val();
if (len->getDoubleValue().round().getNumber() == 1)
- return tm->create_type(*argType, TypeConstants::QUANT_QUESTION);
+ return tm->create_type(*argType, SequenceType::QUANT_QUESTION);
}
- return tm->create_type_x_quant(*argType, TypeConstants::QUANT_QUESTION);
+ return tm->create_type_x_quant(*argType, SequenceType::QUANT_QUESTION);
}
@@ -656,10 +656,10 @@
store::Item* len = static_cast<const_expr*>(caller->get_arg(2))->get_val();
if (len->getIntegerValue() == Integer(1))
- return tm->create_type(*argType, TypeConstants::QUANT_QUESTION);
+ return tm->create_type(*argType, SequenceType::QUANT_QUESTION);
}
- return tm->create_type_x_quant(*argType, TypeConstants::QUANT_QUESTION);
+ return tm->create_type_x_quant(*argType, SequenceType::QUANT_QUESTION);
}
@@ -767,7 +767,7 @@
TypeManager* tm = caller->get_type_manager();
return tm->create_type(*caller->get_arg(0)->get_return_type(),
- TypeConstants::QUANT_QUESTION);
+ SequenceType::QUANT_QUESTION);
}
@@ -887,7 +887,7 @@
xqtref_t srcType = caller->get_arg(0)->get_return_type();
return tm->create_type(*TypeOps::prime_type(tm, *srcType),
- TypeConstants::QUANT_QUESTION);
+ SequenceType::QUANT_QUESTION);
}
@@ -920,7 +920,7 @@
return tm->create_type(
*TypeOps::prime_type(tm, *(caller->get_arg(0)->get_return_type())),
- TypeConstants::QUANT_PLUS);
+ SequenceType::QUANT_PLUS);
}
=== modified file 'src/functions/func_strings_impl.cpp'
--- src/functions/func_strings_impl.cpp 2013-02-07 17:24:36 +0000
+++ src/functions/func_strings_impl.cpp 2013-06-13 19:26:32 +0000
@@ -72,7 +72,7 @@
store::StoreConsts::elementNode,
createQName("http://www.w3.org/2005/xpath-functions","","analyze-string-result";),
NULL,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
false,
false
);
=== modified file 'src/functions/function.cpp'
--- src/functions/function.cpp 2013-04-15 13:52:08 +0000
+++ src/functions/function.cpp 2013-06-13 19:26:32 +0000
@@ -218,8 +218,8 @@
{
if (!theSignature.isVariadic() &&
theSignature.paramCount() > 0 &&
- (theSignature[input]->get_quantifier() == TypeConstants::QUANT_ONE ||
- theSignature[input]->get_quantifier() == TypeConstants::QUANT_QUESTION))
+ (theSignature[input]->get_quantifier() == SequenceType::QUANT_ONE ||
+ theSignature[input]->get_quantifier() == SequenceType::QUANT_QUESTION))
return true;
return false;
=== modified file 'src/runtime/core/arithmetic_impl.cpp'
--- src/runtime/core/arithmetic_impl.cpp 2013-06-11 05:40:04 +0000
+++ src/runtime/core/arithmetic_impl.cpp 2013-06-13 19:26:32 +0000
@@ -75,8 +75,8 @@
store::SchemaTypeCode aType0,
store::SchemaTypeCode aType1)
{
- xqtref_t t0 = tm->create_builtin_atomic_type(aType0,TypeConstants::QUANT_ONE);
- xqtref_t t1 = tm->create_builtin_atomic_type(aType1,TypeConstants::QUANT_ONE);
+ xqtref_t t0 = tm->create_builtin_atomic_type(aType0,SequenceType::QUANT_ONE);
+ xqtref_t t1 = tm->create_builtin_atomic_type(aType1,SequenceType::QUANT_ONE);
RAISE_ERROR(err::XPTY0004, aLoc,
ERROR_PARAMS(ZED(OperationNotPossibleWithTypes_234), aOp, *t0, *t1 ));
=== modified file 'src/runtime/core/path_iterators.cpp'
--- src/runtime/core/path_iterators.cpp 2013-05-17 18:53:05 +0000
+++ src/runtime/core/path_iterators.cpp 2013-06-13 19:26:32 +0000
@@ -309,7 +309,7 @@
if (theType != NULL)
{
xqtref_t atype = sctx->get_typemanager()->
- create_named_type(node->getType(), TypeConstants::QUANT_ONE, loc);
+ create_named_type(node->getType(), SequenceType::QUANT_ONE, loc);
if ((!TypeOps::is_subtype(sctx->get_typemanager(), *atype, *theType)) ||
(theNilledAllowed == false &&
@@ -334,7 +334,7 @@
return false;
xqtref_t atype = sctx->get_typemanager()->
- create_named_type(node->getType(), TypeConstants::QUANT_ONE, loc);
+ create_named_type(node->getType(), SequenceType::QUANT_ONE, loc);
if ((!TypeOps::is_subtype(sctx->get_typemanager(), *atype, *theType)) ||
(theNilledAllowed == false &&
@@ -354,7 +354,7 @@
if (theType != NULL)
{
xqtref_t atype = sctx->get_typemanager()->
- create_named_type(node->getType(), TypeConstants::QUANT_ONE, loc);
+ create_named_type(node->getType(), SequenceType::QUANT_ONE, loc);
if (! TypeOps::is_subtype(sctx->get_typemanager(), *atype, *theType))
return false;
@@ -371,7 +371,7 @@
return false;
xqtref_t atype = sctx->get_typemanager()->
- create_named_type(node->getType(), TypeConstants::QUANT_ONE, loc);
+ create_named_type(node->getType(), SequenceType::QUANT_ONE, loc);
if (! TypeOps::is_subtype(sctx->get_typemanager(), *atype, *theType))
return false;
=== modified file 'src/runtime/core/sequencetypes.cpp'
--- src/runtime/core/sequencetypes.cpp 2013-05-02 00:18:56 +0000
+++ src/runtime/core/sequencetypes.cpp 2013-06-13 19:26:32 +0000
@@ -82,7 +82,7 @@
bool InstanceOfIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
store::Item_t item;
- TypeConstants::quantifier_t quant;
+ SequenceType::Quantifier quant;
bool res = false;
store::Item_t temp;
const TypeManager* tm = theSctx->get_typemanager();
@@ -106,7 +106,7 @@
{
if (consumeNext(item, theChild.getp(), planState))
{
- if (quant == TypeConstants::QUANT_PLUS || quant == TypeConstants::QUANT_STAR)
+ if (quant == SequenceType::QUANT_PLUS || quant == SequenceType::QUANT_STAR)
{
res = true;
do
@@ -140,7 +140,7 @@
{
if (consumeNext(item, theChild.getp(), planState))
{
- if (quant == TypeConstants::QUANT_PLUS || quant == TypeConstants::QUANT_STAR)
+ if (quant == SequenceType::QUANT_PLUS || quant == SequenceType::QUANT_STAR)
{
res = true;
do
@@ -163,7 +163,7 @@
}
else
{
- res = !(quant == TypeConstants::QUANT_ONE || quant == TypeConstants::QUANT_PLUS);
+ res = !(quant == SequenceType::QUANT_ONE || quant == SequenceType::QUANT_PLUS);
}
STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, res), state);
@@ -396,7 +396,7 @@
(UnaryBaseIterator<PromoteIterator, PlanIteratorState>*)this);
ar & thePromoteType;
- SERIALIZE_ENUM(TypeConstants::quantifier_t, theQuantifier);
+ SERIALIZE_ENUM(SequenceType::Quantifier, theQuantifier);
SERIALIZE_ENUM(PromoteErrorKind, theErrorKind);
ar & theQName;
@@ -416,14 +416,14 @@
if (!consumeNext(item, theChild.getp(), planState))
{
- if (theQuantifier == TypeConstants::QUANT_PLUS ||
- theQuantifier == TypeConstants::QUANT_ONE)
+ if (theQuantifier == SequenceType::QUANT_PLUS ||
+ theQuantifier == SequenceType::QUANT_ONE)
{
raiseError("empty-sequence()");
}
}
- else if (theQuantifier == TypeConstants::QUANT_QUESTION ||
- theQuantifier == TypeConstants::QUANT_ONE)
+ else if (theQuantifier == SequenceType::QUANT_QUESTION ||
+ theQuantifier == SequenceType::QUANT_ONE)
{
if (consumeNext(temp, theChild.getp(), planState))
{
@@ -465,7 +465,7 @@
zstring targetType;
if (thePromoteType->type_kind() == XQType::NONE_KIND &&
- theQuantifier == TypeConstants::QUANT_QUESTION)
+ theQuantifier == SequenceType::QUANT_QUESTION)
{
targetType = "empty-sequence()";
}
@@ -473,11 +473,11 @@
{
targetType = thePromoteType->toSchemaString();
- if (theQuantifier == TypeConstants::QUANT_PLUS)
+ if (theQuantifier == SequenceType::QUANT_PLUS)
targetType += "+";
- else if (theQuantifier == TypeConstants::QUANT_STAR)
+ else if (theQuantifier == SequenceType::QUANT_STAR)
targetType += "*";
- else if (theQuantifier == TypeConstants::QUANT_QUESTION)
+ else if (theQuantifier == SequenceType::QUANT_QUESTION)
targetType += "?";
}
@@ -583,7 +583,7 @@
(UnaryBaseIterator<TreatIterator, PlanIteratorState>*)this);
ar & theTreatType;
- SERIALIZE_ENUM(TypeConstants::quantifier_t, theQuantifier);
+ SERIALIZE_ENUM(SequenceType::Quantifier, theQuantifier);
ar & theCheckPrime;
SERIALIZE_ENUM(TreatErrorKind, theErrorKind);
ar & theQName;
@@ -601,14 +601,14 @@
if (!consumeNext(result, theChild.getp(), planState))
{
- if (theQuantifier == TypeConstants::QUANT_PLUS ||
- theQuantifier == TypeConstants::QUANT_ONE)
+ if (theQuantifier == SequenceType::QUANT_PLUS ||
+ theQuantifier == SequenceType::QUANT_ONE)
{
raiseError("empty-sequence()");
}
}
- else if (theQuantifier == TypeConstants::QUANT_QUESTION ||
- theQuantifier == TypeConstants::QUANT_ONE)
+ else if (theQuantifier == SequenceType::QUANT_QUESTION ||
+ theQuantifier == SequenceType::QUANT_ONE)
{
if (consumeNext(temp, theChild.getp(), planState))
{
@@ -683,7 +683,7 @@
zstring targetType;
if (theTreatType->type_kind() == XQType::NONE_KIND &&
- theQuantifier == TypeConstants::QUANT_QUESTION)
+ theQuantifier == SequenceType::QUANT_QUESTION)
{
targetType = "empty-sequence()";
}
@@ -691,11 +691,11 @@
{
targetType = theTreatType->toSchemaString();
- if (theQuantifier == TypeConstants::QUANT_PLUS)
+ if (theQuantifier == SequenceType::QUANT_PLUS)
targetType += "+";
- else if (theQuantifier == TypeConstants::QUANT_STAR)
+ else if (theQuantifier == SequenceType::QUANT_STAR)
targetType += "*";
- else if (theQuantifier == TypeConstants::QUANT_QUESTION)
+ else if (theQuantifier == SequenceType::QUANT_QUESTION)
targetType += "?";
}
=== modified file 'src/runtime/core/sequencetypes.h'
--- src/runtime/core/sequencetypes.h 2013-05-02 00:18:56 +0000
+++ src/runtime/core/sequencetypes.h 2013-06-13 19:26:32 +0000
@@ -17,6 +17,8 @@
#ifndef ZORBA_RUNTIME_SEQUENCETYPES
#define ZORBA_RUNTIME_SEQUENCETYPES
+#include <zorba/typeident.h>
+
#include "common/shared_types.h"
#include "runtime/base/unarybase.h"
@@ -164,11 +166,11 @@
friend class PrinterVisitor;
private:
- xqtref_t thePromoteType;
- TypeConstants::quantifier_t theQuantifier;
- PromoteErrorKind theErrorKind;
- store::Item_t theQName;
- namespace_context theNsCtx;
+ xqtref_t thePromoteType;
+ SequenceType::Quantifier theQuantifier;
+ PromoteErrorKind theErrorKind;
+ store::Item_t theQName;
+ namespace_context theNsCtx;
public:
SERIALIZABLE_CLASS(PromoteIterator);
@@ -213,11 +215,11 @@
friend class PrinterVisitor;
private:
- xqtref_t theTreatType;
- TypeConstants::quantifier_t theQuantifier;
- bool theCheckPrime;
- TreatErrorKind theErrorKind;
- store::Item_t theQName;
+ xqtref_t theTreatType;
+ SequenceType::Quantifier theQuantifier;
+ bool theCheckPrime;
+ TreatErrorKind theErrorKind;
+ store::Item_t theQName;
public:
SERIALIZABLE_CLASS(TreatIterator);
=== modified file 'src/runtime/indexing/index_ddl.cpp'
--- src/runtime/indexing/index_ddl.cpp 2013-06-11 05:40:04 +0000
+++ src/runtime/indexing/index_ddl.cpp 2013-06-13 19:26:32 +0000
@@ -1626,7 +1626,7 @@
xqtref_t keyType = indexDecl->getKeyTypes()[0];
assert(keyType == NULL ||
- keyType->get_quantifier() == TypeConstants::QUANT_ONE);
+ keyType->get_quantifier() == SequenceType::QUANT_ONE);
if (keyType != NULL &&
!TypeOps::is_subtype(tm, *keyType, *GENV_TYPESYSTEM.UNTYPED_ATOMIC_TYPE_ONE) &&
=== modified file 'src/runtime/json/jsoniq_functions_impl.cpp'
--- src/runtime/json/jsoniq_functions_impl.cpp 2013-06-08 05:33:57 +0000
+++ src/runtime/json/jsoniq_functions_impl.cpp 2013-06-13 19:26:32 +0000
@@ -307,7 +307,7 @@
{
TypeManager* lTypeMgr = theSctx->get_typemanager();
xqtref_t lTargetType = lTypeMgr->create_named_type(
- lTypeQName.getp(), TypeConstants::QUANT_ONE, loc);
+ lTypeQName.getp(), SequenceType::QUANT_ONE, loc);
namespace_context lTmpNsCtx(theSctx);
GenericCast::castToAtomic(aResult,
lValueValueItem,
=== modified file 'src/runtime/sequences/sequences_impl.cpp'
--- src/runtime/sequences/sequences_impl.cpp 2013-06-11 23:38:49 +0000
+++ src/runtime/sequences/sequences_impl.cpp 2013-06-13 19:26:32 +0000
@@ -1018,10 +1018,10 @@
TypeManager* tm = sctx->get_typemanager();
xqtref_t type1 =
- tm->create_named_type(typename1, TypeConstants::QUANT_ONE, loc, true);
+ tm->create_named_type(typename1, SequenceType::QUANT_ONE, loc, true);
xqtref_t type2 =
- tm->create_named_type(typename2, TypeConstants::QUANT_ONE, loc, true);
+ tm->create_named_type(typename2, SequenceType::QUANT_ONE, loc, true);
ZORBA_ASSERT(type1->isComplex() && type2->isComplex());
=== modified file 'src/runtime/store/maps_impl.cpp'
--- src/runtime/store/maps_impl.cpp 2013-06-11 05:40:04 +0000
+++ src/runtime/store/maps_impl.cpp 2013-06-13 19:26:32 +0000
@@ -59,7 +59,7 @@
{
xqtref_t searchKeyType = GENV_TYPESYSTEM.create_value_type(aKeyItem);
xqtref_t indexKeyType = GENV_TYPESYSTEM.create_named_type(
- aKeyType.getp(), TypeConstants::QUANT_ONE, loc);
+ aKeyType.getp(), SequenceType::QUANT_ONE, loc);
if ( indexKeyType != NULL )
{
@@ -111,7 +111,7 @@
{
lAnyAtomicType = GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_ONE;
lIndexKeyType = GENV_TYPESYSTEM.create_named_type(
- aTypes[i].getp(), TypeConstants::QUANT_ONE, aLoc);
+ aTypes[i].getp(), SequenceType::QUANT_ONE, aLoc);
if (lIndexKeyType != NULL &&
!TypeOps::is_subtype(&GENV_TYPESYSTEM,
=== modified file 'src/types/casting.cpp'
--- src/types/casting.cpp 2013-05-28 16:07:14 +0000
+++ src/types/casting.cpp 2013-06-13 19:26:32 +0000
@@ -54,7 +54,7 @@
#define ATOMIC_TYPE(type) \
- GENV_TYPESYSTEM.create_atomic_type(store::XS_##type, TypeConstants::QUANT_ONE)
+ GENV_TYPESYSTEM.create_atomic_type(store::XS_##type, SequenceType::QUANT_ONE)
struct ErrorInfo
@@ -105,11 +105,11 @@
xqtref_t sourceType =
tm.create_builtin_atomic_type(info.theSourceTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
xqtref_t targetType =
tm.create_builtin_atomic_type(info.theTargetTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
RAISE_ERROR(err::XPTY0004, info.theLoc,
ERROR_PARAMS(*sourceType, ZED(NoCastTo_34o), *targetType));
@@ -133,11 +133,11 @@
xqtref_t sourceType =
tm.create_builtin_atomic_type(info.theSourceTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
xqtref_t targetType =
tm.create_builtin_atomic_type(info.theTargetTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
RAISE_ERROR(err::FOCA0002, info.theLoc,
ERROR_PARAMS(ZED(FOCA0002_NoCastTo_234),
@@ -168,11 +168,11 @@
xqtref_t sourceType =
tm.create_builtin_atomic_type(info.theSourceTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
xqtref_t targetType =
tm.create_builtin_atomic_type(info.theTargetTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
throw XQUERY_EXCEPTION(
err::FOCA0003,
@@ -203,11 +203,11 @@
xqtref_t sourceType =
tm.create_builtin_atomic_type(info.theSourceTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
xqtref_t targetType =
tm.create_builtin_atomic_type(info.theTargetTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
RAISE_ERROR(err::FORG0001, info.theLoc,
ERROR_PARAMS(ZED(FORG0001_NoCastTo_234),
@@ -233,11 +233,11 @@
xqtref_t sourceType =
tm.create_builtin_atomic_type(info.theSourceTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
xqtref_t targetType =
tm.create_builtin_atomic_type(info.theTargetTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
RAISE_ERROR(err::FODT0001, info.theLoc,
ERROR_PARAMS(ZED(FORG0001_NoCastTo_234),
@@ -264,11 +264,11 @@
xqtref_t sourceType =
tm.create_builtin_atomic_type(info.theSourceTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
xqtref_t targetType =
tm.create_builtin_atomic_type(info.theTargetTypeCode,
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
RAISE_ERROR(err::FODT0002, info.theLoc,
ERROR_PARAMS(ZED(FORG0001_NoCastTo_234),
@@ -2705,7 +2705,7 @@
RootTypeManager& rtm = GENV_TYPESYSTEM;
xqtref_t sourceType = tm->create_named_type(item->getType(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc,
true);
@@ -3025,7 +3025,7 @@
#endif // ZORBA_NO_XMLSCHEMA
xqtref_t lSourceType = tm->create_named_type(aItem->getType(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
QueryLoc::null,
true);
=== modified file 'src/types/root_typemanager.cpp'
--- src/types/root_typemanager.cpp 2013-04-11 22:29:26 +0000
+++ src/types/root_typemanager.cpp 2013-06-13 19:26:32 +0000
@@ -17,7 +17,6 @@
#include <assert.h>
-#include <zorba/identtypes.h>
#include <zorba/typeident.h>
#include "store/api/item_factory.h"
@@ -167,10 +166,10 @@
#undef T
#undef F
-#define Q( q ) TypeConstants::QUANT_##q
-
-
-const TypeConstants::quantifier_t RootTypeManager::QUANT_UNION_MATRIX[4][4] =
+#define Q( q ) SequenceType::QUANT_##q
+
+
+const SequenceType::Quantifier RootTypeManager::QUANT_UNION_MATRIX[4][4] =
{
// ONE QUESTION STAR PLUS
{ Q(ONE), Q(QUESTION), Q(STAR), Q(PLUS) }, // ONE
@@ -180,7 +179,7 @@
};
-const TypeConstants::quantifier_t RootTypeManager::QUANT_INTERS_MATRIX[4][4] =
+const SequenceType::Quantifier RootTypeManager::QUANT_INTERS_MATRIX[4][4] =
{
// ONE QUESTION STAR PLUS
{ Q(ONE), Q(ONE), Q(ONE), Q(ONE) }, // ONE
@@ -221,15 +220,15 @@
EMPTY_TYPE = new EmptyXQType(this, true);
- ITEM_TYPE_ONE = new ItemXQType(this, TypeConstants::QUANT_ONE, true);
- ITEM_TYPE_QUESTION = new ItemXQType(this, TypeConstants::QUANT_QUESTION, true);
- ITEM_TYPE_STAR = new ItemXQType(this, TypeConstants::QUANT_STAR, true);
- ITEM_TYPE_PLUS = new ItemXQType(this, TypeConstants::QUANT_PLUS, true);
+ ITEM_TYPE_ONE = new ItemXQType(this, SequenceType::QUANT_ONE, true);
+ ITEM_TYPE_QUESTION = new ItemXQType(this, SequenceType::QUANT_QUESTION, true);
+ ITEM_TYPE_STAR = new ItemXQType(this, SequenceType::QUANT_STAR, true);
+ ITEM_TYPE_PLUS = new ItemXQType(this, SequenceType::QUANT_PLUS, true);
- ANY_FUNCTION_TYPE_ONE = new AnyFunctionXQType(this, TypeConstants::QUANT_ONE, true);
- ANY_FUNCTION_TYPE_QUESTION = new AnyFunctionXQType(this, TypeConstants::QUANT_QUESTION, true);
- ANY_FUNCTION_TYPE_STAR = new AnyFunctionXQType(this, TypeConstants::QUANT_STAR, true);
- ANY_FUNCTION_TYPE_PLUS = new AnyFunctionXQType(this, TypeConstants::QUANT_PLUS, true);
+ ANY_FUNCTION_TYPE_ONE = new AnyFunctionXQType(this, SequenceType::QUANT_ONE, true);
+ ANY_FUNCTION_TYPE_QUESTION = new AnyFunctionXQType(this, SequenceType::QUANT_QUESTION, true);
+ ANY_FUNCTION_TYPE_STAR = new AnyFunctionXQType(this, SequenceType::QUANT_STAR, true);
+ ANY_FUNCTION_TYPE_PLUS = new AnyFunctionXQType(this, SequenceType::QUANT_PLUS, true);
#define XSQNDECL(var, local) \
GENV.getStore().getItemFactory()-> \
@@ -301,22 +300,22 @@
#define ATOMIC_TYPE_DEFN(tname) \
tname##_TYPE_ONE = new AtomicXQType(this, \
store::XS_##tname, \
- TypeConstants::QUANT_ONE, \
+ SequenceType::QUANT_ONE, \
true); \
\
tname##_TYPE_QUESTION = new AtomicXQType(this, \
store::XS_##tname, \
- TypeConstants::QUANT_QUESTION, \
+ SequenceType::QUANT_QUESTION, \
true); \
\
tname##_TYPE_STAR = new AtomicXQType(this, \
store::XS_##tname, \
- TypeConstants::QUANT_STAR, \
+ SequenceType::QUANT_STAR, \
true); \
\
tname##_TYPE_PLUS = new AtomicXQType(this, \
store::XS_##tname, \
- TypeConstants::QUANT_PLUS, \
+ SequenceType::QUANT_PLUS, \
true); \
\
m_atomic_typecode_qname_map[store::XS_##tname] = XS_##tname##_QNAME; \
@@ -325,16 +324,16 @@
tempCode = store::XS_##tname; \
m_atomic_qnametype_map.insert(tempQN, tempCode); \
\
- m_atomic_typecode_map[store::XS_##tname][TypeConstants::QUANT_ONE] = \
+ m_atomic_typecode_map[store::XS_##tname][SequenceType::QUANT_ONE] = \
&tname##_TYPE_ONE; \
\
- m_atomic_typecode_map[store::XS_##tname][TypeConstants::QUANT_QUESTION] = \
+ m_atomic_typecode_map[store::XS_##tname][SequenceType::QUANT_QUESTION] = \
&tname##_TYPE_QUESTION; \
\
- m_atomic_typecode_map[store::XS_##tname][TypeConstants::QUANT_STAR] = \
+ m_atomic_typecode_map[store::XS_##tname][SequenceType::QUANT_STAR] = \
&tname##_TYPE_STAR; \
\
- m_atomic_typecode_map[store::XS_##tname][TypeConstants::QUANT_PLUS] = \
+ m_atomic_typecode_map[store::XS_##tname][SequenceType::QUANT_PLUS] = \
&tname##_TYPE_PLUS;
ATOMIC_TYPE_DEFN(ANY_ATOMIC)
@@ -407,36 +406,36 @@
true);
STRUCTURED_ITEM_TYPE_ONE =
- new StructuredItemXQType(this, TypeConstants::QUANT_ONE, true);
+ new StructuredItemXQType(this, SequenceType::QUANT_ONE, true);
STRUCTURED_ITEM_TYPE_QUESTION =
- new StructuredItemXQType(this, TypeConstants::QUANT_QUESTION, true);
+ new StructuredItemXQType(this, SequenceType::QUANT_QUESTION, true);
STRUCTURED_ITEM_TYPE_STAR =
- new StructuredItemXQType(this, TypeConstants::QUANT_STAR, true);
+ new StructuredItemXQType(this, SequenceType::QUANT_STAR, true);
STRUCTURED_ITEM_TYPE_PLUS =
- new StructuredItemXQType(this, TypeConstants::QUANT_PLUS, true);
+ new StructuredItemXQType(this, SequenceType::QUANT_PLUS, true);
#ifdef ZORBA_WITH_JSON
JS_NULL_TYPE_ONE = new AtomicXQType(this,
store::JS_NULL,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
true);
JS_NULL_TYPE_QUESTION = new AtomicXQType(this,
store::JS_NULL,
- TypeConstants::QUANT_QUESTION,
+ SequenceType::QUANT_QUESTION,
true);
JS_NULL_TYPE_STAR = new AtomicXQType(this,
store::JS_NULL,
- TypeConstants::QUANT_STAR,
+ SequenceType::QUANT_STAR,
true);
JS_NULL_TYPE_PLUS = new AtomicXQType(this,
store::JS_NULL,
- TypeConstants::QUANT_PLUS,
+ SequenceType::QUANT_PLUS,
true);
m_atomic_typecode_qname_map[store::JS_NULL] = JS_NULL_QNAME;
@@ -445,43 +444,43 @@
tempCode = store::JS_NULL;
m_atomic_qnametype_map.insert(tempQN, tempCode);
- m_atomic_typecode_map[store::JS_NULL][TypeConstants::QUANT_ONE] =
+ m_atomic_typecode_map[store::JS_NULL][SequenceType::QUANT_ONE] =
&JS_NULL_TYPE_ONE;
- m_atomic_typecode_map[store::JS_NULL][TypeConstants::QUANT_QUESTION] =
+ m_atomic_typecode_map[store::JS_NULL][SequenceType::QUANT_QUESTION] =
&JS_NULL_TYPE_QUESTION;
- m_atomic_typecode_map[store::JS_NULL][TypeConstants::QUANT_STAR] =
+ m_atomic_typecode_map[store::JS_NULL][SequenceType::QUANT_STAR] =
&JS_NULL_TYPE_STAR;
- m_atomic_typecode_map[store::JS_NULL][TypeConstants::QUANT_PLUS] =
+ m_atomic_typecode_map[store::JS_NULL][SequenceType::QUANT_PLUS] =
&JS_NULL_TYPE_PLUS;
#define JSON_TYPE_DEFN(basename, kind) \
basename##_TYPE_ONE = new JSONXQType(this, \
kind, \
- TypeConstants::QUANT_ONE, \
+ SequenceType::QUANT_ONE, \
true); \
\
basename##_TYPE_QUESTION = new JSONXQType(this, \
kind, \
- TypeConstants::QUANT_QUESTION, \
+ SequenceType::QUANT_QUESTION, \
true); \
\
basename##_TYPE_STAR = new JSONXQType(this, \
kind, \
- TypeConstants::QUANT_STAR, \
+ SequenceType::QUANT_STAR, \
true); \
\
basename##_TYPE_PLUS = new JSONXQType(this, \
kind, \
- TypeConstants::QUANT_PLUS, \
+ SequenceType::QUANT_PLUS, \
true); \
\
- JSON_TYPES_MAP[kind][TypeConstants::QUANT_ONE] = basename##_TYPE_ONE.getp(); \
- JSON_TYPES_MAP[kind][TypeConstants::QUANT_QUESTION] = basename##_TYPE_QUESTION.getp(); \
- JSON_TYPES_MAP[kind][TypeConstants::QUANT_PLUS] = basename##_TYPE_STAR.getp(); \
- JSON_TYPES_MAP[kind][TypeConstants::QUANT_STAR] = basename##_TYPE_STAR.getp();
+ JSON_TYPES_MAP[kind][SequenceType::QUANT_ONE] = basename##_TYPE_ONE.getp(); \
+ JSON_TYPES_MAP[kind][SequenceType::QUANT_QUESTION] = basename##_TYPE_QUESTION.getp(); \
+ JSON_TYPES_MAP[kind][SequenceType::QUANT_PLUS] = basename##_TYPE_STAR.getp(); \
+ JSON_TYPES_MAP[kind][SequenceType::QUANT_STAR] = basename##_TYPE_STAR.getp();
JSON_TYPE_DEFN(JSON_ITEM, store::StoreConsts::jsonItem);
JSON_TYPE_DEFN(JSON_OBJECT, store::StoreConsts::jsonObject);
@@ -497,7 +496,7 @@
nodeKind, \
nullNodeName, \
contentType, \
- TypeConstants::QUANT_ONE, \
+ SequenceType::QUANT_ONE, \
false, \
false, \
true); \
@@ -506,7 +505,7 @@
nodeKind, \
nullNodeName, \
contentType, \
- TypeConstants::QUANT_QUESTION, \
+ SequenceType::QUANT_QUESTION, \
false, \
false, \
true); \
@@ -515,7 +514,7 @@
nodeKind, \
nullNodeName, \
contentType, \
- TypeConstants::QUANT_STAR, \
+ SequenceType::QUANT_STAR, \
false, \
false, \
true); \
@@ -524,7 +523,7 @@
nodeKind, \
nullNodeName, \
contentType, \
- TypeConstants::QUANT_PLUS, \
+ SequenceType::QUANT_PLUS, \
false, \
false, \
true)
=== modified file 'src/types/root_typemanager.h'
--- src/types/root_typemanager.h 2013-03-12 17:03:31 +0000
+++ src/types/root_typemanager.h 2013-06-13 19:26:32 +0000
@@ -149,7 +149,6 @@
xqtref_t STRUCTURED_ITEM_TYPE_STAR;
xqtref_t STRUCTURED_ITEM_TYPE_PLUS;
-#ifdef ZORBA_WITH_JSON
/**
* Pre-allocate XQType objects for the following JSONTest sequence types:
*
@@ -172,8 +171,6 @@
*/
static const XQType* JSON_TYPES_MAP[3][4];
-#endif // ZORBA_WITH_JSON
-
/**
* Pre-allocate XQType objects for the following KindTest sequence types:
*
@@ -243,7 +240,7 @@
* Maps each atomic type code and each quantifier code to a built-in XQType
* object for that built-in atomic type and quantifier.
*/
- xqtref_t* m_atomic_typecode_map[store::XS_LAST][TypeConstants::QUANTIFIER_LIST_SIZE];
+ xqtref_t* m_atomic_typecode_map[store::XS_LAST][SequenceType::QUANT_INVALID];
/**
* Maps the typecode of a built-in atomic type to its qname.
@@ -277,8 +274,8 @@
* Then, QUANT_SUBTYPE_MATRIX[q1][q2] is true iff S(q1) is a subset of S(q2).
*/
static const bool
- QUANT_SUBTYPE_MATRIX[TypeConstants::QUANTIFIER_LIST_SIZE]
- [TypeConstants::QUANTIFIER_LIST_SIZE];
+ QUANT_SUBTYPE_MATRIX[SequenceType::QUANT_INVALID]
+ [SequenceType::QUANT_INVALID];
/**
* Let IS be the inverse of the function S defined above. Then:
@@ -288,29 +285,29 @@
* In other words, q is the "minimum" quantifier that is equally or more
* permissive than both q1 and q2.
*/
- static const TypeConstants::quantifier_t
- QUANT_UNION_MATRIX[TypeConstants::QUANTIFIER_LIST_SIZE]
- [TypeConstants::QUANTIFIER_LIST_SIZE];
+ static const SequenceType::Quantifier
+ QUANT_UNION_MATRIX[SequenceType::QUANT_INVALID]
+ [SequenceType::QUANT_INVALID];
/**
* QUANT_INTERS_MATRIX[q1][q2] = q <==> q is IS(S(q1) intersect S(q2))
*/
- static const TypeConstants::quantifier_t
- QUANT_INTERS_MATRIX[TypeConstants::QUANTIFIER_LIST_SIZE]
- [TypeConstants::QUANTIFIER_LIST_SIZE];
+ static const SequenceType::Quantifier
+ QUANT_INTERS_MATRIX[SequenceType::QUANT_INVALID]
+ [SequenceType::QUANT_INVALID];
/**
* For each quatifier q, QUANT_MAX_CNT[q] gives the maximum number of items
* that can appear in an instance of a sequence type quantified with q.
* QUANT_MAX_CNT[q] is either 1 or 2, with 2 meaning infinity.
*/
- static const int QUANT_MAX_CNT[TypeConstants::QUANTIFIER_LIST_SIZE];
+ static const int QUANT_MAX_CNT[SequenceType::QUANT_INVALID];
/**
* For each quatifier q, QUANT_MIN_CNT[q] gives the minimum number of items
* that can appear in an instance of a sequence type quantified with q.
*/
- static const int QUANT_MIN_CNT[TypeConstants::QUANTIFIER_LIST_SIZE];
+ static const int QUANT_MIN_CNT[SequenceType::QUANT_INVALID];
/**
* For each pair T1, T2 of built-in atomic types, ATOMIC_CAST_MATRIX[T1][T2]
=== modified file 'src/types/schema/EventSchemaValidator.cpp'
--- src/types/schema/EventSchemaValidator.cpp 2013-04-24 21:40:21 +0000
+++ src/types/schema/EventSchemaValidator.cpp 2013-06-13 19:26:32 +0000
@@ -192,7 +192,7 @@
typeName.localFormOrDefault ("untyped"));
xqtref_t type = theTypeManager->create_named_type(typeQName,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
QueryLoc::null);
return type;
}
=== modified file 'src/types/schema/revalidateUtils.cpp'
--- src/types/schema/revalidateUtils.cpp 2013-05-21 21:44:25 +0000
+++ src/types/schema/revalidateUtils.cpp 2013-06-13 19:26:32 +0000
@@ -200,7 +200,7 @@
if ( !typeQName->equals(element->getType()) )
{
isNewType = true;
- newType = typeManager->create_named_type(typeQName, TypeConstants::QUANT_ONE, loc);
+ newType = typeManager->create_named_type(typeQName, SequenceType::QUANT_ONE, loc);
elm = element;
}
@@ -496,7 +496,7 @@
const QueryLoc& loc)
{
xqtref_t type = typeManager->create_named_atomic_type(typeQName,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc,
false);
//cout << " vup - processTextValue: '" << textValue->c_str() << "'\n";
=== modified file 'src/types/schema/schema.cpp'
--- src/types/schema/schema.cpp 2013-05-16 17:38:41 +0000
+++ src/types/schema/schema.cpp 2013-06-13 19:26:32 +0000
@@ -672,7 +672,7 @@
key += ":";
key += nsuri;
key += " ";
- key += TypeOps::decode_quantifier(TypeConstants::QUANT_ONE);
+ key += TypeOps::decode_quantifier(SequenceType::QUANT_ONE);
if( theUdTypesCache->get(key, res))
return res;
@@ -869,7 +869,7 @@
xsTypeDef->getAnonymous(),
qname,
baseXQType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
XQType::ATOMIC_UDT,
XQType::SIMPLE_CONTENT_KIND);
@@ -961,7 +961,7 @@
xsTypeDef->getAnonymous(),
qname,
baseXQType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
unionItemTypes);
//std::cout << " created UDT Union Type: " << xqType->toString() << std::endl;
@@ -1063,7 +1063,7 @@
xsTypeDef->getAnonymous(),
qname,
baseXQType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
XQType::COMPLEX_UDT,
contentType);
@@ -1535,7 +1535,7 @@
xsTypeDef->getAnonymous(),
qname,
baseXQType,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
XQType::COMPLEX_UDT,
contentType));
=== modified file 'src/types/schema/validate.cpp'
--- src/types/schema/validate.cpp 2013-05-21 21:44:25 +0000
+++ src/types/schema/validate.cpp 2013-06-13 19:26:32 +0000
@@ -15,6 +15,8 @@
*/
#include "stdafx.h"
+#include <zorba/typeident.h>
+
#include "validate.h"
#include "diagnostics/xquery_diagnostics.h"
@@ -54,8 +56,6 @@
#include "diagnostics/assert.h"
#include "zorba/store_consts.h"
-//using namespace std;
-
namespace zorba
{
@@ -354,7 +354,7 @@
if ( typeName!=NULL && typeManager!=NULL )
{
xqtref_t schemaType = typeManager->create_named_type(typeName,
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc);
if ( schemaType!=NULL )
@@ -676,14 +676,11 @@
store::Item_t validatedTextNode;
- TypeIdentifier_t typeIdentifier =
- TypeIdentifier::createNamedType(
- Unmarshaller::newString( typeQName->getNamespace() ),
- Unmarshaller::newString( typeQName->getLocalName() )
- );
-
- //xqType is NULL, create_type can't find it
- xqtref_t xqType = typeManager->create_type(*typeIdentifier);
+ //xqType is NULL if create_named_type can't find it
+ xqtref_t xqType = typeManager->create_named_type(typeQName,
+ SequenceType::QUANT_ONE,
+ loc,
+ false);
#if 0 // enable this to debug children values
if ( typeQName.getp() && xqType.getp() )
@@ -785,7 +782,7 @@
const QueryLoc& loc)
{
xqtref_t type = typeManager->create_named_type(typeQName.getp(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc);
//cout << " - processTextValue: " << typeQName->getPrefix()
=== modified file 'src/types/typeconstants.h'
--- src/types/typeconstants.h 2013-02-07 17:24:36 +0000
+++ src/types/typeconstants.h 2013-06-13 19:26:32 +0000
@@ -24,16 +24,6 @@
public:
typedef enum
{
- QUANT_ONE = 0,
- QUANT_QUESTION,
- QUANT_STAR,
- QUANT_PLUS,
- QUANTIFIER_LIST_SIZE
- } quantifier_t;
-
-
- typedef enum
- {
NOT_CASTABLE,
CASTABLE,
MAYBE_CASTABLE,
=== modified file 'src/types/typeimpl.cpp'
--- src/types/typeimpl.cpp 2013-06-03 23:03:58 +0000
+++ src/types/typeimpl.cpp 2013-06-13 19:26:32 +0000
@@ -173,7 +173,7 @@
XQType::XQType(
const TypeManager* manager,
TypeKind type_kind,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool builtin)
:
theManager((TypeManager*)manager),
@@ -198,7 +198,7 @@
{
SERIALIZE_TYPEMANAGER(TypeManager, theManager);
SERIALIZE_ENUM(TypeKind, theKind);
- SERIALIZE_ENUM(TypeConstants::quantifier_t, theQuantifier);
+ SERIALIZE_ENUM(SequenceType::Quantifier, theQuantifier);
ar & theIsBuiltin;
}
@@ -232,7 +232,7 @@
if (is_empty() || is_none())
return 0;
- TypeConstants::quantifier_t q = get_quantifier();
+ SequenceType::Quantifier q = get_quantifier();
if (RootTypeManager::QUANT_MIN_CNT[q] == RootTypeManager::QUANT_MAX_CNT[q])
return RootTypeManager::QUANT_MIN_CNT[q];
@@ -315,8 +315,8 @@
std::vector<xqtref_t>::const_iterator end = udt->m_unionItemTypes.end();
for (; ite != end; ++ite)
{
- if ((*ite)->get_quantifier() != TypeConstants::QUANT_ONE &&
- (*ite)->get_quantifier() != TypeConstants::QUANT_QUESTION)
+ if ((*ite)->get_quantifier() != SequenceType::QUANT_ONE &&
+ (*ite)->get_quantifier() != SequenceType::QUANT_QUESTION)
return false;
}
@@ -352,7 +352,7 @@
********************************************************************************/
bool XQType::isAtomicOne() const
{
- if (get_quantifier() == TypeConstants::QUANT_ONE)
+ if (get_quantifier() == SequenceType::QUANT_ONE)
{
if (type_kind() == XQType::ATOMIC_TYPE_KIND)
{
@@ -383,7 +383,7 @@
********************************************************************************/
bool XQType::isBuiltinAtomicOne() const
{
- return get_quantifier() == TypeConstants::QUANT_ONE &&
+ return get_quantifier() == SequenceType::QUANT_ONE &&
type_kind() == XQType::ATOMIC_TYPE_KIND;
}
@@ -609,7 +609,7 @@
NoneXQType::NoneXQType(const TypeManager* manager, bool builtin)
:
- XQType(manager, NONE_KIND, TypeConstants::QUANT_ONE, builtin)
+ XQType(manager, NONE_KIND, SequenceType::QUANT_ONE, builtin)
{
}
@@ -628,7 +628,7 @@
EmptyXQType::EmptyXQType(const TypeManager* manager, bool builtin)
:
- XQType(manager, EMPTY_KIND, TypeConstants::QUANT_QUESTION, builtin)
+ XQType(manager, EMPTY_KIND, SequenceType::QUANT_QUESTION, builtin)
{
}
@@ -647,7 +647,7 @@
ItemXQType::ItemXQType(
const TypeManager* tm,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool builtin)
:
XQType(tm, ITEM_KIND, quant, builtin)
@@ -696,7 +696,7 @@
StructuredItemXQType::StructuredItemXQType(
const TypeManager* tm,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool builtin)
:
XQType(tm, STRUCTURED_ITEM_KIND, quant, builtin)
@@ -724,7 +724,7 @@
JSONXQType::JSONXQType(
const TypeManager* manager,
store::StoreConsts::JSONItemKind kind,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool builtin)
:
XQType(manager, JSON_TYPE_KIND, quantifier, builtin),
@@ -771,7 +771,7 @@
store::StoreConsts::NodeKind nodeKind,
const store::Item_t& nodeName,
const xqtref_t& contentType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool nillable,
bool schematest,
bool builtin)
@@ -793,7 +793,7 @@
contentType->type_kind() == USER_DEFINED_KIND);
assert(contentType == NULL ||
- contentType->get_quantifier() == TypeConstants::QUANT_ONE ||
+ contentType->get_quantifier() == SequenceType::QUANT_ONE ||
contentType->type_kind() == ANY_TYPE_KIND ||
contentType->type_kind() == ANY_SIMPLE_TYPE_KIND ||
contentType->type_kind() == UNTYPED_KIND);
@@ -810,7 +810,7 @@
********************************************************************************/
NodeXQType::NodeXQType(
const NodeXQType& source,
- TypeConstants::quantifier_t quantifier)
+ SequenceType::Quantifier quantifier)
:
XQType(source.theManager, NODE_TYPE_KIND, quantifier, false),
theNodeKind(source.theNodeKind),
@@ -1018,7 +1018,7 @@
if (theContentType != NULL)
{
xqtref_t subContentType =
- tm->create_named_type(subitem->getType(), TypeConstants::QUANT_ONE, loc, true);
+ tm->create_named_type(subitem->getType(), SequenceType::QUANT_ONE, loc, true);
return TypeOps::is_subtype(tm, *subContentType, *theContentType);
}
@@ -1059,7 +1059,7 @@
return true;
xqtref_t subContentType = tm->create_named_type(subitem->getType(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc,
true);
@@ -1088,7 +1088,7 @@
return true;
xqtref_t subContentType =
- tm->create_named_type(subitem->getType(), TypeConstants::QUANT_ONE, loc, true);
+ tm->create_named_type(subitem->getType(), SequenceType::QUANT_ONE, loc, true);
return TypeOps::is_subtype(tm, *subContentType, *theContentType);
}
@@ -1248,7 +1248,7 @@
const TypeManager* manager,
const std::vector<xqtref_t>& aParamTypes,
const xqtref_t& aReturnType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool builtin)
:
XQType(manager, FUNCTION_TYPE_KIND, quantifier, builtin),
@@ -1386,7 +1386,7 @@
bool isAnonymous,
store::Item_t qname,
const xqtref_t& baseType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
UDTKind udtKind,
content_kind_t contentKind,
bool builtin)
@@ -1401,7 +1401,7 @@
assert(udtKind == ATOMIC_UDT || udtKind == COMPLEX_UDT);
ZORBA_ASSERT(baseType != NULL);
- ZORBA_ASSERT(udtKind == ATOMIC_UDT || quantifier == TypeConstants::QUANT_ONE);
+ ZORBA_ASSERT(udtKind == ATOMIC_UDT || quantifier == SequenceType::QUANT_ONE);
TRACE("UserDefinedXQType c2: " << theQName->getLocalName() << "@"
<< theQName->getNamespace() << " " << decodeUDTKind(theUDTKind)
@@ -1420,7 +1420,7 @@
const XQType* listItemType,
bool builtin)
:
- XQType(manager, USER_DEFINED_KIND, TypeConstants::QUANT_STAR, builtin),
+ XQType(manager, USER_DEFINED_KIND, SequenceType::QUANT_STAR, builtin),
theIsAnonymous(isAnonymous),
theQName(qname),
theBaseType(baseType),
@@ -1440,7 +1440,7 @@
bool isAnonymous,
store::Item_t qname,
const xqtref_t& baseType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
const std::vector<xqtref_t>& unionItemTypes,
bool builtin)
:
=== modified file 'src/types/typeimpl.h'
--- src/types/typeimpl.h 2013-06-03 23:03:58 +0000
+++ src/types/typeimpl.h 2013-06-13 19:26:32 +0000
@@ -335,12 +335,12 @@
static std::string contentKindStr(XQType::content_kind_t contentKind);
protected:
- static const char * KIND_STRINGS[XQType::MAX_TYPE_KIND];
+ static const char * KIND_STRINGS[XQType::MAX_TYPE_KIND];
- TypeManager * theManager;
- TypeKind theKind;
- TypeConstants::quantifier_t theQuantifier;
- bool theIsBuiltin;
+ TypeManager * theManager;
+ TypeKind theKind;
+ SequenceType::Quantifier theQuantifier;
+ bool theIsBuiltin;
public:
@@ -361,7 +361,7 @@
TypeKind type_kind() const { return theKind; }
- TypeConstants::quantifier_t get_quantifier() const { return theQuantifier; }
+ SequenceType::Quantifier get_quantifier() const { return theQuantifier; }
bool is_builtin() const { return theIsBuiltin; }
@@ -411,7 +411,7 @@
XQType(
const TypeManager* mgr,
TypeKind kind,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool builtin);
};
@@ -459,7 +459,7 @@
public:
ItemXQType(
const TypeManager* tm,
- TypeConstants::quantifier_t q,
+ SequenceType::Quantifier q,
bool builtin = false);
public:
@@ -492,7 +492,7 @@
AtomicXQType(
const TypeManager* manager,
store::SchemaTypeCode code,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool builtin = false)
:
XQType(manager, ATOMIC_TYPE_KIND, quant, builtin),
@@ -515,7 +515,7 @@
public:
StructuredItemXQType(
const TypeManager* tm,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool builtin = false);
public:
@@ -525,7 +525,6 @@
};
-#ifdef ZORBA_WITH_JSON
/***************************************************************************//**
Class JSONXQType represents all the sequence types whose ItemType is a
JSONTest.
@@ -544,14 +543,13 @@
JSONXQType(
const TypeManager* manager,
store::StoreConsts::JSONItemKind kind,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool builtin = false);
store::StoreConsts::JSONItemKind get_json_kind() const { return theJSONKind; }
std::ostream& serialize_ostream(std::ostream& os) const;
};
-#endif
/***************************************************************************//**
@@ -580,12 +578,12 @@
store::StoreConsts::NodeKind nodeKind,
const store::Item_t& nodeName,
const xqtref_t& contentType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool nillable,
bool schematest,
bool builtin = false);
- NodeXQType(const NodeXQType& source, TypeConstants::quantifier_t quant);
+ NodeXQType(const NodeXQType& source, SequenceType::Quantifier quant);
store::StoreConsts::NodeKind get_node_kind() const { return theNodeKind; }
@@ -626,13 +624,13 @@
public:
AnyFunctionXQType(const TypeManager* manager, bool builtin = false)
:
- XQType(manager, ANY_FUNCTION_TYPE_KIND, TypeConstants::QUANT_STAR, builtin)
+ XQType(manager, ANY_FUNCTION_TYPE_KIND, SequenceType::QUANT_STAR, builtin)
{
}
AnyFunctionXQType(
const TypeManager* manager,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool builtin = false)
:
XQType(manager, ANY_FUNCTION_TYPE_KIND, quantifier, builtin)
@@ -666,7 +664,7 @@
const TypeManager* manager,
const std::vector<xqtref_t>& aParamTypes,
const xqtref_t& aReturnType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool builtin = false);
const std::vector<xqtref_t>&
@@ -764,7 +762,7 @@
bool isAnonymous,
store::Item_t qname,
const xqtref_t& baseType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
UDTKind typeCategory,
content_kind_t contentKind,
bool builtin = false);
@@ -784,7 +782,7 @@
bool isAnonymous,
store::Item_t qname,
const xqtref_t& baseType,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
const std::vector<xqtref_t>& unionItemTypes,
bool builtin = false);
@@ -819,7 +817,7 @@
public:
AnyXQType(const TypeManager* manager, bool builtin = false)
:
- XQType(manager, ANY_TYPE_KIND, TypeConstants::QUANT_STAR, builtin)
+ XQType(manager, ANY_TYPE_KIND, SequenceType::QUANT_STAR, builtin)
{
}
@@ -838,7 +836,7 @@
public:
UntypedXQType(const TypeManager* manager, bool builtin = false)
:
- XQType(manager, UNTYPED_KIND, TypeConstants::QUANT_STAR, builtin)
+ XQType(manager, UNTYPED_KIND, SequenceType::QUANT_STAR, builtin)
{
}
@@ -857,7 +855,7 @@
public:
AnySimpleXQType(const TypeManager* manager, bool builtin = false)
:
- XQType(manager, ANY_SIMPLE_TYPE_KIND, TypeConstants::QUANT_STAR, builtin)
+ XQType(manager, ANY_SIMPLE_TYPE_KIND, SequenceType::QUANT_STAR, builtin)
{
}
=== modified file 'src/types/typemanager.h'
--- src/types/typemanager.h 2013-04-17 16:18:23 +0000
+++ src/types/typemanager.h 2013-06-13 19:26:32 +0000
@@ -18,9 +18,11 @@
#define ZORBA_TYPEMANAGER_H
#include <ostream>
+
+#include <zorba/api_shared_types.h>
+#include <zorba/store_consts.h>
+#include <zorba/diagnostic_list.h>
#include <zorba/typeident.h>
-#include <zorba/store_consts.h>
-#include <zorba/diagnostic_list.h>
#include "common/shared_types.h"
@@ -93,23 +95,23 @@
virtual xqtref_t create_none_type() const = 0;
virtual xqtref_t create_any_item_type(
- TypeConstants::quantifier_t q) const = 0;
+ SequenceType::Quantifier q) const = 0;
virtual xqtref_t create_any_function_type(
- TypeConstants::quantifier_t q) const = 0;
+ SequenceType::Quantifier q) const = 0;
virtual xqtref_t create_function_type(
const std::vector<xqtref_t>& aArgs,
const xqtref_t& aReturn,
- TypeConstants::quantifier_t q) const = 0;
+ SequenceType::Quantifier q) const = 0;
virtual xqtref_t create_builtin_atomic_type(
store::SchemaTypeCode type_code,
- TypeConstants::quantifier_t q) const = 0;
+ SequenceType::Quantifier q) const = 0;
virtual xqtref_t create_named_atomic_type(
store::Item* qname,
- TypeConstants::quantifier_t q,
+ SequenceType::Quantifier q,
const QueryLoc& loc,
bool raiseError) const = 0;
@@ -118,45 +120,41 @@
virtual xqtref_t create_named_type(
store::Item* qname,
- TypeConstants::quantifier_t q,
+ SequenceType::Quantifier q,
const QueryLoc& loc,
bool raiseError = false) const = 0;
- virtual xqtref_t create_structured_item_type(TypeConstants::quantifier_t q) const = 0;
+ virtual xqtref_t create_structured_item_type(SequenceType::Quantifier q) const = 0;
-#ifdef ZORBA_WITH_JSON
virtual xqtref_t create_json_type(
store::StoreConsts::JSONItemKind kind,
- TypeConstants::quantifier_t q) const = 0;
-#endif
+ SequenceType::Quantifier q) const = 0;
virtual xqtref_t create_node_type(
store::StoreConsts::NodeKind nodeKind,
const store::Item_t& nodeName,
const xqtref_t& contentType,
- TypeConstants::quantifier_t q,
+ SequenceType::Quantifier q,
bool nillable,
bool schematype) const = 0;
virtual xqtref_t create_type(
const XQType& type,
- TypeConstants::quantifier_t quantifier) const = 0;
+ SequenceType::Quantifier quantifier) const = 0;
virtual xqtref_t create_type_x_quant(
const XQType& type,
- TypeConstants::quantifier_t quantifier) const = 0;
+ SequenceType::Quantifier quantifier) const = 0;
virtual xqtref_t create_value_type(
const store::Item* item,
const QueryLoc& loc = QueryLoc::null) const = 0;
- virtual xqtref_t create_type(const TypeIdentifier& ident) const = 0;
-
#ifndef ZORBA_NO_XMLSCHEMA
virtual xqtref_t create_schema_element_type(
const store::Item_t& eName,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
const QueryLoc& loc) const = 0;
virtual void get_schema_element_typeinfo(
@@ -167,7 +165,7 @@
virtual xqtref_t create_schema_attribute_type(
const store::Item_t& aName,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
const QueryLoc& loc) const = 0;
virtual void get_schema_attribute_typeinfo(
=== modified file 'src/types/typemanagerimpl.cpp'
--- src/types/typemanagerimpl.cpp 2013-05-21 21:44:25 +0000
+++ src/types/typemanagerimpl.cpp 2013-06-13 19:26:32 +0000
@@ -17,7 +17,6 @@
#include <assert.h>
-#include <zorba/identtypes.h>
#include <zorba/typeident.h>
#include "diagnostics/assert.h"
@@ -173,17 +172,17 @@
/***************************************************************************//**
********************************************************************************/
-xqtref_t TypeManagerImpl::create_any_item_type(TypeConstants::quantifier_t q) const
+xqtref_t TypeManagerImpl::create_any_item_type(SequenceType::Quantifier q) const
{
switch(q)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return GENV_TYPESYSTEM.ITEM_TYPE_ONE;
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return GENV_TYPESYSTEM.ITEM_TYPE_QUESTION;
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return GENV_TYPESYSTEM.ITEM_TYPE_STAR;
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return GENV_TYPESYSTEM.ITEM_TYPE_PLUS;
default:
return xqtref_t(0);
@@ -195,17 +194,17 @@
********************************************************************************/
xqtref_t TypeManagerImpl::create_any_function_type(
- TypeConstants::quantifier_t quantifier) const
+ SequenceType::Quantifier quantifier) const
{
switch(quantifier)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_ONE;
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_QUESTION;
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_STAR;
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_PLUS;
default:
return xqtref_t(0);
@@ -219,7 +218,7 @@
xqtref_t TypeManagerImpl::create_function_type(
const std::vector<xqtref_t>& paramTypes,
const xqtref_t& returnType,
- TypeConstants::quantifier_t quant) const
+ SequenceType::Quantifier quant) const
{
return new FunctionXQType(this, paramTypes, returnType, quant);
}
@@ -231,7 +230,7 @@
********************************************************************************/
xqtref_t TypeManagerImpl::create_builtin_atomic_type(
store::SchemaTypeCode type_code,
- TypeConstants::quantifier_t quantifier) const
+ SequenceType::Quantifier quantifier) const
{
return *GENV_TYPESYSTEM.m_atomic_typecode_map[type_code][quantifier];
}
@@ -245,7 +244,7 @@
********************************************************************************/
xqtref_t TypeManagerImpl::create_named_atomic_type(
store::Item* qname,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
const QueryLoc& loc,
bool raiseError) const
{
@@ -329,7 +328,7 @@
store::SchemaTypeCode code = store::XS_LAST;
if (myMap.get(qname, code))
- return create_builtin_atomic_type(code, TypeConstants::QUANT_ONE);
+ return create_builtin_atomic_type(code, SequenceType::QUANT_ONE);
// If the type name is an XML Schema builtin type, then it can only be one of
// xs:NMTOKES, xs:IDREFS, or xs:ENTITIES.
@@ -370,7 +369,7 @@
reinterpret_cast<const UserDefinedXQType*>(namedType.getp());
if (udt->isAtomicAny() || udt->isList() || udt->isUnion())
- return create_type_x_quant(*namedType, TypeConstants::QUANT_ONE);
+ return create_type_x_quant(*namedType, SequenceType::QUANT_ONE);
}
#endif
@@ -383,7 +382,7 @@
********************************************************************************/
xqtref_t TypeManagerImpl::create_named_type(
store::Item* qname,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
const QueryLoc& loc,
bool raiseError) const
{
@@ -466,17 +465,17 @@
********************************************************************************/
xqtref_t TypeManagerImpl::create_structured_item_type(
- TypeConstants::quantifier_t q) const
+ SequenceType::Quantifier q) const
{
switch(q)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return GENV_TYPESYSTEM.STRUCTURED_ITEM_TYPE_ONE;
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return GENV_TYPESYSTEM.STRUCTURED_ITEM_TYPE_QUESTION;
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return GENV_TYPESYSTEM.STRUCTURED_ITEM_TYPE_STAR;
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return GENV_TYPESYSTEM.STRUCTURED_ITEM_TYPE_PLUS;
default:
return xqtref_t(0);
@@ -490,7 +489,7 @@
********************************************************************************/
xqtref_t TypeManagerImpl::create_json_type(
store::StoreConsts::JSONItemKind kind,
- TypeConstants::quantifier_t quantifier) const
+ SequenceType::Quantifier quantifier) const
{
return GENV_TYPESYSTEM.JSON_TYPES_MAP[kind][quantifier];
}
@@ -504,7 +503,7 @@
store::StoreConsts::NodeKind nodeKind,
const store::Item_t& nodeName,
const xqtref_t& contType,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool nillable,
bool schematest) const
{
@@ -614,13 +613,13 @@
{ \
switch(quantifier) \
{ \
- case TypeConstants::QUANT_ONE: \
+ case SequenceType::QUANT_ONE: \
return GENV_TYPESYSTEM.kind##_UNTYPED_TYPE_ONE; \
- case TypeConstants::QUANT_QUESTION: \
+ case SequenceType::QUANT_QUESTION: \
return GENV_TYPESYSTEM.kind##_UNTYPED_TYPE_QUESTION; \
- case TypeConstants::QUANT_STAR: \
+ case SequenceType::QUANT_STAR: \
return GENV_TYPESYSTEM.kind##_UNTYPED_TYPE_STAR; \
- case TypeConstants::QUANT_PLUS: \
+ case SequenceType::QUANT_PLUS: \
return GENV_TYPESYSTEM.kind##_UNTYPED_TYPE_PLUS; \
default: \
ZORBA_ASSERT(false); \
@@ -630,13 +629,13 @@
{ \
switch(quantifier) \
{ \
- case TypeConstants::QUANT_ONE: \
+ case SequenceType::QUANT_ONE: \
return GENV_TYPESYSTEM.kind##_TYPE_ONE; \
- case TypeConstants::QUANT_QUESTION: \
+ case SequenceType::QUANT_QUESTION: \
return GENV_TYPESYSTEM.kind##_TYPE_QUESTION; \
- case TypeConstants::QUANT_STAR: \
+ case SequenceType::QUANT_STAR: \
return GENV_TYPESYSTEM.kind##_TYPE_STAR; \
- case TypeConstants::QUANT_PLUS: \
+ case SequenceType::QUANT_PLUS: \
return GENV_TYPESYSTEM.kind##_TYPE_PLUS; \
default: \
ZORBA_ASSERT(false); \
@@ -646,7 +645,7 @@
xqtref_t TypeManagerImpl::create_builtin_node_type(
store::StoreConsts::NodeKind nodeKind,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool untyped) const
{
switch (nodeKind)
@@ -667,13 +666,13 @@
{
switch(quantifier)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return GENV_TYPESYSTEM.TEXT_TYPE_ONE;
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return GENV_TYPESYSTEM.TEXT_TYPE_QUESTION;
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return GENV_TYPESYSTEM.TEXT_TYPE_STAR;
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return GENV_TYPESYSTEM.TEXT_TYPE_PLUS;
default:
ZORBA_ASSERT(false);
@@ -684,13 +683,13 @@
{
switch(quantifier)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return GENV_TYPESYSTEM.PI_TYPE_ONE;
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return GENV_TYPESYSTEM.PI_TYPE_QUESTION;
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return GENV_TYPESYSTEM.PI_TYPE_STAR;
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return GENV_TYPESYSTEM.PI_TYPE_PLUS;
default:
ZORBA_ASSERT(false);
@@ -701,13 +700,13 @@
{
switch(quantifier)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return GENV_TYPESYSTEM.COMMENT_TYPE_ONE;
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return GENV_TYPESYSTEM.COMMENT_TYPE_QUESTION;
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return GENV_TYPESYSTEM.COMMENT_TYPE_STAR;
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return GENV_TYPESYSTEM.COMMENT_TYPE_PLUS;
default:
ZORBA_ASSERT(false);
@@ -718,13 +717,13 @@
{
switch(quantifier)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return GENV_TYPESYSTEM.NAMESPACE_TYPE_ONE;
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return GENV_TYPESYSTEM.NAMESPACE_TYPE_QUESTION;
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return GENV_TYPESYSTEM.NAMESPACE_TYPE_STAR;
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return GENV_TYPESYSTEM.NAMESPACE_TYPE_PLUS;
default:
ZORBA_ASSERT(false);
@@ -738,6 +737,109 @@
}
+#ifndef ZORBA_NO_XMLSCHEMA
+
+/***************************************************************************//**
+ Create a sequence type of the form "element(elemName, tname) quant", where
+ quant is a given quantifier, elemName is a given element qname, elemName is a
+ globaly declared element name, and tname is the name of the type associated
+ with elemName in the in-scope schema declarations.
+********************************************************************************/
+xqtref_t TypeManagerImpl::create_schema_element_type(
+ const store::Item_t& elemName,
+ SequenceType::Quantifier quant,
+ const QueryLoc& loc) const
+{
+ if (m_schema == NULL)
+ {
+ RAISE_ERROR(err::XPST0008, loc,
+ ERROR_PARAMS(ZED(XPST0008_SchemaElementName_2), elemName->getStringValue()));
+ }
+
+ bool nillable;
+
+ xqtref_t contentType =
+ m_schema->createXQTypeFromGlobalElementDecl(this, elemName, true, nillable, loc);
+
+ return create_node_type(store::StoreConsts::elementNode,
+ elemName,
+ contentType,
+ quant,
+ nillable,
+ true); // schematest
+}
+
+
+/***************************************************************************//**
+ Get the name of the type associated with a given globally declared element name.
+********************************************************************************/
+void TypeManagerImpl::get_schema_element_typeinfo(
+ const store::Item* elemName,
+ store::Item_t& typeName,
+ bool& nillable,
+ const QueryLoc& loc) const
+{
+ if (m_schema == NULL)
+ {
+ RAISE_ERROR(err::XPST0008, loc,
+ ERROR_PARAMS(ZED(XPST0008_SchemaElementName_2), elemName->getStringValue()));
+ }
+
+ m_schema->getInfoFromGlobalElementDecl(elemName, typeName, nillable, loc);
+}
+
+
+/***************************************************************************//**
+ Create a sequence type of the form "attribute(attrName, tname) quant", where
+ quant is a given quantifier, attrName is a given attribute qname, attrName is
+ a globaly declared attribute name, and tname is the name of the type associated
+ with attrName in the in-scope schema declarations.
+********************************************************************************/
+xqtref_t TypeManagerImpl::create_schema_attribute_type(
+ const store::Item_t& attrName,
+ SequenceType::Quantifier quant,
+ const QueryLoc& loc) const
+{
+ if (m_schema == NULL)
+ {
+ RAISE_ERROR(err::XPST0008, loc,
+ ERROR_PARAMS(ZED(XPST0008_SchemaAttributeName_2), attrName->getStringValue()));
+ }
+
+ xqtref_t contentType =
+ m_schema->createXQTypeFromGlobalAttributeDecl(this, attrName, true, loc);
+
+ return create_node_type(store::StoreConsts::attributeNode,
+ attrName,
+ contentType,
+ quant,
+ false,
+ true);
+}
+
+
+/***************************************************************************//**
+ Get the name of the type associated with a given globally declared attribute
+ name.
+********************************************************************************/
+void TypeManagerImpl::get_schema_attribute_typeinfo(
+ const store::Item* attrName,
+ store::Item_t& typeName,
+ const QueryLoc& loc)
+{
+ if (m_schema == NULL)
+ {
+ RAISE_ERROR(err::XPST0008, loc,
+ ERROR_PARAMS(ZED(XPST0008_SchemaAttributeName_2), attrName->getStringValue()));
+ }
+
+ m_schema->getInfoFromGlobalAttributeDecl(attrName, typeName, loc);
+}
+
+
+#endif // ZORBA_NO_XMLSCHEMA
+
+
/***************************************************************************//**
Create a sequence type based on the kind and content of an item.
********************************************************************************/
@@ -745,7 +847,7 @@
const store::Item* item,
const QueryLoc& loc) const
{
- TypeConstants::quantifier_t quant = TypeConstants::QUANT_ONE;
+ SequenceType::Quantifier quant = SequenceType::QUANT_ONE;
if (item->isAtomic())
{
@@ -874,116 +976,13 @@
}
-#ifndef ZORBA_NO_XMLSCHEMA
-
-/***************************************************************************//**
- Create a sequence type of the form "element(elemName, tname) quant", where
- quant is a given quantifier, elemName is a given element qname, elemName is a
- globaly declared element name, and tname is the name of the type associated
- with elemName in the in-scope schema declarations.
-********************************************************************************/
-xqtref_t TypeManagerImpl::create_schema_element_type(
- const store::Item_t& elemName,
- TypeConstants::quantifier_t quant,
- const QueryLoc& loc) const
-{
- if (m_schema == NULL)
- {
- RAISE_ERROR(err::XPST0008, loc,
- ERROR_PARAMS(ZED(XPST0008_SchemaElementName_2), elemName->getStringValue()));
- }
-
- bool nillable;
-
- xqtref_t contentType =
- m_schema->createXQTypeFromGlobalElementDecl(this, elemName, true, nillable, loc);
-
- return create_node_type(store::StoreConsts::elementNode,
- elemName,
- contentType,
- quant,
- nillable,
- true); // schematest
-}
-
-
-/***************************************************************************//**
- Get the name of the type associated with a given globally declared element name.
-********************************************************************************/
-void TypeManagerImpl::get_schema_element_typeinfo(
- const store::Item* elemName,
- store::Item_t& typeName,
- bool& nillable,
- const QueryLoc& loc) const
-{
- if (m_schema == NULL)
- {
- RAISE_ERROR(err::XPST0008, loc,
- ERROR_PARAMS(ZED(XPST0008_SchemaElementName_2), elemName->getStringValue()));
- }
-
- m_schema->getInfoFromGlobalElementDecl(elemName, typeName, nillable, loc);
-}
-
-
-/***************************************************************************//**
- Create a sequence type of the form "attribute(attrName, tname) quant", where
- quant is a given quantifier, attrName is a given attribute qname, attrName is
- a globaly declared attribute name, and tname is the name of the type associated
- with attrName in the in-scope schema declarations.
-********************************************************************************/
-xqtref_t TypeManagerImpl::create_schema_attribute_type(
- const store::Item_t& attrName,
- TypeConstants::quantifier_t quant,
- const QueryLoc& loc) const
-{
- if (m_schema == NULL)
- {
- RAISE_ERROR(err::XPST0008, loc,
- ERROR_PARAMS(ZED(XPST0008_SchemaAttributeName_2), attrName->getStringValue()));
- }
-
- xqtref_t contentType =
- m_schema->createXQTypeFromGlobalAttributeDecl(this, attrName, true, loc);
-
- return create_node_type(store::StoreConsts::attributeNode,
- attrName,
- contentType,
- quant,
- false,
- true);
-}
-
-
-/***************************************************************************//**
- Get the name of the type associated with a given globally declared attribute
- name.
-********************************************************************************/
-void TypeManagerImpl::get_schema_attribute_typeinfo(
- const store::Item* attrName,
- store::Item_t& typeName,
- const QueryLoc& loc)
-{
- if (m_schema == NULL)
- {
- RAISE_ERROR(err::XPST0008, loc,
- ERROR_PARAMS(ZED(XPST0008_SchemaAttributeName_2), attrName->getStringValue()));
- }
-
- m_schema->getInfoFromGlobalAttributeDecl(attrName, typeName, loc);
-}
-
-
-#endif // ZORBA_NO_XMLSCHEMA
-
-
/***************************************************************************//**
Create a sequence type with a given quantifier and the same ItemType as the
one of a given type.
********************************************************************************/
xqtref_t TypeManagerImpl::create_type(
const XQType& type,
- TypeConstants::quantifier_t quantifier) const
+ SequenceType::Quantifier quantifier) const
{
if (type.get_quantifier() == quantifier)
return &type;
@@ -1053,8 +1052,8 @@
return GENV_TYPESYSTEM.EMPTY_TYPE;
case XQType::NONE_KIND:
- return (quantifier == TypeConstants::QUANT_ONE ||
- quantifier == TypeConstants::QUANT_PLUS ?
+ return (quantifier == SequenceType::QUANT_ONE ||
+ quantifier == SequenceType::QUANT_PLUS ?
GENV_TYPESYSTEM.NONE_TYPE :
GENV_TYPESYSTEM.EMPTY_TYPE);
@@ -1106,7 +1105,7 @@
********************************************************************************/
xqtref_t TypeManagerImpl::create_type_x_quant(
const XQType& type,
- TypeConstants::quantifier_t quantifier) const
+ SequenceType::Quantifier quantifier) const
{
return create_type(type,
RootTypeManager::QUANT_UNION_MATRIX[type.get_quantifier()]
@@ -1114,157 +1113,4 @@
}
-/***************************************************************************//**
-
-********************************************************************************/
-xqtref_t TypeManagerImpl::create_type(const TypeIdentifier& ident) const
-{
- TypeConstants::quantifier_t q = TypeConstants::QUANT_ONE;
-
- switch (ident.getQuantifier())
- {
- case IdentTypes::QUANT_ONE:
- q = TypeConstants::QUANT_ONE;
- break;
-
- case IdentTypes::QUANT_QUESTION:
- q = TypeConstants::QUANT_QUESTION;
- break;
-
- case IdentTypes::QUANT_PLUS:
- q = TypeConstants::QUANT_PLUS;
- break;
-
- case IdentTypes::QUANT_STAR:
- q = TypeConstants::QUANT_STAR;
- break;
- }
-
- switch (ident.getKind())
- {
- case IdentTypes::NAMED_TYPE:
- {
- store::Item_t i;
- GENV_ITEMFACTORY->createQName(i,
- ident.getUri().c_str(),
- NULL,
- ident.getLocalName().c_str());
- return create_named_type(i, q, QueryLoc::null, true);
- }
-
- case IdentTypes::ELEMENT_TYPE:
- {
- store::Item_t ename;
- GENV_ITEMFACTORY->createQName(ename,
- ident.getUri().c_str(),
- NULL,
- ident.getLocalName().c_str());
-
- TypeIdentifier_t ci = ident.getContentType();
- xqtref_t content_type = (ci != NULL ? create_type(*ci) : xqtref_t(0));
-
- return create_node_type(store::StoreConsts::elementNode,
- ename.getp(),
- content_type,
- q,
- false,
- false);
- }
-
- case IdentTypes::ATTRIBUTE_TYPE:
- {
- store::Item_t aname;
- GENV_ITEMFACTORY->createQName(aname,
- ident.getUri().c_str(),
- NULL,
- ident.getLocalName().c_str());
-
- TypeIdentifier_t ci = ident.getContentType();
- xqtref_t content_type = (ci != NULL ? create_type(*ci) : xqtref_t(0));
-
- return create_node_type(store::StoreConsts::attributeNode,
- aname.getp(),
- content_type,
- q,
- false,
- false);
- }
-
- case IdentTypes::DOCUMENT_TYPE:
- {
- TypeIdentifier_t ci = ident.getContentType();
- xqtref_t content_type = (ci != NULL ? create_type(*ci) : xqtref_t(0));
-
- return create_node_type(store::StoreConsts::documentNode,
- NULL,
- content_type,
- q,
- false,
- false);
- }
-
- case IdentTypes::PI_TYPE:
- return create_builtin_node_type(store::StoreConsts::piNode, q, false);
-
- case IdentTypes::TEXT_TYPE:
- return create_builtin_node_type(store::StoreConsts::textNode, q, false);
-
- case IdentTypes::COMMENT_TYPE:
- return create_builtin_node_type(store::StoreConsts::commentNode, q, false);
-
- case IdentTypes::NAMESPACE_TYPE:
- return create_builtin_node_type(store::StoreConsts::namespaceNode, q, false);
-
- case IdentTypes::ANY_NODE_TYPE:
- return create_builtin_node_type(store::StoreConsts::anyNode, q, false);
-
-#ifdef ZORBA_WITH_JSON
- case IdentTypes::JSON_ITEM_TYPE:
- return create_json_type(store::StoreConsts::jsonItem, q);
-
- case IdentTypes::JSON_OBJECT_TYPE:
- return create_json_type(store::StoreConsts::jsonObject, q);
-
- case IdentTypes::JSON_ARRAY_TYPE:
- return create_json_type(store::StoreConsts::jsonArray, q);
-#endif // #ifdef ZORBA_WITH_JSON
-
- case IdentTypes::ITEM_TYPE:
- return create_any_item_type(q);
-
- case IdentTypes::EMPTY_TYPE:
- return create_empty_type();
-
- case IdentTypes::SCHEMA_ELEMENT_TYPE:
- {
- store::Item_t ename;
- GENV_ITEMFACTORY->createQName(ename,
- ident.getUri().c_str(),
- NULL,
- ident.getLocalName().c_str());
-
- return create_schema_element_type(ename.getp(),
- q,
- QueryLoc::null);
- }
-
- case IdentTypes::SCHEMA_ATTRIBUTE_TYPE:
- {
- store::Item_t aname;
- GENV_ITEMFACTORY->createQName(aname,
- ident.getUri().c_str(),
- NULL,
- ident.getLocalName().c_str());
-
- return create_schema_attribute_type(aname,
- q,
- QueryLoc::null);
- }
-
- default:
- break;
- }
-
- return xqtref_t(0);
-}
/* vim:set et sw=2 ts=2: */
=== modified file 'src/types/typemanagerimpl.h'
--- src/types/typemanagerimpl.h 2013-04-17 16:18:23 +0000
+++ src/types/typemanagerimpl.h 2013-06-13 19:26:32 +0000
@@ -18,7 +18,7 @@
#define ZORBA_TYPEMANAGERIMPL_H
#include "types/typemanager.h"
-//#include "types/schema/schema.h"
+
#include "store/api/item.h"
#include "system/globalenv.h"
@@ -91,22 +91,22 @@
xqtref_t create_none_type() const;
- xqtref_t create_any_item_type(TypeConstants::quantifier_t q) const;
+ xqtref_t create_any_item_type(SequenceType::Quantifier q) const;
- xqtref_t create_any_function_type(TypeConstants::quantifier_t q) const;
+ xqtref_t create_any_function_type(SequenceType::Quantifier q) const;
xqtref_t create_function_type(
const std::vector<xqtref_t>& aArgs,
const xqtref_t& aReturn,
- TypeConstants::quantifier_t aQuant) const;
+ SequenceType::Quantifier aQuant) const;
xqtref_t create_builtin_atomic_type(
store::SchemaTypeCode type_code,
- TypeConstants::quantifier_t quant) const;
+ SequenceType::Quantifier quant) const;
xqtref_t create_named_atomic_type(
store::Item* qname,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
const QueryLoc& loc,
bool raiseError) const;
@@ -115,23 +115,21 @@
xqtref_t create_named_type(
store::Item* qname,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
const QueryLoc& loc,
bool raiseError = false) const;
- xqtref_t create_structured_item_type(TypeConstants::quantifier_t q) const;
+ xqtref_t create_structured_item_type(SequenceType::Quantifier q) const;
-#ifdef ZORBA_WITH_JSON
xqtref_t create_json_type(
store::StoreConsts::JSONItemKind kind,
- TypeConstants::quantifier_t quantifier) const;
-#endif
+ SequenceType::Quantifier quantifier) const;
xqtref_t create_node_type(
store::StoreConsts::NodeKind nodeKind,
const store::Item_t& nodeName,
const xqtref_t& contentType,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
bool nillable,
bool schematest) const;
@@ -139,13 +137,11 @@
const store::Item* item,
const QueryLoc& loc = QueryLoc::null) const;
- xqtref_t create_type(const TypeIdentifier& ident) const;
-
#ifndef ZORBA_NO_XMLSCHEMA
xqtref_t create_schema_element_type(
const store::Item_t& elemName,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
const QueryLoc& loc) const;
void get_schema_element_typeinfo(
@@ -156,7 +152,7 @@
xqtref_t create_schema_attribute_type(
const store::Item_t& attrName,
- TypeConstants::quantifier_t quant,
+ SequenceType::Quantifier quant,
const QueryLoc& loc) const;
void get_schema_attribute_typeinfo(
@@ -167,16 +163,16 @@
xqtref_t create_type(
const XQType& type,
- TypeConstants::quantifier_t quant) const;
+ SequenceType::Quantifier quant) const;
xqtref_t create_type_x_quant(
const XQType& type,
- TypeConstants::quantifier_t quant) const;
+ SequenceType::Quantifier quant) const;
private:
xqtref_t create_builtin_node_type(
store::StoreConsts::NodeKind nodeKind,
- TypeConstants::quantifier_t quantifier,
+ SequenceType::Quantifier quantifier,
bool untyped) const;
};
=== modified file 'src/types/typeops.cpp'
--- src/types/typeops.cpp 2013-06-11 05:40:04 +0000
+++ src/types/typeops.cpp 2013-06-13 19:26:32 +0000
@@ -15,7 +15,6 @@
*/
#include "stdafx.h"
-#include <zorba/identtypes.h>
#include <zorba/typeident.h>
#include "api/unmarshaller.h"
@@ -53,8 +52,8 @@
********************************************************************************/
bool TypeOps::is_sub_quant(
- TypeConstants::quantifier_t q1,
- TypeConstants::quantifier_t q2)
+ SequenceType::Quantifier q1,
+ SequenceType::Quantifier q2)
{
return RootTypeManager::QUANT_SUBTYPE_MATRIX[q1][q2];
}
@@ -63,9 +62,9 @@
/*******************************************************************************
********************************************************************************/
-TypeConstants::quantifier_t TypeOps::intersect_quant(
- TypeConstants::quantifier_t q1,
- TypeConstants::quantifier_t q2)
+SequenceType::Quantifier TypeOps::intersect_quant(
+ SequenceType::Quantifier q1,
+ SequenceType::Quantifier q2)
{
return RootTypeManager::QUANT_INTERS_MATRIX [q1] [q2];
}
@@ -74,9 +73,9 @@
/*******************************************************************************
********************************************************************************/
-TypeConstants::quantifier_t TypeOps::union_quant(
- TypeConstants::quantifier_t q1,
- TypeConstants::quantifier_t q2)
+SequenceType::Quantifier TypeOps::union_quant(
+ SequenceType::Quantifier q1,
+ SequenceType::Quantifier q2)
{
return RootTypeManager::QUANT_UNION_MATRIX [q1] [q2];
}
@@ -100,7 +99,7 @@
if (type.type_kind() == XQType::USER_DEFINED_KIND)
{
return (tm->create_named_type(type.getQName(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
QueryLoc::null) != NULL);
}
else if (type.type_kind() == XQType::NODE_TYPE_KIND)
@@ -116,7 +115,7 @@
return is_in_scope(tm, *ctype);
}
else if (tm->create_named_type(ctype->getQName(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
QueryLoc::null) == NULL)
{
return false;
@@ -282,12 +281,12 @@
case XQType::ATOMIC_TYPE_KIND:
{
- if (type.get_quantifier() == TypeConstants::QUANT_ONE)
+ if (type.get_quantifier() == SequenceType::QUANT_ONE)
return &type;
const AtomicXQType& atype = static_cast<const AtomicXQType&>(type);
return tm->create_builtin_atomic_type(atype.get_type_code(),
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
}
case XQType::NONE_KIND:
@@ -308,13 +307,13 @@
case XQType::FUNCTION_TYPE_KIND:
{
- if (type.get_quantifier() == TypeConstants::QUANT_ONE)
+ if (type.get_quantifier() == SequenceType::QUANT_ONE)
return &type;
const FunctionXQType& lType = static_cast<const FunctionXQType&>(type);
return tm->create_function_type(lType.get_param_types(),
lType.get_return_type(),
- TypeConstants::QUANT_ONE);
+ SequenceType::QUANT_ONE);
}
case XQType::STRUCTURED_ITEM_KIND:
@@ -326,22 +325,22 @@
case XQType::NODE_TYPE_KIND:
{
- if (type.get_quantifier() == TypeConstants::QUANT_ONE)
+ if (type.get_quantifier() == SequenceType::QUANT_ONE)
return &type;
- return tm->create_type(type, TypeConstants::QUANT_ONE);
+ return tm->create_type(type, SequenceType::QUANT_ONE);
}
case XQType::USER_DEFINED_KIND:
{
- if (type.get_quantifier() == TypeConstants::QUANT_ONE)
+ if (type.get_quantifier() == SequenceType::QUANT_ONE)
return &type;
const UserDefinedXQType& udt = static_cast<const UserDefinedXQType&>(type);
if (udt.isGenAtomicAny())
{
- return tm->create_type(type, TypeConstants::QUANT_ONE);
+ return tm->create_type(type, SequenceType::QUANT_ONE);
}
else
{
@@ -779,7 +778,7 @@
return true;
xqtref_t subtype = tm->create_named_atomic_type(subitem->getType(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc,
true);
switch(subtype->type_kind())
@@ -884,7 +883,7 @@
return false;
xqtref_t subtype = tm->create_named_atomic_type(subitem->getType(),
- TypeConstants::QUANT_ONE,
+ SequenceType::QUANT_ONE,
loc,
true);
const UserDefinedXQType& udSuperType =
@@ -951,13 +950,13 @@
return &type1;
else if (type1.is_empty())
- return tm->create_type_x_quant(type2, TypeConstants::QUANT_QUESTION);
+ return tm->create_type_x_quant(type2, SequenceType::QUANT_QUESTION);
else if (type2.is_empty())
- return tm->create_type_x_quant(type1, TypeConstants::QUANT_QUESTION);
+ return tm->create_type_x_quant(type1, SequenceType::QUANT_QUESTION);
- else if (type1.get_quantifier() == TypeConstants::QUANT_ONE &&
- type2.get_quantifier() == TypeConstants::QUANT_ONE)
+ else if (type1.get_quantifier() == SequenceType::QUANT_ONE &&
+ type2.get_quantifier() == SequenceType::QUANT_ONE)
{
if (kind1 == kind2)
{
@@ -1003,13 +1002,13 @@
if (! is_equal(tm, type1, *pt1) || ! is_equal(tm, type2, *pt2))
{
- TypeConstants::quantifier_t q1 = type1.get_quantifier();
- TypeConstants::quantifier_t q2 = type2.get_quantifier();
+ SequenceType::Quantifier q1 = type1.get_quantifier();
+ SequenceType::Quantifier q2 = type2.get_quantifier();
- TypeConstants::quantifier_t q12 = RootTypeManager::QUANT_UNION_MATRIX[q1][q2];
+ SequenceType::Quantifier q12 = RootTypeManager::QUANT_UNION_MATRIX[q1][q2];
// to be on the safe side
- q12 = RootTypeManager::QUANT_UNION_MATRIX[TypeConstants::QUANT_QUESTION][q12];
+ q12 = RootTypeManager::QUANT_UNION_MATRIX[SequenceType::QUANT_QUESTION][q12];
return tm->create_type_x_quant(*union_type(*pt1, *pt2, tm), q12);
}
@@ -1049,20 +1048,20 @@
if (is_subtype(tm, type2, type1))
return &type2;
- TypeConstants::quantifier_t q1 = type1.get_quantifier();
- TypeConstants::quantifier_t q2 = type2.get_quantifier();
+ SequenceType::Quantifier q1 = type1.get_quantifier();
+ SequenceType::Quantifier q2 = type2.get_quantifier();
if (tk1 == XQType::EMPTY_KIND)
- return (q2 == TypeConstants::QUANT_QUESTION || q2 == TypeConstants::QUANT_STAR ?
+ return (q2 == SequenceType::QUANT_QUESTION || q2 == SequenceType::QUANT_STAR ?
rtm.EMPTY_TYPE :
rtm.NONE_TYPE);
if (tk2 == XQType::EMPTY_KIND)
- return (q1 == TypeConstants::QUANT_QUESTION || q1 == TypeConstants::QUANT_STAR ?
+ return (q1 == SequenceType::QUANT_QUESTION || q1 == SequenceType::QUANT_STAR ?
rtm.EMPTY_TYPE :
rtm.NONE_TYPE);
- if (q1 == TypeConstants::QUANT_ONE && q2 == TypeConstants::QUANT_ONE)
+ if (q1 == SequenceType::QUANT_ONE && q2 == SequenceType::QUANT_ONE)
{
assert(tk1 != XQType::EMPTY_KIND &&
tk1 != XQType::NONE_KIND &&
@@ -1151,6 +1150,7 @@
RootTypeManager& rtm = GENV_TYPESYSTEM;
+<<<<<<< TREE
TypeConstants::quantifier_t resultQuant = TypeConstants::QUANT_ONE;
TypeConstants::quantifier_t quant1 = type1.get_quantifier();
@@ -1160,18 +1160,31 @@
quant1 == TypeConstants::QUANT_STAR ||
quant2 == TypeConstants::QUANT_QUESTION ||
quant2 == TypeConstants::QUANT_STAR)
+=======
+ xqtref_t resultType;
+ SequenceType::Quantifier resultQuant = SequenceType::QUANT_ONE;
+
+ SequenceType::Quantifier quant1 = type1.get_quantifier();
+ SequenceType::Quantifier quant2 = type2.get_quantifier();
+
+ if (quant1 == SequenceType::QUANT_QUESTION ||
+ quant1 == SequenceType::QUANT_STAR ||
+ quant2 == SequenceType::QUANT_QUESTION ||
+ quant2 == SequenceType::QUANT_STAR)
+>>>>>>> MERGE-SOURCE
{
- resultQuant = TypeConstants::QUANT_QUESTION;
+ resultQuant = SequenceType::QUANT_QUESTION;
}
if (division &&
is_subtype(tm, type1, *rtm.INTEGER_TYPE_STAR) &&
is_subtype(tm, type2, *rtm.INTEGER_TYPE_STAR))
{
- return (resultQuant == TypeConstants::QUANT_ONE ?
+ return (resultQuant == SequenceType::QUANT_ONE ?
rtm.DECIMAL_TYPE_ONE : rtm.DECIMAL_TYPE_QUESTION);
}
+<<<<<<< TREE
if (is_subtype(tm, type1, *rtm.UNTYPED_ATOMIC_TYPE_STAR) ||
is_subtype(tm, type2, *rtm.UNTYPED_ATOMIC_TYPE_STAR))
{
@@ -1188,22 +1201,40 @@
if (is_subtype(tm, type1, *rtm.FLOAT_TYPE_STAR) ||
is_subtype(tm, type2, *rtm.FLOAT_TYPE_STAR))
- {
- return (resultQuant == TypeConstants::QUANT_ONE ?
+=======
+ if (TypeOps::is_subtype(tm, type1, *rtm.UNTYPED_ATOMIC_TYPE_STAR) ||
+ TypeOps::is_subtype(tm, type2, *rtm.UNTYPED_ATOMIC_TYPE_STAR))
+ {
+ return (resultQuant == SequenceType::QUANT_ONE ?
+ rtm.DOUBLE_TYPE_ONE : rtm.DOUBLE_TYPE_QUESTION);
+ }
+
+ if (TypeOps::is_subtype(tm, type1, *rtm.DOUBLE_TYPE_STAR) ||
+ TypeOps::is_subtype(tm, type2, *rtm.DOUBLE_TYPE_STAR))
+ {
+ return (resultQuant == SequenceType::QUANT_ONE ?
+ rtm.DOUBLE_TYPE_ONE : rtm.DOUBLE_TYPE_QUESTION);
+ }
+
+ if (TypeOps::is_subtype(tm, type1, *rtm.FLOAT_TYPE_STAR) ||
+ TypeOps::is_subtype(tm, type2, *rtm.FLOAT_TYPE_STAR))
+>>>>>>> MERGE-SOURCE
+ {
+ return (resultQuant == SequenceType::QUANT_ONE ?
rtm.FLOAT_TYPE_ONE : rtm.FLOAT_TYPE_QUESTION);
}
if (is_subtype(tm, type1, *rtm.INTEGER_TYPE_STAR) &&
is_subtype(tm, type2, *rtm.INTEGER_TYPE_STAR))
{
- return (resultQuant == TypeConstants::QUANT_ONE ?
+ return (resultQuant == SequenceType::QUANT_ONE ?
rtm.INTEGER_TYPE_ONE : rtm.INTEGER_TYPE_QUESTION);
}
if (is_subtype(tm, type1, *rtm.DECIMAL_TYPE_STAR) &&
is_subtype(tm, type2, *rtm.DECIMAL_TYPE_STAR))
{
- return (resultQuant == TypeConstants::QUANT_ONE ?
+ return (resultQuant == SequenceType::QUANT_ONE ?
rtm.DECIMAL_TYPE_ONE : rtm.DECIMAL_TYPE_QUESTION);
}
@@ -1214,6 +1245,7 @@
/*******************************************************************************
********************************************************************************/
+<<<<<<< TREE
store::SchemaTypeCode TypeOps::arithmetic_type(
store::SchemaTypeCode type1,
store::SchemaTypeCode type2,
@@ -1478,6 +1510,8 @@
/*******************************************************************************
********************************************************************************/
+=======
+>>>>>>> MERGE-SOURCE
std::ostream& TypeOps::serialize(std::ostream& os, const XQType& type)
{
return type.serialize_ostream(os);
@@ -1487,17 +1521,17 @@
/*******************************************************************************
********************************************************************************/
-const char* TypeOps::decode_quantifier(TypeConstants::quantifier_t quant)
+const char* TypeOps::decode_quantifier(SequenceType::Quantifier quant)
{
switch (quant)
{
- case TypeConstants::QUANT_ONE:
+ case SequenceType::QUANT_ONE:
return "";
- case TypeConstants::QUANT_QUESTION:
+ case SequenceType::QUANT_QUESTION:
return "?";
- case TypeConstants::QUANT_STAR:
+ case SequenceType::QUANT_STAR:
return "*";
- case TypeConstants::QUANT_PLUS:
+ case SequenceType::QUANT_PLUS:
return "+";
default:
return "<unknown-quant>";
=== modified file 'src/types/typeops.h'
--- src/types/typeops.h 2013-06-11 05:40:04 +0000
+++ src/types/typeops.h 2013-06-13 19:26:32 +0000
@@ -14,14 +14,16 @@
* limitations under the License.
*/
#pragma once
-#ifndef ZORBA_TYPEOPS_H
-#define ZORBA_TYPEOPS_H
+#ifndef ZORBA_TYPES_TYPEOPS_H
+#define ZORBA_TYPES_TYPEOPS_H
#include <string>
#include <zorba/config.h>
+#include <zorba/api_shared_types.h>
+#include <zorba/typeident.h>
+
#include "common/shared_types.h"
#include "types/typeconstants.h"
-#include "zorba/typeident.h"
#include "compiler/parser/query_loc.h"
@@ -31,8 +33,7 @@
namespace zorba
{
-// exported for unit testing only
-class ZORBA_DLL_PUBLIC TypeOps
+class TypeOps
{
public:
/**
@@ -40,24 +41,24 @@
* in root_typemanger.h).
*/
static bool is_sub_quant(
- TypeConstants::quantifier_t q1,
- TypeConstants::quantifier_t q2);
+ SequenceType::Quantifier q1,
+ SequenceType::Quantifier q2);
/**
* Return the "intersection" of the 2 given quantifiers (see QUANT_INTERS_MATRIX
* in root_typemanger.h).
*/
- static TypeConstants::quantifier_t intersect_quant(
- TypeConstants::quantifier_t,
- TypeConstants::quantifier_t);
+ static SequenceType::Quantifier intersect_quant(
+ SequenceType::Quantifier,
+ SequenceType::Quantifier);
/**
* Return the "union" of the 2 given quantifiers (see QUANT_UNION_MATRIX
* in root_typemanger.h).
*/
- static TypeConstants::quantifier_t union_quant(
- TypeConstants::quantifier_t,
- TypeConstants::quantifier_t);
+ static SequenceType::Quantifier union_quant(
+ SequenceType::Quantifier,
+ SequenceType::Quantifier);
/*
* Returns the atomic_type_code_t for a given type, which is assumed to be
@@ -187,16 +188,6 @@
bool division);
/*
- * Returns a type identifier that represents the given type.
- * The invariant that is guaranteed is:
- * is_subtype(_t_, create_type(*get_type_identifier(_t_))) == true
- */
- static TypeIdentifier_t get_type_identifier(
- const TypeManager* tm,
- const XQType& type,
- bool nested = false);
-
- /*
* Writes a textual representation of the given type to the output stream.
*/
static std::ostream& serialize(std::ostream& os, const XQType& type);
@@ -204,7 +195,7 @@
/*
* Returns a string with a textual representation of the given quantifier.
*/
- static const char* decode_quantifier(TypeConstants::quantifier_t quant);
+ static const char* decode_quantifier(SequenceType::Quantifier quant);
};
}
=== modified file 'swig/Collection.h'
--- swig/Collection.h 2013-02-07 17:24:36 +0000
+++ swig/Collection.h 2013-06-13 19:26:32 +0000
@@ -101,7 +101,7 @@
*
* @see isStatic()
*/
- TypeIdentifier getType();
+ SequenceType getType();
/**
* This function returns the index of the given node in the collection.
@@ -177,4 +177,4 @@
//void registerDiagnosticHandler(DiagnosticHandler *aDiagnosticHandler );
};
-#endif
\ No newline at end of file
+#endif
=== modified file 'swig/Collection.i'
--- swig/Collection.i 2013-02-07 17:24:36 +0000
+++ swig/Collection.i 2013-06-13 19:26:32 +0000
@@ -51,9 +51,9 @@
return Item( theCollection->getName() );
}
- TypeIdentifier Collection::getType()
+ SequenceType Collection::getType()
{
- return TypeIdentifier( theCollection->getType() );
+ return SequenceType( theCollection->getType() );
}
long long Collection::indexOf(const Item &aNode )
=== modified file 'swig/StaticContext.h'
--- swig/StaticContext.h 2013-02-07 17:24:36 +0000
+++ swig/StaticContext.h 2013-06-13 19:26:32 +0000
@@ -80,6 +80,7 @@
{
friend class Zorba;
friend class XQuery;
+friend class SequenceType;
private:
zorba::StaticContext_t theStaticContext;
@@ -291,19 +292,19 @@
/** \brief Get the type of a statically known collection
*/
- TypeIdentifier getCollectionType(const std::string &aCollectionUri);
+ SequenceType getCollectionType(const std::string &aCollectionUri);
/** \brief Get the type of a statically known document
*/
- TypeIdentifier getDocumentType(const std::string &aDocUri);
+ SequenceType getDocumentType(const std::string &aDocUri);
/** \brief Fetch the type of the context item.
*/
- TypeIdentifier getContextItemStaticType();
+ SequenceType getContextItemStaticType();
/** \brief Set the type of the context item.
*/
- void setContextItemStaticType(const TypeIdentifier &aType);
+ void setContextItemStaticType(const SequenceType &aType);
/** \brief Resets the output stream that is used by the fn:trace function to std::cerr
*/
@@ -437,4 +438,4 @@
void destroy();
}; // class StaticContext
-#endif
\ No newline at end of file
+#endif
=== modified file 'swig/StaticContext.i'
--- swig/StaticContext.i 2013-03-22 23:40:03 +0000
+++ swig/StaticContext.i 2013-06-13 19:26:32 +0000
@@ -168,14 +168,14 @@
return StaticCollectionManager( theStaticContext->getStaticCollectionManager() );
}
-TypeIdentifier StaticContext::getCollectionType(const std::string & aCollectionUri)
- { return TypeIdentifier(theStaticContext->getCollectionType(aCollectionUri)); }
-
-TypeIdentifier StaticContext::getDocumentType(const std::string &aDocUri)
- { return TypeIdentifier(theStaticContext->getDocumentType(aDocUri)); }
-
-TypeIdentifier StaticContext::getContextItemStaticType()
- { return TypeIdentifier(theStaticContext->getContextItemStaticType()); }
+SequenceType StaticContext::getCollectionType(const std::string & aCollectionUri)
+ { return SequenceType(theStaticContext->getCollectionType(aCollectionUri)); }
+
+SequenceType StaticContext::getDocumentType(const std::string &aDocUri)
+ { return SequenceType(theStaticContext->getDocumentType(aDocUri)); }
+
+SequenceType StaticContext::getContextItemStaticType()
+ { return SequenceType(theStaticContext->getContextItemStaticType()); }
std::vector< std::pair< std::string, std::string > > StaticContext::getNamespaceBindings () {
std::vector< std::pair< zorba::String, zorba::String > > items;
@@ -193,8 +193,8 @@
-void StaticContext::setContextItemStaticType(const TypeIdentifier &aType)
- { theStaticContext->setContextItemStaticType(aType.theTypeIdentifier); }
+void StaticContext::setContextItemStaticType(const SequenceType &aType)
+ { theStaticContext->setContextItemStaticType(aType.theSequenceType); }
void StaticContext::resetTraceStream ()
{ theStaticContext->resetTraceStream(); }
=== modified file 'swig/TypeIdentifier.h'
--- swig/TypeIdentifier.h 2013-03-27 19:49:18 +0000
+++ swig/TypeIdentifier.h 2013-06-13 19:26:32 +0000
@@ -17,23 +17,34 @@
#ifndef API_TYPE_IDENTIFIER_H
#define API_TYPE_IDENTIFIER_H
-class IdentTypes {
+class IdentTypes
+{
public:
- typedef enum {
- NAMED_TYPE,
+ typedef enum
+ {
+ EMPTY_TYPE,
+ ITEM_TYPE,
+ ATOMIC_OR_UNION_TYPE,
+ FUNCTION_TYPE,
+ STRUCTURED_ITEM_TYPE,
+ NODE_TYPE,
+ DOCUMENT_TYPE,
ELEMENT_TYPE,
+ SCHEMA_ELEMENT_TYPE,
ATTRIBUTE_TYPE,
- DOCUMENT_TYPE,
+ SCHEMA_ATTRIBUTE_TYPE,
PI_TYPE,
TEXT_TYPE,
COMMENT_TYPE,
- ANY_NODE_TYPE,
- ITEM_TYPE,
- EMPTY_TYPE,
+ NAMESPACE_TYPE,
+ JSON_ITEM_TYPE,
+ JSON_OBJECT_TYPE,
+ JSON_ARRAY_TYPE,
INVALID_TYPE,
} Kind;
- typedef enum {
+ typedef enum
+ {
QUANT_ONE,
QUANT_QUESTION,
QUANT_PLUS,
@@ -41,62 +52,132 @@
} Quantifier;
};
+
+class StaticContext;
+
+
/** \brief Type identifiers
*
* The type identifiers provides a way to identify the type of an Item.
*
*/
-class TypeIdentifier
+class SequenceType
{
friend class StaticContext;
private:
- zorba::TypeIdentifier_t theTypeIdentifier;
- static zorba::IdentTypes::quantifier_t convertQuantifier(IdentTypes::Quantifier quantifier);
+ zorba::SequenceType theSequenceType;
+
+ static zorba::SequenceType::Quantifier convertQuantifier(
+ IdentTypes::Quantifier quantifier);
public:
- TypeIdentifier (const TypeIdentifier& aTypeIdentifier) : theTypeIdentifier(aTypeIdentifier.theTypeIdentifier) {}
- TypeIdentifier (const zorba::TypeIdentifier_t& aZTypeIdentifier) : theTypeIdentifier(aZTypeIdentifier) {}
-
- TypeIdentifier getContentType();
+ SequenceType(const SequenceType& aSequenceType)
+ :
+ theSequenceType(aSequenceType.theSequenceType)
+ {
+ }
+
+ SequenceType(const zorba::SequenceType& aZSequenceType)
+ :
+ theSequenceType(aZSequenceType)
+ {
+ }
+
IdentTypes::Kind getKind();
- const std::string getLocalName();
+
IdentTypes::Quantifier getQuantifier();
- long getRefCount();
- const std::string getUri();
- bool isLocalNameWildcard();
- bool isUriWildcard();
-
- static TypeIdentifier
- createAnyNodeType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
- static TypeIdentifier
- createAttributeType (const std::string &uri, bool uriWildcard, const std::string &localNameName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
- static TypeIdentifier
- createCommentType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
- static TypeIdentifier
- createDocumentType ();
-
- static TypeIdentifier
- createElementType (const std::string &uri, bool uriWildcard, const std::string &localName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
- static TypeIdentifier
- createEmptyType();
-
- static TypeIdentifier
- createItemType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
- static TypeIdentifier
- createNamedType (const std::string &uri, const std::string &localName, IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
- static TypeIdentifier
- createPIType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
- static TypeIdentifier
- createTextType (IdentTypes::Quantifier quantifier=IdentTypes::QUANT_ONE);
-
-}; // class TypeIdentifier
-
-
-#endif
\ No newline at end of file
+
+ const std::string getTypeLocalName();
+
+ const std::string getTypeUri();
+
+ const std::string getNodeLocalName();
+
+ const std::string getNodeUri();
+
+ const std::string getContentTypeLocalName();
+
+ const std::string getContentTypeUri();
+
+ bool isWildcard();
+
+ bool isSchemaTest();
+
+ static SequenceType createEmptyType();
+
+ static SequenceType createItemType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType createAtomicOrUnionType(
+ const StaticContext& sctx,
+ const std::string& uri,
+ const std::string& localName,
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType createStructuredItemType(
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType createAnyNodeType(
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createDocumentType(
+ const SequenceType& contentType,
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createElementType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ const std::string& contentTypeUri,
+ const std::string& contentTypeLocalName,
+ bool nillable,
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createSchemaElementType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createAttributeType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ const std::string& contentTypeUri,
+ const std::string& contentTypeLocalName,
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createSchemaAttributeType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createPIType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createTextType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createCommentType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createNamespaceType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createJSONItemType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createJSONObjectType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+
+ static SequenceType
+ createJSONArrayType(IdentTypes::Quantifier q = IdentTypes::QUANT_ONE);
+}; // class SequenceType
+
+
+#endif
=== modified file 'swig/TypeIdentifier.i'
--- swig/TypeIdentifier.i 2013-03-27 19:49:18 +0000
+++ swig/TypeIdentifier.i 2013-06-13 19:26:32 +0000
@@ -16,177 +16,350 @@
%{ // start Implementation
- zorba::IdentTypes::quantifier_t
- TypeIdentifier::convertQuantifier(IdentTypes::Quantifier quantifier)
- {
- zorba::IdentTypes::quantifier_t result = zorba::IdentTypes::QUANT_ONE;
- switch (quantifier) {
- case IdentTypes::QUANT_ONE:
- result = zorba::IdentTypes::QUANT_ONE;
- break;
- case IdentTypes::QUANT_QUESTION:
- result = zorba::IdentTypes::QUANT_QUESTION;
- break;
- case IdentTypes::QUANT_PLUS:
- result = zorba::IdentTypes::QUANT_PLUS;
- break;
- case IdentTypes::QUANT_STAR:
- result = zorba::IdentTypes::QUANT_STAR;
- break;
- }
- return result;
- }
-
- TypeIdentifier TypeIdentifier::getContentType()
- {
- return TypeIdentifier(theTypeIdentifier->getContentType());
- }
- IdentTypes::Kind TypeIdentifier::getKind()
- {
- zorba::IdentTypes::kind_t lKind = theTypeIdentifier->getKind();
- IdentTypes::Kind result = IdentTypes::ANY_NODE_TYPE;
- switch (lKind) {
- case zorba::IdentTypes::NAMED_TYPE:
- result = IdentTypes::NAMED_TYPE;
- break;
- case zorba::IdentTypes::ELEMENT_TYPE:
- result = IdentTypes::ELEMENT_TYPE;
- break;
- case zorba::IdentTypes::ATTRIBUTE_TYPE:
- result = IdentTypes::ATTRIBUTE_TYPE;
- break;
- case zorba::IdentTypes::DOCUMENT_TYPE:
- result = IdentTypes::DOCUMENT_TYPE;
- break;
- case zorba::IdentTypes::PI_TYPE:
- result = IdentTypes::PI_TYPE;
- break;
- case zorba::IdentTypes::TEXT_TYPE:
- result = IdentTypes::TEXT_TYPE;
- break;
- case zorba::IdentTypes::COMMENT_TYPE:
- result = IdentTypes::COMMENT_TYPE;
- break;
- case zorba::IdentTypes::ANY_NODE_TYPE:
- result = IdentTypes::ANY_NODE_TYPE;
- break;
- case zorba::IdentTypes::ITEM_TYPE:
- result = IdentTypes::ITEM_TYPE;
- break;
- case zorba::IdentTypes::EMPTY_TYPE:
- result = IdentTypes::EMPTY_TYPE;
- break;
- case zorba::IdentTypes::INVALID_TYPE:
- result = IdentTypes::INVALID_TYPE;
- break;
- default:
- result = IdentTypes::ANY_NODE_TYPE;
- break;
- }
- return result;
- }
- const std::string TypeIdentifier::getLocalName()
- {
- return std::string(theTypeIdentifier->getLocalName().c_str());
- }
- IdentTypes::Quantifier TypeIdentifier::getQuantifier()
- {
- zorba::IdentTypes::quantifier_t lQuantifier = theTypeIdentifier->getQuantifier();
- IdentTypes::Quantifier result = IdentTypes::QUANT_ONE;
- switch (lQuantifier) {
- case zorba::IdentTypes::QUANT_ONE:
- result = IdentTypes::QUANT_ONE;
- break;
- case zorba::IdentTypes::QUANT_QUESTION:
- result = IdentTypes::QUANT_QUESTION;
- break;
- case zorba::IdentTypes::QUANT_PLUS:
- result = IdentTypes::QUANT_PLUS;
- break;
- case zorba::IdentTypes::QUANT_STAR:
- result = IdentTypes::QUANT_STAR;
- break;
- }
- return result;
- }
- long TypeIdentifier::getRefCount()
- {
- return theTypeIdentifier->getRefCount();
- }
- const std::string TypeIdentifier::getUri()
- {
- return std::string(theTypeIdentifier->getUri().c_str());
- }
- bool TypeIdentifier::isLocalNameWildcard()
- {
- return theTypeIdentifier->isLocalNameWildcard();
- }
- bool TypeIdentifier::isUriWildcard()
- {
- return theTypeIdentifier->isUriWildcard();
- }
+zorba::SequenceType::Quantifier
+SequenceType::convertQuantifier(IdentTypes::Quantifier quantifier)
+{
+ zorba::SequenceType::Quantifier result = zorba::SequenceType::QUANT_ONE;
+
+ switch (quantifier)
+ {
+ case IdentTypes::QUANT_ONE:
+ result = zorba::SequenceType::QUANT_ONE;
+ break;
+ case IdentTypes::QUANT_QUESTION:
+ result = zorba::SequenceType::QUANT_QUESTION;
+ break;
+ case IdentTypes::QUANT_PLUS:
+ result = zorba::SequenceType::QUANT_PLUS;
+ break;
+ case IdentTypes::QUANT_STAR:
+ result = zorba::SequenceType::QUANT_STAR;
+ break;
+ }
+ return result;
+}
+
+
+IdentTypes::Kind SequenceType::getKind()
+{
+ zorba::SequenceType::Kind lKind = theSequenceType.getKind();
+
+ IdentTypes::Kind result = IdentTypes::NODE_TYPE;
+
+ switch (lKind)
+ {
+ case zorba::SequenceType::EMPTY_TYPE:
+ result = IdentTypes::EMPTY_TYPE;
+ break;
+ case zorba::SequenceType::ITEM_TYPE:
+ result = IdentTypes::ITEM_TYPE;
+ break;
+ case zorba::SequenceType::ATOMIC_OR_UNION_TYPE:
+ result = IdentTypes::ATOMIC_OR_UNION_TYPE;
+ break;
+ case zorba::SequenceType::FUNCTION_TYPE:
+ result = IdentTypes::FUNCTION_TYPE;
+ break;
+ case zorba::SequenceType::STRUCTURED_ITEM_TYPE:
+ result = IdentTypes::STRUCTURED_ITEM_TYPE;
+ break;
+ case zorba::SequenceType::NODE_TYPE:
+ result = IdentTypes::NODE_TYPE;
+ break;
+ case zorba::SequenceType::DOCUMENT_TYPE:
+ result = IdentTypes::DOCUMENT_TYPE;
+ break;
+ case zorba::SequenceType::ELEMENT_TYPE:
+ result = IdentTypes::ELEMENT_TYPE;
+ break;
+ case zorba::SequenceType::SCHEMA_ELEMENT_TYPE:
+ result = IdentTypes::SCHEMA_ELEMENT_TYPE;
+ break;
+ case zorba::SequenceType::ATTRIBUTE_TYPE:
+ result = IdentTypes::ATTRIBUTE_TYPE;
+ break;
+ case zorba::SequenceType::SCHEMA_ATTRIBUTE_TYPE:
+ result = IdentTypes::SCHEMA_ATTRIBUTE_TYPE;
+ break;
+ case zorba::SequenceType::PI_TYPE:
+ result = IdentTypes::PI_TYPE;
+ break;
+ case zorba::SequenceType::TEXT_TYPE:
+ result = IdentTypes::TEXT_TYPE;
+ break;
+ case zorba::SequenceType::COMMENT_TYPE:
+ result = IdentTypes::COMMENT_TYPE;
+ break;
+ case zorba::SequenceType::NAMESPACE_TYPE:
+ result = IdentTypes::NAMESPACE_TYPE;
+ break;
+ case zorba::SequenceType::JSON_ITEM_TYPE:
+ result = IdentTypes::JSON_ITEM_TYPE;
+ break;
+ case zorba::SequenceType::JSON_OBJECT_TYPE:
+ result = IdentTypes::JSON_OBJECT_TYPE;
+ break;
+ case zorba::SequenceType::JSON_ARRAY_TYPE:
+ result = IdentTypes::JSON_ARRAY_TYPE;
+ break;
+ case zorba::SequenceType::INVALID_TYPE:
+ result = IdentTypes::INVALID_TYPE;
+ break;
+ }
+ return result;
+}
+
+
+IdentTypes::Quantifier SequenceType::getQuantifier()
+{
+ zorba::SequenceType::Quantifier lQuantifier = theSequenceType.getQuantifier();
+
+ switch (lQuantifier)
+ {
+ case zorba::SequenceType::QUANT_ONE:
+ return IdentTypes::QUANT_ONE;
+ case zorba::SequenceType::QUANT_QUESTION:
+ return IdentTypes::QUANT_QUESTION;
+ case zorba::SequenceType::QUANT_PLUS:
+ return IdentTypes::QUANT_PLUS;
+ case zorba::SequenceType::QUANT_STAR:
+ return IdentTypes::QUANT_STAR;
+ default:
+ return IdentTypes::QUANT_ONE;
+ }
+}
+
+
+const std::string SequenceType::getTypeLocalName()
+{
+ return std::string(theSequenceType.getTypeLocalName().c_str());
+}
+
+
+const std::string SequenceType::getTypeUri()
+{
+ return std::string(theSequenceType.getTypeUri().c_str());
+}
+
+
+const std::string SequenceType::getNodeLocalName()
+{
+ return std::string(theSequenceType.getNodeLocalName().c_str());
+}
+
+
+const std::string SequenceType::getNodeUri()
+{
+ return std::string(theSequenceType.getNodeUri().c_str());
+}
+
+
+const std::string SequenceType::getContentTypeLocalName()
+{
+ return std::string(theSequenceType.getContentTypeLocalName().c_str());
+}
+
+
+const std::string SequenceType::getContentTypeUri()
+{
+ return std::string(theSequenceType.getContentTypeUri().c_str());
+}
+
+
+bool SequenceType::isWildcard()
+{
+ return theSequenceType.isWildcard();
+}
+
+
+bool SequenceType::isSchemaTest()
+{
+ return theSequenceType.isSchemaTest();
+}
// STATIC METHODS
- TypeIdentifier
- TypeIdentifier::createAnyNodeType (IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createAnyNodeType ( convertQuantifier(quantifier) ) );
- }
-
- TypeIdentifier
- TypeIdentifier::createAttributeType (const std::string &uri, bool uriWildcard, const std::string &localNameName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createAttributeType( uri, uriWildcard, localNameName, localNameWildcard, contentType.theTypeIdentifier, convertQuantifier(quantifier) ) );
- }
-
- TypeIdentifier
- TypeIdentifier::createCommentType (IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createCommentType ( convertQuantifier(quantifier) ) );
- }
-
- TypeIdentifier
- TypeIdentifier::createDocumentType ()
- {
- return TypeIdentifier( zorba::TypeIdentifier::createDocumentType(NULL) );
- }
-
- TypeIdentifier
- TypeIdentifier::createElementType (const std::string &uri, bool uriWildcard, const std::string &localName, bool localNameWildcard, TypeIdentifier contentType, IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createElementType(uri, uriWildcard, localName, localNameWildcard, contentType.theTypeIdentifier, convertQuantifier(quantifier) ) );
- }
-
- TypeIdentifier
- TypeIdentifier::createEmptyType()
- {
- return TypeIdentifier( zorba::TypeIdentifier::createEmptyType() );
- }
-
- TypeIdentifier
- TypeIdentifier::createItemType (IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createItemType( convertQuantifier(quantifier) ) );
- }
-
- TypeIdentifier
- TypeIdentifier::createNamedType (const std::string &uri, const std::string &localName, IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createNamedType( uri, localName, convertQuantifier(quantifier) ) );
- }
-
- TypeIdentifier
- TypeIdentifier::createPIType (IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createPIType( convertQuantifier(quantifier) ) );
- }
-
- TypeIdentifier
- TypeIdentifier::createTextType (IdentTypes::Quantifier quantifier)
- {
- return TypeIdentifier( zorba::TypeIdentifier::createTextType( convertQuantifier(quantifier) ) );
- }
+
+SequenceType
+SequenceType::createEmptyType()
+{
+ return SequenceType(zorba::SequenceType::createEmptyType());
+}
+
+
+SequenceType
+SequenceType::createItemType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createItemType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createAtomicOrUnionType(
+ const StaticContext& sctx,
+ const std::string& uri,
+ const std::string& localName,
+ IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createAtomicOrUnionType(sctx.theStaticContext,
+ uri,
+ localName,
+ convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createStructuredItemType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createStructuredItemType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createAnyNodeType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createAnyNodeType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createDocumentType(
+ const SequenceType& contentType,
+ IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createDocumentType(contentType.theSequenceType,
+ convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createElementType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ const std::string& contentTypeUri,
+ const std::string& contentTypeLocalName,
+ bool nillable,
+ IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createElementType(sctx.theStaticContext,
+ nodeUri,
+ nodeLocalName,
+ contentTypeUri,
+ contentTypeLocalName,
+ convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createSchemaElementType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createSchemaElementType(sctx.theStaticContext,
+ nodeUri,
+ nodeLocalName,
+ convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createAttributeType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ const std::string& contentTypeUri,
+ const std::string& contentTypeLocalName,
+ IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createElementType(sctx.theStaticContext,
+ nodeUri,
+ nodeLocalName,
+ contentTypeUri,
+ contentTypeLocalName,
+ convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createSchemaAttributeType(
+ const StaticContext& sctx,
+ const std::string& nodeUri,
+ const std::string& nodeLocalName,
+ IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createSchemaAttributeType(sctx.theStaticContext,
+ nodeUri,
+ nodeLocalName,
+ convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createPIType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createPIType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createTextType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createTextType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createCommentType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createCommentType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createNamespaceType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createNamespaceType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createJSONItemType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createJSONItemType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createJSONObjectType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createJSONArrayType(convertQuantifier(q)));
+}
+
+
+SequenceType
+SequenceType::createJSONArrayType(IdentTypes::Quantifier q)
+{
+ return SequenceType(
+ zorba::SequenceType::createJSONArrayType(convertQuantifier(q)));
+}
// END OF STATIC METHODS
=== modified file 'swig/xqj/ZorbaXQItemType.java'
--- swig/xqj/ZorbaXQItemType.java 2013-03-27 19:49:18 +0000
+++ swig/xqj/ZorbaXQItemType.java 2013-06-13 19:26:32 +0000
@@ -21,7 +21,9 @@
import javax.xml.xquery.XQSequenceType;
import org.zorbaxquery.api.IdentTypes.Kind;
import org.zorbaxquery.api.Item;
-import org.zorbaxquery.api.TypeIdentifier;
+import org.zorbaxquery.api.SequenceType;
+import org.zorbaxquery.api.StaticContext;
+
/**
* The ZorbaXQItemType class represents an item type as defined in XQuery 1.0: An XML Query language.
* The ZorbaXQItemType extends the XQSequenceType but restricts the occurrance indicator to be exactly one. This derivation allows passing an item type wherever a sequence type is expected, but not the other way. The ZorbaXQItemType interface contains methods to represent information about the following aspects of an item type:
@@ -35,7 +37,8 @@
*
* An instance of the ZorbaXQItemType is a standalone object that is independant of the XQConnection and any XQuery static or dynamic context.
*/
-public class ZorbaXQItemType implements javax.xml.xquery.XQItemType {
+public class ZorbaXQItemType implements javax.xml.xquery.XQItemType
+{
public static final int ZORBA_XQITEMKIND_ANY = 0;
public static final int ZORBA_XQITEMKIND_DOCUMENT = 1;
public static final int ZORBA_XQITEMKIND_ELEMENT = 2;
@@ -51,84 +54,137 @@
private URI schemaURI = null;
private boolean allowNill = false;
private String piTarget = null;
-
- protected TypeIdentifier getTypeIdentifier() throws XQException {
- TypeIdentifier result = null;
- switch (itemKind) {
- case XQITEMKIND_ATOMIC:
- result = TypeIdentifier.createEmptyType();
- break;
- case XQITEMKIND_ATTRIBUTE:
- result = TypeIdentifier.createAttributeType(schemaURI.toString(), true, nodeName.getLocalPart(), true, TypeIdentifier.createAnyNodeType());
- break;
- case XQITEMKIND_COMMENT:
- result = TypeIdentifier.createCommentType();
- break;
- case XQITEMKIND_DOCUMENT:
- case XQITEMKIND_DOCUMENT_ELEMENT:
- case XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT:
- result = TypeIdentifier.createDocumentType();
- break;
- case XQITEMKIND_ELEMENT:
- result = TypeIdentifier.createElementType(schemaURI.toString(), true, nodeName.getLocalPart(), true, TypeIdentifier.createAnyNodeType());
- break;
- case XQITEMKIND_ITEM:
- result = TypeIdentifier.createItemType();
- break;
- case XQITEMKIND_NODE:
- result = TypeIdentifier.createAnyNodeType();
- break;
- case XQITEMKIND_PI:
- result = TypeIdentifier.createPIType();
- break;
- case XQITEMKIND_TEXT:
- result = TypeIdentifier.createTextType();
- break;
- case XQITEMKIND_SCHEMA_ATTRIBUTE:
- case XQITEMKIND_SCHEMA_ELEMENT:
- default:
- throw new XQException("Item kind is not valid.");
-
+ private StaticContext sctx;
+
+ protected SequenceType getSequenceType() throws XQException
+ {
+ SequenceType result = null;
+ switch (itemKind)
+ {
+ case XQITEMKIND_ITEM:
+ result = SequenceType.createItemType();
+ break;
+
+ case XQITEMKIND_ATOMIC:
+ result = SequenceType.createAtomicOrUnionType(sctx,
+ typeName.getNamespaceURI(),
+ typeName.getLocalPart());
+ break;
+
+ case XQITEMKIND_NODE:
+ result = SequenceType.createAnyNodeType();
+ break;
+
+ case XQITEMKIND_DOCUMENT:
+ case XQITEMKIND_DOCUMENT_ELEMENT:
+ case XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT:
+ result = SequenceType.createAnyNodeType();
+ break;
+
+ case XQITEMKIND_ELEMENT:
+ result = SequenceType.createElementType(sctx,
+ nodeName.getNamespaceURI(),
+ nodeName.getLocalPart(),
+ typeName.getNamespaceURI(),
+ typeName.getLocalPart(),
+ allowNill);
+ break;
+ case XQITEMKIND_ATTRIBUTE:
+ result = SequenceType.createAttributeType(sctx,
+ nodeName.getNamespaceURI(),
+ nodeName.getLocalPart(),
+ typeName.getNamespaceURI(),
+ typeName.getLocalPart());
+ break;
+
+ case XQITEMKIND_PI:
+ result = SequenceType.createPIType();
+ break;
+
+ case XQITEMKIND_TEXT:
+ result = SequenceType.createTextType();
+ break;
+
+ case XQITEMKIND_COMMENT:
+ result = SequenceType.createCommentType();
+ break;
+
+ case XQITEMKIND_SCHEMA_ATTRIBUTE:
+ case XQITEMKIND_SCHEMA_ELEMENT:
+ default:
+ throw new XQException("Item kind is not valid.");
+
}
return result;
}
- public ZorbaXQItemType(TypeIdentifier typeIdentifier) {
- switch (typeIdentifier.getKind()) {
- case Kind.ANY_NODE_TYPE:
- itemKind = XQITEMKIND_NODE;
- break;
- case Kind.ATTRIBUTE_TYPE:
- itemKind = XQITEMKIND_ATTRIBUTE;
- break;
- case Kind.COMMENT_TYPE:
- itemKind = XQITEMKIND_COMMENT;
- break;
- case Kind.DOCUMENT_TYPE:
- itemKind = XQITEMKIND_DOCUMENT;
- break;
- case Kind.ELEMENT_TYPE:
- itemKind = XQITEMKIND_ELEMENT;
- break;
- case Kind.EMPTY_TYPE:
- case Kind.INVALID_TYPE:
- case Kind.ITEM_TYPE:
- case Kind.NAMED_TYPE:
- itemKind = XQITEMKIND_ITEM;
- break;
- case Kind.PI_TYPE:
- itemKind = XQITEMKIND_PI;
- break;
- case Kind.TEXT_TYPE:
- itemKind = XQITEMKIND_TEXT;
- break;
- default:
- itemKind = XQITEMKIND_NODE;
- break;
+ public ZorbaXQItemType(SequenceType seqType)
+ {
+ switch (seqType.getKind())
+ {
+ case Kind.EMPTY_TYPE:
+ // TODO: raise error
+ break;
+ case Kind.ITEM_TYPE:
+ itemKind = XQITEMKIND_ITEM;
+ break;
+ case Kind.ATOMIC_OR_UNION_TYPE:
+ itemKind = XQITEMKIND_ATOMIC;
+ break;
+ case Kind.FUNCTION_TYPE:
+ case Kind.STRUCTURED_ITEM_TYPE:
+ itemKind = XQITEMKIND_ITEM;
+ break;
+ case Kind.NODE_TYPE:
+ itemKind = XQITEMKIND_NODE;
+ break;
+ case Kind.DOCUMENT_TYPE:
+ itemKind = XQITEMKIND_DOCUMENT;
+ break;
+ case Kind.ELEMENT_TYPE:
+ itemKind = XQITEMKIND_ELEMENT;
+ break;
+ case Kind.SCHEMA_ELEMENT_TYPE:
+ itemKind = XQITEMKIND_SCHEMA_ELEMENT;
+ break;
+ case Kind.ATTRIBUTE_TYPE:
+ itemKind = XQITEMKIND_ATTRIBUTE;
+ break;
+ case Kind.SCHEMA_ATTRIBUTE_TYPE:
+ itemKind = XQITEMKIND_SCHEMA_ATTRIBUTE;
+ break;
+ case Kind.PI_TYPE:
+ itemKind = XQITEMKIND_PI;
+ break;
+ case Kind.TEXT_TYPE:
+ itemKind = XQITEMKIND_TEXT;
+ break;
+ case Kind.COMMENT_TYPE:
+ itemKind = XQITEMKIND_COMMENT;
+ break;
+ case Kind.NAMESPACE_TYPE:
+ itemKind = XQITEMKIND_NODE;
+ break;
+ case Kind.JSON_ITEM_TYPE:
+ itemKind = XQITEMKIND_ITEM;
+ break;
+ case Kind.JSON_OBJECT_TYPE:
+ itemKind = XQITEMKIND_ITEM;
+ break;
+ case Kind.JSON_ARRAY_TYPE:
+ itemKind = XQITEMKIND_ITEM;
+ break;
+ case Kind.INVALID_TYPE:
+ default:
+ // TODO: raise error
+ itemKind = XQITEMKIND_ITEM;
+ break;
}
- String type = typeIdentifier.getLocalName();
+ String type = seqType.getTypeLocalName();
+
baseType = ZorbaXQItemType.XQBASETYPE_ANYTYPE;
+
if (type.indexOf("anyAtomicType")>=0){
baseType = ZorbaXQItemType.XQBASETYPE_ANYATOMICTYPE;
} else if (type.indexOf("anySimpleType")>=0){
@@ -230,10 +286,13 @@
} else if (type.indexOf("yearMonthDuration")>=0){
baseType = ZorbaXQItemType.XQBASETYPE_YEARMONTHDURATION;
}
+
generateTypeName();
}
- public ZorbaXQItemType(Item zorbaItem) {
-
+
+
+ public ZorbaXQItemType(Item zorbaItem)
+ {
String type = "";
if (zorbaItem.isNode()) {
switch (zorbaItem.getNodeKind()) {
@@ -377,21 +436,29 @@
this.piTarget = piTarget;
generateTypeName();
}
+
+
public ZorbaXQItemType(int itemkind) {
this.itemKind = itemkind;
generateTypeName();
}
+
+
public ZorbaXQItemType(int itemkind, int basetype) {
this.itemKind = itemkind;
this.baseType = basetype;
generateTypeName();
}
+
+
public ZorbaXQItemType(int itemkind, QName nodename, int basetype) {
this.itemKind = itemkind;
this.nodeName = nodename;
this.baseType = basetype;
generateTypeName();
}
+
+
public ZorbaXQItemType(int itemkind, QName nodename, int basetype, QName typename, URI schemaURI, boolean allowNill) throws XQException {
this.itemKind = itemkind;
this.nodeName = nodename;
@@ -400,6 +467,8 @@
this.schemaURI = schemaURI;
this.allowNill = allowNill;
}
+
+
public ZorbaXQItemType(int itemkind, QName nodename, int basetype, URI schemaURI) throws XQException {
this.itemKind = itemkind;
this.nodeName = nodename;
@@ -409,169 +478,171 @@
}
- private void generateTypeName() {
+ private void generateTypeName()
+ {
String namespaceURI = "http://www.w3.org/2001/XMLSchema";;
String localPart = "untyped";
String prefix = "";
- switch (baseType) {
- case ZorbaXQItemType.XQBASETYPE_ANYATOMICTYPE:
- localPart = "anyAtomicType";
- break;
- case ZorbaXQItemType.XQBASETYPE_ANYSIMPLETYPE:
- localPart = "anySimpleType";
- break;
- case ZorbaXQItemType.XQBASETYPE_ANYTYPE:
- localPart = "anyType";
- break;
- case ZorbaXQItemType.XQBASETYPE_ANYURI:
- localPart = "anyURI";
- break;
- case ZorbaXQItemType.XQBASETYPE_BASE64BINARY:
- localPart = "base64Binary";
- break;
- case ZorbaXQItemType.XQBASETYPE_BOOLEAN:
- localPart = "boolean";
- break;
- case ZorbaXQItemType.XQBASETYPE_BYTE:
- localPart = "byte";
- break;
- case ZorbaXQItemType.XQBASETYPE_DATE:
- localPart = "date";
- break;
- case ZorbaXQItemType.XQBASETYPE_DATETIME:
- localPart = "dateTime";
- break;
- case ZorbaXQItemType.XQBASETYPE_DAYTIMEDURATION:
- localPart = "dayTimeDuration";
- break;
- case ZorbaXQItemType.XQBASETYPE_DECIMAL:
- localPart = "decimal";
- break;
- case ZorbaXQItemType.XQBASETYPE_DOUBLE:
- localPart = "double";
- break;
- case ZorbaXQItemType.XQBASETYPE_DURATION:
- localPart = "duration";
- break;
- case ZorbaXQItemType.XQBASETYPE_ENTITIES:
- localPart = "ENTITIES";
- break;
- case ZorbaXQItemType.XQBASETYPE_ENTITY:
- localPart = "ENTITY";
- break;
- case ZorbaXQItemType.XQBASETYPE_FLOAT:
- localPart = "float";
- break;
- case ZorbaXQItemType.XQBASETYPE_GDAY:
- localPart = "gDay";
- break;
- case ZorbaXQItemType.XQBASETYPE_GMONTH:
- localPart = "gMonth";
- break;
- case ZorbaXQItemType.XQBASETYPE_GMONTHDAY:
- localPart = "gMonthDay";
- break;
- case ZorbaXQItemType.XQBASETYPE_GYEAR:
- localPart = "gYear";
- break;
- case ZorbaXQItemType.XQBASETYPE_GYEARMONTH:
- localPart = "gYearMonth";
- break;
- case ZorbaXQItemType.XQBASETYPE_HEXBINARY:
- localPart = "hexBinary";
- break;
- case ZorbaXQItemType.XQBASETYPE_ID:
- localPart = "ID";
- break;
- case ZorbaXQItemType.XQBASETYPE_IDREF:
- localPart = "IDREF";
- break;
- case ZorbaXQItemType.XQBASETYPE_IDREFS:
- localPart = "IDREFS";
- break;
- case ZorbaXQItemType.XQBASETYPE_INT:
- localPart = "int";
- break;
- case ZorbaXQItemType.XQBASETYPE_INTEGER:
- localPart = "integer";
- break;
- case ZorbaXQItemType.XQBASETYPE_LANGUAGE:
- localPart = "language";
- break;
- case ZorbaXQItemType.XQBASETYPE_LONG:
- localPart = "long";
- break;
- case ZorbaXQItemType.XQBASETYPE_NAME:
- localPart = "Name";
- break;
- case ZorbaXQItemType.XQBASETYPE_NCNAME:
- localPart = "NCName";
- break;
- case ZorbaXQItemType.XQBASETYPE_NEGATIVE_INTEGER:
- localPart = "negativeInteger";
- break;
- case ZorbaXQItemType.XQBASETYPE_NMTOKEN:
- localPart = "NMTOKEN";
- break;
- case ZorbaXQItemType.XQBASETYPE_NMTOKENS:
- localPart = "NMTOKENS";
- break;
- case ZorbaXQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
- localPart = "nonNegativeInteger";
- break;
- case ZorbaXQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
- localPart = "nonPositiveInteger";
- break;
- case ZorbaXQItemType.XQBASETYPE_NORMALIZED_STRING:
- localPart = "normalizedString";
- break;
- case ZorbaXQItemType.XQBASETYPE_NOTATION:
- localPart = "NOTATION";
- break;
- case ZorbaXQItemType.XQBASETYPE_POSITIVE_INTEGER:
- localPart = "positiveInteger";
- break;
- case ZorbaXQItemType.XQBASETYPE_QNAME:
- localPart = "QName";
- break;
- case ZorbaXQItemType.XQBASETYPE_SHORT:
- localPart = "short";
- break;
- case ZorbaXQItemType.XQBASETYPE_STRING:
- localPart = "string";
- break;
- case ZorbaXQItemType.XQBASETYPE_TIME:
- localPart = "time";
- break;
- case ZorbaXQItemType.XQBASETYPE_TOKEN:
- localPart = "token";
- break;
- case ZorbaXQItemType.XQBASETYPE_UNSIGNED_BYTE:
- localPart = "unsignedByte";
- break;
- case ZorbaXQItemType.XQBASETYPE_UNSIGNED_INT:
- localPart = "unsignedInt";
- break;
- case ZorbaXQItemType.XQBASETYPE_UNSIGNED_LONG:
- localPart = "unsignedLong";
- break;
- case ZorbaXQItemType.XQBASETYPE_UNSIGNED_SHORT:
- localPart = "unsignedShort";
- break;
- case ZorbaXQItemType.XQBASETYPE_UNTYPED:
- localPart = "untyped";
- break;
- case ZorbaXQItemType.XQBASETYPE_UNTYPEDATOMIC:
- localPart = "untypedAtomic";
- break;
- case ZorbaXQItemType.XQBASETYPE_YEARMONTHDURATION:
- localPart = "yearMonthDuration";
- break;
- default:
- localPart = "untyped";
- break;
- }
+ switch (baseType)
+ {
+ case ZorbaXQItemType.XQBASETYPE_ANYATOMICTYPE:
+ localPart = "anyAtomicType";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_ANYSIMPLETYPE:
+ localPart = "anySimpleType";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_ANYTYPE:
+ localPart = "anyType";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_ANYURI:
+ localPart = "anyURI";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_BASE64BINARY:
+ localPart = "base64Binary";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_BOOLEAN:
+ localPart = "boolean";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_BYTE:
+ localPart = "byte";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_DATE:
+ localPart = "date";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_DATETIME:
+ localPart = "dateTime";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_DAYTIMEDURATION:
+ localPart = "dayTimeDuration";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_DECIMAL:
+ localPart = "decimal";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_DOUBLE:
+ localPart = "double";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_DURATION:
+ localPart = "duration";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_ENTITIES:
+ localPart = "ENTITIES";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_ENTITY:
+ localPart = "ENTITY";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_FLOAT:
+ localPart = "float";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_GDAY:
+ localPart = "gDay";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_GMONTH:
+ localPart = "gMonth";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_GMONTHDAY:
+ localPart = "gMonthDay";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_GYEAR:
+ localPart = "gYear";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_GYEARMONTH:
+ localPart = "gYearMonth";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_HEXBINARY:
+ localPart = "hexBinary";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_ID:
+ localPart = "ID";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_IDREF:
+ localPart = "IDREF";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_IDREFS:
+ localPart = "IDREFS";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_INT:
+ localPart = "int";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_INTEGER:
+ localPart = "integer";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_LANGUAGE:
+ localPart = "language";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_LONG:
+ localPart = "long";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NAME:
+ localPart = "Name";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NCNAME:
+ localPart = "NCName";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NEGATIVE_INTEGER:
+ localPart = "negativeInteger";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NMTOKEN:
+ localPart = "NMTOKEN";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NMTOKENS:
+ localPart = "NMTOKENS";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
+ localPart = "nonNegativeInteger";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
+ localPart = "nonPositiveInteger";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NORMALIZED_STRING:
+ localPart = "normalizedString";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_NOTATION:
+ localPart = "NOTATION";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_POSITIVE_INTEGER:
+ localPart = "positiveInteger";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_QNAME:
+ localPart = "QName";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_SHORT:
+ localPart = "short";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_STRING:
+ localPart = "string";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_TIME:
+ localPart = "time";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_TOKEN:
+ localPart = "token";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_UNSIGNED_BYTE:
+ localPart = "unsignedByte";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_UNSIGNED_INT:
+ localPart = "unsignedInt";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_UNSIGNED_LONG:
+ localPart = "unsignedLong";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_UNSIGNED_SHORT:
+ localPart = "unsignedShort";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_UNTYPED:
+ localPart = "untyped";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_UNTYPEDATOMIC:
+ localPart = "untypedAtomic";
+ break;
+ case ZorbaXQItemType.XQBASETYPE_YEARMONTHDURATION:
+ localPart = "yearMonthDuration";
+ break;
+ default:
+ localPart = "untyped";
+ break;
+ }
typeName = new QName(namespaceURI, localPart, prefix);
}
=== modified file 'swig/xqj/ZorbaXQStaticContext.java'
--- swig/xqj/ZorbaXQStaticContext.java 2013-02-07 17:24:36 +0000
+++ swig/xqj/ZorbaXQStaticContext.java 2013-06-13 19:26:32 +0000
@@ -95,7 +95,7 @@
private ZorbaXQStaticCollectionManager lStaticCollectionManager;
String baseURI = null; //Patch for Zorba, bug filed on https://bugs.launchpad.net/zorba/+bug/905028
- XQItemType contextItemStaticType = null; //Patch for Zorba, TypeIdentifier is not complete
+ XQItemType contextItemStaticType = null; //Patch for Zorba, SequenceType is not complete
protected StaticContext getZorbaStaticContext() {
return staticContext;
}
@@ -264,7 +264,7 @@
@Override
public XQItemType getContextItemStaticType() {
//not very complete implementation
- //TypeIdentifier type = staticContext.getContextItemStaticType();
+ //SequenceType type = staticContext.getContextItemStaticType();
return contextItemStaticType;
}
@@ -278,7 +278,7 @@
contextItemStaticType = xqit;
if (xqit instanceof XQItemType) {
org.zorbaxquery.api.xqj.ZorbaXQItemType wrapper = (org.zorbaxquery.api.xqj.ZorbaXQItemType) xqit;
- staticContext.setContextItemStaticType(wrapper.getTypeIdentifier());
+ staticContext.setContextItemStaticType(wrapper.getSequenceType());
}
}
=== modified file 'test/unit/context_item.cpp'
--- test/unit/context_item.cpp 2013-02-07 17:24:36 +0000
+++ test/unit/context_item.cpp 2013-06-13 19:26:32 +0000
@@ -40,15 +40,16 @@
{
zorba::StaticContext_t sctx = zorba->createStaticContext();
- zorba::TypeIdentifier_t type = sctx->getContextItemStaticType();
- zorba::IdentTypes::kind_t kind = type->getKind();
- if (kind != zorba::IdentTypes::ITEM_TYPE)
+ zorba::SequenceType type = sctx->getContextItemStaticType();
+ zorba::SequenceType::Kind kind = type.getKind();
+ if (kind != zorba::SequenceType::ITEM_TYPE)
{
return 10;
}
- type = zorba::TypeIdentifier::createNamedType("http://www.w3.org/2001/XMLSchema";,
- "integer");
+ type = zorba::SequenceType::
+ createAtomicOrUnionType(sctx, "http://www.w3.org/2001/XMLSchema";, "integer");
+
sctx->setContextItemStaticType(type);
zorba::XQuery_t query = zorba->compileQuery(queryStream, sctx);
@@ -140,9 +141,8 @@
std::ostringstream resultStream;
{
- zorba::TypeIdentifier_t type =
- zorba::TypeIdentifier::createNamedType("http://www.w3.org/2001/XMLSchema";,
- "integer");
+ zorba::SequenceType type = zorba::SequenceType::
+ createAtomicOrUnionType(NULL, "http://www.w3.org/2001/XMLSchema";, "integer");
zorba::Item ctxValue = zorba->getItemFactory()->createInteger(10);
@@ -181,15 +181,15 @@
{
zorba::StaticContext_t sctx = zorba->createStaticContext();
- zorba::TypeIdentifier_t element =
- zorba::TypeIdentifier::createElementType("http://zorba-xquery.org";,
+ zorba::SequenceType_t element =
+ zorba::SequenceType::createElementType("http://zorba-xquery.org";,
false,
"zorba.org",
false,
- zorba::TypeIdentifier::createAnyNodeType());
+ zorba::SequenceType::createAnyNodeType());
- zorba::TypeIdentifier_t document =
- zorba::TypeIdentifier::createDocumentType(element);
+ zorba::SequenceType_t document =
+ zorba::SequenceType::createDocumentType(element);
sctx->setContextItemStaticType(document);
=== modified file 'test/unit/staticcollectionmanager.cpp'
--- test/unit/staticcollectionmanager.cpp 2013-02-07 17:24:36 +0000
+++ test/unit/staticcollectionmanager.cpp 2013-06-13 19:26:32 +0000
@@ -150,7 +150,7 @@
return false;
}
- if (lCollection->getType()->getKind() != IdentTypes::ANY_NODE_TYPE)
+ if (lCollection->getType().getKind() != SequenceType::NODE_TYPE)
{
return false;
}
@@ -261,56 +261,72 @@
return i == 1;
}
+
bool
check_types(StaticCollectionManager* aColMgr,
ItemFactory* aFac,
const char* const aCollName,
int aDepth,
- IdentTypes::kind_t someKinds[],
- IdentTypes::quantifier_t someQuantifiers[])
+ SequenceType::Kind someKinds[],
+ SequenceType::Quantifier someQuantifiers[])
{
Item lCollName = aFac->createQName("http://www.mod6.com/";, aCollName);
- if (! aColMgr->isDeclaredCollection(lCollName)) {
+
+ if (! aColMgr->isDeclaredCollection(lCollName))
+ {
std::cout << "no collection "
<< lCollName.getStringValue().c_str()
<< std::endl;
return false;
}
+
aColMgr->createCollection(lCollName);
Collection_t lCollection = aColMgr->getCollection(lCollName);
- zorba::TypeIdentifier_t lType = lCollection->getType();
+ zorba::SequenceType lType = lCollection->getType();
std::cout << lType << std::endl;
- for (int i = 0; i < aDepth; ++i) {
- if (lType->getKind() != someKinds[i]) {
- std::cout << lType << std::endl;
- return false;
- }
- if (lType->getQuantifier() != someQuantifiers[i]) {
- std::cout << lType << std::endl;
- return false;
- }
- lType = lType->getContentType();
+ for (int i = 0; i < aDepth; ++i)
+ {
+ if (lType.getKind() != someKinds[i])
+ {
+ std::cout << lType << std::endl;
+ return false;
+ }
+
+ if (lType.getQuantifier() != someQuantifiers[i])
+ {
+ std::cout << lType << std::endl;
+ return false;
+ }
+
+ break;
+ //lType = lType->getContentType();
}
- assert(lType.isNull());
+ //assert(lType.isNull());
aColMgr->deleteCollection(lCollName);
return true;
}
+
bool
staticcollectionamanger5(zorba::Zorba* z)
{
std::ifstream lIn("module5.xq");
zorba::XQuery_t lQuery = z->createQuery();
- try {
+ try
+ {
Zorba_CompilerHints lHints;
lQuery->compile(lIn, lHints);
- } catch (zorba::XQueryException &e) {
+ }
+ catch (zorba::XQueryException &e)
+ {
std::cout << e << std::endl;
return false;
- } catch (...) {
+ }
+ catch (...)
+ {
std::cout << "compilation failed" << std::endl;
return false;
}
@@ -318,102 +334,109 @@
StaticCollectionManager* lColMgr = lQuery->getStaticCollectionManager();
ItemFactory* lFac = z->getItemFactory();
- IdentTypes::kind_t lC01Kinds[] = { IdentTypes::DOCUMENT_TYPE,
- IdentTypes::ELEMENT_TYPE,
- IdentTypes::NAMED_TYPE };
- IdentTypes::quantifier_t lC01Quants[] = { IdentTypes::QUANT_STAR,
- IdentTypes::QUANT_ONE,
+ SequenceType::Kind lC01Kinds[] = { SequenceType::DOCUMENT_TYPE,
+ SequenceType::ELEMENT_TYPE,
+ SequenceType::ATOMIC_OR_UNION_TYPE };
+ SequenceType::Quantifier lC01Quants[] = { SequenceType::QUANT_STAR,
+ SequenceType::QUANT_ONE,
// this '*' is probably a bug
- IdentTypes::QUANT_STAR };
+ SequenceType::QUANT_STAR };
if (!check_types(lColMgr, lFac, "coll01", 3, lC01Kinds, lC01Quants)) {
return false;
}
- IdentTypes::kind_t lC02Kinds[] = { IdentTypes::DOCUMENT_TYPE,
- IdentTypes::ELEMENT_TYPE,
- IdentTypes::NAMED_TYPE };
- IdentTypes::quantifier_t lC02Quants[] = { IdentTypes::QUANT_STAR,
- IdentTypes::QUANT_ONE,
- IdentTypes::QUANT_ONE };
+ SequenceType::Kind lC02Kinds[] = { SequenceType::DOCUMENT_TYPE,
+ SequenceType::ELEMENT_TYPE,
+ SequenceType::ATOMIC_OR_UNION_TYPE };
+ SequenceType::Quantifier lC02Quants[] = { SequenceType::QUANT_STAR,
+ SequenceType::QUANT_ONE,
+ SequenceType::QUANT_ONE };
if (!check_types(lColMgr, lFac, "coll02", 3, lC02Kinds, lC02Quants)) {
return false;
}
- IdentTypes::kind_t lC03Kinds[] = { IdentTypes::DOCUMENT_TYPE,
- IdentTypes::SCHEMA_ELEMENT_TYPE };
- IdentTypes::quantifier_t lC03Quants[] = { IdentTypes::QUANT_STAR,
- IdentTypes::QUANT_ONE };
+ SequenceType::Kind lC03Kinds[] = { SequenceType::DOCUMENT_TYPE,
+ SequenceType::SCHEMA_ELEMENT_TYPE };
+ SequenceType::Quantifier lC03Quants[] = { SequenceType::QUANT_STAR,
+ SequenceType::QUANT_ONE };
if (!check_types(lColMgr, lFac, "coll03", 2, lC03Kinds, lC03Quants)) {
return false;
}
- IdentTypes::kind_t lC04Kinds[] = { IdentTypes::ELEMENT_TYPE,
- IdentTypes::NAMED_TYPE };
- IdentTypes::quantifier_t lC04Quants[] = { IdentTypes::QUANT_STAR,
+ SequenceType::Kind lC04Kinds[] = { SequenceType::ELEMENT_TYPE,
+ SequenceType::ATOMIC_OR_UNION_TYPE };
+ SequenceType::Quantifier lC04Quants[] = { SequenceType::QUANT_STAR,
// this '*' is probably a bug
- IdentTypes::QUANT_STAR };
+ SequenceType::QUANT_STAR };
if (!check_types(lColMgr, lFac, "coll04", 2, lC04Kinds, lC04Quants)) {
return false;
}
- IdentTypes::kind_t lC05Kinds[] = { IdentTypes::ELEMENT_TYPE,
- IdentTypes::NAMED_TYPE };
- IdentTypes::quantifier_t lC05Quants[] = { IdentTypes::QUANT_STAR,
- IdentTypes::QUANT_ONE };
+ SequenceType::Kind lC05Kinds[] = { SequenceType::ELEMENT_TYPE,
+ SequenceType::ATOMIC_OR_UNION_TYPE };
+ SequenceType::Quantifier lC05Quants[] = { SequenceType::QUANT_STAR,
+ SequenceType::QUANT_ONE };
if (!check_types(lColMgr, lFac, "coll05", 2, lC05Kinds, lC05Quants)) {
return false;
}
- IdentTypes::kind_t lC06Kinds[] = { IdentTypes::SCHEMA_ELEMENT_TYPE };
- IdentTypes::quantifier_t lC06Quants[] = { IdentTypes::QUANT_STAR };
- if (!check_types(lColMgr, lFac, "coll06", 1, lC06Kinds, lC06Quants)) {
+ SequenceType::Kind lC06Kinds[] = { SequenceType::SCHEMA_ELEMENT_TYPE };
+ SequenceType::Quantifier lC06Quants[] = { SequenceType::QUANT_STAR };
+ if (!check_types(lColMgr, lFac, "coll06", 1, lC06Kinds, lC06Quants))
+ {
return false;
}
- IdentTypes::kind_t lC07Kinds[] = { IdentTypes::ATTRIBUTE_TYPE,
- IdentTypes::NAMED_TYPE };
- IdentTypes::quantifier_t lC07Quants[] = { IdentTypes::QUANT_STAR,
+ SequenceType::Kind lC07Kinds[] = { SequenceType::ATTRIBUTE_TYPE,
+ SequenceType::ATOMIC_OR_UNION_TYPE };
+ SequenceType::Quantifier lC07Quants[] = { SequenceType::QUANT_STAR,
// this '*' is probably a bug
- IdentTypes::QUANT_STAR };
+ SequenceType::QUANT_STAR };
if (!check_types(lColMgr, lFac, "coll07", 2, lC07Kinds, lC07Quants)) {
return false;
}
- IdentTypes::kind_t lC08Kinds[] = { IdentTypes::ATTRIBUTE_TYPE,
- IdentTypes::NAMED_TYPE };
- IdentTypes::quantifier_t lC08Quants[] = { IdentTypes::QUANT_STAR,
- IdentTypes::QUANT_ONE };
- if (!check_types(lColMgr, lFac, "coll08", 2, lC08Kinds, lC08Quants)) {
- return false;
- }
-
- IdentTypes::kind_t lC09Kinds[] = { IdentTypes::SCHEMA_ATTRIBUTE_TYPE };
- IdentTypes::quantifier_t lC09Quants[] = { IdentTypes::QUANT_STAR };
- if (!check_types(lColMgr, lFac, "coll09", 1, lC09Kinds, lC09Quants)) {
- return false;
- }
-
- IdentTypes::kind_t lC10Kinds[] = { IdentTypes::COMMENT_TYPE };
- IdentTypes::quantifier_t lC10Quants[] = { IdentTypes::QUANT_ONE };
- if (!check_types(lColMgr, lFac, "coll10", 1, lC10Kinds, lC10Quants)) {
- return false;
- }
-
- IdentTypes::kind_t lC11Kinds[] = { IdentTypes::PI_TYPE };
- IdentTypes::quantifier_t lC11Quants[] = { IdentTypes::QUANT_QUESTION };
- if (!check_types(lColMgr, lFac, "coll11", 1, lC11Kinds, lC11Quants)) {
- return false;
- }
-
- IdentTypes::kind_t lC12Kinds[] = { IdentTypes::TEXT_TYPE };
- IdentTypes::quantifier_t lC12Quants[] = { IdentTypes::QUANT_PLUS };
- if (!check_types(lColMgr, lFac, "coll12", 1, lC12Kinds, lC12Quants)) {
- return false;
- }
-
- IdentTypes::kind_t lC13Kinds[] = { IdentTypes::ANY_NODE_TYPE };
- IdentTypes::quantifier_t lC13Quants[] = { IdentTypes::QUANT_STAR };
- if (!check_types(lColMgr, lFac, "coll13", 1, lC13Kinds, lC13Quants)) {
+ SequenceType::Kind lC08Kinds[] = { SequenceType::ATTRIBUTE_TYPE,
+ SequenceType::ATOMIC_OR_UNION_TYPE };
+ SequenceType::Quantifier lC08Quants[] = { SequenceType::QUANT_STAR,
+ SequenceType::QUANT_ONE };
+ if (!check_types(lColMgr, lFac, "coll08", 2, lC08Kinds, lC08Quants))
+ {
+ return false;
+ }
+
+ SequenceType::Kind lC09Kinds[] = { SequenceType::SCHEMA_ATTRIBUTE_TYPE };
+ SequenceType::Quantifier lC09Quants[] = { SequenceType::QUANT_STAR };
+ if (!check_types(lColMgr, lFac, "coll09", 1, lC09Kinds, lC09Quants))
+ {
+ return false;
+ }
+
+ SequenceType::Kind lC10Kinds[] = { SequenceType::COMMENT_TYPE };
+ SequenceType::Quantifier lC10Quants[] = { SequenceType::QUANT_ONE };
+ if (!check_types(lColMgr, lFac, "coll10", 1, lC10Kinds, lC10Quants))
+ {
+ return false;
+ }
+
+ SequenceType::Kind lC11Kinds[] = { SequenceType::PI_TYPE };
+ SequenceType::Quantifier lC11Quants[] = { SequenceType::QUANT_QUESTION };
+ if (!check_types(lColMgr, lFac, "coll11", 1, lC11Kinds, lC11Quants))
+ {
+ return false;
+ }
+
+ SequenceType::Kind lC12Kinds[] = { SequenceType::TEXT_TYPE };
+ SequenceType::Quantifier lC12Quants[] = { SequenceType::QUANT_PLUS };
+ if (!check_types(lColMgr, lFac, "coll12", 1, lC12Kinds, lC12Quants))
+ {
+ return false;
+ }
+
+ SequenceType::Kind lC13Kinds[] = { SequenceType::NODE_TYPE };
+ SequenceType::Quantifier lC13Quants[] = { SequenceType::QUANT_STAR };
+ if (!check_types(lColMgr, lFac, "coll13", 1, lC13Kinds, lC13Quants))
+ {
return false;
}
Follow ups
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-24
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: noreply, 2013-09-24
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-24
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Rodolfo Ochoa, 2013-09-24
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Rodolfo Ochoa, 2013-09-24
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-23
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Rodolfo Ochoa, 2013-09-21
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-16
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-16
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-16
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-16
-
Re: [Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Markos Zaharioudakis, 2013-09-16
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-16
-
[Merge] lp:~zorba-coders/zorba/type-api into lp:zorba
From: Zorba Build Bot, 2013-09-16
