~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

bool FormulasLoader15::begin__newparam____formula_newparam_type( const COLLADASaxFWL15::newparam____formula_newparam_type__AttributeData& attributeData )

{

SaxVirtualFunctionTest15(begin__newparam____formula_newparam_type(attributeData));

COLLADASaxFWL::formula_newparam_type__AttributeData attrData;

attrData.sid = attributeData.sid;

return mLoader->begin__newparam(attrData);

}

bool FormulasLoader15::end__newparam____formula_newparam_type()

{

SaxVirtualFunctionTest15(end__newparam____formula_newparam_type());

return mLoader->end__newparam();

}

bool FormulasLoader15::begin__target()

{

SaxVirtualFunctionTest15(begin__target());

return mLoader->begin__target();

}

bool FormulasLoader15::end__target()

{

SaxVirtualFunctionTest15(end__target());

return mLoader->end__target();

}

bool FormulasLoader15::begin__param____common_param_type()

{

SaxVirtualFunctionTest15(begin__param____common_param_type());

return mLoader->begin__param();

}

bool FormulasLoader15::end__param____common_param_type()

{

SaxVirtualFunctionTest15(end__param____common_param_type());

return mLoader->end__param();

}

bool FormulasLoader15::data__param____common_param_type( const ParserChar* value, size_t length )

{

SaxVirtualFunctionTest15(data__param____common_param_type(value, length));

return mLoader->data__param(value, length);

}

bool FormulasLoader15::begin__float____float_type()

{

SaxVirtualFunctionTest15(begin__float____float_type());

return mLoader->begin__float();

}

bool FormulasLoader15::end__float____float_type()

{

SaxVirtualFunctionTest15(end__float____float_type());

return mLoader->end__float();

100

}

101

102

103

bool FormulasLoader15::data__float____float_type( float value )

104

{

105

SaxVirtualFunctionTest15(data__float____float_type(value));

106

return mLoader->data__float(value);

107

}

108

109

110

bool FormulasLoader15::begin__int____int_type()

111

{

112

SaxVirtualFunctionTest15(begin__int____int_type());

113

return mLoader->begin__int();

114

}

115

116

117

bool FormulasLoader15::end__int____int_type()

118

{

119

SaxVirtualFunctionTest15(end__int____int_type());

120

return mLoader->end__int();

121

}

122

123

124

bool FormulasLoader15::data__int____int_type( sint64 value )

125

{

126

SaxVirtualFunctionTest15(data__int____int_type(value));

127

return mLoader->data__int(value);

128

}

129

130

131

bool FormulasLoader15::begin__bool()

132

{

133

SaxVirtualFunctionTest15(begin__bool());

134

return mLoader->begin__bool();

135

}

136

137

138

bool FormulasLoader15::end__bool()

139

{

140

SaxVirtualFunctionTest15(end__bool());

141

return mLoader->end__bool();

142

}

143

144

145

bool FormulasLoader15::data__bool( bool value )

146

{

147

SaxVirtualFunctionTest15(data__bool(value));

148

return mLoader->data__bool(value);

149

}

150

151

152

bool FormulasLoader15::begin__technique_common____formula_technique_type()

153

{

154

SaxVirtualFunctionTest15(begin__technique_common____formula_technique_type());

155

return mLoader->begin__technique_common();

156

}

157

158

159

bool FormulasLoader15::end__technique_common____formula_technique_type()

160

{

161

SaxVirtualFunctionTest15(end__technique_common____formula_technique_type());

162

return mLoader->end__technique_common();

163

}

164

165

166

bool FormulasLoader15::begin__math( const COLLADASaxFWL15::math__AttributeData& attributeData )

167

