include/axis/AxisUserAPIArrays.hpp

/*
 *   Copyright 2003-2004 The Apache Software Foundation.
// (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
 *
 *   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.
 *
 */

#if !defined(_AXISUSERAPIARRAYS_H____OF_AXIS_INCLUDED_)
#define _AXISUSERAPIARRAYS_H____OF_AXIS_INCLUDED_

/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
/* NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE   */
/* ----------------------------------------------------------------   */
/* CHANGES TO hpp HEADER FILE MAY NEED TO BE PROPAGATED TO THE        */
/* C-EQUIVALENT HEADER FILE IN SUPPORT OF THE C-BINDING INTERFACES.   */
/* ----------------------------------------------------------------   */
/* NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE   */
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */

 /**
  * @file AxisUserAPIArrays.hpp
  * This file contains arrays defined for the basic types declared in AxisUserAPI.hpp
  * 
  */

#include <time.h>
#include <string.h>

#include <axis/GDefine.hpp>
#include <axis/TypeMapping.hpp>
#include <axis/AxisUserAPI.hpp>


AXIS_CPP_NAMESPACE_START



/**
 * @class xsd__duration_Array
 * 
 * The storage class for arrays of xsd__duration
 * 
 */
class STORAGE_CLASS_INFO xsd__duration_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__duration_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__duration_Array(const xsd__duration_Array & original);
    
    /**
     * Destructor
     */
    virtual ~xsd__duration_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__duration** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__duration** get(int& size) const;
};

/**
 * @class xsd__dateTime_Array
 * 
 * The storage class for arrays of xsd__dateTime
 * 
 */
class STORAGE_CLASS_INFO xsd__dateTime_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__dateTime_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__dateTime_Array(const xsd__dateTime_Array & original);
    
    /**
     * Destructor
     */
    virtual ~xsd__dateTime_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__dateTime** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__dateTime** get(int& size) const;
};

/**
 * @class xsd__time_Array
 * 
 * The storage class for arrays of xsd__time
 * 
 */
class STORAGE_CLASS_INFO xsd__time_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__time_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__time_Array(const xsd__time_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__time_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__time** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__time** get(int& size) const;
};

/**
 * @class xsd__date_Array
 * 
 * The storage class for arrays of xsd__date
 * 
 */
class STORAGE_CLASS_INFO xsd__date_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__date_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__date_Array(const xsd__date_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__date_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__date** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__date** get(int& size) const;
};

/**
 * @class xsd__gYearMonth_Array
 * 
 * The storage class for arrays of xsd__gYearMonth
 * 
 */
class STORAGE_CLASS_INFO xsd__gYearMonth_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__gYearMonth_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__gYearMonth_Array(const xsd__gYearMonth_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__gYearMonth_Array();
    
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__gYearMonth** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__gYearMonth** get(int& size) const;
};

/**
 * @class xsd__gYear_Array
 * 
 * The storage class for arrays of xsd__gYear
 * 
 */
class STORAGE_CLASS_INFO xsd__gYear_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__gYear_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__gYear_Array(const xsd__gYear_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__gYear_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__gYear** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__gYear** get(int& size) const;
};

/**
 * @class xsd__gMonthDay_Array
 * 
 * The storage class for arrays of xsd__gMonthDay
 * 
 */
class STORAGE_CLASS_INFO xsd__gMonthDay_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__gMonthDay_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__gMonthDay_Array(const xsd__gMonthDay_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__gMonthDay_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__gMonthDay** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__gMonthDay** get(int& size) const;
};
/**
 * @class xsd__gDay_Array
 * 
 * The storage class for arrays of xsd__gDay
 * 
 */
class STORAGE_CLASS_INFO xsd__gDay_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__gDay_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__gDay_Array(const xsd__gDay_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__gDay_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__gDay** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__gDay** get(int& size) const;
};

/**
 * @class xsd__gMonth_Array
 * 
 * The storage class for arrays of xsd__gMonth
 * 
 */
class STORAGE_CLASS_INFO xsd__gMonth_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__gMonth_Array();

    /**
     * Copy constructor
     * @param original Axis_Array to copy.
     */
    xsd__gMonth_Array(const xsd__gMonth_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__gMonth_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd_duration data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__gMonth** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd_duration data.
     */
    const xsd__gMonth** get(int& size) const;
};

/**
 * @class xsd__string_Array
 * 
 * The storage class for arrays of xsd__string
 * 
 */
class STORAGE_CLASS_INFO xsd__string_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__string_Array();

    /**
     * Copy constructor
     * @param original xsd__string_Array to copy.
     */
    xsd__string_Array(const xsd__string_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__string_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__string data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__string* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__string data.
     */
    const xsd__string* get(int& size) const;
};

