unit SharedMLUnitDecorator;
interface
uses SharedML, TSSafeUnitConverter;

type MathPrUnitDecorator = class(MathPr)
public
	function Create(_obj: MathPr);
	function GetObject();
	function Convert();
private
	object_: MathPr;
end;

type OMathParaUnitDecorator = class(OMathPara)
public
	function Create(_obj: OMathPara);
	function GetObject();
	function Convert();
private
	object_: OMathPara;
end;

type OMathParaPrUnitDecorator = class(OMathParaPr)
public
	function Create(_obj: OMathParaPr);
	function GetObject();
	function Convert();
private
	object_: OMathParaPr;
end;

type PureMValUnitDecorator = class(PureMVal)
public
	function Create(_obj: PureMVal);
	function GetObject();
	function Convert();
private
	object_: PureMVal;
end;

type OMathUnitDecorator = class(OMath)
public
	function Create(_obj: OMath);
	function GetObject();
	function Convert();
private
	object_: OMath;
end;

type RUnitDecorator = class(R)
public
	function Create(_obj: R);
	function GetObject();
	function Convert();
private
	object_: R;
end;

type RPrUnitDecorator = class(RPr)
public
	function Create(_obj: RPr);
	function GetObject();
	function Convert();
private
	object_: RPr;
end;

type TUnitDecorator = class(T)
public
	function Create(_obj: T);
	function GetObject();
	function Convert();
private
	object_: T;
end;

type DUnitDecorator = class(D)
public
	function Create(_obj: D);
	function GetObject();
	function Convert();
private
	object_: D;
end;

type DPrUnitDecorator = class(DPr)
public
	function Create(_obj: DPr);
	function GetObject();
	function Convert();
private
	object_: DPr;
end;

type CtrlPrUnitDecorator = class(CtrlPr)
public
	function Create(_obj: CtrlPr);
	function GetObject();
	function Convert();
private
	object_: CtrlPr;
end;

type EUnitDecorator = class(E)
public
	function Create(_obj: E);
	function GetObject();
	function Convert();
private
	object_: E;
end;

type SSupUnitDecorator = class(SSup)
public
	function Create(_obj: SSup);
	function GetObject();
	function Convert();
private
	object_: SSup;
end;

type SSupPrUnitDecorator = class(SSupPr)
public
	function Create(_obj: SSupPr);
	function GetObject();
	function Convert();
private
	object_: SSupPr;
end;

type SupUnitDecorator = class(Sup)
public
	function Create(_obj: Sup);
	function GetObject();
	function Convert();
private
	object_: Sup;
end;

type FUnitDecorator = class(F)
public
	function Create(_obj: F);
	function GetObject();
	function Convert();
private
	object_: F;
end;

type FPrUnitDecorator = class(FPr)
public
	function Create(_obj: FPr);
	function GetObject();
	function Convert();
private
	object_: FPr;
end;

type NumUnitDecorator = class(Num)
public
	function Create(_obj: Num);
	function GetObject();
	function Convert();
private
	object_: Num;
end;

type RadUnitDecorator = class(Rad)
public
	function Create(_obj: Rad);
	function GetObject();
	function Convert();
private
	object_: Rad;
end;

type RadPrUnitDecorator = class(RadPr)
public
	function Create(_obj: RadPr);
	function GetObject();
	function Convert();
private
	object_: RadPr;
end;

type DegUnitDecorator = class(Deg)
public
	function Create(_obj: Deg);
	function GetObject();
	function Convert();
private
	object_: Deg;
end;

type DenUnitDecorator = class(Den)
public
	function Create(_obj: Den);
	function GetObject();
	function Convert();
private
	object_: Den;
end;

type SSubUnitDecorator = class(SSub)
public
	function Create(_obj: SSub);
	function GetObject();
	function Convert();
private
	object_: SSub;
end;

type SSubPrUnitDecorator = class(SSubPr)
public
	function Create(_obj: SSubPr);
	function GetObject();
	function Convert();
private
	object_: SSubPr;
end;

type SubUnitDecorator = class(Sub)
public
	function Create(_obj: Sub);
	function GetObject();
	function Convert();
private
	object_: Sub;
end;

type NaryUnitDecorator = class(Nary)
public
	function Create(_obj: Nary);
	function GetObject();
	function Convert();
