gdtf-pimpl.cpp

// Not copyrighted - public domain.
//
// This sample parser implementation was generated by CodeSynthesis XSD,
// an XML Schema to C++ data binding compiler. You may use it in your
// programs without any restrictions.
//

#include "gdtf-pimpl.h"

#include <iostream>

namespace device
{
  // matrixtype_pimpl
  //

  void matrixtype_pimpl::
  pre ()
  {
  }

  void matrixtype_pimpl::
  post_matrixtype ()
  {
    const ::std::string& v (post_string ());

    std::cout << "matrixtype: " << v << std::endl;
  }

  // colorcietype_pimpl
  //

  void colorcietype_pimpl::
  pre ()
  {
  }

  void colorcietype_pimpl::
  post_colorcietype ()
  {
    const ::std::string& v (post_string ());

    std::cout << "colorcietype: " << v << std::endl;
  }

  // offsettype_pimpl
  //

  void offsettype_pimpl::
  pre ()
  {
  }

  void offsettype_pimpl::
  post_offsettype ()
  {
    const ::std::string& v (post_string ());

    std::cout << "offsettype: " << v << std::endl;
  }

  // dmxtype_pimpl
  //

  void dmxtype_pimpl::
  pre ()
  {
  }

  void dmxtype_pimpl::
  post_dmxtype ()
  {
    const ::std::string& v (post_string ());

    std::cout << "dmxtype: " << v << std::endl;
  }

  // dmxvalue_pimpl
  //

  void dmxvalue_pimpl::
  pre ()
  {
  }

  void dmxvalue_pimpl::
  post_dmxvalue ()
  {
    const ::std::string& v (post_string ());

    std::cout << "dmxvalue: " << v << std::endl;
  }

  // nametype_pimpl
  //

  void nametype_pimpl::
  pre ()
  {
  }

  void nametype_pimpl::
  post_nametype ()
  {
    const ::std::string& v (post_string ());

    std::cout << "nametype: " << v << std::endl;
  }

  // dataversion_pimpl
  //

  void dataversion_pimpl::
  pre ()
  {
  }

  void dataversion_pimpl::
  post_dataversion ()
  {
    float v (post_float ());

    std::cout << "dataversion: " << v << std::endl;
  }

  // guidtype_pimpl
  //

  void guidtype_pimpl::
  pre ()
  {
  }

  void guidtype_pimpl::
  post_guidtype ()
  {
    const ::std::string& v (post_string ());

    std::cout << "guidtype: " << v << std::endl;
  }

  // PhysicalUnitEnum_pimpl
  //

  void PhysicalUnitEnum_pimpl::
  pre ()
  {
  }