/**
 * @class xsd__normalizedString_Array
 * 
 * The storage class for arrays of xsd__normalizedString
 * 
 */
class STORAGE_CLASS_INFO xsd__normalizedString_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__normalizedString_Array();

    /**
     * Copy constructor
     * @param original xsd__normalizedString_Array to copy.
     */
    xsd__normalizedString_Array(const xsd__normalizedString_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__normalizedString_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__normalizedString data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__normalizedString* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__normalizedString data.
     */
    const xsd__normalizedString* get(int& size) const;
};

/**
 * @class xsd__token_Array
 * 
 * The storage class for arrays of xsd__token
 * 
 */
class STORAGE_CLASS_INFO xsd__token_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__token_Array();

    /**
     * Copy constructor
     * @param original xsd__token_Array to copy.
     */
    xsd__token_Array(const xsd__token_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__token_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__token data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__token* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__token data.
     */
    const xsd__token* get(int& size) const;
};

/**
 * @class xsd__language_Array
 * 
 * The storage class for arrays of xsd__language
 * 
 */
class STORAGE_CLASS_INFO xsd__language_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__language_Array();

    /**
     * Copy constructor
     * @param original xsd__language_Array to copy.
     */
    xsd__language_Array(const xsd__language_Array & original);
    
        
    /**
     * Destructor
     */
    virtual ~xsd__language_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__language data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__language* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__language data.
     */
    const xsd__language* get(int& size) const;
};

/**
 * @class xsd__Name_Array
 * 
 * The storage class for arrays of xsd__Name
 * 
 */
class STORAGE_CLASS_INFO xsd__Name_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__Name_Array();

    /**
     * Copy constructor
     * @param original xsd__Name_Array to copy.
     */
    xsd__Name_Array(const xsd__Name_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__Name_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__Name data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__Name* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__Name data.
     */
    const xsd__Name* get(int& size) const;
};

/**
 * @class xsd__NCName_Array
 * 
 * The storage class for arrays of xsd__NCName
 * 
 */
class STORAGE_CLASS_INFO xsd__NCName_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__NCName_Array();

    /**
     * Copy constructor
     * @param original xsd__NCName_Array to copy.
     */
    xsd__NCName_Array(const xsd__NCName_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__NCName_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__NCName data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__NCName* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__NCName data.
     */
    const xsd__NCName* get(int& size) const;
};

/**
 * @class xsd__ID_Array
 * 
 * The storage class for arrays of xsd__ID
 * 
 */
class STORAGE_CLASS_INFO xsd__ID_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__ID_Array();

    /**
     * Copy constructor
     * @param original xsd__ID_Array to copy.
     */
    xsd__ID_Array(const xsd__ID_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__ID_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__ID data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__ID* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__ID data.
     */
    const xsd__ID* get(int& size) const;
};

/**
 * @class xsd__IDREF_Array
 * 
 * The storage class for arrays of xsd__IDREF
 * 
 */
class STORAGE_CLASS_INFO xsd__IDREF_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__IDREF_Array();

    /**
     * Copy constructor
     * @param original xsd__IDREF_Array to copy.
     */
    xsd__IDREF_Array(const xsd__IDREF_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__IDREF_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__IDREF data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__IDREF* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__IDREF data.
     */
    const xsd__IDREF* get(int& size) const;
};

/**
 * @class xsd__IDREFS_Array
 * 
 * The storage class for arrays of xsd__IDREFS
 * 
 */
class STORAGE_CLASS_INFO xsd__IDREFS_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__IDREFS_Array();

    /**
     * Copy constructor
     * @param original xsd__IDREFS_Array to copy.
     */
    xsd__IDREFS_Array(const xsd__IDREFS_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__IDREFS_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__IDREFS data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__IDREFS* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__IDREFS data.
     */
    const xsd__IDREFS* get(int& size) const;
};

/**
 * @class xsd__ENTITY_Array
 * 
 * The storage class for arrays of xsd__ENTITY
 * 
 */
class STORAGE_CLASS_INFO xsd__ENTITY_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__ENTITY_Array();

    /**
     * Copy constructor
     * @param original xsd__ENTITY_Array to copy.
     */
    xsd__ENTITY_Array(const xsd__ENTITY_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__ENTITY_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__ENTITY data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__ENTITY* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__ENTITY data.
     */
    const xsd__ENTITY* get(int& size) const;
};

/**
 * @class xsd__ENTITIES_Array
 * 
 * The storage class for arrays of xsd__ENTITIES
 * 
 */