private
	object_: Nary;
end;

type NaryPrUnitDecorator = class(NaryPr)
public
	function Create(_obj: NaryPr);
	function GetObject();
	function Convert();
private
	object_: NaryPr;
end;

type FuncUnitDecorator = class(Func)
public
	function Create(_obj: Func);
	function GetObject();
	function Convert();
private
	object_: Func;
end;

type FNameUnitDecorator = class(FName)
public
	function Create(_obj: FName);
	function GetObject();
	function Convert();
private
	object_: FName;
end;

type FuncPrUnitDecorator = class(FuncPr)
public
	function Create(_obj: FuncPr);
	function GetObject();
	function Convert();
private
	object_: FuncPr;
end;

type CorePropertiesUnitDecorator = class(CoreProperties)
public
	function Create(_obj: CoreProperties);
	function GetObject();
	function Convert();
private
	object_: CoreProperties;
end;

type CreatedUnitDecorator = class(Created)
public
	function Create(_obj: Created);
	function GetObject();
	function Convert();
private
	object_: Created;
end;

type ModifiedUnitDecorator = class(Modified)
public
	function Create(_obj: Modified);
	function GetObject();
	function Convert();
private
	object_: Modified;
end;

type RelationshipsUnitDecorator = class(Relationships)
public
	function Create(_obj: Relationships);
	function GetObject();
	function Convert();
private
	object_: Relationships;
end;

type RelationshipUnitDecorator = class(Relationship)
public
	function Create(_obj: Relationship);
	function GetObject();
	function Convert();
private
	object_: Relationship;
end;

type TypesUnitDecorator = class(Types)
public
	function Create(_obj: Types);
	function GetObject();
	function Convert();
private
	object_: Types;
end;

type DefaultUnitDecorator = class(Default)
public
	function Create(_obj: Default);
	function GetObject();
	function Convert();
private
	object_: Default;
end;

type _OverrideUnitDecorator = class(_Override)
public
	function Create(_obj: _Override);
	function GetObject();
	function Convert();
private
	object_: _Override;
end;

implementation

function MathPrUnitDecorator.Create(_obj: MathPr);
begin
	class(MathPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function MathPrUnitDecorator.GetObject();
begin
	return object_;
end;

function MathPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildMathFont) then
		{self.}XmlChildMathFont := new PureMValUnitDecorator(object_.XmlChildMathFont);
	if not ifnil(object_.XmlChildBrkBin) then
		{self.}XmlChildBrkBin := new PureMValUnitDecorator(object_.XmlChildBrkBin);
	if not ifnil(object_.XmlChildBrkBinSub) then
		{self.}XmlChildBrkBinSub := new PureMValUnitDecorator(object_.XmlChildBrkBinSub);
	if not ifnil(object_.XmlChildSmallFrac) then
		{self.}XmlChildSmallFrac := new PureMValUnitDecorator(object_.XmlChildSmallFrac);
	if not ifnil(object_.XmlChildDispDef) then
		{self.}DispDef.Copy(object_.XmlChildDispDef);
	if not ifnil(object_.XmlChildLMargin) then
		{self.}XmlChildLMargin := new PureMValUnitDecorator(object_.XmlChildLMargin);
	if not ifnil(object_.XmlChildRMargin) then
		{self.}XmlChildRMargin := new PureMValUnitDecorator(object_.XmlChildRMargin);
	if not ifnil(object_.XmlChildDefJc) then
		{self.}XmlChildDefJc := new PureMValUnitDecorator(object_.XmlChildDefJc);
	if not ifnil(object_.XmlChildWrapIndent) then
		{self.}XmlChildWrapIndent := new PureMValUnitDecorator(object_.XmlChildWrapIndent);
	if not ifnil(object_.XmlChildIntLim) then
		{self.}XmlChildIntLim := new PureMValUnitDecorator(object_.XmlChildIntLim);
	if not ifnil(object_.XmlChildNaryLim) then
		{self.}XmlChildNaryLim := new PureMValUnitDecorator(object_.XmlChildNaryLim);
	tslassigning := tslassigning_backup;
end;

function OMathParaUnitDecorator.Create(_obj: OMathPara);
begin
	class(OMathPara).Create();
	object_ := _obj;
	{self.}Convert();
