// Copyright (c) 2005-2011 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD/e, an XML Schema
// to C++ data binding compiler for embedded systems.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
//

#ifndef SCENE_DESCRIPTION_H
#define SCENE_DESCRIPTION_H

#include <xsde/cxx/version.hxx>

#if (XSDE_INT_VERSION != 3020000L)
#error XSD/e runtime version mismatch
#endif

#include <xsde/cxx/config.hxx>

#ifndef XSDE_ENCODING_UTF8
#error the generated code uses the UTF-8 encodingwhile the XSD/e runtime does not (reconfigure the runtime or change the --char-encoding value)
#endif

#ifndef XSDE_STL
#error the generated code uses STL while the XSD/e runtime does not (reconfigure the runtime or add --no-stl)
#endif

#ifndef XSDE_EXCEPTIONS
#error the generated code uses exceptions while the XSD/e runtime does not (reconfigure the runtime or add --no-exceptions)
#endif

#ifndef XSDE_LONGLONG
#error the generated code uses long long while the XSD/e runtime does not (reconfigure the runtime or add --no-long-long)
#endif

#ifdef XSDE_CUSTOM_ALLOCATOR
#error the XSD/e runtime uses custom allocator while the generated code does not (reconfigure the runtime or add --custom-allocator)
#endif

#include <xsde/cxx/pre.hxx>

// Begin prologue.
//
//
// End prologue.

#include <string>
#include <xsde/cxx/hybrid/xml-schema.hxx>
#include <xsde/cxx/hybrid/sequence.hxx>

namespace xml_schema
{
  using ::xsde::cxx::hybrid::any_type;
  typedef ::std::string any_simple_type;

  typedef signed char byte;
  using ::xsde::cxx::hybrid::byte_base;

  typedef unsigned char unsigned_byte;
  using ::xsde::cxx::hybrid::unsigned_byte_base;

  typedef short short_;
  using ::xsde::cxx::hybrid::short_base;

  typedef unsigned short unsigned_short;
  using ::xsde::cxx::hybrid::unsigned_short_base;

  typedef int int_;
  using ::xsde::cxx::hybrid::int_base;

  typedef unsigned int unsigned_int;
  using ::xsde::cxx::hybrid::unsigned_int_base;

  typedef long long long_;
  using ::xsde::cxx::hybrid::long_base;

  typedef unsigned long long unsigned_long;
  using ::xsde::cxx::hybrid::unsigned_long_base;

  typedef long integer;
  using ::xsde::cxx::hybrid::integer_base;

  typedef long non_positive_integer;
  using ::xsde::cxx::hybrid::non_positive_integer_base;

  typedef unsigned long non_negative_integer;
  using ::xsde::cxx::hybrid::non_negative_integer_base;

  typedef unsigned long positive_integer;
  using ::xsde::cxx::hybrid::positive_integer_base;

  typedef long negative_integer;
  using ::xsde::cxx::hybrid::negative_integer_base;

  typedef bool boolean;
  using ::xsde::cxx::hybrid::boolean_base;

  typedef float float_;
  using ::xsde::cxx::hybrid::float_base;

  typedef double double_;
  using ::xsde::cxx::hybrid::double_base;

  typedef double decimal;
  using ::xsde::cxx::hybrid::decimal_base;

  typedef ::std::string string;

  typedef ::std::string normalized_string;

  typedef ::std::string token;

  typedef ::std::string name;

  typedef ::std::string nmtoken;

  typedef ::xsde::cxx::string_sequence nmtokens;

  typedef ::std::string ncname;

  typedef ::std::string language;

  typedef ::std::string id;

  typedef ::std::string idref;

  typedef ::xsde::cxx::string_sequence idrefs;

  typedef ::std::string uri;

  using ::xsde::cxx::qname;

  using ::xsde::cxx::buffer;
  typedef ::xsde::cxx::buffer base64_binary;
  typedef ::xsde::cxx::buffer hex_binary;

  using ::xsde::cxx::time_zone;
  using ::xsde::cxx::date;
  using ::xsde::cxx::date_time;
  using ::xsde::cxx::duration;
  using ::xsde::cxx::gday;
  using ::xsde::cxx::gmonth;
  using ::xsde::cxx::gmonth_day;
  using ::xsde::cxx::gyear;
  using ::xsde::cxx::gyear_month;
  using ::xsde::cxx::time;

  using ::xsde::cxx::hybrid::pod_sequence;
  using ::xsde::cxx::hybrid::fix_sequence;
  using ::xsde::cxx::hybrid::var_sequence;
  using ::xsde::cxx::string_sequence;
  using ::xsde::cxx::hybrid::data_sequence;
}

class Vector;
class Color;
class BlockType;
class GroupReferenceType;
class GroupType;
class SceneDescriptionType;

// Vector (fixed-length)
//
class Vector
{
  public:
  Vector ();

  Vector (const Vector&);
  Vector& operator= (const Vector&);

  ~Vector ();

  // X
  //
  float
  X () const;

  float&
  X ();

  void
  X (float);

  // Y
  //
  float
  Y () const;

  float&
  Y ();

  void
  Y (float);

  // Z
  //
  float
  Z () const;

  float&
  Z ();

  void
  Z (float);

  private:
  float X_;
  float Y_;
  float Z_;
};

// Color (fixed-length)
//
class Color
{
  public:
  Color ();

  Color (const Color&);
  Color& operator= (const Color&);

  ~Color ();

  // R
  //
  float
  R () const;