class STORAGE_CLASS_INFO xsd__ENTITIES_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__ENTITIES_Array();

    /**
     * Copy constructor
     * @param original xsd__ENTITIES_Array to copy.
     */
    xsd__ENTITIES_Array(const xsd__ENTITIES_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__ENTITIES_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__ENTITIES data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__ENTITIES* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__ENTITIES data.
     */
    const xsd__ENTITIES* get(int& size) const;
};

/**
 * @class xsd__NMTOKEN_Array
 * 
 * The storage class for arrays of xsd__NMTOKEN
 * 
 */
class STORAGE_CLASS_INFO xsd__NMTOKEN_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__NMTOKEN_Array();

    /**
     * Copy constructor
     * @param original xsd__NMTOKEN_Array to copy.
     */
    xsd__NMTOKEN_Array(const xsd__NMTOKEN_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__NMTOKEN_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__NMTOKEN data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__NMTOKEN* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__NMTOKEN data.
     */
    const xsd__NMTOKEN* get(int& size) const;
};

/**
 * @class xsd__NMTOKENS_Array
 * 
 * The storage class for arrays of xsd__NMTOKENS
 * 
 */
class STORAGE_CLASS_INFO xsd__NMTOKENS_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__NMTOKENS_Array();

    /**
     * Copy constructor
     * @param original xsd__NMTOKENS_Array to copy.
     */
    xsd__NMTOKENS_Array(const xsd__NMTOKENS_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__NMTOKENS_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__NMTOKENS data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__NMTOKENS* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__NMTOKENS data.
     */
    const xsd__NMTOKENS* get(int& size) const;
};

/**
 * @class xsd__string_Array
 * 
 * The storage class for arrays of xsd__string
 * 
 */
class STORAGE_CLASS_INFO xsd__anyType_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__anyType_Array();

    /**
     * Copy constructor
     * @param original xsd__anyType_Array to copy.
     */
    xsd__anyType_Array(const xsd__anyType_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__anyType_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__anyType data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__anyType* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__anyType data.
     */
    const xsd__anyType* get(int& size) const;
};

/**
 * @class xsd__boolean_Array
 * 
 * The storage class for arrays of xsd__boolean
 * 
 */
class STORAGE_CLASS_INFO xsd__boolean_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__boolean_Array();

    /**
     * Copy constructor
     * @param original xsd__boolean_Array to copy.
     */
    xsd__boolean_Array(const xsd__boolean_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__boolean_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__boolean data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__boolean** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__boolean data.
     */
    const xsd__boolean** get(int& size) const;
};

/**
 * @class xsd__base64Binary_Array
 * 
 * The storage class for arrays of xsd__base64Binary
 * 
 */
class STORAGE_CLASS_INFO xsd__base64Binary_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__base64Binary_Array();

    /**
     * Copy constructor
     * @param original xsd__base64Binary_Array to copy.
     */
    xsd__base64Binary_Array(const xsd__base64Binary_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__base64Binary_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__base64Binary data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__base64Binary** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__base64Binary data.
     */
    const xsd__base64Binary** get(int& size) const;
};

/**
 * @class xsd__hexBinary_Array
 * 
 * The storage class for arrays of xsd__hexBinary
 * 
 */
class STORAGE_CLASS_INFO xsd__hexBinary_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__hexBinary_Array();

    /**
     * Copy constructor
     * @param original xsd__hexBinary_Array to copy.
     */
    xsd__hexBinary_Array(const xsd__hexBinary_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__hexBinary_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__hexBinary data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__hexBinary** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__hexBinary data.
     */
    const xsd__hexBinary** get(int& size) const;
};

/**
 * @class xsd__float_Array
 * 
 * The storage class for arrays of xsd__float
 * 
 */
class STORAGE_CLASS_INFO xsd__float_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__float_Array();

    /**
     * Copy constructor
     * @param original xsd__float_Array to copy.
     */
    xsd__float_Array(const xsd__float_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__float_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__float data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__float** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__float data.
     */
    const xsd__float** get(int& size) const;
};

/**
 * @class xsd__decimal_Array
 * 
 * The storage class for arrays of xsd__decimal
 * 
 */
class STORAGE_CLASS_INFO xsd__decimal_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__decimal_Array();

    /**
     * Copy constructor
     * @param original xsd__decimal_Array to copy.
     */
    xsd__decimal_Array(const xsd__decimal_Array & original);
    
    /**
     * Destructor
     */
    virtual ~xsd__decimal_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__decimal data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__decimal** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__decimal data.
     */
    const xsd__decimal** get(int& size) const;
};

