OfficeXml/autounit/SharedMLUnitDecorator.tsf

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.}XmlChildDispDef.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));
    elems := object_.Fs();
    for _,elem in elems do
        {self.}AppendChild(new FUnitDecorator(elem));
    elems := object_.Rads();
    for _,elem in elems do
        {self.}AppendChild(new RadUnitDecorator(elem));
    elems := object_.SSubs();
    for _,elem in elems do
        {self.}AppendChild(new SSubUnitDecorator(elem));
    elems := object_.Naries();
    for _,elem in elems do
        {self.}AppendChild(new NaryUnitDecorator(elem));
    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.