  void PhysicalUnitEnum_pimpl::
  post_PhysicalUnitEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "PhysicalUnitEnum: " << v << std::endl;
  }

  // MasterEnum_pimpl
  //

  void MasterEnum_pimpl::
  pre ()
  {
  }

  void MasterEnum_pimpl::
  post_MasterEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "MasterEnum: " << v << std::endl;
  }

  // PrimitiveTypeEnum_pimpl
  //

  void PrimitiveTypeEnum_pimpl::
  pre ()
  {
  }

  void PrimitiveTypeEnum_pimpl::
  post_PrimitiveTypeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "PrimitiveTypeEnum: " << v << std::endl;
  }

  // LampTypeEnum_pimpl
  //

  void LampTypeEnum_pimpl::
  pre ()
  {
  }

  void LampTypeEnum_pimpl::
  post_LampTypeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "LampTypeEnum: " << v << std::endl;
  }

  // BeamTypeEnum_pimpl
  //

  void BeamTypeEnum_pimpl::
  pre ()
  {
  }

  void BeamTypeEnum_pimpl::
  post_BeamTypeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "BeamTypeEnum: " << v << std::endl;
  }

  // ColorSpaceEnum_pimpl
  //

  void ColorSpaceEnum_pimpl::
  pre ()
  {
  }

  void ColorSpaceEnum_pimpl::
  post_ColorSpaceEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "ColorSpaceEnum: " << v << std::endl;
  }

  // InterpolationToEnum_pimpl
  //

  void InterpolationToEnum_pimpl::
  pre ()
  {
  }

  void InterpolationToEnum_pimpl::
  post_InterpolationToEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "InterpolationToEnum: " << v << std::endl;
  }

  // SnapEnum_pimpl
  //

  void SnapEnum_pimpl::
  pre ()
  {
  }

  void SnapEnum_pimpl::
  post_SnapEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "SnapEnum: " << v << std::endl;
  }

  // YesNoEnum_pimpl
  //

  void YesNoEnum_pimpl::
  pre ()
  {
  }

  void YesNoEnum_pimpl::
  post_YesNoEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "YesNoEnum: " << v << std::endl;
  }

  // RelationTypesEnum_pimpl
  //

  void RelationTypesEnum_pimpl::
  pre ()
  {
  }

  void RelationTypesEnum_pimpl::
  post_RelationTypesEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RelationTypesEnum: " << v << std::endl;
  }

  // RDMParameterTypeEnum_pimpl
  //

  void RDMParameterTypeEnum_pimpl::
  pre ()
  {
  }

  void RDMParameterTypeEnum_pimpl::
  post_RDMParameterTypeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMParameterTypeEnum: " << v << std::endl;
  }

  // ThresholdOperatorEnum_pimpl
  //

  void ThresholdOperatorEnum_pimpl::
  pre ()
  {
  }

  void ThresholdOperatorEnum_pimpl::
  post_ThresholdOperatorEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "ThresholdOperatorEnum: " << v << std::endl;
  }

  // RDMParameterDataTypeEnum_pimpl
  //

  void RDMParameterDataTypeEnum_pimpl::
  pre ()
  {
  }

  void RDMParameterDataTypeEnum_pimpl::
  post_RDMParameterDataTypeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMParameterDataTypeEnum: " << v << std::endl;
  }

  // RDMParameterCommandEnum_pimpl
  //

  void RDMParameterCommandEnum_pimpl::
  pre ()
  {
  }

  void RDMParameterCommandEnum_pimpl::
  post_RDMParameterCommandEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMParameterCommandEnum: " << v << std::endl;
  }

  // RDMSensorTypeEnum_pimpl
  //

  void RDMSensorTypeEnum_pimpl::
  pre ()
  {
  }

  void RDMSensorTypeEnum_pimpl::
  post_RDMSensorTypeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMSensorTypeEnum: " << v << std::endl;
  }

  // RDMParameterSensorUnitEnum_pimpl
  //

  void RDMParameterSensorUnitEnum_pimpl::
  pre ()
  {
  }

  void RDMParameterSensorUnitEnum_pimpl::
  post_RDMParameterSensorUnitEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMParameterSensorUnitEnum: " << v << std::endl;
  }

  // RDMSlotInfoTypeEnum_pimpl
  //

  void RDMSlotInfoTypeEnum_pimpl::
  pre ()
  {
  }

  void RDMSlotInfoTypeEnum_pimpl::
  post_RDMSlotInfoTypeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMSlotInfoTypeEnum: " << v << std::endl;
  }

  // RDMSlotLabelIDEnum_pimpl
  //

  void RDMSlotLabelIDEnum_pimpl::
  pre ()
  {
  }

  void RDMSlotLabelIDEnum_pimpl::
  post_RDMSlotLabelIDEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMSlotLabelIDEnum: " << v << std::endl;
  }

  // RDMParameterSensorUnitPrefixEnum_pimpl
  //

  void RDMParameterSensorUnitPrefixEnum_pimpl::
  pre ()
  {
  }

  void RDMParameterSensorUnitPrefixEnum_pimpl::
  post_RDMParameterSensorUnitPrefixEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "RDMParameterSensorUnitPrefixEnum: " << v << std::endl;
  }

  // CESEnum_pimpl
  //

  void CESEnum_pimpl::
  pre ()
  {
  }

  void CESEnum_pimpl::
  post_CESEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "CESEnum: " << v << std::endl;
  }

  // AttributeEnum_pimpl
  //

  void AttributeEnum_pimpl::
  pre ()
  {
  }

  void AttributeEnum_pimpl::
  post_AttributeEnum ()
  {
    const ::std::string& v (post_string ());

    std::cout << "AttributeEnum: " << v << std::endl;
  }

  // GDTF_pimpl
  //

  void GDTF_pimpl::
  pre ()
  {
  }

  void GDTF_pimpl::
  FixtureType ()
  {
  }

  void GDTF_pimpl::
  DataVersion ()
  {
  }

  void GDTF_pimpl::
  post_GDTF ()
  {
  }

  // FixtureType_pimpl
  //

  void FixtureType_pimpl::
  pre ()
  {
  }

  void FixtureType_pimpl::
  AttributeDefinitions ()
  {
  }

  void FixtureType_pimpl::
  Wheels ()
  {
  }

  void FixtureType_pimpl::
  PhysicalDescriptions ()
  {
  }

  void FixtureType_pimpl::
  Models ()
  {
  }

  void FixtureType_pimpl::
  Geometries ()
  {
  }

  void FixtureType_pimpl::
  DMXModes ()
  {
  }

  void FixtureType_pimpl::
  Revisions ()
  {
  }

  void FixtureType_pimpl::
  FTPresets ()
  {
  }

  void FixtureType_pimpl::
  Protocols ()
  {
  }

  void FixtureType_pimpl::
  Name ()
  {
  }

  void FixtureType_pimpl::
  ShortName (const ::std::string& ShortName)
  {
    std::cout << "ShortName: " << ShortName << std::endl;
  }

  void FixtureType_pimpl::
  LongName (const ::std::string& LongName)
  {
    std::cout << "LongName: " << LongName << std::endl;
  }

  void FixtureType_pimpl::
  Manufacturer (const ::std::string& Manufacturer)
  {
    std::cout << "Manufacturer: " << Manufacturer << std::endl;
  }

  void FixtureType_pimpl::
  Description (const ::std::string& Description)
  {
    std::cout << "Description: " << Description << std::endl;
  }

  void FixtureType_pimpl::
  FixtureTypeID ()
  {
  }

  void FixtureType_pimpl::
  Thumbnail (const ::std::string& Thumbnail)
  {
    std::cout << "Thumbnail: " << Thumbnail << std::endl;
  }

  void FixtureType_pimpl::
  RefFT ()
  {
  }

  void FixtureType_pimpl::
  post_FixtureType ()
  {
  }

  // Wheels_pimpl
  //

  void Wheels_pimpl::
  pre ()
  {
  }

  void Wheels_pimpl::
  Wheel ()
  {
  }

  void Wheels_pimpl::
  post_Wheels ()
  {
  }

  // Wheel_pimpl
  //

  void Wheel_pimpl::
  pre ()
  {
  }

  void Wheel_pimpl::
  Slot ()
  {
  }

  void Wheel_pimpl::
  Name ()
  {
  }

  void Wheel_pimpl::
  post_Wheel ()
  {
  }

  // Slot_pimpl
  //

  void Slot_pimpl::
  pre ()
  {
  }

  void Slot_pimpl::
  Facet ()
  {
  }

  void Slot_pimpl::
  Name ()
  {
  }

  void Slot_pimpl::
  Color ()
  {
  }

  void Slot_pimpl::
  Filter (const ::std::string& Filter)
  {
    std::cout << "Filter: " << Filter << std::endl;
  }

  void Slot_pimpl::
  MediaFileName (const ::std::string& MediaFileName)
  {
    std::cout << "MediaFileName: " << MediaFileName << std::endl;
  }

  void Slot_pimpl::
  post_Slot ()
  {
  }

  // Facet_pimpl
  //

  void Facet_pimpl::
  pre ()
  {
  }

  void Facet_pimpl::
  Color ()
  {
  }

  void Facet_pimpl::
  Rotation (const ::std::string& Rotation)
  {
    std::cout << "Rotation: " << Rotation << std::endl;
  }

  void Facet_pimpl::
  post_Facet ()
  {
  }

  // Models_pimpl
  //

  void Models_pimpl::
  pre ()
  {
  }

  void Models_pimpl::
  Model ()
  {
  }

  void Models_pimpl::
  post_Models ()
  {
  }

  // Model_pimpl
  //

  void Model_pimpl::
  pre ()
  {
  }

  void Model_pimpl::
  Name ()
  {
  }

  void Model_pimpl::
  Length (float Length)
  {
    std::cout << "Length: " << Length << std::endl;
  }

  void Model_pimpl::
  Width (float Width)
  {
    std::cout << "Width: " << Width << std::endl;
  }

  void Model_pimpl::
  Height (float Height)
  {
    std::cout << "Height: " << Height << std::endl;
  }

  void Model_pimpl::
  PrimitiveType ()
  {
  }

  void Model_pimpl::
  File (const ::std::string& File)
  {
    std::cout << "File: " << File << std::endl;
  }

  void Model_pimpl::
  post_Model ()
  {
  }

  // Geometries_pimpl
  //

  void Geometries_pimpl::
  pre ()
  {
  }

  void Geometries_pimpl::
  Geometry ()
  {
  }

  void Geometries_pimpl::
  Axis ()
  {
  }

  void Geometries_pimpl::
  FilterBeam ()
  {
  }

  void Geometries_pimpl::
  FilterColor ()
  {
  }

  void Geometries_pimpl::
  FilterGobo ()
  {
  }

  void Geometries_pimpl::
  FilterShaper ()
  {
  }

  void Geometries_pimpl::
  Beam ()
  {
  }

  void Geometries_pimpl::
  GeometryReference ()
  {
  }

  void Geometries_pimpl::
  post_Geometries ()
  {
  }

  // Geometry_pimpl
  //

  void Geometry_pimpl::
  pre ()
  {
  }

  void Geometry_pimpl::
  Geometry ()
  {
  }

  void Geometry_pimpl::
  Axis ()
  {
  }

  void Geometry_pimpl::
  FilterBeam ()
  {
  }

  void Geometry_pimpl::
  FilterColor ()
  {
  }

  void Geometry_pimpl::
  FilterGobo ()
  {
  }

  void Geometry_pimpl::
  FilterShaper ()
  {
  }

  void Geometry_pimpl::
  Beam ()
  {
  }

  void Geometry_pimpl::
  GeometryReference ()
  {
  }

  void Geometry_pimpl::
  Name ()
  {
  }

  void Geometry_pimpl::
  Model ()
  {
  }

  void Geometry_pimpl::
  Position ()
  {
  }

  void Geometry_pimpl::
  post_Geometry ()
  {
  }

  // Axis_pimpl
  //

  void Axis_pimpl::
  pre ()
  {
  }

  void Axis_pimpl::
  Geometry ()
  {
  }

  void Axis_pimpl::
  Axis ()
  {
  }

  void Axis_pimpl::
  FilterBeam ()
  {
  }

  void Axis_pimpl::
  FilterColor ()
  {
  }

  void Axis_pimpl::
  FilterGobo ()
  {
  }

  void Axis_pimpl::
  FilterShaper ()
  {
  }

  void Axis_pimpl::
  Beam ()
  {
  }

  void Axis_pimpl::
  GeometryReference ()
  {
  }

  void Axis_pimpl::
  Name ()
  {
  }

  void Axis_pimpl::
  Model ()
  {
  }

  void Axis_pimpl::
  Position ()
  {
  }

  void Axis_pimpl::
  post_Axis ()
  {
  }

  // FilterBeam_pimpl
  //

  void FilterBeam_pimpl::
  pre ()
  {
  }

  void FilterBeam_pimpl::
  Geometry ()
  {
  }

  void FilterBeam_pimpl::
  Axis ()
  {
  }

  void FilterBeam_pimpl::
  FilterBeam ()
  {
  }

  void FilterBeam_pimpl::
  FilterColor ()
  {
  }

  void FilterBeam_pimpl::
  FilterGobo ()
  {
  }

  void FilterBeam_pimpl::
  FilterShaper ()
  {
  }

  void FilterBeam_pimpl::
  Beam ()
  {
  }

  void FilterBeam_pimpl::
  GeometryReference ()
  {
  }

  void FilterBeam_pimpl::
  Name ()
  {
  }

  void FilterBeam_pimpl::
  Model ()
  {
  }

  void FilterBeam_pimpl::
  Position ()
  {
  }

  void FilterBeam_pimpl::
  post_FilterBeam ()
  {
  }

  // FilterColor_pimpl
  //

  void FilterColor_pimpl::
  pre ()
  {
  }

  void FilterColor_pimpl::
  Geometry ()
  {
  }

  void FilterColor_pimpl::
  Axis ()
  {
  }

  void FilterColor_pimpl::
  FilterBeam ()
  {
  }

  void FilterColor_pimpl::
  FilterColor ()
  {
  }

  void FilterColor_pimpl::
  FilterGobo ()
  {
  }

  void FilterColor_pimpl::
  FilterShaper ()
  {
  }

  void FilterColor_pimpl::
  Beam ()
  {
  }

  void FilterColor_pimpl::
  GeometryReference ()
  {
  }

  void FilterColor_pimpl::
  Name ()
  {
  }

  void FilterColor_pimpl::
  Model ()
  {
  }

  void FilterColor_pimpl::
  Position ()
  {
  }

  void FilterColor_pimpl::
  post_FilterColor ()
  {
  }

  // FilterGobo_pimpl
  //

  void FilterGobo_pimpl::
  pre ()
  {
  }

  void FilterGobo_pimpl::
  Geometry ()
  {
  }

  void FilterGobo_pimpl::
  Axis ()
  {
  }

  void FilterGobo_pimpl::
  FilterBeam ()
  {
  }

  void FilterGobo_pimpl::
  FilterColor ()
  {
  }

  void FilterGobo_pimpl::
  FilterGobo ()
  {
  }

  void FilterGobo_pimpl::
  FilterShaper ()
  {
  }

  void FilterGobo_pimpl::
  Beam ()
  {
  }

  void FilterGobo_pimpl::
  GeometryReference ()
  {
  }

  void FilterGobo_pimpl::
  Name ()
  {
  }

  void FilterGobo_pimpl::
  Model ()
  {
  }

  void FilterGobo_pimpl::
  Position ()
  {
  }

  void FilterGobo_pimpl::
  post_FilterGobo ()
  {
  }

  // FilterShaper_pimpl
  //

  void FilterShaper_pimpl::
  pre ()
  {
  }

  void FilterShaper_pimpl::
  Geometry ()
  {
  }

  void FilterShaper_pimpl::
  Axis ()
  {
  }

  void FilterShaper_pimpl::
  FilterBeam ()
  {
  }

  void FilterShaper_pimpl::
  FilterColor ()
  {
  }

  void FilterShaper_pimpl::
  FilterGobo ()
  {
  }

  void FilterShaper_pimpl::
  FilterShaper ()
  {
  }

  void FilterShaper_pimpl::
  Beam ()
  {
  }

  void FilterShaper_pimpl::
  GeometryReference ()
  {
  }

  void FilterShaper_pimpl::
  Name ()
  {
  }

  void FilterShaper_pimpl::
  Model ()
  {
  }

  void FilterShaper_pimpl::
  Position ()
  {
  }

  void FilterShaper_pimpl::
  post_FilterShaper ()
  {
  }

  // Beam_pimpl
  //

  void Beam_pimpl::
  pre ()
  {
  }

  void Beam_pimpl::
  Geometry ()
  {
  }

  void Beam_pimpl::
  Axis ()
  {
  }

  void Beam_pimpl::
  FilterBeam ()
  {
  }

  void Beam_pimpl::
  FilterColor ()
  {
  }

  void Beam_pimpl::
  FilterGobo ()
  {
  }

  void Beam_pimpl::
  FilterShaper ()
  {
  }

  void Beam_pimpl::
  Beam ()
  {
  }

  void Beam_pimpl::
  GeometryReference ()
  {
  }

  void Beam_pimpl::
  Name ()
  {
  }

  void Beam_pimpl::
  Model ()
  {
  }

  void Beam_pimpl::
  Position ()
  {
  }

  void Beam_pimpl::
  LampType ()
  {
  }

  void Beam_pimpl::
  PowerConsumption (float PowerConsumption)
  {
    std::cout << "PowerConsumption: " << PowerConsumption << std::endl;
  }

  void Beam_pimpl::
  LuminousFlux (float LuminousFlux)
  {
    std::cout << "LuminousFlux: " << LuminousFlux << std::endl;
  }

  void Beam_pimpl::
  ColorTemperature (float ColorTemperature)
  {
    std::cout << "ColorTemperature: " << ColorTemperature << std::endl;
  }

  void Beam_pimpl::
  BeamAngle (float BeamAngle)
  {
    std::cout << "BeamAngle: " << BeamAngle << std::endl;
  }

  void Beam_pimpl::
  FieldAngle (float FieldAngle)
  {
    std::cout << "FieldAngle: " << FieldAngle << std::endl;
  }

  void Beam_pimpl::
  BeamRadius (float BeamRadius)
  {
    std::cout << "BeamRadius: " << BeamRadius << std::endl;
  }

  void Beam_pimpl::
  BeamType ()
  {
  }

  void Beam_pimpl::
  ColorRenderingIndex (long long ColorRenderingIndex)
  {
    std::cout << "ColorRenderingIndex: " << ColorRenderingIndex << std::endl;
  }

  void Beam_pimpl::
  post_Beam ()
  {
  }

  // GeometryReference_pimpl
  //

  void GeometryReference_pimpl::
  pre ()
  {
  }

  void GeometryReference_pimpl::
  Break ()
  {
  }

  void GeometryReference_pimpl::
  Name ()
  {
  }

  void GeometryReference_pimpl::
  Position ()
  {
  }

  void GeometryReference_pimpl::
  Geometry ()
  {
  }

  void GeometryReference_pimpl::
  Model ()
  {
  }

  void GeometryReference_pimpl::
  post_GeometryReference ()
  {
  }

  // Break_pimpl
  //

  void Break_pimpl::
  pre ()
  {
  }

  void Break_pimpl::
  DMXOffset (long long DMXOffset)
  {
    std::cout << "DMXOffset: " << DMXOffset << std::endl;
  }

  void Break_pimpl::
  DMXBreak (long long DMXBreak)
  {
    std::cout << "DMXBreak: " << DMXBreak << std::endl;
  }

  void Break_pimpl::
  post_Break ()
  {
  }

  // DMXModes_pimpl
  //

  void DMXModes_pimpl::
  pre ()
  {
  }

  void DMXModes_pimpl::
  DMXMode ()
  {
  }

  void DMXModes_pimpl::
  post_DMXModes ()
  {
  }

  // DMXMode_pimpl
  //

  void DMXMode_pimpl::
  pre ()
  {
  }

  void DMXMode_pimpl::
  DMXChannels ()
  {
  }

  void DMXMode_pimpl::
  Relations ()
  {
  }

  void DMXMode_pimpl::
  FTMacros ()
  {
  }

  void DMXMode_pimpl::
  Name ()
  {
  }

  void DMXMode_pimpl::
  Geometry ()
  {
  }

  void DMXMode_pimpl::
  post_DMXMode ()
  {
  }

  // DMXChannels_pimpl
  //

  void DMXChannels_pimpl::
  pre ()
  {
  }

  void DMXChannels_pimpl::
  DMXChannel ()
  {
  }

  void DMXChannels_pimpl::
  post_DMXChannels ()
  {
  }

  // DMXChannel_pimpl
  //

  void DMXChannel_pimpl::
  pre ()
  {
  }

  void DMXChannel_pimpl::
  LogicalChannel ()
  {
  }

  void DMXChannel_pimpl::
  Name ()
  {
  }

  void DMXChannel_pimpl::
  DMXBreak (long long DMXBreak)
  {
    std::cout << "DMXBreak: " << DMXBreak << std::endl;
  }

  void DMXChannel_pimpl::
  Offset ()
  {
  }

  void DMXChannel_pimpl::
  Default ()
  {
  }

  void DMXChannel_pimpl::
  Highlight ()
  {
  }

  void DMXChannel_pimpl::
  Geometry (const ::std::string& Geometry)
  {
    std::cout << "Geometry: " << Geometry << std::endl;
  }

  void DMXChannel_pimpl::
  post_DMXChannel ()
  {
  }

  // LogicalChannel_pimpl
  //

  void LogicalChannel_pimpl::
  pre ()
  {
  }

  void LogicalChannel_pimpl::
  ChannelFunction ()
  {
  }

  void LogicalChannel_pimpl::
  Name ()
  {
  }

  void LogicalChannel_pimpl::
  Attribute ()
  {
  }

  void LogicalChannel_pimpl::
  Snap ()
  {
  }

  void LogicalChannel_pimpl::
  Master ()
  {
  }

  void LogicalChannel_pimpl::
  MibFade (float MibFade)
  {
    std::cout << "MibFade: " << MibFade << std::endl;
  }

  void LogicalChannel_pimpl::
  DMXChangeTimeLimit (float DMXChangeTimeLimit)
  {
    std::cout << "DMXChangeTimeLimit: " << DMXChangeTimeLimit << std::endl;
  }

  void LogicalChannel_pimpl::
  post_LogicalChannel ()
  {
  }

  // ChannelFunction_pimpl
  //

  void ChannelFunction_pimpl::
  pre ()
  {
  }

  void ChannelFunction_pimpl::
  ChannelSet ()
  {
  }

  void ChannelFunction_pimpl::
  Name (const ::std::string& Name)
  {
    std::cout << "Name: " << Name << std::endl;
  }

  void ChannelFunction_pimpl::
  Attribute ()
  {
  }

  void ChannelFunction_pimpl::
  OriginalAttribute (const ::std::string& OriginalAttribute)
  {
    std::cout << "OriginalAttribute: " << OriginalAttribute << std::endl;
  }

  void ChannelFunction_pimpl::
  DMXFrom ()
  {
  }

  void ChannelFunction_pimpl::
  PhysicalFrom (float PhysicalFrom)
  {
    std::cout << "PhysicalFrom: " << PhysicalFrom << std::endl;
  }

  void ChannelFunction_pimpl::
  PhysicalTo (float PhysicalTo)
  {
    std::cout << "PhysicalTo: " << PhysicalTo << std::endl;
  }

  void ChannelFunction_pimpl::
  RealFade (float RealFade)
  {
    std::cout << "RealFade: " << RealFade << std::endl;
  }

  void ChannelFunction_pimpl::
  Wheel (const ::std::string& Wheel)
  {
    std::cout << "Wheel: " << Wheel << std::endl;
  }

  void ChannelFunction_pimpl::
  Emitter (const ::std::string& Emitter)
  {
    std::cout << "Emitter: " << Emitter << std::endl;
  }

  void ChannelFunction_pimpl::
  Filter (const ::std::string& Filter)
  {
    std::cout << "Filter: " << Filter << std::endl;
  }

  void ChannelFunction_pimpl::
  ModeMaster (const ::std::string& ModeMaster)
  {
    std::cout << "ModeMaster: " << ModeMaster << std::endl;
  }

  void ChannelFunction_pimpl::
  ModeFrom ()
  {
  }

  void ChannelFunction_pimpl::
  ModeTo ()
  {
  }

  void ChannelFunction_pimpl::
  post_ChannelFunction ()
  {
  }

  // ChannelSet_pimpl
  //

  void ChannelSet_pimpl::
  pre ()
  {
  }

  void ChannelSet_pimpl::
  Name (const ::std::string& Name)
  {
    std::cout << "Name: " << Name << std::endl;
  }

  void ChannelSet_pimpl::
  DMXFrom ()
  {
  }

  void ChannelSet_pimpl::
  DMXTo ()
  {
  }

  void ChannelSet_pimpl::
  PhysicalFrom (float PhysicalFrom)
  {
    std::cout << "PhysicalFrom: " << PhysicalFrom << std::endl;
  }

  void ChannelSet_pimpl::
  PhysicalTo (float PhysicalTo)
  {
    std::cout << "PhysicalTo: " << PhysicalTo << std::endl;
  }

  void ChannelSet_pimpl::
  WheelSlotIndex (long long WheelSlotIndex)
  {
    std::cout << "WheelSlotIndex: " << WheelSlotIndex << std::endl;
  }

  void ChannelSet_pimpl::
  post_ChannelSet ()
  {
  }

  // Relations_pimpl
  //

  void Relations_pimpl::
  pre ()
  {
  }

  void Relations_pimpl::
  Relation ()
  {
  }

  void Relations_pimpl::
  post_Relations ()
  {
  }

  // Relation_pimpl
  //

  void Relation_pimpl::
  pre ()
  {
  }

  void Relation_pimpl::
  Name (const ::std::string& Name)
  {
    std::cout << "Name: " << Name << std::endl;
  }

  void Relation_pimpl::
  Master (const ::std::string& Master)
  {
    std::cout << "Master: " << Master << std::endl;
  }

  void Relation_pimpl::
  Follower (const ::std::string& Follower)
  {
    std::cout << "Follower: " << Follower << std::endl;
  }

  void Relation_pimpl::
  Type ()
  {
  }

  void Relation_pimpl::
  post_Relation ()
  {
  }

  // Revisions_pimpl
  //

  void Revisions_pimpl::
  pre ()
  {
  }

  void Revisions_pimpl::
  Revision ()
  {
  }

  void Revisions_pimpl::
  post_Revisions ()
  {
  }

  // Revision_pimpl
  //

  void Revision_pimpl::
  pre ()
  {
  }

  void Revision_pimpl::
  Text (const ::std::string& Text)
  {
    std::cout << "Text: " << Text << std::endl;
  }

  void Revision_pimpl::
  Date (const ::xml_schema::date_time& Date)
  {
    std::cout << "Date: "
     << Date.year () << '-'
     << Date.month () << '-'
     << Date.day () << 'T'
     << Date.hours () << ':'
     << Date.minutes () << ':'
     << Date.seconds ();

    if (Date.zone_present ())
    {
      if (Date.zone_hours () < 0)
        std::cout << Date.zone_hours () << ':' << -Date.zone_minutes ();
      else
        std::cout << '+' << Date.zone_hours () << ':' << Date.zone_minutes ();
    }

    std::cout << std::endl;
  }

  void Revision_pimpl::
  UserID (long long UserID)
  {
    std::cout << "UserID: " << UserID << std::endl;
  }

  void Revision_pimpl::
  post_Revision ()
  {
  }

  // FTPresets_pimpl
  //

  void FTPresets_pimpl::
  pre ()
  {
  }

  void FTPresets_pimpl::
  FTPreset ()
  {
  }

  void FTPresets_pimpl::
  post_FTPresets ()
  {
  }

  // FTPreset_pimpl
  //

  void FTPreset_pimpl::
  pre ()
  {
  }

  void FTPreset_pimpl::
  post_FTPreset ()
  {
  }

  // FTMacros_pimpl
  //

  void FTMacros_pimpl::
  pre ()
  {
  }

  void FTMacros_pimpl::
  FTMacro ()
  {
  }

  void FTMacros_pimpl::
  post_FTMacros ()
  {
  }

  // FTMacro_pimpl
  //

  void FTMacro_pimpl::
  pre ()
  {
  }

  void FTMacro_pimpl::
  MacroDMX ()
  {
  }

  void FTMacro_pimpl::
  MacroVisual ()
  {
  }

  void FTMacro_pimpl::
  Name (const ::std::string& Name)
  {
    std::cout << "Name: " << Name << std::endl;
  }

  void FTMacro_pimpl::
  post_FTMacro ()
  {
  }

  // MacroDMX_pimpl
  //

  void MacroDMX_pimpl::
  pre ()
  {
  }

  void MacroDMX_pimpl::
  DMXStep ()
  {
  }

  void MacroDMX_pimpl::
  post_MacroDMX ()
  {
  }

  // DMXStep_pimpl
  //

  void DMXStep_pimpl::
  pre ()
  {
  }

  void DMXStep_pimpl::
  DMXValue ()
  {
  }

  void DMXStep_pimpl::
  Duration (long long Duration)
  {
    std::cout << "Duration: " << Duration << std::endl;
  }

  void DMXStep_pimpl::
  post_DMXStep ()
  {
  }

  // DMXValue_pimpl
  //

  void DMXValue_pimpl::
  pre ()
  {
  }

  void DMXValue_pimpl::
  Value ()
  {
  }

  void DMXValue_pimpl::
  DMXChannel (const ::std::string& DMXChannel)
  {
    std::cout << "DMXChannel: " << DMXChannel << std::endl;
  }

  void DMXValue_pimpl::
  post_DMXValue ()
  {
  }

  // MacroVisual_pimpl
  //

  void MacroVisual_pimpl::
  pre ()
  {
  }

  void MacroVisual_pimpl::
  VisualStep ()
  {
  }

  void MacroVisual_pimpl::
  post_MacroVisual ()
  {
  }

  // VisualStep_pimpl
  //

  void VisualStep_pimpl::
  pre ()
  {
  }

  void VisualStep_pimpl::
  VisualValue ()
  {
  }

  void VisualStep_pimpl::
  Duration (long long Duration)
  {
    std::cout << "Duration: " << Duration << std::endl;
  }

  void VisualStep_pimpl::
  Fade (const ::std::string& Fade)
  {
    std::cout << "Fade: " << Fade << std::endl;
  }

  void VisualStep_pimpl::
  Delay (const ::std::string& Delay)
  {
    std::cout << "Delay: " << Delay << std::endl;
  }

  void VisualStep_pimpl::
  post_VisualStep ()
  {
  }

  // VisualValue_pimpl
  //

  void VisualValue_pimpl::
  pre ()
  {
  }

  void VisualValue_pimpl::
  Value (const ::std::string& Value)
  {
    std::cout << "Value: " << Value << std::endl;
  }

  void VisualValue_pimpl::
  ChannelFunction (const ::std::string& ChannelFunction)
  {
    std::cout << "ChannelFunction: " << ChannelFunction << std::endl;
  }

  void VisualValue_pimpl::
  post_VisualValue ()
  {
  }

  // PhysicalDescriptions_pimpl
  //

  void PhysicalDescriptions_pimpl::
  pre ()
  {
  }

  void PhysicalDescriptions_pimpl::
  Emitters ()
  {
  }

  void PhysicalDescriptions_pimpl::
  Filters ()
  {
  }

  void PhysicalDescriptions_pimpl::
  ColorSpace ()
  {
  }

  void PhysicalDescriptions_pimpl::
  DMXProfiles ()
  {
  }

  void PhysicalDescriptions_pimpl::
  CRIs ()
  {
  }

  void PhysicalDescriptions_pimpl::
  post_PhysicalDescriptions ()
  {
  }

  // Emitters_pimpl
  //

  void Emitters_pimpl::
  pre ()
  {
  }

  void Emitters_pimpl::
  Emitter ()
  {
  }

  void Emitters_pimpl::
  post_Emitters ()
  {
  }

  // Emitter_pimpl
  //

  void Emitter_pimpl::
  pre ()
  {
  }

  void Emitter_pimpl::
  Measurement ()
  {
  }

  void Emitter_pimpl::
  Name ()
  {
  }

  void Emitter_pimpl::
  Color ()
  {
  }

  void Emitter_pimpl::
  DominantWaveLength (float DominantWaveLength)
  {
    std::cout << "DominantWaveLength: " << DominantWaveLength << std::endl;
  }

  void Emitter_pimpl::
  DiodePart (const ::std::string& DiodePart)
  {
    std::cout << "DiodePart: " << DiodePart << std::endl;
  }

  void Emitter_pimpl::
  post_Emitter ()
  {
  }

  // Filters_pimpl
  //

  void Filters_pimpl::
  pre ()
  {
  }

  void Filters_pimpl::
  Filter ()
  {
  }

  void Filters_pimpl::
  post_Filters ()
  {
  }

  // Filter_pimpl
  //

  void Filter_pimpl::
  pre ()
  {
  }

  void Filter_pimpl::
  Measurement ()
  {
  }

  void Filter_pimpl::
  Name ()
  {
  }

  void Filter_pimpl::
  Color ()
  {
  }

  void Filter_pimpl::
  post_Filter ()
  {
  }

  // Measurement_pimpl
  //

  void Measurement_pimpl::
  pre ()
  {
  }

  void Measurement_pimpl::
  MeasurementPoint ()
  {
  }

  void Measurement_pimpl::
  Physical (float Physical)
  {
    std::cout << "Physical: " << Physical << std::endl;
  }

  void Measurement_pimpl::
  LuminousIntensity (float LuminousIntensity)
  {
    std::cout << "LuminousIntensity: " << LuminousIntensity << std::endl;
  }

  void Measurement_pimpl::
  Transmission (float Transmission)
  {
    std::cout << "Transmission: " << Transmission << std::endl;
  }

  void Measurement_pimpl::
  InterpolationTo ()
  {
  }

  void Measurement_pimpl::
  post_Measurement ()
  {
  }

  // MeasurementPoint_pimpl
  //

  void MeasurementPoint_pimpl::
  pre ()
  {
  }

  void MeasurementPoint_pimpl::
  WaveLength (float WaveLength)
  {
    std::cout << "WaveLength: " << WaveLength << std::endl;
  }

  void MeasurementPoint_pimpl::
  Energy (float Energy)
  {
    std::cout << "Energy: " << Energy << std::endl;
  }

  void MeasurementPoint_pimpl::
  post_MeasurementPoint ()
  {
  }

  // ColorSpace_pimpl
  //

  void ColorSpace_pimpl::
  pre ()
  {
  }

  void ColorSpace_pimpl::
  Mode ()
  {
  }

  void ColorSpace_pimpl::
  Red ()
  {
  }

  void ColorSpace_pimpl::
  Green ()
  {
  }

  void ColorSpace_pimpl::
  Blue ()
  {
  }

  void ColorSpace_pimpl::
  WhitePoint ()
  {
  }

  void ColorSpace_pimpl::
  post_ColorSpace ()
  {
  }

  // DMXProfiles_pimpl
  //

  void DMXProfiles_pimpl::
  pre ()
  {
  }

  void DMXProfiles_pimpl::
  DMXProfile ()
  {
  }

  void DMXProfiles_pimpl::
  post_DMXProfiles ()
  {
  }

  // DMXProfile_pimpl
  //

  void DMXProfile_pimpl::
  pre ()
  {
  }

  void DMXProfile_pimpl::
  post_DMXProfile ()
  {
  }

  // CRIs_pimpl
  //

  void CRIs_pimpl::
  pre ()
  {
  }

  void CRIs_pimpl::
  CRI ()
  {
  }

  void CRIs_pimpl::
  post_CRIs ()
  {
  }

  // CRI_pimpl
  //

  void CRI_pimpl::
  pre ()
  {
  }

  void CRI_pimpl::
  CES ()
  {
  }

  void CRI_pimpl::
  ColorRenderingIndex (long long ColorRenderingIndex)
  {
    std::cout << "ColorRenderingIndex: " << ColorRenderingIndex << std::endl;
  }

  void CRI_pimpl::
  post_CRI ()
  {
  }

  // Protocols_pimpl
  //

  void Protocols_pimpl::
  pre ()
  {
  }

  void Protocols_pimpl::
  RDM ()
  {
  }

  void Protocols_pimpl::
  Art_Net ()
  {
  }

  void Protocols_pimpl::
  sACN ()
  {
  }

  void Protocols_pimpl::
  KiNET ()
  {
  }

  void Protocols_pimpl::
  PosiStageNet ()
  {
  }

  void Protocols_pimpl::
  OpenSoundControl ()
  {
  }

  void Protocols_pimpl::
  CITP ()
  {
  }

  void Protocols_pimpl::
  post_Protocols ()
  {
  }

  // Art_Net_pimpl
  //

  void Art_Net_pimpl::
  pre ()
  {
  }

  void Art_Net_pimpl::
  post_Art_Net ()
  {
  }

  // sACN_pimpl
  //

  void sACN_pimpl::
  pre ()
  {
  }

  void sACN_pimpl::
  post_sACN ()
  {
  }

  // KiNET_pimpl
  //

  void KiNET_pimpl::
  pre ()
  {
  }

  void KiNET_pimpl::
  post_KiNET ()
  {
  }

  // PosiStageNet_pimpl
  //

  void PosiStageNet_pimpl::
  pre ()
  {
  }

  void PosiStageNet_pimpl::
  post_PosiStageNet ()
  {
  }

  // OpenSoundControl_pimpl
  //

  void OpenSoundControl_pimpl::
  pre ()
  {
  }

  void OpenSoundControl_pimpl::
  post_OpenSoundControl ()
  {
  }

  // CITP_pimpl
  //

  void CITP_pimpl::
  pre ()
  {
  }

  void CITP_pimpl::
  post_CITP ()
  {
  }

  // RDM_pimpl
  //

  void RDM_pimpl::
  pre ()
  {
  }

  void RDM_pimpl::
  SoftwareVersionID ()
  {
  }

  void RDM_pimpl::
  ManufacturerID (const ::std::string& ManufacturerID)
  {
    std::cout << "ManufacturerID: " << ManufacturerID << std::endl;
  }

  void RDM_pimpl::
  DeviceModelID (const ::std::string& DeviceModelID)
  {
    std::cout << "DeviceModelID: " << DeviceModelID << std::endl;
  }

  void RDM_pimpl::
  post_RDM ()
  {
  }

  // SoftwareVersionID_pimpl
  //

  void SoftwareVersionID_pimpl::
  pre ()
  {
  }

  void SoftwareVersionID_pimpl::
  DMXPersonality ()
  {
  }

  void SoftwareVersionID_pimpl::
  Value (const ::std::string& Value)
  {
    std::cout << "Value: " << Value << std::endl;
  }

  void SoftwareVersionID_pimpl::
  post_SoftwareVersionID ()
  {
  }

  // DMXPersonality_pimpl
  //

  void DMXPersonality_pimpl::
  pre ()
  {
  }

  void DMXPersonality_pimpl::
  Value (const ::std::string& Value)
  {
    std::cout << "Value: " << Value << std::endl;
  }

  void DMXPersonality_pimpl::
  DMXMode ()
  {
  }

  void DMXPersonality_pimpl::
  post_DMXPersonality ()
  {
  }

  // AttributeDefinitions_pimpl
  //

  void AttributeDefinitions_pimpl::
  pre ()
  {
  }

  void AttributeDefinitions_pimpl::
  ActivationGroups ()
  {
  }

  void AttributeDefinitions_pimpl::
  FeatureGroups ()
  {
  }

  void AttributeDefinitions_pimpl::
  Attributes ()
  {
  }

  void AttributeDefinitions_pimpl::
  post_AttributeDefinitions ()
  {
  }

  // ActivationGroups_pimpl
  //

  void ActivationGroups_pimpl::
  pre ()
  {
  }

  void ActivationGroups_pimpl::
  ActivationGroup ()
  {
  }

  void ActivationGroups_pimpl::
  post_ActivationGroups ()
  {
  }

  // FeatureGroups_pimpl
  //

  void FeatureGroups_pimpl::
  pre ()
  {
  }

  void FeatureGroups_pimpl::
  FeatureGroup ()
  {
  }

  void FeatureGroups_pimpl::
  post_FeatureGroups ()
  {
  }

  // ActivationGroup_pimpl
  //

  void ActivationGroup_pimpl::
  pre ()
  {
  }

  void ActivationGroup_pimpl::
  Name (const ::std::string& Name)
  {
    std::cout << "Name: " << Name << std::endl;
  }

  void ActivationGroup_pimpl::
  post_ActivationGroup ()
  {
  }

  // FeatureGroup_pimpl
  //

  void FeatureGroup_pimpl::
  pre ()
  {
  }

  void FeatureGroup_pimpl::
  Feature ()
  {
  }

  void FeatureGroup_pimpl::
  Name (const ::std::string& Name)
  {
    std::cout << "Name: " << Name << std::endl;
  }

  void FeatureGroup_pimpl::
  Pretty (const ::std::string& Pretty)
  {
    std::cout << "Pretty: " << Pretty << std::endl;
  }

  void FeatureGroup_pimpl::
  post_FeatureGroup ()
  {
  }

  // Feature_pimpl
  //

  void Feature_pimpl::
  pre ()
  {
  }

  void Feature_pimpl::
  Name (const ::std::string& Name)
  {
    std::cout << "Name: " << Name << std::endl;
  }

  void Feature_pimpl::
  post_Feature ()
  {
  }

  // Attributes_pimpl
  //

  void Attributes_pimpl::
  pre ()
  {
  }

  void Attributes_pimpl::
  Attribute ()
  {
  }

  void Attributes_pimpl::
  post_Attributes ()
  {
  }

  // Attribute_pimpl
  //

  void Attribute_pimpl::
  pre ()
  {
  }

  void Attribute_pimpl::
  Name ()
  {
  }

  void Attribute_pimpl::
  Pretty (const ::std::string& Pretty)
  {
    std::cout << "Pretty: " << Pretty << std::endl;
  }

  void Attribute_pimpl::
  ActivationGroup (const ::std::string& ActivationGroup)
  {
    std::cout << "ActivationGroup: " << ActivationGroup << std::endl;
  }

  void Attribute_pimpl::
  PhysicalUnit ()
  {
  }

  void Attribute_pimpl::
  Color ()
  {
  }

  void Attribute_pimpl::
  Feature (const ::std::string& Feature)
  {
    std::cout << "Feature: " << Feature << std::endl;
  }

  void Attribute_pimpl::
  MainAttribute (const ::std::string& MainAttribute)
  {
    std::cout << "MainAttribute: " << MainAttribute << std::endl;
  }

  void Attribute_pimpl::
  post_Attribute ()
  {
  }
}