/**
 * @class xsd__integer_Array
 * 
 * The storage class for arrays of xsd__integer
 * 
 */
class STORAGE_CLASS_INFO xsd__integer_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__integer_Array();

    /**
     * Copy constructor
     * @param original xsd__integer_Array to copy.
     */
    xsd__integer_Array(const xsd__integer_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__integer_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__integer data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__integer** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__integer data.
     */
    const xsd__integer** get(int& size) const;
};

/**
 * @class xsd__nonPositiveInteger_Array
 * 
 * The storage class for arrays of xsd__nonPositiveInteger
 * 
 */
class STORAGE_CLASS_INFO xsd__nonPositiveInteger_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__nonPositiveInteger_Array();

    /**
     * Copy constructor
     * @param original xsd__nonPositiveInteger_Array to copy.
     */
    xsd__nonPositiveInteger_Array(const xsd__nonPositiveInteger_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__nonPositiveInteger_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__nonPositiveInteger data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__nonPositiveInteger** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__nonPositiveInteger data.
     */
    const xsd__nonPositiveInteger** get(int& size) const;
};

/**
 * @class xsd__negativeInteger_Array
 * 
 * The storage class for arrays of xsd__negativeInteger
 * 
 */
class STORAGE_CLASS_INFO xsd__negativeInteger_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__negativeInteger_Array();

    /**
     * Copy constructor
     * @param original xsd__negativeInteger_Array to copy.
     */
    xsd__negativeInteger_Array(const xsd__negativeInteger_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__negativeInteger_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__negativeInteger data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__negativeInteger** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__negativeInteger data.
     */
    const xsd__negativeInteger** get(int& size) const;
};

/**
 * @class xsd__long_Array
 * 
 * The storage class for arrays of xsd__long
 * 
 */
class STORAGE_CLASS_INFO xsd__long_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__long_Array();

    /**
     * Copy constructor
     * @param original xsd__long_Array to copy.
     */
    xsd__long_Array(const xsd__long_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__long_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__long data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__long** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__long data.
     */
    const xsd__long** get(int& size) const;
};

/**
 * @class xsd__int_Array
 * 
 * The storage class for arrays of xsd__int
 * 
 */
class STORAGE_CLASS_INFO xsd__int_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__int_Array();

    /**
     * Copy constructor
     * @param original xsd__int_Array to copy.
     */
    xsd__int_Array(const xsd__int_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__int_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__int data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__int** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__int data.
     */
    const xsd__int** get(int& size) const;
};

/**
 * @class xsd__short_Array
 * 
 * The storage class for arrays of xsd__short
 * 
 */
class STORAGE_CLASS_INFO xsd__short_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__short_Array();

    /**
     * Copy constructor
     * @param original xsd__short_Array to copy.
     */
    xsd__short_Array(const xsd__short_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__short_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__short data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__short** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__short data.
     */
    const xsd__short** get(int& size) const;
};

/**
 * @class xsd__byte_Array
 * 
 * The storage class for arrays of xsd__byte
 * 
 */
class STORAGE_CLASS_INFO xsd__byte_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__byte_Array();

    /**
     * Copy constructor
     * @param original xsd__byte_Array to copy.
     */
    xsd__byte_Array(const xsd__byte_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__byte_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__byte data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__byte** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__byte data.
     */
    const xsd__byte** get(int& size) const;
};

/**
 * @class xsd__nonNegativeInteger_Array
 * 
 * The storage class for arrays of xsd__nonNegativeInteger
 * 
 */
class STORAGE_CLASS_INFO xsd__nonNegativeInteger_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__nonNegativeInteger_Array();

    /**
     * Copy constructor
     * @param original xsd__nonNegativeInteger_Array to copy.
     */
    xsd__nonNegativeInteger_Array(const xsd__nonNegativeInteger_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__nonNegativeInteger_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__nonNegativeInteger data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__nonNegativeInteger** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__nonNegativeInteger data.
     */
    const xsd__nonNegativeInteger** get(int& size) const;
};

/**
 * @class xsd__unsignedLong_Array
 * 
 * The storage class for arrays of xsd__unsignedLong
 * 
 */
class STORAGE_CLASS_INFO xsd__unsignedLong_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__unsignedLong_Array();

    /**
     * Copy constructor
     * @param original xsd__unsignedLong_Array to copy.
     */
    xsd__unsignedLong_Array(const xsd__unsignedLong_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__unsignedLong_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__unsignedLong data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__unsignedLong** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__unsignedLong data.
     */
    const xsd__unsignedLong** get(int& size) const;
};

/**
 * @class xsd__unsignedInt_Array
 * 
 * The storage class for arrays of xsd__unsignedInt
 * 
 */