{

168

SaxVirtualFunctionTest15(begin__math(attributeData));

169

COLLADASaxFWL::math__AttributeData attrData;

170

attrData.baseline = attributeData.baseline;

171

attrData.alttext = attributeData.alttext;

172

attrData.type = attributeData.type;

173

attrData.name = attributeData.name;

174

attrData.height = attributeData.height;

175

attrData.width = attributeData.width;

176

attrData.macros = attributeData.macros;

177

attrData.style = attributeData.style;

178

attrData.xref = attributeData.xref;

179

attrData.id = attributeData.id;

180

attrData.unknownAttributes = attributeData.unknownAttributes;

181

switch (attributeData.overflow) {

182

case COLLADASaxFWL15::ENUM__mathml__overflow__scroll: attrData.overflow=COLLADASaxFWL::ENUM__mathml__overflow__scroll; break;

183

case COLLADASaxFWL15::ENUM__mathml__overflow__elide: attrData.overflow=COLLADASaxFWL::ENUM__mathml__overflow__elide; break;

184

case COLLADASaxFWL15::ENUM__mathml__overflow__truncate: attrData.overflow=COLLADASaxFWL::ENUM__mathml__overflow__truncate; break;

185

case COLLADASaxFWL15::ENUM__mathml__overflow__scale: attrData.overflow=COLLADASaxFWL::ENUM__mathml__overflow__scale; break;

186

case COLLADASaxFWL15::ENUM__mathml__overflow__COUNT: attrData.overflow=COLLADASaxFWL::ENUM__mathml__overflow__INVALID; break;

187

case COLLADASaxFWL15::ENUM__mathml__overflow__NOT_PRESENT: attrData.overflow=COLLADASaxFWL::ENUM__mathml__overflow__NOT_PRESENT; break;

188

}

189

switch (attributeData.display) {

190

case COLLADASaxFWL15::ENUM__mathml__display__block: attrData.display=COLLADASaxFWL::ENUM__mathml__display__block; break;

191

case COLLADASaxFWL15::ENUM__mathml__display__inline: attrData.display=COLLADASaxFWL::ENUM__mathml__display__inline; break;

192

case COLLADASaxFWL15::ENUM__mathml__display__COUNT: attrData.display=COLLADASaxFWL::ENUM__mathml__display__INVALID; break;

193

case COLLADASaxFWL15::ENUM__mathml__display__NOT_PRESENT: attrData.display=COLLADASaxFWL::ENUM__mathml__display__NOT_PRESENT; break;

194

}

195

attrData.present_attributes = 0;

196

if ( (attributeData.present_attributes & COLLADASaxFWL15::math__AttributeData::ATTRIBUTE_ALTIMG_PRESENT) == COLLADASaxFWL15::math__AttributeData::ATTRIBUTE_ALTIMG_PRESENT ) {

197

attrData.altimg = attributeData.altimg;

198

attrData.present_attributes |= COLLADASaxFWL::math__AttributeData::ATTRIBUTE_ALTIMG_PRESENT;

199

}

200

if ( (attributeData.present_attributes & COLLADASaxFWL15::math__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::math__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

201

attrData._class = attributeData._class;

202

attrData.present_attributes |= COLLADASaxFWL::math__AttributeData::ATTRIBUTE__CLASS_PRESENT;

203

}

204

if ( (attributeData.present_attributes & COLLADASaxFWL15::math__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::math__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

205

attrData.href = attributeData.href;

206

attrData.present_attributes |= COLLADASaxFWL::math__AttributeData::ATTRIBUTE_HREF_PRESENT;

207

}

208

return mLoader->begin__math(attrData);

209

}

210

211

212

bool FormulasLoader15::end__math()

213

{

214

SaxVirtualFunctionTest15(end__math());

215

return mLoader->end__math();

216

}

217

218

219

bool FormulasLoader15::begin__apply( const COLLADASaxFWL15::apply__AttributeData& attributeData )

220

{

221

SaxVirtualFunctionTest15(begin__apply(attributeData));

222

COLLADASaxFWL::apply__AttributeData attrData;

223

attrData.style = attributeData.style;

224

attrData.xref = attributeData.xref;

225

attrData.id = attributeData.id;

226

attrData.unknownAttributes = attributeData.unknownAttributes;

227

attrData.present_attributes = 0;

228

if ( (attributeData.present_attributes & COLLADASaxFWL15::apply__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::apply__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

229

attrData._class = attributeData._class;

230

attrData.present_attributes |= COLLADASaxFWL::apply__AttributeData::ATTRIBUTE__CLASS_PRESENT;

231

}

232

if ( (attributeData.present_attributes & COLLADASaxFWL15::apply__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::apply__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

233

attrData.href = attributeData.href;

234

attrData.present_attributes |= COLLADASaxFWL::apply__AttributeData::ATTRIBUTE_HREF_PRESENT;

235

}

236

return mLoader->begin__apply(attrData);

237

}

238

239

240

bool FormulasLoader15::end__apply()

241

{

242

SaxVirtualFunctionTest15(end__apply());

243

return mLoader->end__apply();

244

}

245

246

247

bool FormulasLoader15::begin__cn( const COLLADASaxFWL15::cn__AttributeData& attributeData )

248

{

249

SaxVirtualFunctionTest15(begin__cn(attributeData));

250

COLLADASaxFWL::cn__AttributeData attrData;

251

attrData.style = attributeData.style;

252

attrData.xref = attributeData.xref;

253

attrData.id = attributeData.id;

254

attrData.encoding = attributeData.encoding;

255

attrData.unknownAttributes = attributeData.unknownAttributes;

256

attrData.present_attributes = 0;

257

if ( (attributeData.present_attributes & COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

258

attrData._class = attributeData._class;

259

attrData.present_attributes |= COLLADASaxFWL::cn__AttributeData::ATTRIBUTE__CLASS_PRESENT;

260

}

261

if ( (attributeData.present_attributes & COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

262

attrData.href = attributeData.href;

263

attrData.present_attributes |= COLLADASaxFWL::cn__AttributeData::ATTRIBUTE_HREF_PRESENT;

264

}

265

if ( (attributeData.present_attributes & COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE_BASE_PRESENT) == COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE_BASE_PRESENT ) {

266

attrData.base = attributeData.base;

267

attrData.present_attributes |= COLLADASaxFWL::cn__AttributeData::ATTRIBUTE_BASE_PRESENT;

268

}

269

if ( (attributeData.present_attributes & COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::cn__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

270

attrData.definitionURL = attributeData.definitionURL;

271

attrData.present_attributes |= COLLADASaxFWL::cn__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

272

}

273

switch (attributeData.type) {

274

case COLLADASaxFWL15::ENUM__mathml__cn__type__e_notation: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__e_notation; break;

275

case COLLADASaxFWL15::ENUM__mathml__cn__type__integer: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__integer; break;

276

case COLLADASaxFWL15::ENUM__mathml__cn__type__rational: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__rational; break;

277

case COLLADASaxFWL15::ENUM__mathml__cn__type__real: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__real; break;

278

case COLLADASaxFWL15::ENUM__mathml__cn__type__complex_cartesian: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__complex_cartesian; break;

279

case COLLADASaxFWL15::ENUM__mathml__cn__type__complex_polar: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__complex_polar; break;

280

case COLLADASaxFWL15::ENUM__mathml__cn__type__constant: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__constant; break;

281

case COLLADASaxFWL15::ENUM__mathml__cn__type__COUNT: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__INVALID; break;

282

case COLLADASaxFWL15::ENUM__mathml__cn__type__NOT_PRESENT: attrData.type=COLLADASaxFWL::ENUM__mathml__cn__type__NOT_PRESENT; break;

283

}

284

return mLoader->begin__cn(attrData);

285

}

286

287

288

bool FormulasLoader15::end__cn()

289

{

290

SaxVirtualFunctionTest15(end__cn());

291

return mLoader->end__cn();

292

}

293

294

295

bool FormulasLoader15::data__cn( const ParserChar* value, size_t length )

296

{

297

SaxVirtualFunctionTest15(data__cn(value, length));

298

return mLoader->data__cn(value, length);

299

}

300

301

302

bool FormulasLoader15::begin__sep()

303

{

304

SaxVirtualFunctionTest15(begin__sep());

305

return mLoader->begin__sep();

306

}

307

308

309

bool FormulasLoader15::end__sep()

310

{

311

SaxVirtualFunctionTest15(end__sep());

312

return mLoader->end__sep();

313

}

314

315

316

bool FormulasLoader15::begin__ci( const COLLADASaxFWL15::ci__AttributeData& attributeData )

317

{

318

SaxVirtualFunctionTest15(begin__ci(attributeData));

319

COLLADASaxFWL::ci__AttributeData attrData;

320

attrData.style = attributeData.style;

321

attrData.xref = attributeData.xref;

322

attrData.id = attributeData.id;

323

attrData.type = attributeData.type;

324

attrData.encoding = attributeData.encoding;

325

attrData.unknownAttributes = attributeData.unknownAttributes;

326

attrData.present_attributes = 0;

327

if ( (attributeData.present_attributes & COLLADASaxFWL15::ci__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::ci__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

328

attrData._class = attributeData._class;

329

attrData.present_attributes |= COLLADASaxFWL::ci__AttributeData::ATTRIBUTE__CLASS_PRESENT;

330

}

331

if ( (attributeData.present_attributes & COLLADASaxFWL15::ci__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::ci__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

332

attrData.href = attributeData.href;

333

attrData.present_attributes |= COLLADASaxFWL::ci__AttributeData::ATTRIBUTE_HREF_PRESENT;

334

}

335

if ( (attributeData.present_attributes & COLLADASaxFWL15::ci__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::ci__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

336

attrData.definitionURL = attributeData.definitionURL;

337

attrData.present_attributes |= COLLADASaxFWL::ci__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

338

}

339

return mLoader->begin__ci(attrData);

340

}

341

342

343

bool FormulasLoader15::end__ci()

344

{

345

SaxVirtualFunctionTest15(end__ci());

346

return mLoader->end__ci();

347

}

348

349

350

bool FormulasLoader15::data__ci( const ParserChar* value, size_t length )

351

{

352

SaxVirtualFunctionTest15(data__ci(value, length));

353

return mLoader->data__ci(value, length);

354

}

355

356

357

bool FormulasLoader15::begin__csymbol( const COLLADASaxFWL15::csymbol__AttributeData& attributeData )

358

{

359

SaxVirtualFunctionTest15(begin__csymbol(attributeData));

360

COLLADASaxFWL::csymbol__AttributeData attrData;

361

attrData.style = attributeData.style;

362

attrData.xref = attributeData.xref;

363

attrData.id = attributeData.id;

364

attrData.encoding = attributeData.encoding;

365

attrData.unknownAttributes = attributeData.unknownAttributes;

366

attrData.present_attributes = 0;

367

if ( (attributeData.present_attributes & COLLADASaxFWL15::csymbol__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::csymbol__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

368

attrData._class = attributeData._class;

369

attrData.present_attributes |= COLLADASaxFWL::csymbol__AttributeData::ATTRIBUTE__CLASS_PRESENT;

370

}

371

if ( (attributeData.present_attributes & COLLADASaxFWL15::csymbol__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::csymbol__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

372

attrData.href = attributeData.href;

373

attrData.present_attributes |= COLLADASaxFWL::csymbol__AttributeData::ATTRIBUTE_HREF_PRESENT;

374

}

375

if ( (attributeData.present_attributes & COLLADASaxFWL15::csymbol__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::csymbol__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

376

attrData.definitionURL = attributeData.definitionURL;

377

attrData.present_attributes |= COLLADASaxFWL::csymbol__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

378

}

379

return mLoader->begin__csymbol(attrData);

380

}

381

382

383

bool FormulasLoader15::end__csymbol()

384

{

385

SaxVirtualFunctionTest15(end__csymbol());

386

return mLoader->end__csymbol();

387

}

388

389

390

bool FormulasLoader15::data__csymbol( const ParserChar* value, size_t length )

391

{

392

SaxVirtualFunctionTest15(data__csymbol(value, length));

393

return mLoader->data__csymbol(value, length);

394

}

395

396

397

bool FormulasLoader15::begin__declare( const COLLADASaxFWL15::declare__AttributeData& attributeData )

398

{

399

SaxVirtualFunctionTest15(begin__declare(attributeData));

400

COLLADASaxFWL::declare__AttributeData attrData;

401

attrData.type = attributeData.type;

402

attrData.scope = attributeData.scope;

403

attrData.encoding = attributeData.encoding;

404

attrData.present_attributes = 0;

405

if ( (attributeData.present_attributes & COLLADASaxFWL15::declare__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::declare__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

406

attrData.definitionURL = attributeData.definitionURL;

407

attrData.present_attributes |= COLLADASaxFWL::declare__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

408

}

409

if ( (attributeData.present_attributes & COLLADASaxFWL15::declare__AttributeData::ATTRIBUTE_NARGS_PRESENT) == COLLADASaxFWL15::declare__AttributeData::ATTRIBUTE_NARGS_PRESENT ) {

410

attrData.nargs = attributeData.nargs;

411

attrData.present_attributes |= COLLADASaxFWL::declare__AttributeData::ATTRIBUTE_NARGS_PRESENT;

412

}

413

switch (attributeData.occurrence) {

414

case COLLADASaxFWL15::ENUM__mathml__declare__occurrence__prefix: attrData.occurrence=COLLADASaxFWL::ENUM__mathml__declare__occurrence__prefix; break;

415

case COLLADASaxFWL15::ENUM__mathml__declare__occurrence__infix: attrData.occurrence=COLLADASaxFWL::ENUM__mathml__declare__occurrence__infix; break;

416

case COLLADASaxFWL15::ENUM__mathml__declare__occurrence__function_model: attrData.occurrence=COLLADASaxFWL::ENUM__mathml__declare__occurrence__function_model; break;

417

case COLLADASaxFWL15::ENUM__mathml__declare__occurrence__COUNT: attrData.occurrence=COLLADASaxFWL::ENUM__mathml__declare__occurrence__INVALID; break;

418

case COLLADASaxFWL15::ENUM__mathml__declare__occurrence__NOT_PRESENT: attrData.occurrence=COLLADASaxFWL::ENUM__mathml__declare__occurrence__NOT_PRESENT; break;

419

}

420

return mLoader->begin__declare(attrData);

421

}

422

423

424

bool FormulasLoader15::end__declare()

425

{

426

SaxVirtualFunctionTest15(end__declare());

427

return mLoader->end__declare();

428

}

429

430

431

bool FormulasLoader15::begin__quotient( const COLLADASaxFWL15::quotient__AttributeData& attributeData )

432

{

433

SaxVirtualFunctionTest15(begin__quotient(attributeData));

434

COLLADASaxFWL::quotient__AttributeData attrData;

435

attrData.style = attributeData.style;

436

attrData.xref = attributeData.xref;

437

attrData.id = attributeData.id;

438

attrData.encoding = attributeData.encoding;

439

attrData.unknownAttributes = attributeData.unknownAttributes;

440

attrData.present_attributes = 0;

441

if ( (attributeData.present_attributes & COLLADASaxFWL15::quotient__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::quotient__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

442

attrData.definitionURL = attributeData.definitionURL;

443

attrData.present_attributes |= COLLADASaxFWL::quotient__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

444

}

445

if ( (attributeData.present_attributes & COLLADASaxFWL15::quotient__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::quotient__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

446

attrData._class = attributeData._class;

447

attrData.present_attributes |= COLLADASaxFWL::quotient__AttributeData::ATTRIBUTE__CLASS_PRESENT;

448

}

449

if ( (attributeData.present_attributes & COLLADASaxFWL15::quotient__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::quotient__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

450

attrData.href = attributeData.href;

451

attrData.present_attributes |= COLLADASaxFWL::quotient__AttributeData::ATTRIBUTE_HREF_PRESENT;

452

}

453

return mLoader->begin__quotient(attrData);

454

}

455

456

457

bool FormulasLoader15::end__quotient()

458

{

459

SaxVirtualFunctionTest15(end__quotient());

460

return mLoader->end__quotient();

461

}

462

463

464

bool FormulasLoader15::begin__divide( const COLLADASaxFWL15::divide__AttributeData& attributeData )

465

{

466

SaxVirtualFunctionTest15(begin__divide(attributeData));

467

COLLADASaxFWL::divide__AttributeData attrData;

468

attrData.style = attributeData.style;

469

attrData.xref = attributeData.xref;

470

attrData.id = attributeData.id;

471

attrData.encoding = attributeData.encoding;

472

attrData.unknownAttributes = attributeData.unknownAttributes;

473

attrData.present_attributes = 0;

474

if ( (attributeData.present_attributes & COLLADASaxFWL15::divide__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::divide__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

475

attrData.definitionURL = attributeData.definitionURL;

476

attrData.present_attributes |= COLLADASaxFWL::divide__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

477

}

478

if ( (attributeData.present_attributes & COLLADASaxFWL15::divide__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::divide__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

479

attrData._class = attributeData._class;

480

attrData.present_attributes |= COLLADASaxFWL::divide__AttributeData::ATTRIBUTE__CLASS_PRESENT;

481

}

482

if ( (attributeData.present_attributes & COLLADASaxFWL15::divide__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::divide__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

483

attrData.href = attributeData.href;

484

attrData.present_attributes |= COLLADASaxFWL::divide__AttributeData::ATTRIBUTE_HREF_PRESENT;

485

}

486

return mLoader->begin__divide(attrData);

487

}

488

489

490

bool FormulasLoader15::end__divide()

491

{

492

SaxVirtualFunctionTest15(end__divide());

493

return mLoader->end__divide();

494

}

495

496

497

bool FormulasLoader15::begin__minus( const COLLADASaxFWL15::minus__AttributeData& attributeData )

498

{

499

SaxVirtualFunctionTest15(begin__minus(attributeData));

500

COLLADASaxFWL::minus__AttributeData attrData;

501

attrData.style = attributeData.style;

502

attrData.xref = attributeData.xref;

503

attrData.id = attributeData.id;

504

attrData.encoding = attributeData.encoding;

505

attrData.unknownAttributes = attributeData.unknownAttributes;

506

attrData.present_attributes = 0;

507

if ( (attributeData.present_attributes & COLLADASaxFWL15::minus__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::minus__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

508

attrData.definitionURL = attributeData.definitionURL;

509

attrData.present_attributes |= COLLADASaxFWL::minus__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

510

}

511

if ( (attributeData.present_attributes & COLLADASaxFWL15::minus__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::minus__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

512

attrData._class = attributeData._class;

513

attrData.present_attributes |= COLLADASaxFWL::minus__AttributeData::ATTRIBUTE__CLASS_PRESENT;

514

}

515

if ( (attributeData.present_attributes & COLLADASaxFWL15::minus__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::minus__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

516

attrData.href = attributeData.href;

517

attrData.present_attributes |= COLLADASaxFWL::minus__AttributeData::ATTRIBUTE_HREF_PRESENT;

518

}

519

return mLoader->begin__minus(attrData);

520

}

521

522

523

bool FormulasLoader15::end__minus()

524

{

525

SaxVirtualFunctionTest15(end__minus());

526

return mLoader->end__minus();

527

}

528

529

530

bool FormulasLoader15::begin__plus( const COLLADASaxFWL15::plus__AttributeData& attributeData )

531

{

532

SaxVirtualFunctionTest15(begin__plus(attributeData));

533

COLLADASaxFWL::plus__AttributeData attrData;

534

attrData.style = attributeData.style;

535

attrData.xref = attributeData.xref;

536

attrData.id = attributeData.id;

537

attrData.encoding = attributeData.encoding;

538

attrData.unknownAttributes = attributeData.unknownAttributes;

539

attrData.present_attributes = 0;

540

if ( (attributeData.present_attributes & COLLADASaxFWL15::plus__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::plus__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

541

attrData.definitionURL = attributeData.definitionURL;

542

attrData.present_attributes |= COLLADASaxFWL::plus__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

543

}

544

if ( (attributeData.present_attributes & COLLADASaxFWL15::plus__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::plus__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

545

attrData._class = attributeData._class;

546

attrData.present_attributes |= COLLADASaxFWL::plus__AttributeData::ATTRIBUTE__CLASS_PRESENT;

547

}

548

if ( (attributeData.present_attributes & COLLADASaxFWL15::plus__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::plus__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

549

attrData.href = attributeData.href;

550

attrData.present_attributes |= COLLADASaxFWL::plus__AttributeData::ATTRIBUTE_HREF_PRESENT;

551

}

552

return mLoader->begin__plus(attrData);

553

}

554

555

556

bool FormulasLoader15::end__plus()

557

{

558

SaxVirtualFunctionTest15(end__plus());

559

return mLoader->end__plus();

560

}

561

562

563

bool FormulasLoader15::begin__times( const COLLADASaxFWL15::times__AttributeData& attributeData )

564

{

565

SaxVirtualFunctionTest15(begin__times(attributeData));

566

COLLADASaxFWL::times__AttributeData attrData;

567

attrData.style = attributeData.style;

568

attrData.xref = attributeData.xref;

569

attrData.id = attributeData.id;

570

attrData.encoding = attributeData.encoding;

571

attrData.unknownAttributes = attributeData.unknownAttributes;

572

attrData.present_attributes = 0;

573

if ( (attributeData.present_attributes & COLLADASaxFWL15::times__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::times__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

574

attrData.definitionURL = attributeData.definitionURL;

575

attrData.present_attributes |= COLLADASaxFWL::times__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

576

}

577

if ( (attributeData.present_attributes & COLLADASaxFWL15::times__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::times__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

578

attrData._class = attributeData._class;

579

attrData.present_attributes |= COLLADASaxFWL::times__AttributeData::ATTRIBUTE__CLASS_PRESENT;

580

}

581

if ( (attributeData.present_attributes & COLLADASaxFWL15::times__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::times__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

582

attrData.href = attributeData.href;

583

attrData.present_attributes |= COLLADASaxFWL::times__AttributeData::ATTRIBUTE_HREF_PRESENT;

584

}

585

return mLoader->begin__times(attrData);

586

}

587

588

589

bool FormulasLoader15::end__times()

590

{

591

SaxVirtualFunctionTest15(end__times());

592

return mLoader->end__times();

593

}

594

595

596

bool FormulasLoader15::begin__sum( const COLLADASaxFWL15::sum__AttributeData& attributeData )

597

{

598

SaxVirtualFunctionTest15(begin__sum(attributeData));

599

COLLADASaxFWL::sum__AttributeData attrData;

600

attrData.style = attributeData.style;

601

attrData.xref = attributeData.xref;

602

attrData.id = attributeData.id;

603

attrData.encoding = attributeData.encoding;

604

attrData.unknownAttributes = attributeData.unknownAttributes;

605

attrData.present_attributes = 0;

606

if ( (attributeData.present_attributes & COLLADASaxFWL15::sum__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::sum__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

607

attrData.definitionURL = attributeData.definitionURL;

608

attrData.present_attributes |= COLLADASaxFWL::sum__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

609

}

610

if ( (attributeData.present_attributes & COLLADASaxFWL15::sum__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::sum__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

611

attrData._class = attributeData._class;

612

attrData.present_attributes |= COLLADASaxFWL::sum__AttributeData::ATTRIBUTE__CLASS_PRESENT;

613

}

614

if ( (attributeData.present_attributes & COLLADASaxFWL15::sum__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::sum__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

615

attrData.href = attributeData.href;

616

attrData.present_attributes |= COLLADASaxFWL::sum__AttributeData::ATTRIBUTE_HREF_PRESENT;

617

}

618

return mLoader->begin__sum(attrData);

619

}

620

621

622

bool FormulasLoader15::end__sum()

623

{

624

SaxVirtualFunctionTest15(end__sum());

625

return mLoader->end__sum();

626

}

627

628

629

bool FormulasLoader15::begin__product( const COLLADASaxFWL15::product__AttributeData& attributeData )

630

{

631

SaxVirtualFunctionTest15(begin__product(attributeData));

632

COLLADASaxFWL::product__AttributeData attrData;

633

attrData.style = attributeData.style;

634

attrData.xref = attributeData.xref;

635

attrData.id = attributeData.id;

636

attrData.encoding = attributeData.encoding;

637

attrData.unknownAttributes = attributeData.unknownAttributes;

638

attrData.present_attributes = 0;

639

if ( (attributeData.present_attributes & COLLADASaxFWL15::product__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::product__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

640

attrData.definitionURL = attributeData.definitionURL;

641

attrData.present_attributes |= COLLADASaxFWL::product__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

642

}

643

if ( (attributeData.present_attributes & COLLADASaxFWL15::product__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::product__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

644

attrData._class = attributeData._class;

645

attrData.present_attributes |= COLLADASaxFWL::product__AttributeData::ATTRIBUTE__CLASS_PRESENT;

646

}

647

if ( (attributeData.present_attributes & COLLADASaxFWL15::product__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::product__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

648

attrData.href = attributeData.href;

649

attrData.present_attributes |= COLLADASaxFWL::product__AttributeData::ATTRIBUTE_HREF_PRESENT;

650

}

651

return mLoader->begin__product(attrData);

652

}

653

654

655

bool FormulasLoader15::end__product()

656

{

657

SaxVirtualFunctionTest15(end__product());

658

return mLoader->end__product();

659

}

660

661

662

bool FormulasLoader15::begin__exponentiale( const COLLADASaxFWL15::exponentiale__AttributeData& attributeData )

663

{

664

SaxVirtualFunctionTest15(begin__exponentiale(attributeData));

665

COLLADASaxFWL::exponentiale__AttributeData attrData;

666

attrData.style = attributeData.style;

667

attrData.xref = attributeData.xref;

668

attrData.id = attributeData.id;

669

attrData.encoding = attributeData.encoding;

670

attrData.unknownAttributes = attributeData.unknownAttributes;

671

attrData.present_attributes = 0;

672

if ( (attributeData.present_attributes & COLLADASaxFWL15::exponentiale__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::exponentiale__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

673

attrData.definitionURL = attributeData.definitionURL;

674

attrData.present_attributes |= COLLADASaxFWL::exponentiale__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

675

}

676

if ( (attributeData.present_attributes & COLLADASaxFWL15::exponentiale__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::exponentiale__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

677

attrData._class = attributeData._class;

678

attrData.present_attributes |= COLLADASaxFWL::exponentiale__AttributeData::ATTRIBUTE__CLASS_PRESENT;

679

}

680

if ( (attributeData.present_attributes & COLLADASaxFWL15::exponentiale__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::exponentiale__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

681

attrData.href = attributeData.href;

682

attrData.present_attributes |= COLLADASaxFWL::exponentiale__AttributeData::ATTRIBUTE_HREF_PRESENT;

683

}

684

return mLoader->begin__exponentiale(attrData);

685

}

686

687

688

bool FormulasLoader15::end__exponentiale()

689

{

690

SaxVirtualFunctionTest15(end__exponentiale());

691

return mLoader->end__exponentiale();

692

}

693

694

695

bool FormulasLoader15::begin__pi( const COLLADASaxFWL15::pi__AttributeData& attributeData )

696

{

697

SaxVirtualFunctionTest15(begin__pi(attributeData));

698

COLLADASaxFWL::pi__AttributeData attrData;

699

attrData.style = attributeData.style;

700

attrData.xref = attributeData.xref;

701

attrData.id = attributeData.id;

702

attrData.encoding = attributeData.encoding;

703

attrData.unknownAttributes = attributeData.unknownAttributes;

704

attrData.present_attributes = 0;

705

if ( (attributeData.present_attributes & COLLADASaxFWL15::pi__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::pi__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

706

attrData.definitionURL = attributeData.definitionURL;

707

attrData.present_attributes |= COLLADASaxFWL::pi__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

708

}

709

if ( (attributeData.present_attributes & COLLADASaxFWL15::pi__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::pi__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

710

attrData._class = attributeData._class;

711

attrData.present_attributes |= COLLADASaxFWL::pi__AttributeData::ATTRIBUTE__CLASS_PRESENT;

712

}

713

if ( (attributeData.present_attributes & COLLADASaxFWL15::pi__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::pi__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

714

attrData.href = attributeData.href;

715

attrData.present_attributes |= COLLADASaxFWL::pi__AttributeData::ATTRIBUTE_HREF_PRESENT;

716

}

717

return mLoader->begin__pi(attrData);

718

}

719

720

721

bool FormulasLoader15::end__pi()

722

{

723

SaxVirtualFunctionTest15(end__pi());

724

return mLoader->end__pi();

725

}

726

727

728

bool FormulasLoader15::begin__true( const COLLADASaxFWL15::true__AttributeData& attributeData )

729

{

730

SaxVirtualFunctionTest15(begin__true(attributeData));

731

COLLADASaxFWL::true__AttributeData attrData;

732

attrData.style = attributeData.style;

733

attrData.xref = attributeData.xref;

734

attrData.id = attributeData.id;

735

attrData.encoding = attributeData.encoding;

736

attrData.unknownAttributes = attributeData.unknownAttributes;

737

attrData.present_attributes = 0;

738

if ( (attributeData.present_attributes & COLLADASaxFWL15::true__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::true__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

739

attrData.definitionURL = attributeData.definitionURL;

740

attrData.present_attributes |= COLLADASaxFWL::true__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

741

}

742

if ( (attributeData.present_attributes & COLLADASaxFWL15::true__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::true__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

743

attrData._class = attributeData._class;

744

attrData.present_attributes |= COLLADASaxFWL::true__AttributeData::ATTRIBUTE__CLASS_PRESENT;

745

}

746

if ( (attributeData.present_attributes & COLLADASaxFWL15::true__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::true__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

747

attrData.href = attributeData.href;

748

attrData.present_attributes |= COLLADASaxFWL::true__AttributeData::ATTRIBUTE_HREF_PRESENT;

749

}

750

return mLoader->begin__true(attrData);

751

}

752

753

754

bool FormulasLoader15::end__true()

755

{

756

SaxVirtualFunctionTest15(end__true());

757

return mLoader->end__true();

758

}

759

760

761

bool FormulasLoader15::begin__false( const COLLADASaxFWL15::false__AttributeData& attributeData )

762

{

763

SaxVirtualFunctionTest15(begin__false(attributeData));

764

COLLADASaxFWL::false__AttributeData attrData;

765

attrData.style = attributeData.style;

766

attrData.xref = attributeData.xref;

767

attrData.id = attributeData.id;

768

attrData.encoding = attributeData.encoding;

769

attrData.unknownAttributes = attributeData.unknownAttributes;

770

attrData.present_attributes = 0;

771

if ( (attributeData.present_attributes & COLLADASaxFWL15::false__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::false__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

772

attrData.definitionURL = attributeData.definitionURL;

773

attrData.present_attributes |= COLLADASaxFWL::false__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

774

}

775

if ( (attributeData.present_attributes & COLLADASaxFWL15::false__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::false__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

776

attrData._class = attributeData._class;

777

attrData.present_attributes |= COLLADASaxFWL::false__AttributeData::ATTRIBUTE__CLASS_PRESENT;

778

}

779

if ( (attributeData.present_attributes & COLLADASaxFWL15::false__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::false__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

780

attrData.href = attributeData.href;

781

attrData.present_attributes |= COLLADASaxFWL::false__AttributeData::ATTRIBUTE_HREF_PRESENT;

782

}

783

return mLoader->begin__false(attrData);

784

}

785

786

787

bool FormulasLoader15::end__false()

788

{

789

SaxVirtualFunctionTest15(end__false());

790

return mLoader->end__false();

791

}

792

793

794

bool FormulasLoader15::begin__and( const COLLADASaxFWL15::and__AttributeData& attributeData )

795

{

796

SaxVirtualFunctionTest15(begin__and(attributeData));

797

COLLADASaxFWL::and__AttributeData attrData;

798

attrData.style = attributeData.style;

799

attrData.xref = attributeData.xref;

800

attrData.id = attributeData.id;

801

attrData.encoding = attributeData.encoding;

802

attrData.unknownAttributes = attributeData.unknownAttributes;

803

attrData.present_attributes = 0;

804

if ( (attributeData.present_attributes & COLLADASaxFWL15::and__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::and__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

805

attrData.definitionURL = attributeData.definitionURL;

806

attrData.present_attributes |= COLLADASaxFWL::and__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

807

}

808

if ( (attributeData.present_attributes & COLLADASaxFWL15::and__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::and__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

809

attrData._class = attributeData._class;

810

attrData.present_attributes |= COLLADASaxFWL::and__AttributeData::ATTRIBUTE__CLASS_PRESENT;

811

}

812

if ( (attributeData.present_attributes & COLLADASaxFWL15::and__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::and__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

813

attrData.href = attributeData.href;

814

attrData.present_attributes |= COLLADASaxFWL::and__AttributeData::ATTRIBUTE_HREF_PRESENT;

815

}

816

return mLoader->begin__and(attrData);

817

}

818

819

820

bool FormulasLoader15::end__and()

821

{

822

SaxVirtualFunctionTest15(end__and());

823

return mLoader->end__and();

824

}

825

826

827

bool FormulasLoader15::begin__or( const COLLADASaxFWL15::or__AttributeData& attributeData )

828

{

829

SaxVirtualFunctionTest15(begin__or(attributeData));

830

COLLADASaxFWL::or__AttributeData attrData;

831

attrData.style = attributeData.style;

832

attrData.xref = attributeData.xref;

833

attrData.id = attributeData.id;

834

attrData.encoding = attributeData.encoding;

835

attrData.unknownAttributes = attributeData.unknownAttributes;

836

attrData.present_attributes = 0;

837

if ( (attributeData.present_attributes & COLLADASaxFWL15::or__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::or__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

838

attrData.definitionURL = attributeData.definitionURL;

839

attrData.present_attributes |= COLLADASaxFWL::or__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

840

}

841

if ( (attributeData.present_attributes & COLLADASaxFWL15::or__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::or__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

842

attrData._class = attributeData._class;

843

attrData.present_attributes |= COLLADASaxFWL::or__AttributeData::ATTRIBUTE__CLASS_PRESENT;

844

}

845

if ( (attributeData.present_attributes & COLLADASaxFWL15::or__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::or__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

846

attrData.href = attributeData.href;

847

attrData.present_attributes |= COLLADASaxFWL::or__AttributeData::ATTRIBUTE_HREF_PRESENT;

848

}

849

return mLoader->begin__or(attrData);

850

}

851

852

853

bool FormulasLoader15::end__or()

854

{

855

SaxVirtualFunctionTest15(end__or());

856

return mLoader->end__or();

857

}

858

859

860

bool FormulasLoader15::begin__xor( const COLLADASaxFWL15::xor__AttributeData& attributeData )

861

{

862

SaxVirtualFunctionTest15(begin__xor(attributeData));

863

COLLADASaxFWL::xor__AttributeData attrData;

864

attrData.style = attributeData.style;

865

attrData.xref = attributeData.xref;

866

attrData.id = attributeData.id;

867

attrData.encoding = attributeData.encoding;

868

attrData.unknownAttributes = attributeData.unknownAttributes;

869

attrData.present_attributes = 0;

870

if ( (attributeData.present_attributes & COLLADASaxFWL15::xor__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::xor__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

871

attrData.definitionURL = attributeData.definitionURL;

872

attrData.present_attributes |= COLLADASaxFWL::xor__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

873

}

874

if ( (attributeData.present_attributes & COLLADASaxFWL15::xor__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::xor__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

875

attrData._class = attributeData._class;

876

attrData.present_attributes |= COLLADASaxFWL::xor__AttributeData::ATTRIBUTE__CLASS_PRESENT;

877

}

878

if ( (attributeData.present_attributes & COLLADASaxFWL15::xor__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::xor__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

879

attrData.href = attributeData.href;

880

attrData.present_attributes |= COLLADASaxFWL::xor__AttributeData::ATTRIBUTE_HREF_PRESENT;

881

}

882

return mLoader->begin__xor(attrData);

883

}

884

885

886

bool FormulasLoader15::end__xor()

887

{

888

SaxVirtualFunctionTest15(end__xor());

889

return mLoader->end__xor();

890

}

891

892

893

bool FormulasLoader15::begin__not( const COLLADASaxFWL15::not__AttributeData& attributeData )

894

{

895

SaxVirtualFunctionTest15(begin__not(attributeData));

896

COLLADASaxFWL::not__AttributeData attrData;

897

attrData.style = attributeData.style;

898

attrData.xref = attributeData.xref;

899

attrData.id = attributeData.id;

900

attrData.encoding = attributeData.encoding;

901

attrData.unknownAttributes = attributeData.unknownAttributes;

902

attrData.present_attributes = 0;

903

if ( (attributeData.present_attributes & COLLADASaxFWL15::not__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::not__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

904

attrData.definitionURL = attributeData.definitionURL;

905

attrData.present_attributes |= COLLADASaxFWL::not__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

906

}

907

if ( (attributeData.present_attributes & COLLADASaxFWL15::not__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::not__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

908

attrData._class = attributeData._class;

909

attrData.present_attributes |= COLLADASaxFWL::not__AttributeData::ATTRIBUTE__CLASS_PRESENT;

910

}

911

if ( (attributeData.present_attributes & COLLADASaxFWL15::not__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::not__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

912

attrData.href = attributeData.href;

913

attrData.present_attributes |= COLLADASaxFWL::not__AttributeData::ATTRIBUTE_HREF_PRESENT;

914

}

915

return mLoader->begin__not(attrData);

916

}

917

918

919

bool FormulasLoader15::end__not()

920

{

921

SaxVirtualFunctionTest15(end__not());

922

return mLoader->end__not();

923

}

924

925

926

bool FormulasLoader15::begin__eq( const COLLADASaxFWL15::eq__AttributeData& attributeData )

927

{

928

SaxVirtualFunctionTest15(begin__eq(attributeData));

929

COLLADASaxFWL::eq__AttributeData attrData;

930

attrData.style = attributeData.style;

931

attrData.xref = attributeData.xref;

932

attrData.id = attributeData.id;

933

attrData.encoding = attributeData.encoding;

934

attrData.unknownAttributes = attributeData.unknownAttributes;

935

attrData.present_attributes = 0;

936

if ( (attributeData.present_attributes & COLLADASaxFWL15::eq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::eq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

937

attrData.definitionURL = attributeData.definitionURL;

938

attrData.present_attributes |= COLLADASaxFWL::eq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

939

}

940

if ( (attributeData.present_attributes & COLLADASaxFWL15::eq__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::eq__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

941

attrData._class = attributeData._class;

942

attrData.present_attributes |= COLLADASaxFWL::eq__AttributeData::ATTRIBUTE__CLASS_PRESENT;

943

}

944

if ( (attributeData.present_attributes & COLLADASaxFWL15::eq__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::eq__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

945

attrData.href = attributeData.href;

946

attrData.present_attributes |= COLLADASaxFWL::eq__AttributeData::ATTRIBUTE_HREF_PRESENT;

947

}

948

return mLoader->begin__eq(attrData);

949

}

950

951

952

bool FormulasLoader15::end__eq()

953

{

954

SaxVirtualFunctionTest15(end__eq());

955

return mLoader->end__eq();

956

}

957

958

959

bool FormulasLoader15::begin__neq( const COLLADASaxFWL15::neq__AttributeData& attributeData )

960

{

961

SaxVirtualFunctionTest15(begin__neq(attributeData));

962

COLLADASaxFWL::neq__AttributeData attrData;

963

attrData.style = attributeData.style;

964

attrData.xref = attributeData.xref;

965

attrData.id = attributeData.id;

966

attrData.encoding = attributeData.encoding;

967

attrData.unknownAttributes = attributeData.unknownAttributes;

968

attrData.present_attributes = 0;

969

if ( (attributeData.present_attributes & COLLADASaxFWL15::neq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::neq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

970

attrData.definitionURL = attributeData.definitionURL;

971

attrData.present_attributes |= COLLADASaxFWL::neq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

972

}

973

if ( (attributeData.present_attributes & COLLADASaxFWL15::neq__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::neq__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

974

attrData._class = attributeData._class;

975

attrData.present_attributes |= COLLADASaxFWL::neq__AttributeData::ATTRIBUTE__CLASS_PRESENT;

976

}

977

if ( (attributeData.present_attributes & COLLADASaxFWL15::neq__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::neq__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

978

attrData.href = attributeData.href;

979

attrData.present_attributes |= COLLADASaxFWL::neq__AttributeData::ATTRIBUTE_HREF_PRESENT;

980

}

981

return mLoader->begin__neq(attrData);

982

}

983

984

985

bool FormulasLoader15::end__neq()

986

{

987

SaxVirtualFunctionTest15(end__neq());

988

return mLoader->end__neq();

989

}

990

991

992

bool FormulasLoader15::begin__leq( const COLLADASaxFWL15::leq__AttributeData& attributeData )

993

{

994

SaxVirtualFunctionTest15(begin__leq(attributeData));

995

COLLADASaxFWL::leq__AttributeData attrData;

996

attrData.style = attributeData.style;

997

attrData.xref = attributeData.xref;

998

attrData.id = attributeData.id;

999

attrData.encoding = attributeData.encoding;

1000

attrData.unknownAttributes = attributeData.unknownAttributes;

1001

attrData.present_attributes = 0;

1002

if ( (attributeData.present_attributes & COLLADASaxFWL15::leq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::leq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1003

attrData.definitionURL = attributeData.definitionURL;

1004

attrData.present_attributes |= COLLADASaxFWL::leq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1005

}

1006

if ( (attributeData.present_attributes & COLLADASaxFWL15::leq__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::leq__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1007

attrData._class = attributeData._class;

1008

attrData.present_attributes |= COLLADASaxFWL::leq__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1009

}

1010

if ( (attributeData.present_attributes & COLLADASaxFWL15::leq__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::leq__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1011

attrData.href = attributeData.href;

1012

attrData.present_attributes |= COLLADASaxFWL::leq__AttributeData::ATTRIBUTE_HREF_PRESENT;

1013

}

1014

return mLoader->begin__leq(attrData);

1015

}

1016

1017

1018

bool FormulasLoader15::end__leq()

1019

{

1020

SaxVirtualFunctionTest15(end__leq());

1021

return mLoader->end__leq();

1022

}

1023

1024

1025

bool FormulasLoader15::begin__lt( const COLLADASaxFWL15::lt__AttributeData& attributeData )

1026

{

1027

SaxVirtualFunctionTest15(begin__lt(attributeData));

1028

COLLADASaxFWL::lt__AttributeData attrData;

1029

attrData.style = attributeData.style;

1030

attrData.xref = attributeData.xref;

1031

attrData.id = attributeData.id;

1032

attrData.encoding = attributeData.encoding;

1033

attrData.unknownAttributes = attributeData.unknownAttributes;

1034

attrData.present_attributes = 0;

1035

if ( (attributeData.present_attributes & COLLADASaxFWL15::lt__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::lt__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1036

attrData.definitionURL = attributeData.definitionURL;

1037

attrData.present_attributes |= COLLADASaxFWL::lt__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1038

}

1039

if ( (attributeData.present_attributes & COLLADASaxFWL15::lt__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::lt__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1040

attrData._class = attributeData._class;

1041

attrData.present_attributes |= COLLADASaxFWL::lt__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1042

}

1043

if ( (attributeData.present_attributes & COLLADASaxFWL15::lt__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::lt__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1044

attrData.href = attributeData.href;

1045

attrData.present_attributes |= COLLADASaxFWL::lt__AttributeData::ATTRIBUTE_HREF_PRESENT;

1046

}

1047

return mLoader->begin__lt(attrData);

1048

}

1049

1050

1051

bool FormulasLoader15::end__lt()

1052

{

1053

SaxVirtualFunctionTest15(end__lt());

1054

return mLoader->end__lt();

1055

}

1056

1057

1058

bool FormulasLoader15::begin__geq( const COLLADASaxFWL15::geq__AttributeData& attributeData )

1059

{

1060

SaxVirtualFunctionTest15(begin__geq(attributeData));

1061

COLLADASaxFWL::geq__AttributeData attrData;

1062

attrData.style = attributeData.style;

1063

attrData.xref = attributeData.xref;

1064

attrData.id = attributeData.id;

1065

attrData.encoding = attributeData.encoding;

1066

attrData.unknownAttributes = attributeData.unknownAttributes;

1067

attrData.present_attributes = 0;

1068

if ( (attributeData.present_attributes & COLLADASaxFWL15::geq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::geq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1069

attrData.definitionURL = attributeData.definitionURL;

1070

attrData.present_attributes |= COLLADASaxFWL::geq__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1071

}

1072

if ( (attributeData.present_attributes & COLLADASaxFWL15::geq__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::geq__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1073

attrData._class = attributeData._class;

1074

attrData.present_attributes |= COLLADASaxFWL::geq__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1075

}

1076

if ( (attributeData.present_attributes & COLLADASaxFWL15::geq__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::geq__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1077

attrData.href = attributeData.href;

1078

attrData.present_attributes |= COLLADASaxFWL::geq__AttributeData::ATTRIBUTE_HREF_PRESENT;

1079

}

1080

return mLoader->begin__geq(attrData);

1081

}

1082

1083

1084

bool FormulasLoader15::end__geq()

1085

{

1086

SaxVirtualFunctionTest15(end__geq());

1087

return mLoader->end__geq();

1088

}

1089

1090

1091

bool FormulasLoader15::begin__gt( const COLLADASaxFWL15::gt__AttributeData& attributeData )

1092

{

1093

SaxVirtualFunctionTest15(begin__gt(attributeData));

1094

COLLADASaxFWL::gt__AttributeData attrData;

1095

attrData.style = attributeData.style;

1096

attrData.xref = attributeData.xref;

1097

attrData.id = attributeData.id;

1098

attrData.encoding = attributeData.encoding;

1099

attrData.unknownAttributes = attributeData.unknownAttributes;

1100

attrData.present_attributes = 0;

1101

if ( (attributeData.present_attributes & COLLADASaxFWL15::gt__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::gt__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1102

attrData.definitionURL = attributeData.definitionURL;

1103

attrData.present_attributes |= COLLADASaxFWL::gt__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1104

}

1105

if ( (attributeData.present_attributes & COLLADASaxFWL15::gt__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::gt__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1106

attrData._class = attributeData._class;

1107

attrData.present_attributes |= COLLADASaxFWL::gt__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1108

}

1109

if ( (attributeData.present_attributes & COLLADASaxFWL15::gt__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::gt__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1110

attrData.href = attributeData.href;

1111

attrData.present_attributes |= COLLADASaxFWL::gt__AttributeData::ATTRIBUTE_HREF_PRESENT;

1112

}

1113

return mLoader->begin__gt(attrData);

1114

}

1115

1116

1117

bool FormulasLoader15::end__gt()

1118

{

1119

SaxVirtualFunctionTest15(end__gt());

1120

return mLoader->end__gt();

1121

}

1122

1123

1124

bool FormulasLoader15::begin__equivalent( const COLLADASaxFWL15::equivalent__AttributeData& attributeData )

1125

{

1126

SaxVirtualFunctionTest15(begin__equivalent(attributeData));

1127

COLLADASaxFWL::equivalent__AttributeData attrData;

1128

attrData.style = attributeData.style;

1129

attrData.xref = attributeData.xref;

1130

attrData.id = attributeData.id;

1131

attrData.encoding = attributeData.encoding;

1132

attrData.unknownAttributes = attributeData.unknownAttributes;

1133

attrData.present_attributes = 0;

1134

if ( (attributeData.present_attributes & COLLADASaxFWL15::equivalent__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::equivalent__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1135

attrData.definitionURL = attributeData.definitionURL;

1136

attrData.present_attributes |= COLLADASaxFWL::equivalent__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1137

}

1138

if ( (attributeData.present_attributes & COLLADASaxFWL15::equivalent__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::equivalent__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1139

attrData._class = attributeData._class;

1140

attrData.present_attributes |= COLLADASaxFWL::equivalent__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1141

}

1142

if ( (attributeData.present_attributes & COLLADASaxFWL15::equivalent__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::equivalent__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1143

attrData.href = attributeData.href;

1144

attrData.present_attributes |= COLLADASaxFWL::equivalent__AttributeData::ATTRIBUTE_HREF_PRESENT;

1145

}

1146

return mLoader->begin__equivalent(attrData);

1147

}

1148

1149

1150

bool FormulasLoader15::end__equivalent()

1151

{

1152

SaxVirtualFunctionTest15(end__equivalent());

1153

return mLoader->end__equivalent();

1154

}

1155

1156

1157

bool FormulasLoader15::begin__power( const COLLADASaxFWL15::power__AttributeData& attributeData )

1158

{

1159

SaxVirtualFunctionTest15(begin__power(attributeData));

1160

COLLADASaxFWL::power__AttributeData attrData;

1161

attrData.style = attributeData.style;

1162

attrData.xref = attributeData.xref;

1163

attrData.id = attributeData.id;

1164

attrData.encoding = attributeData.encoding;

1165

attrData.unknownAttributes = attributeData.unknownAttributes;

1166

attrData.present_attributes = 0;

1167

if ( (attributeData.present_attributes & COLLADASaxFWL15::power__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::power__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1168

attrData.definitionURL = attributeData.definitionURL;

1169

attrData.present_attributes |= COLLADASaxFWL::power__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1170

}

1171

if ( (attributeData.present_attributes & COLLADASaxFWL15::power__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::power__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1172

attrData._class = attributeData._class;

1173

attrData.present_attributes |= COLLADASaxFWL::power__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1174

}

1175

if ( (attributeData.present_attributes & COLLADASaxFWL15::power__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::power__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1176

attrData.href = attributeData.href;

1177

attrData.present_attributes |= COLLADASaxFWL::power__AttributeData::ATTRIBUTE_HREF_PRESENT;

1178

}

1179

return mLoader->begin__power(attrData);

1180

}

1181

1182

1183

bool FormulasLoader15::end__power()

1184

{

1185

SaxVirtualFunctionTest15(end__power());

1186

return mLoader->end__power();

1187

}

1188

1189

1190

bool FormulasLoader15::begin__factorial( const COLLADASaxFWL15::factorial__AttributeData& attributeData )

1191

{

1192

SaxVirtualFunctionTest15(begin__factorial(attributeData));

1193

COLLADASaxFWL::factorial__AttributeData attrData;

1194

attrData.style = attributeData.style;

1195

attrData.xref = attributeData.xref;

1196

attrData.id = attributeData.id;

1197

attrData.encoding = attributeData.encoding;

1198

attrData.unknownAttributes = attributeData.unknownAttributes;

1199

attrData.present_attributes = 0;

1200

if ( (attributeData.present_attributes & COLLADASaxFWL15::factorial__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::factorial__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1201

attrData.definitionURL = attributeData.definitionURL;

1202

attrData.present_attributes |= COLLADASaxFWL::factorial__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1203

}

1204

if ( (attributeData.present_attributes & COLLADASaxFWL15::factorial__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::factorial__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1205

attrData._class = attributeData._class;

1206

attrData.present_attributes |= COLLADASaxFWL::factorial__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1207

}

1208

if ( (attributeData.present_attributes & COLLADASaxFWL15::factorial__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::factorial__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1209

attrData.href = attributeData.href;

1210

attrData.present_attributes |= COLLADASaxFWL::factorial__AttributeData::ATTRIBUTE_HREF_PRESENT;

1211

}

1212

return mLoader->begin__factorial(attrData);

1213

}

1214

1215

1216

bool FormulasLoader15::end__factorial()

1217

{

1218

SaxVirtualFunctionTest15(end__factorial());

1219

return mLoader->end__factorial();

1220

}

1221

1222

1223

bool FormulasLoader15::begin__abs( const COLLADASaxFWL15::abs__AttributeData& attributeData )

1224

{

1225

SaxVirtualFunctionTest15(begin__abs(attributeData));

1226

COLLADASaxFWL::abs__AttributeData attrData;

1227

attrData.style = attributeData.style;

1228

attrData.xref = attributeData.xref;

1229

attrData.id = attributeData.id;

1230

attrData.encoding = attributeData.encoding;

1231

attrData.unknownAttributes = attributeData.unknownAttributes;

1232

attrData.present_attributes = 0;

1233

if ( (attributeData.present_attributes & COLLADASaxFWL15::abs__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::abs__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1234

attrData.definitionURL = attributeData.definitionURL;

1235

attrData.present_attributes |= COLLADASaxFWL::abs__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1236

}

1237

if ( (attributeData.present_attributes & COLLADASaxFWL15::abs__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::abs__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1238

attrData._class = attributeData._class;

1239

attrData.present_attributes |= COLLADASaxFWL::abs__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1240

}

1241

if ( (attributeData.present_attributes & COLLADASaxFWL15::abs__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::abs__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1242

attrData.href = attributeData.href;

1243

attrData.present_attributes |= COLLADASaxFWL::abs__AttributeData::ATTRIBUTE_HREF_PRESENT;

1244

}

1245

return mLoader->begin__abs(attrData);

1246

}

1247

1248

1249

bool FormulasLoader15::end__abs()

1250

{

1251

SaxVirtualFunctionTest15(end__abs());

1252

return mLoader->end__abs();

1253

}

1254

1255

1256

bool FormulasLoader15::begin__exp( const COLLADASaxFWL15::exp__AttributeData& attributeData )

1257

{

1258

SaxVirtualFunctionTest15(begin__exp(attributeData));

1259

COLLADASaxFWL::exp__AttributeData attrData;

1260

attrData.style = attributeData.style;

1261

attrData.xref = attributeData.xref;

1262

attrData.id = attributeData.id;

1263

attrData.encoding = attributeData.encoding;

1264

attrData.unknownAttributes = attributeData.unknownAttributes;

1265

attrData.present_attributes = 0;

1266

if ( (attributeData.present_attributes & COLLADASaxFWL15::exp__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::exp__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1267

attrData.definitionURL = attributeData.definitionURL;

1268

attrData.present_attributes |= COLLADASaxFWL::exp__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1269

}

1270

if ( (attributeData.present_attributes & COLLADASaxFWL15::exp__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::exp__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1271

attrData._class = attributeData._class;

1272

attrData.present_attributes |= COLLADASaxFWL::exp__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1273

}

1274

if ( (attributeData.present_attributes & COLLADASaxFWL15::exp__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::exp__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1275

attrData.href = attributeData.href;

1276

attrData.present_attributes |= COLLADASaxFWL::exp__AttributeData::ATTRIBUTE_HREF_PRESENT;

1277

}

1278

return mLoader->begin__exp(attrData);

1279

}

1280

1281

1282

bool FormulasLoader15::end__exp()

1283

{

1284

SaxVirtualFunctionTest15(end__exp());

1285

return mLoader->end__exp();

1286

}

1287

1288

1289

bool FormulasLoader15::begin__ln( const COLLADASaxFWL15::ln__AttributeData& attributeData )

1290

{

1291

SaxVirtualFunctionTest15(begin__ln(attributeData));

1292

COLLADASaxFWL::ln__AttributeData attrData;

1293

attrData.style = attributeData.style;

1294

attrData.xref = attributeData.xref;

1295

attrData.id = attributeData.id;

1296

attrData.encoding = attributeData.encoding;

1297

attrData.unknownAttributes = attributeData.unknownAttributes;

1298

attrData.present_attributes = 0;

1299

if ( (attributeData.present_attributes & COLLADASaxFWL15::ln__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::ln__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1300

attrData.definitionURL = attributeData.definitionURL;

1301

attrData.present_attributes |= COLLADASaxFWL::ln__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1302

}

1303

if ( (attributeData.present_attributes & COLLADASaxFWL15::ln__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::ln__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1304

attrData._class = attributeData._class;

1305

attrData.present_attributes |= COLLADASaxFWL::ln__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1306

}

1307

if ( (attributeData.present_attributes & COLLADASaxFWL15::ln__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::ln__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1308

attrData.href = attributeData.href;

1309

attrData.present_attributes |= COLLADASaxFWL::ln__AttributeData::ATTRIBUTE_HREF_PRESENT;

1310

}

1311

return mLoader->begin__ln(attrData);

1312

}

1313

1314

1315

bool FormulasLoader15::end__ln()

1316

{

1317

SaxVirtualFunctionTest15(end__ln());

1318

return mLoader->end__ln();

1319

}

1320

1321

1322

bool FormulasLoader15::begin__min____Arith_type( const COLLADASaxFWL15::min____Arith_type__AttributeData& attributeData )

1323

{

1324

SaxVirtualFunctionTest15(begin__min____Arith_type(attributeData));

1325

COLLADASaxFWL::min__AttributeData attrData;

1326

attrData.style = attributeData.style;

1327

attrData.xref = attributeData.xref;

1328

attrData.id = attributeData.id;

1329

attrData.encoding = attributeData.encoding;

1330

attrData.unknownAttributes = attributeData.unknownAttributes;

1331

attrData.present_attributes = 0;

1332

if ( (attributeData.present_attributes & COLLADASaxFWL15::min____Arith_type__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::min____Arith_type__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1333

attrData.definitionURL = attributeData.definitionURL;

1334

attrData.present_attributes |= COLLADASaxFWL::min__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1335

}

1336

if ( (attributeData.present_attributes & COLLADASaxFWL15::min____Arith_type__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::min____Arith_type__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1337

attrData._class = attributeData._class;

1338

attrData.present_attributes |= COLLADASaxFWL::min__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1339

}

1340

if ( (attributeData.present_attributes & COLLADASaxFWL15::min____Arith_type__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::min____Arith_type__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1341

attrData.href = attributeData.href;

1342

attrData.present_attributes |= COLLADASaxFWL::min__AttributeData::ATTRIBUTE_HREF_PRESENT;

1343

}

1344

return mLoader->begin__min(attrData);

1345

}

1346

1347

1348

bool FormulasLoader15::end__min____Arith_type()

1349

{

1350

SaxVirtualFunctionTest15(end__min____Arith_type());

1351

return mLoader->end__min();

1352

}

1353

1354

1355

bool FormulasLoader15::begin__max____Arith_type( const COLLADASaxFWL15::max____Arith_type__AttributeData& attributeData )

1356

{

1357

SaxVirtualFunctionTest15(begin__max____Arith_type(attributeData));

1358

COLLADASaxFWL::max__AttributeData attrData;

1359

attrData.style = attributeData.style;

1360

attrData.xref = attributeData.xref;

1361

attrData.id = attributeData.id;

1362

attrData.encoding = attributeData.encoding;

1363

attrData.unknownAttributes = attributeData.unknownAttributes;

1364

attrData.present_attributes = 0;

1365

if ( (attributeData.present_attributes & COLLADASaxFWL15::max____Arith_type__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::max____Arith_type__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1366

attrData.definitionURL = attributeData.definitionURL;

1367

attrData.present_attributes |= COLLADASaxFWL::max__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1368

}

1369

if ( (attributeData.present_attributes & COLLADASaxFWL15::max____Arith_type__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::max____Arith_type__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1370

attrData._class = attributeData._class;

1371

attrData.present_attributes |= COLLADASaxFWL::max__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1372

}

1373

if ( (attributeData.present_attributes & COLLADASaxFWL15::max____Arith_type__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::max____Arith_type__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1374

attrData.href = attributeData.href;

1375

attrData.present_attributes |= COLLADASaxFWL::max__AttributeData::ATTRIBUTE_HREF_PRESENT;

1376

}

1377

return mLoader->begin__max(attrData);

1378

}

1379

1380

1381

bool FormulasLoader15::end__max____Arith_type()

1382

{

1383

SaxVirtualFunctionTest15(end__max____Arith_type());

1384

return mLoader->end__max();

1385

}

1386

1387

1388

bool FormulasLoader15::begin__ceiling( const COLLADASaxFWL15::ceiling__AttributeData& attributeData )

1389

{

1390

SaxVirtualFunctionTest15(begin__ceiling(attributeData));

1391

COLLADASaxFWL::ceiling__AttributeData attrData;

1392

attrData.style = attributeData.style;

1393

attrData.xref = attributeData.xref;

1394

attrData.id = attributeData.id;

1395

attrData.encoding = attributeData.encoding;

1396

attrData.unknownAttributes = attributeData.unknownAttributes;

1397

attrData.present_attributes = 0;

1398

if ( (attributeData.present_attributes & COLLADASaxFWL15::ceiling__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::ceiling__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1399

attrData.definitionURL = attributeData.definitionURL;

1400

attrData.present_attributes |= COLLADASaxFWL::ceiling__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1401

}

1402

if ( (attributeData.present_attributes & COLLADASaxFWL15::ceiling__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::ceiling__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1403

attrData._class = attributeData._class;

1404

attrData.present_attributes |= COLLADASaxFWL::ceiling__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1405

}

1406

if ( (attributeData.present_attributes & COLLADASaxFWL15::ceiling__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::ceiling__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1407

attrData.href = attributeData.href;

1408

attrData.present_attributes |= COLLADASaxFWL::ceiling__AttributeData::ATTRIBUTE_HREF_PRESENT;

1409

}

1410

return mLoader->begin__ceiling(attrData);

1411

}

1412

1413

1414

bool FormulasLoader15::end__ceiling()

1415

{

1416

SaxVirtualFunctionTest15(end__ceiling());

1417

return mLoader->end__ceiling();

1418

}

1419

1420

1421

bool FormulasLoader15::begin__floor( const COLLADASaxFWL15::floor__AttributeData& attributeData )

1422

{

1423

SaxVirtualFunctionTest15(begin__floor(attributeData));

1424

COLLADASaxFWL::floor__AttributeData attrData;

1425

attrData.style = attributeData.style;

1426

attrData.xref = attributeData.xref;

1427

attrData.id = attributeData.id;

1428

attrData.encoding = attributeData.encoding;

1429

attrData.unknownAttributes = attributeData.unknownAttributes;

1430

attrData.present_attributes = 0;

1431

if ( (attributeData.present_attributes & COLLADASaxFWL15::floor__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::floor__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1432

attrData.definitionURL = attributeData.definitionURL;

1433

attrData.present_attributes |= COLLADASaxFWL::floor__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1434

}

1435

if ( (attributeData.present_attributes & COLLADASaxFWL15::floor__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::floor__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1436

attrData._class = attributeData._class;

1437

attrData.present_attributes |= COLLADASaxFWL::floor__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1438

}

1439

if ( (attributeData.present_attributes & COLLADASaxFWL15::floor__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::floor__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1440

attrData.href = attributeData.href;

1441

attrData.present_attributes |= COLLADASaxFWL::floor__AttributeData::ATTRIBUTE_HREF_PRESENT;

1442

}

1443

return mLoader->begin__floor(attrData);

1444

}

1445

1446

1447

bool FormulasLoader15::end__floor()

1448

{

1449

SaxVirtualFunctionTest15(end__floor());

1450

return mLoader->end__floor();

1451

}

1452

1453

1454

bool FormulasLoader15::begin__gcd( const COLLADASaxFWL15::gcd__AttributeData& attributeData )

1455

{

1456

SaxVirtualFunctionTest15(begin__gcd(attributeData));

1457

COLLADASaxFWL::gcd__AttributeData attrData;

1458

attrData.style = attributeData.style;

1459

attrData.xref = attributeData.xref;

1460

attrData.id = attributeData.id;

1461

attrData.encoding = attributeData.encoding;

1462

attrData.unknownAttributes = attributeData.unknownAttributes;

1463

attrData.present_attributes = 0;

1464

if ( (attributeData.present_attributes & COLLADASaxFWL15::gcd__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::gcd__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1465

attrData.definitionURL = attributeData.definitionURL;

1466

attrData.present_attributes |= COLLADASaxFWL::gcd__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1467

}

1468

if ( (attributeData.present_attributes & COLLADASaxFWL15::gcd__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::gcd__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1469

attrData._class = attributeData._class;

1470

attrData.present_attributes |= COLLADASaxFWL::gcd__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1471

}

1472

if ( (attributeData.present_attributes & COLLADASaxFWL15::gcd__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::gcd__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1473

attrData.href = attributeData.href;

1474

attrData.present_attributes |= COLLADASaxFWL::gcd__AttributeData::ATTRIBUTE_HREF_PRESENT;

1475

}

1476

return mLoader->begin__gcd(attrData);

1477

}

1478

1479

1480

bool FormulasLoader15::end__gcd()

1481

{

1482

SaxVirtualFunctionTest15(end__gcd());

1483

return mLoader->end__gcd();

1484

}

1485

1486

1487

bool FormulasLoader15::begin__lcm( const COLLADASaxFWL15::lcm__AttributeData& attributeData )

1488

{

1489

SaxVirtualFunctionTest15(begin__lcm(attributeData));

1490

COLLADASaxFWL::lcm__AttributeData attrData;

1491

attrData.style = attributeData.style;

1492

attrData.xref = attributeData.xref;

1493

attrData.id = attributeData.id;

1494

attrData.encoding = attributeData.encoding;

1495

attrData.unknownAttributes = attributeData.unknownAttributes;

1496

attrData.present_attributes = 0;

1497

if ( (attributeData.present_attributes & COLLADASaxFWL15::lcm__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::lcm__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1498

attrData.definitionURL = attributeData.definitionURL;

1499

attrData.present_attributes |= COLLADASaxFWL::lcm__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1500

}

1501

if ( (attributeData.present_attributes & COLLADASaxFWL15::lcm__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::lcm__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1502

attrData._class = attributeData._class;

1503

attrData.present_attributes |= COLLADASaxFWL::lcm__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1504

}

1505

if ( (attributeData.present_attributes & COLLADASaxFWL15::lcm__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::lcm__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1506

attrData.href = attributeData.href;

1507

attrData.present_attributes |= COLLADASaxFWL::lcm__AttributeData::ATTRIBUTE_HREF_PRESENT;

1508

}

1509

return mLoader->begin__lcm(attrData);

1510

}

1511

1512

1513

bool FormulasLoader15::end__lcm()

1514

{

1515

SaxVirtualFunctionTest15(end__lcm());

1516

return mLoader->end__lcm();

1517

}

1518

1519

1520

bool FormulasLoader15::begin__rem( const COLLADASaxFWL15::rem__AttributeData& attributeData )

1521

{

1522

SaxVirtualFunctionTest15(begin__rem(attributeData));

1523

COLLADASaxFWL::rem__AttributeData attrData;

1524

attrData.style = attributeData.style;

1525

attrData.xref = attributeData.xref;

1526

attrData.id = attributeData.id;

1527

attrData.encoding = attributeData.encoding;

1528

attrData.unknownAttributes = attributeData.unknownAttributes;

1529

attrData.present_attributes = 0;

1530

if ( (attributeData.present_attributes & COLLADASaxFWL15::rem__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::rem__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1531

attrData.definitionURL = attributeData.definitionURL;

1532

attrData.present_attributes |= COLLADASaxFWL::rem__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1533

}

1534

if ( (attributeData.present_attributes & COLLADASaxFWL15::rem__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::rem__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1535

attrData._class = attributeData._class;

1536

attrData.present_attributes |= COLLADASaxFWL::rem__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1537

}

1538

if ( (attributeData.present_attributes & COLLADASaxFWL15::rem__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::rem__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1539

attrData.href = attributeData.href;

1540

attrData.present_attributes |= COLLADASaxFWL::rem__AttributeData::ATTRIBUTE_HREF_PRESENT;

1541

}

1542

return mLoader->begin__rem(attrData);

1543

}

1544

1545

1546

bool FormulasLoader15::end__rem()

1547

{

1548

SaxVirtualFunctionTest15(end__rem());

1549

return mLoader->end__rem();

1550

}

1551

1552

1553

bool FormulasLoader15::begin__root( const COLLADASaxFWL15::root__AttributeData& attributeData )

1554

{

1555

SaxVirtualFunctionTest15(begin__root(attributeData));

1556

COLLADASaxFWL::root__AttributeData attrData;

1557

attrData.style = attributeData.style;

1558

attrData.xref = attributeData.xref;

1559

attrData.id = attributeData.id;

1560

attrData.encoding = attributeData.encoding;

1561

attrData.unknownAttributes = attributeData.unknownAttributes;

1562

attrData.present_attributes = 0;

1563

if ( (attributeData.present_attributes & COLLADASaxFWL15::root__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::root__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1564

attrData.definitionURL = attributeData.definitionURL;

1565

attrData.present_attributes |= COLLADASaxFWL::root__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1566

}

1567

if ( (attributeData.present_attributes & COLLADASaxFWL15::root__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::root__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1568

attrData._class = attributeData._class;

1569

attrData.present_attributes |= COLLADASaxFWL::root__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1570

}

1571

if ( (attributeData.present_attributes & COLLADASaxFWL15::root__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::root__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1572

attrData.href = attributeData.href;

1573

attrData.present_attributes |= COLLADASaxFWL::root__AttributeData::ATTRIBUTE_HREF_PRESENT;

1574

}

1575

return mLoader->begin__root(attrData);

1576

}

1577

1578

1579

bool FormulasLoader15::end__root()

1580

{

1581

SaxVirtualFunctionTest15(end__root());

1582

return mLoader->end__root();

1583

}

1584

1585

1586

bool FormulasLoader15::begin__log( const COLLADASaxFWL15::log__AttributeData& attributeData )

1587

{

1588

SaxVirtualFunctionTest15(begin__log(attributeData));

1589

COLLADASaxFWL::log__AttributeData attrData;

1590

attrData.style = attributeData.style;

1591

attrData.xref = attributeData.xref;

1592

attrData.id = attributeData.id;

1593

attrData.encoding = attributeData.encoding;

1594

attrData.unknownAttributes = attributeData.unknownAttributes;

1595

attrData.present_attributes = 0;

1596

if ( (attributeData.present_attributes & COLLADASaxFWL15::log__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::log__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1597

attrData.definitionURL = attributeData.definitionURL;

1598

attrData.present_attributes |= COLLADASaxFWL::log__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1599

}

1600

if ( (attributeData.present_attributes & COLLADASaxFWL15::log__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::log__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1601

attrData._class = attributeData._class;

1602

attrData.present_attributes |= COLLADASaxFWL::log__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1603

}

1604

if ( (attributeData.present_attributes & COLLADASaxFWL15::log__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::log__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1605

attrData.href = attributeData.href;

1606

attrData.present_attributes |= COLLADASaxFWL::log__AttributeData::ATTRIBUTE_HREF_PRESENT;

1607

}

1608

return mLoader->begin__log(attrData);

1609

}

1610

1611

1612

bool FormulasLoader15::end__log()

1613

{

1614

SaxVirtualFunctionTest15(end__log());

1615

return mLoader->end__log();

1616

}

1617

1618

1619

bool FormulasLoader15::begin__logbase( const COLLADASaxFWL15::logbase__AttributeData& attributeData )

1620

{

1621

SaxVirtualFunctionTest15(begin__logbase(attributeData));

1622

COLLADASaxFWL::logbase__AttributeData attrData;

1623

attrData.style = attributeData.style;

1624

attrData.xref = attributeData.xref;

1625

attrData.id = attributeData.id;

1626

attrData.unknownAttributes = attributeData.unknownAttributes;

1627

attrData.present_attributes = 0;

1628

if ( (attributeData.present_attributes & COLLADASaxFWL15::logbase__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::logbase__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1629

attrData._class = attributeData._class;

1630

attrData.present_attributes |= COLLADASaxFWL::logbase__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1631

}

1632

if ( (attributeData.present_attributes & COLLADASaxFWL15::logbase__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::logbase__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1633

attrData.href = attributeData.href;

1634

attrData.present_attributes |= COLLADASaxFWL::logbase__AttributeData::ATTRIBUTE_HREF_PRESENT;

1635

}

1636

return mLoader->begin__logbase(attrData);

1637

}

1638

1639

1640

bool FormulasLoader15::end__logbase()

1641

{

1642

SaxVirtualFunctionTest15(end__logbase());

1643

return mLoader->end__logbase();

1644

}

1645

1646

1647

bool FormulasLoader15::begin__sin( const COLLADASaxFWL15::sin__AttributeData& attributeData )

1648

{

1649

SaxVirtualFunctionTest15(begin__sin(attributeData));

1650

COLLADASaxFWL::sin__AttributeData attrData;

1651

attrData.style = attributeData.style;

1652

attrData.xref = attributeData.xref;

1653

attrData.id = attributeData.id;

1654

attrData.encoding = attributeData.encoding;

1655

attrData.unknownAttributes = attributeData.unknownAttributes;

1656

attrData.present_attributes = 0;

1657

if ( (attributeData.present_attributes & COLLADASaxFWL15::sin__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::sin__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1658

attrData.definitionURL = attributeData.definitionURL;

1659

attrData.present_attributes |= COLLADASaxFWL::sin__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1660

}

1661

if ( (attributeData.present_attributes & COLLADASaxFWL15::sin__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::sin__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1662

attrData._class = attributeData._class;

1663

attrData.present_attributes |= COLLADASaxFWL::sin__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1664

}

1665

if ( (attributeData.present_attributes & COLLADASaxFWL15::sin__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::sin__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1666

attrData.href = attributeData.href;

1667

attrData.present_attributes |= COLLADASaxFWL::sin__AttributeData::ATTRIBUTE_HREF_PRESENT;

1668

}

1669

return mLoader->begin__sin(attrData);

1670

}

1671

1672

1673

bool FormulasLoader15::end__sin()

1674

{

1675

SaxVirtualFunctionTest15(end__sin());

1676

return mLoader->end__sin();

1677

}

1678

1679

1680

bool FormulasLoader15::begin__cos( const COLLADASaxFWL15::cos__AttributeData& attributeData )

1681

{

1682

SaxVirtualFunctionTest15(begin__cos(attributeData));

1683

COLLADASaxFWL::cos__AttributeData attrData;

1684

attrData.style = attributeData.style;

1685

attrData.xref = attributeData.xref;

1686

attrData.id = attributeData.id;

1687

attrData.encoding = attributeData.encoding;

1688

attrData.unknownAttributes = attributeData.unknownAttributes;

1689

attrData.present_attributes = 0;

1690

if ( (attributeData.present_attributes & COLLADASaxFWL15::cos__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::cos__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1691

attrData.definitionURL = attributeData.definitionURL;

1692

attrData.present_attributes |= COLLADASaxFWL::cos__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1693

}

1694

if ( (attributeData.present_attributes & COLLADASaxFWL15::cos__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::cos__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1695

attrData._class = attributeData._class;

1696

attrData.present_attributes |= COLLADASaxFWL::cos__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1697

}

1698

if ( (attributeData.present_attributes & COLLADASaxFWL15::cos__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::cos__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1699

attrData.href = attributeData.href;

1700

attrData.present_attributes |= COLLADASaxFWL::cos__AttributeData::ATTRIBUTE_HREF_PRESENT;

1701

}

1702

return mLoader->begin__cos(attrData);

1703

}

1704

1705

1706

bool FormulasLoader15::end__cos()

1707

{

1708

SaxVirtualFunctionTest15(end__cos());

1709

return mLoader->end__cos();

1710

}

1711

1712

1713

bool FormulasLoader15::begin__tan( const COLLADASaxFWL15::tan__AttributeData& attributeData )

1714

{

1715

SaxVirtualFunctionTest15(begin__tan(attributeData));

1716

COLLADASaxFWL::tan__AttributeData attrData;

1717

attrData.style = attributeData.style;

1718

attrData.xref = attributeData.xref;

1719

attrData.id = attributeData.id;

1720

attrData.encoding = attributeData.encoding;

1721

attrData.unknownAttributes = attributeData.unknownAttributes;

1722

attrData.present_attributes = 0;

1723

if ( (attributeData.present_attributes & COLLADASaxFWL15::tan__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::tan__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1724

attrData.definitionURL = attributeData.definitionURL;

1725

attrData.present_attributes |= COLLADASaxFWL::tan__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1726

}

1727

if ( (attributeData.present_attributes & COLLADASaxFWL15::tan__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::tan__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1728

attrData._class = attributeData._class;

1729

attrData.present_attributes |= COLLADASaxFWL::tan__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1730

}

1731

if ( (attributeData.present_attributes & COLLADASaxFWL15::tan__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::tan__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1732

attrData.href = attributeData.href;

1733

attrData.present_attributes |= COLLADASaxFWL::tan__AttributeData::ATTRIBUTE_HREF_PRESENT;

1734

}

1735

return mLoader->begin__tan(attrData);

1736

}

1737

1738

1739

bool FormulasLoader15::end__tan()

1740

{

1741

SaxVirtualFunctionTest15(end__tan());

1742

return mLoader->end__tan();

1743

}

1744

1745

1746

bool FormulasLoader15::begin__cot( const COLLADASaxFWL15::cot__AttributeData& attributeData )

1747

{

1748

SaxVirtualFunctionTest15(begin__cot(attributeData));

1749

COLLADASaxFWL::cot__AttributeData attrData;

1750

attrData.style = attributeData.style;

1751

attrData.xref = attributeData.xref;

1752

attrData.id = attributeData.id;

1753

attrData.encoding = attributeData.encoding;

1754

attrData.unknownAttributes = attributeData.unknownAttributes;

1755

attrData.present_attributes = 0;

1756

if ( (attributeData.present_attributes & COLLADASaxFWL15::cot__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::cot__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1757

attrData.definitionURL = attributeData.definitionURL;

1758

attrData.present_attributes |= COLLADASaxFWL::cot__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1759

}

1760

if ( (attributeData.present_attributes & COLLADASaxFWL15::cot__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::cot__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1761

attrData._class = attributeData._class;

1762

attrData.present_attributes |= COLLADASaxFWL::cot__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1763

}

1764

if ( (attributeData.present_attributes & COLLADASaxFWL15::cot__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::cot__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1765

attrData.href = attributeData.href;

1766

attrData.present_attributes |= COLLADASaxFWL::cot__AttributeData::ATTRIBUTE_HREF_PRESENT;

1767

}

1768

return mLoader->begin__cot(attrData);

1769

}

1770

1771

1772

bool FormulasLoader15::end__cot()

1773

{

1774

SaxVirtualFunctionTest15(end__cot());

1775

return mLoader->end__cot();

1776

}

1777

1778

1779

bool FormulasLoader15::begin__sec( const COLLADASaxFWL15::sec__AttributeData& attributeData )

1780

{

1781

SaxVirtualFunctionTest15(begin__sec(attributeData));

1782

COLLADASaxFWL::sec__AttributeData attrData;

1783

attrData.style = attributeData.style;

1784

attrData.xref = attributeData.xref;

1785

attrData.id = attributeData.id;

1786

attrData.encoding = attributeData.encoding;

1787

attrData.unknownAttributes = attributeData.unknownAttributes;

1788

attrData.present_attributes = 0;

1789

if ( (attributeData.present_attributes & COLLADASaxFWL15::sec__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::sec__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1790

attrData.definitionURL = attributeData.definitionURL;

1791

attrData.present_attributes |= COLLADASaxFWL::sec__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1792

}

1793

if ( (attributeData.present_attributes & COLLADASaxFWL15::sec__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::sec__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1794

attrData._class = attributeData._class;

1795

attrData.present_attributes |= COLLADASaxFWL::sec__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1796

}

1797

if ( (attributeData.present_attributes & COLLADASaxFWL15::sec__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::sec__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1798

attrData.href = attributeData.href;

1799

attrData.present_attributes |= COLLADASaxFWL::sec__AttributeData::ATTRIBUTE_HREF_PRESENT;

1800

}

1801

return mLoader->begin__sec(attrData);

1802

}

1803

1804

1805

bool FormulasLoader15::end__sec()

1806

{

1807

SaxVirtualFunctionTest15(end__sec());

1808

return mLoader->end__sec();

1809

}

1810

1811

1812

bool FormulasLoader15::begin__csc( const COLLADASaxFWL15::csc__AttributeData& attributeData )

1813

{

1814

SaxVirtualFunctionTest15(begin__csc(attributeData));

1815

COLLADASaxFWL::csc__AttributeData attrData;

1816

attrData.style = attributeData.style;

1817

attrData.xref = attributeData.xref;

1818

attrData.id = attributeData.id;

1819

attrData.encoding = attributeData.encoding;

1820

attrData.unknownAttributes = attributeData.unknownAttributes;

1821

attrData.present_attributes = 0;

1822

if ( (attributeData.present_attributes & COLLADASaxFWL15::csc__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::csc__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1823

attrData.definitionURL = attributeData.definitionURL;

1824

attrData.present_attributes |= COLLADASaxFWL::csc__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1825

}

1826

if ( (attributeData.present_attributes & COLLADASaxFWL15::csc__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::csc__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1827

attrData._class = attributeData._class;

1828

attrData.present_attributes |= COLLADASaxFWL::csc__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1829

}

1830

if ( (attributeData.present_attributes & COLLADASaxFWL15::csc__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::csc__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1831

attrData.href = attributeData.href;

1832

attrData.present_attributes |= COLLADASaxFWL::csc__AttributeData::ATTRIBUTE_HREF_PRESENT;

1833

}

1834

return mLoader->begin__csc(attrData);

1835

}

1836

1837

1838

bool FormulasLoader15::end__csc()

1839

{

1840

SaxVirtualFunctionTest15(end__csc());

1841

return mLoader->end__csc();

1842

}

1843

1844

1845

bool FormulasLoader15::begin__arcsin( const COLLADASaxFWL15::arcsin__AttributeData& attributeData )

1846

{

1847

SaxVirtualFunctionTest15(begin__arcsin(attributeData));

1848

COLLADASaxFWL::arcsin__AttributeData attrData;

1849

attrData.style = attributeData.style;

1850

attrData.xref = attributeData.xref;

1851

attrData.id = attributeData.id;

1852

attrData.encoding = attributeData.encoding;

1853

attrData.unknownAttributes = attributeData.unknownAttributes;

1854

attrData.present_attributes = 0;

1855

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsin__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arcsin__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1856

attrData.definitionURL = attributeData.definitionURL;

1857

attrData.present_attributes |= COLLADASaxFWL::arcsin__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1858

}

1859

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsin__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arcsin__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1860

attrData._class = attributeData._class;

1861

attrData.present_attributes |= COLLADASaxFWL::arcsin__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1862

}

1863

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsin__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arcsin__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1864

attrData.href = attributeData.href;

1865

attrData.present_attributes |= COLLADASaxFWL::arcsin__AttributeData::ATTRIBUTE_HREF_PRESENT;

1866

}

1867

return mLoader->begin__arcsin(attrData);

1868

}

1869

1870

1871

bool FormulasLoader15::end__arcsin()

1872

{

1873

SaxVirtualFunctionTest15(end__arcsin());

1874

return mLoader->end__arcsin();

1875

}

1876

1877

1878

bool FormulasLoader15::begin__arccos( const COLLADASaxFWL15::arccos__AttributeData& attributeData )

1879

{

1880

SaxVirtualFunctionTest15(begin__arccos(attributeData));

1881

COLLADASaxFWL::arccos__AttributeData attrData;

1882

attrData.style = attributeData.style;

1883

attrData.xref = attributeData.xref;

1884

attrData.id = attributeData.id;

1885

attrData.encoding = attributeData.encoding;

1886

attrData.unknownAttributes = attributeData.unknownAttributes;

1887

attrData.present_attributes = 0;

1888

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccos__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arccos__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1889

attrData.definitionURL = attributeData.definitionURL;

1890

attrData.present_attributes |= COLLADASaxFWL::arccos__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1891

}

1892

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccos__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arccos__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1893

attrData._class = attributeData._class;

1894

attrData.present_attributes |= COLLADASaxFWL::arccos__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1895

}

1896

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccos__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arccos__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1897

attrData.href = attributeData.href;

1898

attrData.present_attributes |= COLLADASaxFWL::arccos__AttributeData::ATTRIBUTE_HREF_PRESENT;

1899

}

1900

return mLoader->begin__arccos(attrData);

1901

}

1902

1903

1904

bool FormulasLoader15::end__arccos()

1905

{

1906

SaxVirtualFunctionTest15(end__arccos());

1907

return mLoader->end__arccos();

1908

}

1909

1910

1911

bool FormulasLoader15::begin__arctan( const COLLADASaxFWL15::arctan__AttributeData& attributeData )

1912

{

1913

SaxVirtualFunctionTest15(begin__arctan(attributeData));

1914

COLLADASaxFWL::arctan__AttributeData attrData;

1915

attrData.style = attributeData.style;

1916

attrData.xref = attributeData.xref;

1917

attrData.id = attributeData.id;

1918

attrData.encoding = attributeData.encoding;

1919

attrData.unknownAttributes = attributeData.unknownAttributes;

1920

attrData.present_attributes = 0;

1921

if ( (attributeData.present_attributes & COLLADASaxFWL15::arctan__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arctan__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1922

attrData.definitionURL = attributeData.definitionURL;

1923

attrData.present_attributes |= COLLADASaxFWL::arctan__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1924

}

1925

if ( (attributeData.present_attributes & COLLADASaxFWL15::arctan__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arctan__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1926

attrData._class = attributeData._class;

1927

attrData.present_attributes |= COLLADASaxFWL::arctan__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1928

}

1929

if ( (attributeData.present_attributes & COLLADASaxFWL15::arctan__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arctan__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1930

attrData.href = attributeData.href;

1931

attrData.present_attributes |= COLLADASaxFWL::arctan__AttributeData::ATTRIBUTE_HREF_PRESENT;

1932

}

1933

return mLoader->begin__arctan(attrData);

1934

}

1935

1936

1937

bool FormulasLoader15::end__arctan()

1938

{

1939

SaxVirtualFunctionTest15(end__arctan());

1940

return mLoader->end__arctan();

1941

}

1942

1943

1944

bool FormulasLoader15::begin__arccot( const COLLADASaxFWL15::arccot__AttributeData& attributeData )

1945

{

1946

SaxVirtualFunctionTest15(begin__arccot(attributeData));

1947

COLLADASaxFWL::arccot__AttributeData attrData;

1948

attrData.style = attributeData.style;

1949

attrData.xref = attributeData.xref;

1950

attrData.id = attributeData.id;

1951

attrData.encoding = attributeData.encoding;

1952

attrData.unknownAttributes = attributeData.unknownAttributes;

1953

attrData.present_attributes = 0;

1954

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccot__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arccot__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1955

attrData.definitionURL = attributeData.definitionURL;

1956

attrData.present_attributes |= COLLADASaxFWL::arccot__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1957

}

1958

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccot__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arccot__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1959

attrData._class = attributeData._class;

1960

attrData.present_attributes |= COLLADASaxFWL::arccot__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1961

}

1962

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccot__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arccot__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1963

attrData.href = attributeData.href;

1964

attrData.present_attributes |= COLLADASaxFWL::arccot__AttributeData::ATTRIBUTE_HREF_PRESENT;

1965

}

1966

return mLoader->begin__arccot(attrData);

1967

}

1968

1969

1970

bool FormulasLoader15::end__arccot()

1971

{

1972

SaxVirtualFunctionTest15(end__arccot());

1973

return mLoader->end__arccot();

1974

}

1975

1976

1977

bool FormulasLoader15::begin__arcsec( const COLLADASaxFWL15::arcsec__AttributeData& attributeData )

1978

{

1979

SaxVirtualFunctionTest15(begin__arcsec(attributeData));

1980

COLLADASaxFWL::arcsec__AttributeData attrData;

1981

attrData.style = attributeData.style;

1982

attrData.xref = attributeData.xref;

1983

attrData.id = attributeData.id;

1984

attrData.encoding = attributeData.encoding;

1985

attrData.unknownAttributes = attributeData.unknownAttributes;

1986

attrData.present_attributes = 0;

1987

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsec__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arcsec__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

1988

attrData.definitionURL = attributeData.definitionURL;

1989

attrData.present_attributes |= COLLADASaxFWL::arcsec__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

1990

}

1991

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsec__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arcsec__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

1992

attrData._class = attributeData._class;

1993

attrData.present_attributes |= COLLADASaxFWL::arcsec__AttributeData::ATTRIBUTE__CLASS_PRESENT;

1994

}

1995

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsec__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arcsec__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

1996

attrData.href = attributeData.href;

1997

attrData.present_attributes |= COLLADASaxFWL::arcsec__AttributeData::ATTRIBUTE_HREF_PRESENT;

1998

}

1999

return mLoader->begin__arcsec(attrData);

2000

}

2001

2002

2003

bool FormulasLoader15::end__arcsec()

2004

{

2005

SaxVirtualFunctionTest15(end__arcsec());

2006

return mLoader->end__arcsec();

2007

}

2008

2009

2010

bool FormulasLoader15::begin__arccsc( const COLLADASaxFWL15::arccsc__AttributeData& attributeData )

2011

{

2012

SaxVirtualFunctionTest15(begin__arccsc(attributeData));

2013

COLLADASaxFWL::arccsc__AttributeData attrData;

2014

attrData.style = attributeData.style;

2015

attrData.xref = attributeData.xref;

2016

attrData.id = attributeData.id;

2017

attrData.encoding = attributeData.encoding;

2018

attrData.unknownAttributes = attributeData.unknownAttributes;

2019

attrData.present_attributes = 0;

2020

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccsc__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arccsc__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2021

attrData.definitionURL = attributeData.definitionURL;

2022

attrData.present_attributes |= COLLADASaxFWL::arccsc__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2023

}

2024

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccsc__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arccsc__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2025

attrData._class = attributeData._class;

2026

attrData.present_attributes |= COLLADASaxFWL::arccsc__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2027

}

2028

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccsc__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arccsc__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2029

attrData.href = attributeData.href;

2030

attrData.present_attributes |= COLLADASaxFWL::arccsc__AttributeData::ATTRIBUTE_HREF_PRESENT;

2031

}

2032

return mLoader->begin__arccsc(attrData);

2033

}

2034

2035

2036

bool FormulasLoader15::end__arccsc()

2037

{

2038

SaxVirtualFunctionTest15(end__arccsc());

2039

return mLoader->end__arccsc();

2040

}

2041

2042

2043

bool FormulasLoader15::begin__sinh( const COLLADASaxFWL15::sinh__AttributeData& attributeData )

2044

{

2045

SaxVirtualFunctionTest15(begin__sinh(attributeData));

2046

COLLADASaxFWL::sinh__AttributeData attrData;

2047

attrData.style = attributeData.style;

2048

attrData.xref = attributeData.xref;

2049

attrData.id = attributeData.id;

2050

attrData.encoding = attributeData.encoding;

2051

attrData.unknownAttributes = attributeData.unknownAttributes;

2052

attrData.present_attributes = 0;

2053

if ( (attributeData.present_attributes & COLLADASaxFWL15::sinh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::sinh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2054

attrData.definitionURL = attributeData.definitionURL;

2055

attrData.present_attributes |= COLLADASaxFWL::sinh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2056

}

2057

if ( (attributeData.present_attributes & COLLADASaxFWL15::sinh__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::sinh__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2058

attrData._class = attributeData._class;

2059

attrData.present_attributes |= COLLADASaxFWL::sinh__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2060

}

2061

if ( (attributeData.present_attributes & COLLADASaxFWL15::sinh__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::sinh__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2062

attrData.href = attributeData.href;

2063

attrData.present_attributes |= COLLADASaxFWL::sinh__AttributeData::ATTRIBUTE_HREF_PRESENT;

2064

}

2065

return mLoader->begin__sinh(attrData);

2066

}

2067

2068

2069

bool FormulasLoader15::end__sinh()

2070

{

2071

SaxVirtualFunctionTest15(end__sinh());

2072

return mLoader->end__sinh();

2073

}

2074

2075

2076

bool FormulasLoader15::begin__cosh( const COLLADASaxFWL15::cosh__AttributeData& attributeData )

2077

{

2078

SaxVirtualFunctionTest15(begin__cosh(attributeData));

2079

COLLADASaxFWL::cosh__AttributeData attrData;

2080

attrData.style = attributeData.style;

2081

attrData.xref = attributeData.xref;

2082

attrData.id = attributeData.id;

2083

attrData.encoding = attributeData.encoding;

2084

attrData.unknownAttributes = attributeData.unknownAttributes;

2085

attrData.present_attributes = 0;

2086

if ( (attributeData.present_attributes & COLLADASaxFWL15::cosh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::cosh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2087

attrData.definitionURL = attributeData.definitionURL;

2088

attrData.present_attributes |= COLLADASaxFWL::cosh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2089

}

2090

if ( (attributeData.present_attributes & COLLADASaxFWL15::cosh__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::cosh__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2091

attrData._class = attributeData._class;

2092

attrData.present_attributes |= COLLADASaxFWL::cosh__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2093

}

2094

if ( (attributeData.present_attributes & COLLADASaxFWL15::cosh__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::cosh__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2095

attrData.href = attributeData.href;

2096

attrData.present_attributes |= COLLADASaxFWL::cosh__AttributeData::ATTRIBUTE_HREF_PRESENT;

2097

}

2098

return mLoader->begin__cosh(attrData);

2099

}

2100

2101

2102

bool FormulasLoader15::end__cosh()

2103

{

2104

SaxVirtualFunctionTest15(end__cosh());

2105

return mLoader->end__cosh();

2106

}

2107

2108

2109

bool FormulasLoader15::begin__tanh( const COLLADASaxFWL15::tanh__AttributeData& attributeData )

2110

{

2111

SaxVirtualFunctionTest15(begin__tanh(attributeData));

2112

COLLADASaxFWL::tanh__AttributeData attrData;

2113

attrData.style = attributeData.style;

2114

attrData.xref = attributeData.xref;

2115

attrData.id = attributeData.id;

2116

attrData.encoding = attributeData.encoding;

2117

attrData.unknownAttributes = attributeData.unknownAttributes;

2118

attrData.present_attributes = 0;

2119

if ( (attributeData.present_attributes & COLLADASaxFWL15::tanh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::tanh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2120

attrData.definitionURL = attributeData.definitionURL;

2121

attrData.present_attributes |= COLLADASaxFWL::tanh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2122

}

2123

if ( (attributeData.present_attributes & COLLADASaxFWL15::tanh__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::tanh__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2124

attrData._class = attributeData._class;

2125

attrData.present_attributes |= COLLADASaxFWL::tanh__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2126

}

2127

if ( (attributeData.present_attributes & COLLADASaxFWL15::tanh__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::tanh__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2128

attrData.href = attributeData.href;

2129

attrData.present_attributes |= COLLADASaxFWL::tanh__AttributeData::ATTRIBUTE_HREF_PRESENT;

2130

}

2131

return mLoader->begin__tanh(attrData);

2132

}

2133

2134

2135

bool FormulasLoader15::end__tanh()

2136

{

2137

SaxVirtualFunctionTest15(end__tanh());

2138

return mLoader->end__tanh();

2139

}

2140

2141

2142

bool FormulasLoader15::begin__sech( const COLLADASaxFWL15::sech__AttributeData& attributeData )

2143

{

2144

SaxVirtualFunctionTest15(begin__sech(attributeData));

2145

COLLADASaxFWL::sech__AttributeData attrData;

2146

attrData.style = attributeData.style;

2147

attrData.xref = attributeData.xref;

2148

attrData.id = attributeData.id;

2149

attrData.encoding = attributeData.encoding;

2150

attrData.unknownAttributes = attributeData.unknownAttributes;

2151

attrData.present_attributes = 0;

2152

if ( (attributeData.present_attributes & COLLADASaxFWL15::sech__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::sech__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2153

attrData.definitionURL = attributeData.definitionURL;

2154

attrData.present_attributes |= COLLADASaxFWL::sech__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2155

}

2156

if ( (attributeData.present_attributes & COLLADASaxFWL15::sech__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::sech__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2157

attrData._class = attributeData._class;

2158

attrData.present_attributes |= COLLADASaxFWL::sech__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2159

}

2160

if ( (attributeData.present_attributes & COLLADASaxFWL15::sech__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::sech__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2161

attrData.href = attributeData.href;

2162

attrData.present_attributes |= COLLADASaxFWL::sech__AttributeData::ATTRIBUTE_HREF_PRESENT;

2163

}

2164

return mLoader->begin__sech(attrData);

2165

}

2166

2167

2168

bool FormulasLoader15::end__sech()

2169

{

2170

SaxVirtualFunctionTest15(end__sech());

2171

return mLoader->end__sech();

2172

}

2173

2174

2175

bool FormulasLoader15::begin__csch( const COLLADASaxFWL15::csch__AttributeData& attributeData )

2176

{

2177

SaxVirtualFunctionTest15(begin__csch(attributeData));

2178

COLLADASaxFWL::csch__AttributeData attrData;

2179

attrData.style = attributeData.style;

2180

attrData.xref = attributeData.xref;

2181

attrData.id = attributeData.id;

2182

attrData.encoding = attributeData.encoding;

2183

attrData.unknownAttributes = attributeData.unknownAttributes;

2184

attrData.present_attributes = 0;

2185

if ( (attributeData.present_attributes & COLLADASaxFWL15::csch__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::csch__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2186

attrData.definitionURL = attributeData.definitionURL;

2187

attrData.present_attributes |= COLLADASaxFWL::csch__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2188

}

2189

if ( (attributeData.present_attributes & COLLADASaxFWL15::csch__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::csch__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2190

attrData._class = attributeData._class;

2191

attrData.present_attributes |= COLLADASaxFWL::csch__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2192

}

2193

if ( (attributeData.present_attributes & COLLADASaxFWL15::csch__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::csch__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2194

attrData.href = attributeData.href;

2195

attrData.present_attributes |= COLLADASaxFWL::csch__AttributeData::ATTRIBUTE_HREF_PRESENT;

2196

}

2197

return mLoader->begin__csch(attrData);

2198

}

2199

2200

2201

bool FormulasLoader15::end__csch()

2202

{

2203

SaxVirtualFunctionTest15(end__csch());

2204

return mLoader->end__csch();

2205

}

2206

2207

2208

bool FormulasLoader15::begin__coth( const COLLADASaxFWL15::coth__AttributeData& attributeData )

2209

{

2210

SaxVirtualFunctionTest15(begin__coth(attributeData));

2211

COLLADASaxFWL::coth__AttributeData attrData;

2212

attrData.style = attributeData.style;

2213

attrData.xref = attributeData.xref;

2214

attrData.id = attributeData.id;

2215

attrData.encoding = attributeData.encoding;

2216

attrData.unknownAttributes = attributeData.unknownAttributes;

2217

attrData.present_attributes = 0;

2218

if ( (attributeData.present_attributes & COLLADASaxFWL15::coth__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::coth__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2219

attrData.definitionURL = attributeData.definitionURL;

2220

attrData.present_attributes |= COLLADASaxFWL::coth__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2221

}

2222

if ( (attributeData.present_attributes & COLLADASaxFWL15::coth__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::coth__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2223

attrData._class = attributeData._class;

2224

attrData.present_attributes |= COLLADASaxFWL::coth__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2225

}

2226

if ( (attributeData.present_attributes & COLLADASaxFWL15::coth__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::coth__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2227

attrData.href = attributeData.href;

2228

attrData.present_attributes |= COLLADASaxFWL::coth__AttributeData::ATTRIBUTE_HREF_PRESENT;

2229

}

2230

return mLoader->begin__coth(attrData);

2231

}

2232

2233

2234

bool FormulasLoader15::end__coth()

2235

{

2236

SaxVirtualFunctionTest15(end__coth());

2237

return mLoader->end__coth();

2238

}

2239

2240

2241

bool FormulasLoader15::begin__arcsinh( const COLLADASaxFWL15::arcsinh__AttributeData& attributeData )

2242

{

2243

SaxVirtualFunctionTest15(begin__arcsinh(attributeData));

2244

COLLADASaxFWL::arcsinh__AttributeData attrData;

2245

attrData.style = attributeData.style;

2246

attrData.xref = attributeData.xref;

2247

attrData.id = attributeData.id;

2248

attrData.encoding = attributeData.encoding;

2249

attrData.unknownAttributes = attributeData.unknownAttributes;

2250

attrData.present_attributes = 0;

2251

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsinh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arcsinh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2252

attrData.definitionURL = attributeData.definitionURL;

2253

attrData.present_attributes |= COLLADASaxFWL::arcsinh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2254

}

2255

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsinh__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arcsinh__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2256

attrData._class = attributeData._class;

2257

attrData.present_attributes |= COLLADASaxFWL::arcsinh__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2258

}

2259

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsinh__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arcsinh__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2260

attrData.href = attributeData.href;

2261

attrData.present_attributes |= COLLADASaxFWL::arcsinh__AttributeData::ATTRIBUTE_HREF_PRESENT;

2262

}

2263

return mLoader->begin__arcsinh(attrData);

2264

}

2265

2266

2267

bool FormulasLoader15::end__arcsinh()

2268

{

2269

SaxVirtualFunctionTest15(end__arcsinh());

2270

return mLoader->end__arcsinh();

2271

}

2272

2273

2274

bool FormulasLoader15::begin__arccosh( const COLLADASaxFWL15::arccosh__AttributeData& attributeData )

2275

{

2276

SaxVirtualFunctionTest15(begin__arccosh(attributeData));

2277

COLLADASaxFWL::arccosh__AttributeData attrData;

2278

attrData.style = attributeData.style;

2279

attrData.xref = attributeData.xref;

2280

attrData.id = attributeData.id;

2281

attrData.encoding = attributeData.encoding;

2282

attrData.unknownAttributes = attributeData.unknownAttributes;

2283

attrData.present_attributes = 0;

2284

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccosh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arccosh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2285

attrData.definitionURL = attributeData.definitionURL;

2286

attrData.present_attributes |= COLLADASaxFWL::arccosh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2287

}

2288

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccosh__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arccosh__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2289

attrData._class = attributeData._class;

2290

attrData.present_attributes |= COLLADASaxFWL::arccosh__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2291

}

2292

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccosh__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arccosh__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2293

attrData.href = attributeData.href;

2294

attrData.present_attributes |= COLLADASaxFWL::arccosh__AttributeData::ATTRIBUTE_HREF_PRESENT;

2295

}

2296

return mLoader->begin__arccosh(attrData);

2297

}

2298

2299

2300

bool FormulasLoader15::end__arccosh()

2301

{

2302

SaxVirtualFunctionTest15(end__arccosh());

2303

return mLoader->end__arccosh();

2304

}

2305

2306

2307

bool FormulasLoader15::begin__arctanh( const COLLADASaxFWL15::arctanh__AttributeData& attributeData )

2308

{

2309

SaxVirtualFunctionTest15(begin__arctanh(attributeData));

2310

COLLADASaxFWL::arctanh__AttributeData attrData;

2311

attrData.style = attributeData.style;

2312

attrData.xref = attributeData.xref;

2313

attrData.id = attributeData.id;

2314

attrData.encoding = attributeData.encoding;

2315

attrData.unknownAttributes = attributeData.unknownAttributes;

2316

attrData.present_attributes = 0;

2317

if ( (attributeData.present_attributes & COLLADASaxFWL15::arctanh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arctanh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2318

attrData.definitionURL = attributeData.definitionURL;

2319

attrData.present_attributes |= COLLADASaxFWL::arctanh__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2320

}

2321

if ( (attributeData.present_attributes & COLLADASaxFWL15::arctanh__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arctanh__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2322

attrData._class = attributeData._class;

2323

attrData.present_attributes |= COLLADASaxFWL::arctanh__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2324

}

2325

if ( (attributeData.present_attributes & COLLADASaxFWL15::arctanh__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arctanh__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2326

attrData.href = attributeData.href;

2327

attrData.present_attributes |= COLLADASaxFWL::arctanh__AttributeData::ATTRIBUTE_HREF_PRESENT;

2328

}

2329

return mLoader->begin__arctanh(attrData);

2330

}

2331

2332

2333

bool FormulasLoader15::end__arctanh()

2334

{

2335

SaxVirtualFunctionTest15(end__arctanh());

2336

return mLoader->end__arctanh();

2337

}

2338

2339

2340

bool FormulasLoader15::begin__arcsech( const COLLADASaxFWL15::arcsech__AttributeData& attributeData )

2341

{

2342

SaxVirtualFunctionTest15(begin__arcsech(attributeData));

2343

COLLADASaxFWL::arcsech__AttributeData attrData;

2344

attrData.style = attributeData.style;

2345

attrData.xref = attributeData.xref;

2346

attrData.id = attributeData.id;

2347

attrData.encoding = attributeData.encoding;

2348

attrData.unknownAttributes = attributeData.unknownAttributes;

2349

attrData.present_attributes = 0;

2350

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsech__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arcsech__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2351

attrData.definitionURL = attributeData.definitionURL;

2352

attrData.present_attributes |= COLLADASaxFWL::arcsech__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2353

}

2354

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsech__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arcsech__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2355

attrData._class = attributeData._class;

2356

attrData.present_attributes |= COLLADASaxFWL::arcsech__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2357

}

2358

if ( (attributeData.present_attributes & COLLADASaxFWL15::arcsech__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arcsech__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2359

attrData.href = attributeData.href;

2360

attrData.present_attributes |= COLLADASaxFWL::arcsech__AttributeData::ATTRIBUTE_HREF_PRESENT;

2361

}

2362

return mLoader->begin__arcsech(attrData);

2363

}

2364

2365

2366

bool FormulasLoader15::end__arcsech()

2367

{

2368

SaxVirtualFunctionTest15(end__arcsech());

2369

return mLoader->end__arcsech();

2370

}

2371

2372

2373

bool FormulasLoader15::begin__arccsch( const COLLADASaxFWL15::arccsch__AttributeData& attributeData )

2374

{

2375

SaxVirtualFunctionTest15(begin__arccsch(attributeData));

2376

COLLADASaxFWL::arccsch__AttributeData attrData;

2377

attrData.style = attributeData.style;

2378

attrData.xref = attributeData.xref;

2379

attrData.id = attributeData.id;

2380

attrData.encoding = attributeData.encoding;

2381

attrData.unknownAttributes = attributeData.unknownAttributes;

2382

attrData.present_attributes = 0;

2383

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccsch__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arccsch__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2384

attrData.definitionURL = attributeData.definitionURL;

2385

attrData.present_attributes |= COLLADASaxFWL::arccsch__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2386

}

2387

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccsch__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arccsch__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2388

attrData._class = attributeData._class;

2389

attrData.present_attributes |= COLLADASaxFWL::arccsch__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2390

}

2391

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccsch__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arccsch__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2392

attrData.href = attributeData.href;

2393

attrData.present_attributes |= COLLADASaxFWL::arccsch__AttributeData::ATTRIBUTE_HREF_PRESENT;

2394

}

2395

return mLoader->begin__arccsch(attrData);

2396

}

2397

2398

2399

bool FormulasLoader15::end__arccsch()

2400

{

2401

SaxVirtualFunctionTest15(end__arccsch());

2402

return mLoader->end__arccsch();

2403

}

2404

2405

2406

bool FormulasLoader15::begin__arccoth( const COLLADASaxFWL15::arccoth__AttributeData& attributeData )

2407

{

2408

SaxVirtualFunctionTest15(begin__arccoth(attributeData));

2409

COLLADASaxFWL::arccoth__AttributeData attrData;

2410

attrData.style = attributeData.style;

2411

attrData.xref = attributeData.xref;

2412

attrData.id = attributeData.id;

2413

attrData.encoding = attributeData.encoding;

2414

attrData.unknownAttributes = attributeData.unknownAttributes;

2415

attrData.present_attributes = 0;

2416

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccoth__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT) == COLLADASaxFWL15::arccoth__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT ) {

2417

attrData.definitionURL = attributeData.definitionURL;

2418

attrData.present_attributes |= COLLADASaxFWL::arccoth__AttributeData::ATTRIBUTE_DEFINITIONURL_PRESENT;

2419

}

2420

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccoth__AttributeData::ATTRIBUTE__CLASS_PRESENT) == COLLADASaxFWL15::arccoth__AttributeData::ATTRIBUTE__CLASS_PRESENT ) {

2421

attrData._class = attributeData._class;

2422

attrData.present_attributes |= COLLADASaxFWL::arccoth__AttributeData::ATTRIBUTE__CLASS_PRESENT;

2423

}

2424

if ( (attributeData.present_attributes & COLLADASaxFWL15::arccoth__AttributeData::ATTRIBUTE_HREF_PRESENT) == COLLADASaxFWL15::arccoth__AttributeData::ATTRIBUTE_HREF_PRESENT ) {

2425

attrData.href = attributeData.href;

2426

attrData.present_attributes |= COLLADASaxFWL::arccoth__AttributeData::ATTRIBUTE_HREF_PRESENT;

2427

}

2428

return mLoader->begin__arccoth(attrData);

2429

}

2430

2431

2432

bool FormulasLoader15::end__arccoth()

2433

{

2434

SaxVirtualFunctionTest15(end__arccoth());

2435

return mLoader->end__arccoth();

2436

}

2437

2438

2439

2440

}

Older »