end;

function OMathParaUnitDecorator.GetObject();
begin
	return object_;
end;

function OMathParaUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildOMathParaPr) then
		{self.}XmlChildOMathParaPr := new OMathParaPrUnitDecorator(object_.XmlChildOMathParaPr);
	if not ifnil(object_.XmlChildOMath) then
		{self.}XmlChildOMath := new OMathUnitDecorator(object_.XmlChildOMath);
	tslassigning := tslassigning_backup;
end;

function OMathParaPrUnitDecorator.Create(_obj: OMathParaPr);
begin
	class(OMathParaPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function OMathParaPrUnitDecorator.GetObject();
begin
	return object_;
end;

function OMathParaPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildJc) then
		{self.}XmlChildJc := new PureMValUnitDecorator(object_.XmlChildJc);
	tslassigning := tslassigning_backup;
end;

function PureMValUnitDecorator.Create(_obj: PureMVal);
begin
	class(PureMVal).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PureMValUnitDecorator.GetObject();
begin
	return object_;
end;

function PureMValUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	tslassigning := tslassigning_backup;
end;

function OMathUnitDecorator.Create(_obj: OMath);
begin
	class(OMath).Create();
	object_ := _obj;
	{self.}Convert();
end;

function OMathUnitDecorator.GetObject();
begin
	return object_;
end;

function OMathUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	elems := object_.Ds();
	for _,elem in elems do
		{self.}AppendChild(new DUnitDecorator(elem));
	if not ifnil(object_.XmlChildF) then
		{self.}XmlChildF := new FUnitDecorator(object_.XmlChildF);
	if not ifnil(object_.XmlChildRad) then
		{self.}XmlChildRad := new RadUnitDecorator(object_.XmlChildRad);
	if not ifnil(object_.XmlChildSSub) then
		{self.}XmlChildSSub := new SSubUnitDecorator(object_.XmlChildSSub);
	if not ifnil(object_.XmlChildNary) then
		{self.}XmlChildNary := new NaryUnitDecorator(object_.XmlChildNary);
	tslassigning := tslassigning_backup;
end;

function RUnitDecorator.Create(_obj: R);
begin
	class(R).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RUnitDecorator.GetObject();
begin
	return object_;
end;

function RUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildARPr) then
		{self.}XmlChildARPr := new RPrUnitDecorator(object_.XmlChildARPr);
	if not ifnil(object_.XmlChildWRPr) then
		{self.}XmlChildWRPr := new RPrUnitDecorator(object_.XmlChildWRPr);
	if not ifnil(object_.XmlChildT) then
		{self.}XmlChildT := new TUnitDecorator(object_.XmlChildT);
	tslassigning := tslassigning_backup;
end;

function RPrUnitDecorator.Create(_obj: RPr);
begin
	class(RPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RPrUnitDecorator.GetObject();
begin
	return object_;
end;

function RPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSty) then
		{self.}XmlChildSty := new PureMValUnitDecorator(object_.XmlChildSty);
	tslassigning := tslassigning_backup;
end;

function TUnitDecorator.Create(_obj: T);
begin
	class(T).Create();
	object_ := _obj;
	{self.}Convert();
end;

function TUnitDecorator.GetObject();
begin
	return object_;
end;

function TUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := object_.XmlAttrSpace.Value;
	tslassigning := tslassigning_backup;
end;

function DUnitDecorator.Create(_obj: D);
begin
	class(D).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DUnitDecorator.GetObject();
begin
	return object_;
end;

function DUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildDPr) then
		{self.}XmlChildDPr := new DPrUnitDecorator(object_.XmlChildDPr);
	if not ifnil(object_.XmlChildE) then
		{self.}XmlChildE := new EUnitDecorator(object_.XmlChildE);
	tslassigning := tslassigning_backup;
end;