class STORAGE_CLASS_INFO xsd__unsignedInt_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__unsignedInt_Array();

    /**
     * Copy constructor
     * @param original xsd__unsignedInt_Array to copy.
     */
    xsd__unsignedInt_Array(const xsd__unsignedInt_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__unsignedInt_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__unsignedInt data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__unsignedInt** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__unsignedInt data.
     */
    const xsd__unsignedInt** get(int& size) const;
};

/**
 * @class xsd__unsignedByte_Array
 * 
 * The storage class for arrays of xsd__unsignedByte
 * 
 */
class STORAGE_CLASS_INFO xsd__unsignedByte_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__unsignedByte_Array();

    /**
     * Copy constructor
     * @param original xsd__unsignedByte_Array to copy.
     */
    xsd__unsignedByte_Array(const xsd__unsignedByte_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__unsignedByte_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__unsignedByte data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__unsignedByte** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__unsignedByte data.
     */
    const xsd__unsignedByte** get(int& size) const;
};

/**
 * @class xsd__unsignedShort_Array
 * 
 * The storage class for arrays of xsd__unsignedShort
 * 
 */
class STORAGE_CLASS_INFO xsd__unsignedShort_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__unsignedShort_Array();

    /**
     * Copy constructor
     * @param original xsd__unsignedShort_Array to copy.
     */
    xsd__unsignedShort_Array(const xsd__unsignedShort_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__unsignedShort_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__unsignedShort data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__unsignedShort** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__unsignedShort data.
     */
    const xsd__unsignedShort** get(int& size) const;
};

/**
 * @class xsd__positiveInteger_Array
 * 
 * The storage class for arrays of xsd__positiveInteger
 * 
 */
class STORAGE_CLASS_INFO xsd__positiveInteger_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__positiveInteger_Array();

    /**
     * Copy constructor
     * @param original xsd__positiveInteger_Array to copy.
     */
    xsd__positiveInteger_Array(const xsd__positiveInteger_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__positiveInteger_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__positiveInteger data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__positiveInteger** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__positiveInteger data.
     */
    const xsd__positiveInteger** get(int& size) const;
};

/**
 * @class xsd__double_Array
 * 
 * The storage class for arrays of xsd__double
 * 
 */
class STORAGE_CLASS_INFO xsd__double_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__double_Array();

    /**
     * Copy constructor
     * @param original xsd__double_Array to copy.
     */
    xsd__double_Array(const xsd__double_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__double_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__double data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__double** array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__double data.
     */
    const xsd__double** get(int& size) const;
};

/**
 * @class xsd__anyURI_Array
 * 
 * The storage class for arrays of xsd__anyURI
 * 
 */
class STORAGE_CLASS_INFO xsd__anyURI_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__anyURI_Array();

    /**
     * Copy constructor
     * @param original xsd__anyURI_Array to copy.
     */
    xsd__anyURI_Array(const xsd__anyURI_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__anyURI_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__anyURI data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__anyURI* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__anyURI data.
     */
    const xsd__anyURI* get(int& size) const;
};

/**
 * @class xsd__QName_Array
 * 
 * The storage class for arrays of xsd__QName
 * 
 */
class STORAGE_CLASS_INFO xsd__QName_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__QName_Array();

    /**
     * Copy constructor
     * @param original xsd__QName_Array to copy.
     */
    xsd__QName_Array(const xsd__QName_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__QName_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__QName data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__QName* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__QName data.
     */
    const xsd__QName* get(int& size) const;
};

/**
 * @class xsd__NOTATION_Array
 * 
 * The storage class for arrays of xsd__NOTATION
 * 
 */
class STORAGE_CLASS_INFO xsd__NOTATION_Array : public Axis_Array {
  public:
    /**
     * Constructor
     */
    xsd__NOTATION_Array();

    /**
     * Copy constructor
     * @param original xsd__NOTATION_Array to copy.
     */
    xsd__NOTATION_Array(const xsd__NOTATION_Array & original);
        
    /**
     * Destructor
     */
    virtual ~xsd__NOTATION_Array();
    
    /**
     * Populate the array from a c-style array
     * 
     * @param array is a c-style array of pointers to the xsd__NOTATION data.
     * @param size of the array, including NULL entries.
     */
     void set(xsd__NOTATION* array, int size);

    /**
     * Return a c-style array.
     * 
     * @param size will be updated with the size of the array returned.
     * @return c-style array of pointers to the xsd__NOTATION data.
     */
    const xsd__NOTATION* get(int& size) const;
};

AXIS_CPP_NAMESPACE_END
#endif