  float&
  R ();

  void
  R (float);

  // G
  //
  float
  G () const;

  float&
  G ();

  void
  G (float);

  // B
  //
  float
  B () const;

  float&
  B ();

  void
  B (float);

  private:
  float R_;
  float G_;
  float B_;
};

// BlockType (fixed-length)
//
class BlockType
{
  public:
  BlockType ();

  BlockType (const BlockType&);
  BlockType& operator= (const BlockType&);

  ~BlockType ();

  // Mass
  //
  float
  Mass () const;

  float&
  Mass ();

  void
  Mass (float);

  // Size
  //
  const ::Vector&
  Size () const;

  ::Vector&
  Size ();

  void
  Size (const ::Vector&);

  // Location
  //
  const ::Vector&
  Location () const;

  ::Vector&
  Location ();

  void
  Location (const ::Vector&);

  // Color
  //
  bool
  Color_present () const;

  void
  Color_present (bool);

  const ::Color&
  Color () const;

  ::Color&
  Color ();

  void
  Color (const ::Color&);

  // Value
  //
  bool
  Value_present () const;

  void
  Value_present (bool);

  long
  Value () const;

  long&
  Value ();

  void
  Value (long);

  private:
  float Mass_;
  ::Vector Size_;
  ::Vector Location_;
  ::Color Color_;
  unsigned char Color_present_;
  long Value_;
  unsigned char Value_present_;
};

// GroupReferenceType (fixed-length)
//
class GroupReferenceType
{
  public:
  GroupReferenceType ();

  GroupReferenceType (const GroupReferenceType&);
  GroupReferenceType& operator= (const GroupReferenceType&);

  ~GroupReferenceType ();

  // Location
  //
  const ::Vector&
  Location () const;

  ::Vector&
  Location ();

  void
  Location (const ::Vector&);

  // Color
  //
  bool
  Color_present () const;

  void
  Color_present (bool);

  const ::Color&
  Color () const;

  ::Color&
  Color ();

  void
  Color (const ::Color&);

  // Ref
  //
  const ::std::string&
  Ref () const;

  ::std::string&
  Ref ();

  void
  Ref (const ::std::string&);

  private:
  ::Vector Location_;
  ::Color Color_;
  unsigned char Color_present_;
  ::std::string Ref_;
};

// GroupType (variable-length)
//
class GroupType
{
  private:
  GroupType (const GroupType&);
  GroupType& operator= (const GroupType&);

  public:
  GroupType ();

  ~GroupType ();

  // id
  //
  const ::std::string&
  id () const;

  ::std::string&
  id ();

  void
  id (const ::std::string&);

  // choice (fixed-length)
  //
  class choice_type
  {
    public:
    choice_type ();

    ~choice_type ();

    choice_type (const choice_type&);
    choice_type& operator= (const choice_type&);

    enum choice_arm_tag
    {
      Block_tag,
      GroupReference_tag
    };

    choice_arm_tag
    choice_arm () const;

    void
    choice_arm (choice_arm_tag);

    // Block
    //
    const ::BlockType&
    Block () const;

    ::BlockType&
    Block ();

    void
    Block (const ::BlockType&);

    // GroupReference
    //
    const ::GroupReferenceType&
    GroupReference () const;

    ::GroupReferenceType&
    GroupReference ();

    void
    GroupReference (const ::GroupReferenceType&);

    private:
    union
    {
      union
      {
        long align_;
        char data_[sizeof (::BlockType)];
      } Block_;
      union
      {
        size_t align_;
        char data_[sizeof (::GroupReferenceType)];
      } GroupReference_;
    } choice_;
    choice_arm_tag choice_arm_;
  };

  typedef ::xsde::cxx::hybrid::fix_sequence< choice_type > choice_sequence;
  typedef choice_sequence::iterator choice_iterator;
  typedef choice_sequence::const_iterator choice_const_iterator;

  const choice_sequence&
  choice () const;

  choice_sequence&
  choice ();

  private:
  ::std::string id_;
  choice_sequence choice_;
};

// SceneDescriptionType (variable-length)
//
class SceneDescriptionType
{
  private:
  SceneDescriptionType (const SceneDescriptionType&);
  SceneDescriptionType& operator= (const SceneDescriptionType&);

  public:
  SceneDescriptionType ();

  ~SceneDescriptionType ();

  // Group
  //
  typedef ::xsde::cxx::hybrid::var_sequence< ::GroupType > Group_sequence;
  typedef Group_sequence::iterator Group_iterator;
  typedef Group_sequence::const_iterator Group_const_iterator;

  const Group_sequence&
  Group () const;

  Group_sequence&
  Group ();

  // Base
  //
  const ::BlockType&
  Base () const;

  ::BlockType&
  Base ();

  void
  Base (const ::BlockType&);

  // GroupReference
  //
  typedef ::xsde::cxx::hybrid::fix_sequence< ::GroupReferenceType > GroupReference_sequence;
  typedef GroupReference_sequence::iterator GroupReference_iterator;
  typedef GroupReference_sequence::const_iterator GroupReference_const_iterator;

  const GroupReference_sequence&
  GroupReference () const;

  GroupReference_sequence&
  GroupReference ();

  private:
  Group_sequence Group_;
  ::BlockType Base_;
  GroupReference_sequence GroupReference_;
};

// Begin epilogue.
//
//
// End epilogue.

#include <xsde/cxx/post.hxx>

#endif // SCENE_DESCRIPTION_H