function DPrUnitDecorator.Create(_obj: DPr);
begin
	class(DPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DPrUnitDecorator.GetObject();
begin
	return object_;
end;

function DPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildBegChr) then
		{self.}XmlChildBegChr := new PureMValUnitDecorator(object_.XmlChildBegChr);
	if not ifnil(object_.XmlChildEndChr) then
		{self.}XmlChildEndChr := new PureMValUnitDecorator(object_.XmlChildEndChr);
	if not ifnil(object_.XmlChildSepChr) then
		{self.}XmlChildSepChr := new PureMValUnitDecorator(object_.XmlChildSepChr);
	if not ifnil(object_.XmlChildShp) then
		{self.}XmlChildShp := new PureMValUnitDecorator(object_.XmlChildShp);
	if not ifnil(object_.XmlChildGrow) then
		{self.}XmlChildGrow := new PureMValUnitDecorator(object_.XmlChildGrow);
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	tslassigning := tslassigning_backup;
end;

function CtrlPrUnitDecorator.Create(_obj: CtrlPr);
begin
	class(CtrlPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CtrlPrUnitDecorator.GetObject();
begin
	return object_;
end;

function CtrlPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildDel) then
		{self.}XmlChildDel := new DelUnitDecorator(object_.XmlChildDel);
	tslassigning := tslassigning_backup;
end;

function EUnitDecorator.Create(_obj: E);
begin
	class(E).Create();
	object_ := _obj;
	{self.}Convert();
end;

function EUnitDecorator.GetObject();
begin
	return object_;
end;

function EUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	elems := object_.Ds();
	for _,elem in elems do
		{self.}AppendChild(new DUnitDecorator(elem));
	elems := object_.SSups();
	for _,elem in elems do
		{self.}AppendChild(new SSupUnitDecorator(elem));
	elems := object_.SSubs();
	for _,elem in elems do
		{self.}AppendChild(new SSubUnitDecorator(elem));
	elems := object_.Funcs();
	for _,elem in elems do
		{self.}AppendChild(new FuncUnitDecorator(elem));
	if not ifnil(object_.XmlChildF) then
		{self.}XmlChildF := new FUnitDecorator(object_.XmlChildF);
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function SSupUnitDecorator.Create(_obj: SSup);
begin
	class(SSup).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SSupUnitDecorator.GetObject();
begin
	return object_;
end;

function SSupUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSSupPr) then
		{self.}XmlChildSSupPr := new SSupPrUnitDecorator(object_.XmlChildSSupPr);
	if not ifnil(object_.XmlChildE) then
		{self.}XmlChildE := new EUnitDecorator(object_.XmlChildE);
	if not ifnil(object_.XmlChildSup) then
		{self.}XmlChildSup := new SupUnitDecorator(object_.XmlChildSup);
	tslassigning := tslassigning_backup;
end;

function SSupPrUnitDecorator.Create(_obj: SSupPr);
begin
	class(SSupPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SSupPrUnitDecorator.GetObject();
begin
	return object_;
end;

function SSupPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function SupUnitDecorator.Create(_obj: Sup);
begin
	class(Sup).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SupUnitDecorator.GetObject();
begin
	return object_;
end;

function SupUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function FUnitDecorator.Create(_obj: F);
begin
	class(F).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FUnitDecorator.GetObject();
begin
	return object_;
end;

function FUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildFPr) then
		{self.}XmlChildFPr := new FPrUnitDecorator(object_.XmlChildFPr);
	if not ifnil(object_.XmlChildNum) then
		{self.}XmlChildNum := new NumUnitDecorator(object_.XmlChildNum);
	if not ifnil(object_.XmlChildDen) then
		{self.}XmlChildDen := new DenUnitDecorator(object_.XmlChildDen);
	tslassigning := tslassigning_backup;
end;

function FPrUnitDecorator.Create(_obj: FPr);
begin
	class(FPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FPrUnitDecorator.GetObject();
begin
	return object_;
end;

function FPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildType) then
		{self.}XmlChildType := new PureMValUnitDecorator(object_.XmlChildType);
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function NumUnitDecorator.Create(_obj: Num);
begin
	class(Num).Create();
	object_ := _obj;
	{self.}Convert();
end;

function NumUnitDecorator.GetObject();
begin
	return object_;
end;

function NumUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	if not ifnil(object_.XmlChildRad) then
		{self.}XmlChildRad := new RadUnitDecorator(object_.XmlChildRad);
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function RadUnitDecorator.Create(_obj: Rad);
begin
	class(Rad).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RadUnitDecorator.GetObject();
begin
	return object_;
end;

function RadUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRadPr) then
		{self.}XmlChildRadPr := new RadPrUnitDecorator(object_.XmlChildRadPr);
	if not ifnil(object_.XmlChildDeg) then
		{self.}XmlChildDeg := new DegUnitDecorator(object_.XmlChildDeg);
	if not ifnil(object_.XmlChildE) then
		{self.}XmlChildE := new EUnitDecorator(object_.XmlChildE);
	tslassigning := tslassigning_backup;
end;

function RadPrUnitDecorator.Create(_obj: RadPr);
begin
	class(RadPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RadPrUnitDecorator.GetObject();
begin
	return object_;
end;

function RadPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildDegHide) then
		{self.}XmlChildDegHide := new PureMValUnitDecorator(object_.XmlChildDegHide);
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function DegUnitDecorator.Create(_obj: Deg);
begin
	class(Deg).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DegUnitDecorator.GetObject();
begin
	return object_;
end;

function DegUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function DenUnitDecorator.Create(_obj: Den);
begin
	class(Den).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DenUnitDecorator.GetObject();
begin
	return object_;
end;

function DenUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function SSubUnitDecorator.Create(_obj: SSub);
begin
	class(SSub).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SSubUnitDecorator.GetObject();
begin
	return object_;
end;

function SSubUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSSubPr) then
		{self.}XmlChildSSubPr := new SSubPrUnitDecorator(object_.XmlChildSSubPr);
	if not ifnil(object_.XmlChildE) then
		{self.}XmlChildE := new EUnitDecorator(object_.XmlChildE);
	if not ifnil(object_.XmlChildSub) then
		{self.}XmlChildSub := new SubUnitDecorator(object_.XmlChildSub);
	tslassigning := tslassigning_backup;
end;

function SSubPrUnitDecorator.Create(_obj: SSubPr);
begin
	class(SSubPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SSubPrUnitDecorator.GetObject();
begin
	return object_;
end;

function SSubPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function SubUnitDecorator.Create(_obj: Sub);
begin
	class(Sub).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SubUnitDecorator.GetObject();
begin
	return object_;
end;

function SubUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function NaryUnitDecorator.Create(_obj: Nary);
begin
	class(Nary).Create();
	object_ := _obj;
	{self.}Convert();
end;

function NaryUnitDecorator.GetObject();
begin
	return object_;
end;

function NaryUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildNaryPr) then
		{self.}XmlChildNaryPr := new NaryPrUnitDecorator(object_.XmlChildNaryPr);
	if not ifnil(object_.XmlChildSub) then
		{self.}XmlChildSub := new SubUnitDecorator(object_.XmlChildSub);
	if not ifnil(object_.XmlChildSup) then
		{self.}XmlChildSup := new SupUnitDecorator(object_.XmlChildSup);
	if not ifnil(object_.XmlChildE) then
		{self.}XmlChildE := new EUnitDecorator(object_.XmlChildE);
	tslassigning := tslassigning_backup;
end;

function NaryPrUnitDecorator.Create(_obj: NaryPr);
begin
	class(NaryPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function NaryPrUnitDecorator.GetObject();
begin
	return object_;
end;

function NaryPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildChr) then
		{self.}XmlChildChr := new PureMValUnitDecorator(object_.XmlChildChr);
	if not ifnil(object_.XmlChildGrow) then
		{self.}XmlChildGrow := new PureMValUnitDecorator(object_.XmlChildGrow);
	if not ifnil(object_.XmlChildSubHide) then
		{self.}XmlChildSubHide := new PureMValUnitDecorator(object_.XmlChildSubHide);
	if not ifnil(object_.XmlChildSupHide) then
		{self.}XmlChildSupHide := new PureMValUnitDecorator(object_.XmlChildSupHide);
	if not ifnil(object_.XmlChildLimLoc) then
		{self.}XmlChildLimLoc := new PureMValUnitDecorator(object_.XmlChildLimLoc);
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function FuncUnitDecorator.Create(_obj: Func);
begin
	class(Func).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FuncUnitDecorator.GetObject();
begin
	return object_;
end;

function FuncUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildFuncPr) then
		{self.}XmlChildFuncPr := new FuncPrUnitDecorator(object_.XmlChildFuncPr);
	if not ifnil(object_.XmlChildFName) then
		{self.}XmlChildFName := new FNameUnitDecorator(object_.XmlChildFName);
	if not ifnil(object_.XmlChildE) then
		{self.}XmlChildE := new EUnitDecorator(object_.XmlChildE);
	tslassigning := tslassigning_backup;
end;

function FNameUnitDecorator.Create(_obj: FName);
begin
	class(FName).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FNameUnitDecorator.GetObject();
begin
	return object_;
end;

function FNameUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function FuncPrUnitDecorator.Create(_obj: FuncPr);
begin
	class(FuncPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FuncPrUnitDecorator.GetObject();
begin
	return object_;
end;

function FuncPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildCtrlPr) then
		{self.}XmlChildCtrlPr := new CtrlPrUnitDecorator(object_.XmlChildCtrlPr);
	tslassigning := tslassigning_backup;
end;

function CorePropertiesUnitDecorator.Create(_obj: CoreProperties);
begin
	class(CoreProperties).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CorePropertiesUnitDecorator.GetObject();
begin
	return object_;
end;

function CorePropertiesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTitle) then
	if not ifnil(object_.XmlChildSubject) then
	if not ifnil(object_.XmlChildCreator) then
	if not ifnil(object_.XmlChildKeywords) then
	if not ifnil(object_.XmlChildDescription) then
	if not ifnil(object_.XmlChildLastModifiedBy) then
	if not ifnil(object_.XmlChildRevision) then
	if not ifnil(object_.XmlChildLastPrinted) then
	if not ifnil(object_.XmlChildCreated) then
		{self.}XmlChildCreated := new CreatedUnitDecorator(object_.XmlChildCreated);
	if not ifnil(object_.XmlChildModified) then
		{self.}XmlChildModified := new ModifiedUnitDecorator(object_.XmlChildModified);
	tslassigning := tslassigning_backup;
end;

function CreatedUnitDecorator.Create(_obj: Created);
begin
	class(Created).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CreatedUnitDecorator.GetObject();
begin
	return object_;
end;

function CreatedUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	tslassigning := tslassigning_backup;
end;

function ModifiedUnitDecorator.Create(_obj: Modified);
begin
	class(Modified).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ModifiedUnitDecorator.GetObject();
begin
	return object_;
end;

function ModifiedUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	tslassigning := tslassigning_backup;
end;

function RelationshipsUnitDecorator.Create(_obj: Relationships);
begin
	class(Relationships).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RelationshipsUnitDecorator.GetObject();
begin
	return object_;
end;

function RelationshipsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Relationships();
	for _,elem in elems do
		{self.}AppendChild(new RelationshipUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function RelationshipUnitDecorator.Create(_obj: Relationship);
begin
	class(Relationship).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RelationshipUnitDecorator.GetObject();
begin
	return object_;
end;

function RelationshipUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	if not ifnil(object_.XmlAttrTarget) then
		{self.}Target := object_.XmlAttrTarget.Value;
	tslassigning := tslassigning_backup;
end;

function TypesUnitDecorator.Create(_obj: Types);
begin
	class(Types).Create();
	object_ := _obj;
	{self.}Convert();
end;

function TypesUnitDecorator.GetObject();
begin
	return object_;
end;

function TypesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Defaults();
	for _,elem in elems do
		{self.}AppendChild(new DefaultUnitDecorator(elem));
	elems := object_.Overrides();
	for _,elem in elems do
		{self.}AppendChild(new _OverrideUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function DefaultUnitDecorator.Create(_obj: Default);
begin
	class(Default).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DefaultUnitDecorator.GetObject();
begin
	return object_;
end;

function DefaultUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrExtension) then
		{self.}Extension := object_.XmlAttrExtension.Value;
	if not ifnil(object_.XmlAttrContentType) then
		{self.}ContentType := object_.XmlAttrContentType.Value;
	tslassigning := tslassigning_backup;
end;

function _OverrideUnitDecorator.Create(_obj: _Override);
begin
	class(_Override).Create();
	object_ := _obj;
	{self.}Convert();
end;

function _OverrideUnitDecorator.GetObject();
begin
	return object_;
end;

function _OverrideUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrPartName) then
		{self.}PartName := object_.XmlAttrPartName.Value;
	if not ifnil(object_.XmlAttrContentType) then
		{self.}ContentType := object_.XmlAttrContentType.Value;
	tslassigning := tslassigning_backup;
end;

end.